From afdd3c044c0f7465237785e1f0230b1e8c9b56a6 Mon Sep 17 00:00:00 2001
From: David Malcolm <dmalcolm@redhat.com>
Date: Tue, 29 Sep 2020 09:13:47 -0400
Subject: [PATCH 07/47] FIXME: add pr97240.C to root dir

---
 pr97240.C | 166497 +++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 166497 insertions(+)
 create mode 100644 pr97240.C

diff --git a/pr97240.C b/pr97240.C
new file mode 100644
index 00000000000..705ce898de7
--- /dev/null
+++ b/pr97240.C
@@ -0,0 +1,166497 @@
+# 1 "FastMathTest.cpp"
+# 1 "/home/andris/Work/FMI/smartmet/smartmet-library-macgyver/test//"
+# 1 "<built-in>"
+#define __STDC__ 1
+#define __cplusplus 201703L
+#define __STDC_UTF_16__ 1
+#define __STDC_UTF_32__ 1
+#define __STDC_HOSTED__ 1
+#define __GNUC__ 10
+#define __GNUC_MINOR__ 2
+#define __GNUC_PATCHLEVEL__ 0
+#define __VERSION__ "10.2.0"
+#define __ATOMIC_RELAXED 0
+#define __ATOMIC_SEQ_CST 5
+#define __ATOMIC_ACQUIRE 2
+#define __ATOMIC_RELEASE 3
+#define __ATOMIC_ACQ_REL 4
+#define __ATOMIC_CONSUME 1
+#define __pic__ 2
+#define __PIC__ 2
+#define __FINITE_MATH_ONLY__ 0
+#define _LP64 1
+#define __LP64__ 1
+#define __SIZEOF_INT__ 4
+#define __SIZEOF_LONG__ 8
+#define __SIZEOF_LONG_LONG__ 8
+#define __SIZEOF_SHORT__ 2
+#define __SIZEOF_FLOAT__ 4
+#define __SIZEOF_DOUBLE__ 8
+#define __SIZEOF_LONG_DOUBLE__ 16
+#define __SIZEOF_SIZE_T__ 8
+#define __CHAR_BIT__ 8
+#define __BIGGEST_ALIGNMENT__ 16
+#define __ORDER_LITTLE_ENDIAN__ 1234
+#define __ORDER_BIG_ENDIAN__ 4321
+#define __ORDER_PDP_ENDIAN__ 3412
+#define __BYTE_ORDER__ __ORDER_LITTLE_ENDIAN__
+#define __FLOAT_WORD_ORDER__ __ORDER_LITTLE_ENDIAN__
+#define __SIZEOF_POINTER__ 8
+#define __GNUG__ 10
+#define __SIZE_TYPE__ long unsigned int
+#define __PTRDIFF_TYPE__ long int
+#define __WCHAR_TYPE__ int
+#define __WINT_TYPE__ unsigned int
+#define __INTMAX_TYPE__ long int
+#define __UINTMAX_TYPE__ long unsigned int
+#define __CHAR16_TYPE__ short unsigned int
+#define __CHAR32_TYPE__ unsigned int
+#define __SIG_ATOMIC_TYPE__ int
+#define __INT8_TYPE__ signed char
+#define __INT16_TYPE__ short int
+#define __INT32_TYPE__ int
+#define __INT64_TYPE__ long int
+#define __UINT8_TYPE__ unsigned char
+#define __UINT16_TYPE__ short unsigned int
+#define __UINT32_TYPE__ unsigned int
+#define __UINT64_TYPE__ long unsigned int
+#define __INT_LEAST8_TYPE__ signed char
+#define __INT_LEAST16_TYPE__ short int
+#define __INT_LEAST32_TYPE__ int
+#define __INT_LEAST64_TYPE__ long int
+#define __UINT_LEAST8_TYPE__ unsigned char
+#define __UINT_LEAST16_TYPE__ short unsigned int
+#define __UINT_LEAST32_TYPE__ unsigned int
+#define __UINT_LEAST64_TYPE__ long unsigned int
+#define __INT_FAST8_TYPE__ signed char
+#define __INT_FAST16_TYPE__ long int
+#define __INT_FAST32_TYPE__ long int
+#define __INT_FAST64_TYPE__ long int
+#define __UINT_FAST8_TYPE__ unsigned char
+#define __UINT_FAST16_TYPE__ long unsigned int
+#define __UINT_FAST32_TYPE__ long unsigned int
+#define __UINT_FAST64_TYPE__ long unsigned int
+#define __INTPTR_TYPE__ long int
+#define __UINTPTR_TYPE__ long unsigned int
+#define __GXX_WEAK__ 1
+#define __DEPRECATED 1
+#define __GXX_RTTI 1
+#define __cpp_rtti 199711L
+#define __GXX_EXPERIMENTAL_CXX0X__ 1
+#define __cpp_binary_literals 201304L
+#define __cpp_hex_float 201603L
+#define __cpp_runtime_arrays 198712L
+#define __cpp_raw_strings 200710L
+#define __cpp_unicode_literals 200710L
+#define __cpp_user_defined_literals 200809L
+#define __cpp_lambdas 200907L
+#define __cpp_decltype 200707L
+#define __cpp_attributes 200809L
+#define __cpp_rvalue_reference 200610L
+#define __cpp_rvalue_references 200610L
+#define __cpp_variadic_templates 200704L
+#define __cpp_initializer_lists 200806L
+#define __cpp_delegating_constructors 200604L
+#define __cpp_nsdmi 200809L
+#define __cpp_inheriting_constructors 201511L
+#define __cpp_ref_qualifiers 200710L
+#define __cpp_alias_templates 200704L
+#define __cpp_return_type_deduction 201304L
+#define __cpp_init_captures 201304L
+#define __cpp_generic_lambdas 201304L
+#define __cpp_decltype_auto 201304L
+#define __cpp_aggregate_nsdmi 201304L
+#define __cpp_variable_templates 201304L
+#define __cpp_digit_separators 201309L
+#define __cpp_unicode_characters 201411L
+#define __cpp_static_assert 201411L
+#define __cpp_namespace_attributes 201411L
+#define __cpp_enumerator_attributes 201411L
+#define __cpp_nested_namespace_definitions 201411L
+#define __cpp_fold_expressions 201603L
+#define __cpp_nontype_template_args 201411L
+#define __cpp_range_based_for 201603L
+#define __cpp_constexpr 201603L
+#define __cpp_if_constexpr 201606L
+#define __cpp_capture_star_this 201603L
+#define __cpp_inline_variables 201606L
+#define __cpp_aggregate_bases 201603L
+#define __cpp_deduction_guides 201703L
+#define __cpp_noexcept_function_type 201510L
+#define __cpp_template_auto 201606L
+#define __cpp_structured_bindings 201606L
+#define __cpp_variadic_using 201611L
+#define __cpp_guaranteed_copy_elision 201606L
+#define __cpp_nontype_template_parameter_auto 201606L
+#define __cpp_sized_deallocation 201309L
+#define __cpp_aligned_new 201606L
+#define __STDCPP_DEFAULT_NEW_ALIGNMENT__ 16
+#define __cpp_template_template_args 201611L
+#define __cpp_threadsafe_static_init 200806L
+#define __EXCEPTIONS 1
+#define __cpp_exceptions 199711L
+#define __GXX_ABI_VERSION 1014
+#define __SCHAR_MAX__ 0x7f
+#define __SHRT_MAX__ 0x7fff
+#define __INT_MAX__ 0x7fffffff
+#define __LONG_MAX__ 0x7fffffffffffffffL
+#define __LONG_LONG_MAX__ 0x7fffffffffffffffLL
+#define __WCHAR_MAX__ 0x7fffffff
+#define __WCHAR_MIN__ (-__WCHAR_MAX__ - 1)
+#define __WINT_MAX__ 0xffffffffU
+#define __WINT_MIN__ 0U
+#define __PTRDIFF_MAX__ 0x7fffffffffffffffL
+#define __SIZE_MAX__ 0xffffffffffffffffUL
+#define __SCHAR_WIDTH__ 8
+#define __SHRT_WIDTH__ 16
+#define __INT_WIDTH__ 32
+#define __LONG_WIDTH__ 64
+#define __LONG_LONG_WIDTH__ 64
+#define __WCHAR_WIDTH__ 32
+#define __WINT_WIDTH__ 32
+#define __PTRDIFF_WIDTH__ 64
+#define __SIZE_WIDTH__ 64
+#define __INTMAX_MAX__ 0x7fffffffffffffffL
+#define __INTMAX_C(c) c ## L
+#define __UINTMAX_MAX__ 0xffffffffffffffffUL
+#define __UINTMAX_C(c) c ## UL
+#define __INTMAX_WIDTH__ 64
+#define __SIG_ATOMIC_MAX__ 0x7fffffff
+#define __SIG_ATOMIC_MIN__ (-__SIG_ATOMIC_MAX__ - 1)
+#define __SIG_ATOMIC_WIDTH__ 32
+#define __INT8_MAX__ 0x7f
+#define __INT16_MAX__ 0x7fff
+#define __INT32_MAX__ 0x7fffffff
+#define __INT64_MAX__ 0x7fffffffffffffffL
+#define __UINT8_MAX__ 0xff
+#define __UINT16_MAX__ 0xffff
+#define __UINT32_MAX__ 0xffffffffU
+#define __UINT64_MAX__ 0xffffffffffffffffUL
+#define __INT_LEAST8_MAX__ 0x7f
+#define __INT8_C(c) c
+#define __INT_LEAST8_WIDTH__ 8
+#define __INT_LEAST16_MAX__ 0x7fff
+#define __INT16_C(c) c
+#define __INT_LEAST16_WIDTH__ 16
+#define __INT_LEAST32_MAX__ 0x7fffffff
+#define __INT32_C(c) c
+#define __INT_LEAST32_WIDTH__ 32
+#define __INT_LEAST64_MAX__ 0x7fffffffffffffffL
+#define __INT64_C(c) c ## L
+#define __INT_LEAST64_WIDTH__ 64
+#define __UINT_LEAST8_MAX__ 0xff
+#define __UINT8_C(c) c
+#define __UINT_LEAST16_MAX__ 0xffff
+#define __UINT16_C(c) c
+#define __UINT_LEAST32_MAX__ 0xffffffffU
+#define __UINT32_C(c) c ## U
+#define __UINT_LEAST64_MAX__ 0xffffffffffffffffUL
+#define __UINT64_C(c) c ## UL
+#define __INT_FAST8_MAX__ 0x7f
+#define __INT_FAST8_WIDTH__ 8
+#define __INT_FAST16_MAX__ 0x7fffffffffffffffL
+#define __INT_FAST16_WIDTH__ 64
+#define __INT_FAST32_MAX__ 0x7fffffffffffffffL
+#define __INT_FAST32_WIDTH__ 64
+#define __INT_FAST64_MAX__ 0x7fffffffffffffffL
+#define __INT_FAST64_WIDTH__ 64
+#define __UINT_FAST8_MAX__ 0xff
+#define __UINT_FAST16_MAX__ 0xffffffffffffffffUL
+#define __UINT_FAST32_MAX__ 0xffffffffffffffffUL
+#define __UINT_FAST64_MAX__ 0xffffffffffffffffUL
+#define __INTPTR_MAX__ 0x7fffffffffffffffL
+#define __INTPTR_WIDTH__ 64
+#define __UINTPTR_MAX__ 0xffffffffffffffffUL
+#define __GCC_IEC_559 2
+#define __GCC_IEC_559_COMPLEX 2
+#define __FLT_EVAL_METHOD__ 0
+#define __FLT_EVAL_METHOD_TS_18661_3__ 0
+#define __DEC_EVAL_METHOD__ 2
+#define __FLT_RADIX__ 2
+#define __FLT_MANT_DIG__ 24
+#define __FLT_DIG__ 6
+#define __FLT_MIN_EXP__ (-125)
+#define __FLT_MIN_10_EXP__ (-37)
+#define __FLT_MAX_EXP__ 128
+#define __FLT_MAX_10_EXP__ 38
+#define __FLT_DECIMAL_DIG__ 9
+#define __FLT_MAX__ 3.40282346638528859811704183484516925e+38F
+#define __FLT_NORM_MAX__ 3.40282346638528859811704183484516925e+38F
+#define __FLT_MIN__ 1.17549435082228750796873653722224568e-38F
+#define __FLT_EPSILON__ 1.19209289550781250000000000000000000e-7F
+#define __FLT_DENORM_MIN__ 1.40129846432481707092372958328991613e-45F
+#define __FLT_HAS_DENORM__ 1
+#define __FLT_HAS_INFINITY__ 1
+#define __FLT_HAS_QUIET_NAN__ 1
+#define __DBL_MANT_DIG__ 53
+#define __DBL_DIG__ 15
+#define __DBL_MIN_EXP__ (-1021)
+#define __DBL_MIN_10_EXP__ (-307)
+#define __DBL_MAX_EXP__ 1024
+#define __DBL_MAX_10_EXP__ 308
+#define __DBL_DECIMAL_DIG__ 17
+#define __DBL_MAX__ double(1.79769313486231570814527423731704357e+308L)
+#define __DBL_NORM_MAX__ double(1.79769313486231570814527423731704357e+308L)
+#define __DBL_MIN__ double(2.22507385850720138309023271733240406e-308L)
+#define __DBL_EPSILON__ double(2.22044604925031308084726333618164062e-16L)
+#define __DBL_DENORM_MIN__ double(4.94065645841246544176568792868221372e-324L)
+#define __DBL_HAS_DENORM__ 1
+#define __DBL_HAS_INFINITY__ 1
+#define __DBL_HAS_QUIET_NAN__ 1
+#define __LDBL_MANT_DIG__ 64
+#define __LDBL_DIG__ 18
+#define __LDBL_MIN_EXP__ (-16381)
+#define __LDBL_MIN_10_EXP__ (-4931)
+#define __LDBL_MAX_EXP__ 16384
+#define __LDBL_MAX_10_EXP__ 4932
+#define __DECIMAL_DIG__ 21
+#define __LDBL_DECIMAL_DIG__ 21
+#define __LDBL_MAX__ 1.18973149535723176502126385303097021e+4932L
+#define __LDBL_NORM_MAX__ 1.18973149535723176502126385303097021e+4932L
+#define __LDBL_MIN__ 3.36210314311209350626267781732175260e-4932L
+#define __LDBL_EPSILON__ 1.08420217248550443400745280086994171e-19L
+#define __LDBL_DENORM_MIN__ 3.64519953188247460252840593361941982e-4951L
+#define __LDBL_HAS_DENORM__ 1
+#define __LDBL_HAS_INFINITY__ 1
+#define __LDBL_HAS_QUIET_NAN__ 1
+#define __FLT32_MANT_DIG__ 24
+#define __FLT32_DIG__ 6
+#define __FLT32_MIN_EXP__ (-125)
+#define __FLT32_MIN_10_EXP__ (-37)
+#define __FLT32_MAX_EXP__ 128
+#define __FLT32_MAX_10_EXP__ 38
+#define __FLT32_DECIMAL_DIG__ 9
+#define __FLT32_MAX__ 3.40282346638528859811704183484516925e+38F32
+#define __FLT32_NORM_MAX__ 3.40282346638528859811704183484516925e+38F32
+#define __FLT32_MIN__ 1.17549435082228750796873653722224568e-38F32
+#define __FLT32_EPSILON__ 1.19209289550781250000000000000000000e-7F32
+#define __FLT32_DENORM_MIN__ 1.40129846432481707092372958328991613e-45F32
+#define __FLT32_HAS_DENORM__ 1
+#define __FLT32_HAS_INFINITY__ 1
+#define __FLT32_HAS_QUIET_NAN__ 1
+#define __FLT64_MANT_DIG__ 53
+#define __FLT64_DIG__ 15
+#define __FLT64_MIN_EXP__ (-1021)
+#define __FLT64_MIN_10_EXP__ (-307)
+#define __FLT64_MAX_EXP__ 1024
+#define __FLT64_MAX_10_EXP__ 308
+#define __FLT64_DECIMAL_DIG__ 17
+#define __FLT64_MAX__ 1.79769313486231570814527423731704357e+308F64
+#define __FLT64_NORM_MAX__ 1.79769313486231570814527423731704357e+308F64
+#define __FLT64_MIN__ 2.22507385850720138309023271733240406e-308F64
+#define __FLT64_EPSILON__ 2.22044604925031308084726333618164062e-16F64
+#define __FLT64_DENORM_MIN__ 4.94065645841246544176568792868221372e-324F64
+#define __FLT64_HAS_DENORM__ 1
+#define __FLT64_HAS_INFINITY__ 1
+#define __FLT64_HAS_QUIET_NAN__ 1
+#define __FLT128_MANT_DIG__ 113
+#define __FLT128_DIG__ 33
+#define __FLT128_MIN_EXP__ (-16381)
+#define __FLT128_MIN_10_EXP__ (-4931)
+#define __FLT128_MAX_EXP__ 16384
+#define __FLT128_MAX_10_EXP__ 4932
+#define __FLT128_DECIMAL_DIG__ 36
+#define __FLT128_MAX__ 1.18973149535723176508575932662800702e+4932F128
+#define __FLT128_NORM_MAX__ 1.18973149535723176508575932662800702e+4932F128
+#define __FLT128_MIN__ 3.36210314311209350626267781732175260e-4932F128
+#define __FLT128_EPSILON__ 1.92592994438723585305597794258492732e-34F128
+#define __FLT128_DENORM_MIN__ 6.47517511943802511092443895822764655e-4966F128
+#define __FLT128_HAS_DENORM__ 1
+#define __FLT128_HAS_INFINITY__ 1
+#define __FLT128_HAS_QUIET_NAN__ 1
+#define __FLT32X_MANT_DIG__ 53
+#define __FLT32X_DIG__ 15
+#define __FLT32X_MIN_EXP__ (-1021)
+#define __FLT32X_MIN_10_EXP__ (-307)
+#define __FLT32X_MAX_EXP__ 1024
+#define __FLT32X_MAX_10_EXP__ 308
+#define __FLT32X_DECIMAL_DIG__ 17
+#define __FLT32X_MAX__ 1.79769313486231570814527423731704357e+308F32x
+#define __FLT32X_NORM_MAX__ 1.79769313486231570814527423731704357e+308F32x
+#define __FLT32X_MIN__ 2.22507385850720138309023271733240406e-308F32x
+#define __FLT32X_EPSILON__ 2.22044604925031308084726333618164062e-16F32x
+#define __FLT32X_DENORM_MIN__ 4.94065645841246544176568792868221372e-324F32x
+#define __FLT32X_HAS_DENORM__ 1
+#define __FLT32X_HAS_INFINITY__ 1
+#define __FLT32X_HAS_QUIET_NAN__ 1
+#define __FLT64X_MANT_DIG__ 64
+#define __FLT64X_DIG__ 18
+#define __FLT64X_MIN_EXP__ (-16381)
+#define __FLT64X_MIN_10_EXP__ (-4931)
+#define __FLT64X_MAX_EXP__ 16384
+#define __FLT64X_MAX_10_EXP__ 4932
+#define __FLT64X_DECIMAL_DIG__ 21
+#define __FLT64X_MAX__ 1.18973149535723176502126385303097021e+4932F64x
+#define __FLT64X_NORM_MAX__ 1.18973149535723176502126385303097021e+4932F64x
+#define __FLT64X_MIN__ 3.36210314311209350626267781732175260e-4932F64x
+#define __FLT64X_EPSILON__ 1.08420217248550443400745280086994171e-19F64x
+#define __FLT64X_DENORM_MIN__ 3.64519953188247460252840593361941982e-4951F64x
+#define __FLT64X_HAS_DENORM__ 1
+#define __FLT64X_HAS_INFINITY__ 1
+#define __FLT64X_HAS_QUIET_NAN__ 1
+#define __DEC32_MANT_DIG__ 7
+#define __DEC32_MIN_EXP__ (-94)
+#define __DEC32_MAX_EXP__ 97
+#define __DEC32_MIN__ 1E-95DF
+#define __DEC32_MAX__ 9.999999E96DF
+#define __DEC32_EPSILON__ 1E-6DF
+#define __DEC32_SUBNORMAL_MIN__ 0.000001E-95DF
+#define __DEC64_MANT_DIG__ 16
+#define __DEC64_MIN_EXP__ (-382)
+#define __DEC64_MAX_EXP__ 385
+#define __DEC64_MIN__ 1E-383DD
+#define __DEC64_MAX__ 9.999999999999999E384DD
+#define __DEC64_EPSILON__ 1E-15DD
+#define __DEC64_SUBNORMAL_MIN__ 0.000000000000001E-383DD
+#define __DEC128_MANT_DIG__ 34
+#define __DEC128_MIN_EXP__ (-6142)
+#define __DEC128_MAX_EXP__ 6145
+#define __DEC128_MIN__ 1E-6143DL
+#define __DEC128_MAX__ 9.999999999999999999999999999999999E6144DL
+#define __DEC128_EPSILON__ 1E-33DL
+#define __DEC128_SUBNORMAL_MIN__ 0.000000000000000000000000000000001E-6143DL
+#define __REGISTER_PREFIX__ 
+#define __USER_LABEL_PREFIX__ 
+#define __GNUC_STDC_INLINE__ 1
+#define __NO_INLINE__ 1
+#define __STRICT_ANSI__ 1
+#define __GCC_HAVE_SYNC_COMPARE_AND_SWAP_1 1
+#define __GCC_HAVE_SYNC_COMPARE_AND_SWAP_2 1
+#define __GCC_HAVE_SYNC_COMPARE_AND_SWAP_4 1
+#define __GCC_HAVE_SYNC_COMPARE_AND_SWAP_8 1
+#define __GCC_ATOMIC_BOOL_LOCK_FREE 2
+#define __GCC_ATOMIC_CHAR_LOCK_FREE 2
+#define __GCC_ATOMIC_CHAR16_T_LOCK_FREE 2
+#define __GCC_ATOMIC_CHAR32_T_LOCK_FREE 2
+#define __GCC_ATOMIC_WCHAR_T_LOCK_FREE 2
+#define __GCC_ATOMIC_SHORT_LOCK_FREE 2
+#define __GCC_ATOMIC_INT_LOCK_FREE 2
+#define __GCC_ATOMIC_LONG_LOCK_FREE 2
+#define __GCC_ATOMIC_LLONG_LOCK_FREE 2
+#define __GCC_ATOMIC_TEST_AND_SET_TRUEVAL 1
+#define __GCC_ATOMIC_POINTER_LOCK_FREE 2
+#define __HAVE_SPECULATION_SAFE_VALUE 1
+#define __GCC_HAVE_DWARF2_CFI_ASM 1
+#define __PRAGMA_REDEFINE_EXTNAME 1
+#define __SSP_STRONG__ 3
+#define __SIZEOF_INT128__ 16
+#define __SIZEOF_WCHAR_T__ 4
+#define __SIZEOF_WINT_T__ 4
+#define __SIZEOF_PTRDIFF_T__ 8
+#define __amd64 1
+#define __amd64__ 1
+#define __x86_64 1
+#define __x86_64__ 1
+#define __SIZEOF_FLOAT80__ 16
+#define __SIZEOF_FLOAT128__ 16
+#define __ATOMIC_HLE_ACQUIRE 65536
+#define __ATOMIC_HLE_RELEASE 131072
+#define __GCC_ASM_FLAG_OUTPUTS__ 1
+#define __k8 1
+#define __k8__ 1
+#define __code_model_small__ 1
+#define __MMX__ 1
+#define __SSE__ 1
+#define __SSE2__ 1
+#define __FXSR__ 1
+#define __SSE_MATH__ 1
+#define __SSE2_MATH__ 1
+#define __MMX_WITH_SSE__ 1
+#define __SEG_FS 1
+#define __SEG_GS 1
+#define __gnu_linux__ 1
+#define __linux 1
+#define __linux__ 1
+#define __unix 1
+#define __unix__ 1
+#define __ELF__ 1
+#define __DECIMAL_BID_FORMAT__ 1
+# 1 "<command-line>"
+#define _GNU_SOURCE 1
+#define UNIX 1
+#define _REENTRANT 1
+# 1 "/usr/include/stdc-predef.h" 1 3 4
+# 19 "/usr/include/stdc-predef.h" 3 4
+#define _STDC_PREDEF_H 1
+# 38 "/usr/include/stdc-predef.h" 3 4
+#define __STDC_IEC_559__ 1
+
+
+
+
+
+
+
+#define __STDC_IEC_559_COMPLEX__ 1
+# 58 "/usr/include/stdc-predef.h" 3 4
+#define __STDC_ISO_10646__ 201706L
+# 1 "<command-line>" 2
+# 1 "FastMathTest.cpp"
+
+
+
+
+
+
+
+# 1 "../macgyver/FastMath.h" 1
+       
+
+
+
+
+
+namespace Fmi
+{
+
+
+inline long floor(double x) { return static_cast<long>(x) - (x < static_cast<long>(x)); }
+
+inline long ceil(double x) { return static_cast<long>(x) + (x > static_cast<long>(x)); }
+
+}
+# 9 "FastMathTest.cpp" 2
+# 1 "/usr/include/boost/test/included/unit_test.hpp" 1 3 4
+# 14 "/usr/include/boost/test/included/unit_test.hpp" 3 4
+#define BOOST_INCLUDED_UNIT_TEST_FRAMEWORK_HPP_071894GER 
+
+#define BOOST_TEST_INCLUDED 
+
+# 1 "/usr/include/boost/test/impl/compiler_log_formatter.ipp" 1 3 4
+# 16 "/usr/include/boost/test/impl/compiler_log_formatter.ipp" 3 4
+#define BOOST_TEST_COMPILER_LOG_FORMATTER_IPP_020105GER 
+
+
+# 1 "/usr/include/boost/test/output/compiler_log_formatter.hpp" 1 3 4
+# 13 "/usr/include/boost/test/output/compiler_log_formatter.hpp" 3 4
+#define BOOST_TEST_COMPILER_LOG_FORMATTER_HPP_020105GER 
+
+
+# 1 "/usr/include/boost/test/detail/global_typedef.hpp" 1 3 4
+# 13 "/usr/include/boost/test/detail/global_typedef.hpp" 3 4
+#define BOOST_TEST_GLOBAL_TYPEDEF_HPP_021005GER 
+
+# 1 "/usr/include/boost/test/utils/basic_cstring/basic_cstring.hpp" 1 3 4
+# 17 "/usr/include/boost/test/utils/basic_cstring/basic_cstring.hpp" 3 4
+#define BOOST_TEST_UTILS_BASIC_CSTRING_HPP 
+
+
+# 1 "/usr/include/boost/test/utils/basic_cstring/basic_cstring_fwd.hpp" 1 3 4
+# 17 "/usr/include/boost/test/utils/basic_cstring/basic_cstring_fwd.hpp" 3 4
+#define BOOST_TEST_UTILS_BASIC_CSTRING_FWD_HPP 
+
+# 1 "/usr/include/boost/test/detail/config.hpp" 1 3 4
+# 13 "/usr/include/boost/test/detail/config.hpp" 3 4
+#define BOOST_TEST_CONFIG_HPP_071894GER 
+
+
+# 1 "/usr/include/boost/config.hpp" 1 3 4
+# 18 "/usr/include/boost/config.hpp" 3 4
+#define BOOST_CONFIG_HPP 
+
+
+
+#define BOOST_USER_CONFIG <boost/config/user.hpp>
+
+
+
+
+
+
+
+# 1 "/usr/include/boost/config/user.hpp" 1 3 4
+# 31 "/usr/include/boost/config.hpp" 2 3 4
+
+
+
+
+# 1 "/usr/include/boost/config/detail/select_compiler_config.hpp" 1 3 4
+# 60 "/usr/include/boost/config/detail/select_compiler_config.hpp" 3 4
+#define BOOST_COMPILER_CONFIG "boost/config/compiler/gcc.hpp"
+# 36 "/usr/include/boost/config.hpp" 2 3 4
+
+
+
+# 1 "/usr/include/boost/config/compiler/gcc.hpp" 1 3 4
+# 19 "/usr/include/boost/config/compiler/gcc.hpp" 3 4
+#define BOOST_GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
+
+#define BOOST_GCC BOOST_GCC_VERSION
+
+
+
+#define BOOST_GCC_CXX11 
+# 51 "/usr/include/boost/config/compiler/gcc.hpp" 3 4
+#define BOOST_HAS_PRAGMA_ONCE 
+# 86 "/usr/include/boost/config/compiler/gcc.hpp" 3 4
+#define BOOST_HAS_LONG_LONG 
+
+
+
+
+
+#define BOOST_HAS_NRVO 
+
+
+#define BOOST_LIKELY(x) __builtin_expect(x, 1)
+#define BOOST_UNLIKELY(x) __builtin_expect(x, 0)
+# 110 "/usr/include/boost/config/compiler/gcc.hpp" 3 4
+#define BOOST_SYMBOL_EXPORT __attribute__((__visibility__("default")))
+#define BOOST_SYMBOL_IMPORT 
+
+#define BOOST_SYMBOL_VISIBLE __attribute__((__visibility__("default")))
+# 153 "/usr/include/boost/config/compiler/gcc.hpp" 3 4
+#define BOOST_HAS_INT128 
+# 165 "/usr/include/boost/config/compiler/gcc.hpp" 3 4
+# 1 "/usr/include/c++/10.2.0/cstddef" 1 3 4
+# 40 "/usr/include/c++/10.2.0/cstddef" 3 4
+#define _GLIBCXX_CSTDDEF 1
+
+       
+# 43 "/usr/include/c++/10.2.0/cstddef" 3
+
+#undef __need_wchar_t
+#undef __need_ptrdiff_t
+#undef __need_size_t
+#undef __need_NULL
+#undef __need_wint_t
+# 1 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++config.h" 1 3
+# 31 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++config.h" 3
+#define _GLIBCXX_CXX_CONFIG_H 1
+
+
+#define _GLIBCXX_RELEASE 10
+
+
+#define __GLIBCXX__ 20200723
+# 46 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++config.h" 3
+#define _GLIBCXX_PURE __attribute__ ((__pure__))
+
+
+
+#define _GLIBCXX_CONST __attribute__ ((__const__))
+
+
+
+#define _GLIBCXX_NORETURN __attribute__ ((__noreturn__))
+# 67 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++config.h" 3
+#define _GLIBCXX_HAVE_ATTRIBUTE_VISIBILITY 1
+
+
+#define _GLIBCXX_VISIBILITY(V) __attribute__ ((__visibility__ (#V)))
+# 83 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++config.h" 3
+#define _GLIBCXX_USE_DEPRECATED 1
+
+
+
+#define _GLIBCXX_DEPRECATED __attribute__ ((__deprecated__))
+
+
+
+
+
+#define _GLIBCXX17_DEPRECATED [[__deprecated__]]
+
+
+
+
+
+
+
+#define _GLIBCXX20_DEPRECATED(MSG) 
+
+
+
+
+#define _GLIBCXX_ABI_TAG_CXX11 __attribute ((__abi_tag__ ("cxx11")))
+
+
+
+
+#define _GLIBCXX_NODISCARD [[__nodiscard__]]
+# 123 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++config.h" 3
+#define _GLIBCXX_CONSTEXPR constexpr
+#define _GLIBCXX_USE_CONSTEXPR constexpr
+# 133 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++config.h" 3
+#define _GLIBCXX14_CONSTEXPR constexpr
+
+
+
+
+
+
+
+#define _GLIBCXX17_CONSTEXPR constexpr
+# 151 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++config.h" 3
+#define _GLIBCXX20_CONSTEXPR 
+
+
+
+
+
+#define _GLIBCXX17_INLINE inline
+# 166 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++config.h" 3
+#define _GLIBCXX_NOEXCEPT noexcept
+#define _GLIBCXX_NOEXCEPT_IF(...) noexcept(__VA_ARGS__)
+#define _GLIBCXX_USE_NOEXCEPT noexcept
+#define _GLIBCXX_THROW(_EXC) 
+# 179 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++config.h" 3
+#define _GLIBCXX_NOTHROW _GLIBCXX_USE_NOEXCEPT
+
+
+
+
+#define _GLIBCXX_THROW_OR_ABORT(_EXC) (throw (_EXC))
+
+
+
+
+
+
+#define _GLIBCXX_NOEXCEPT_PARM , bool _NE
+#define _GLIBCXX_NOEXCEPT_QUAL noexcept (_NE)
+# 208 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++config.h" 3
+#define _GLIBCXX_EXTERN_TEMPLATE 1
+# 258 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++config.h" 3
+
+# 258 "/usr/include/c++/10.2.0/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;
+
+}
+
+#define _GLIBCXX_USE_DUAL_ABI 1
+
+
+
+
+
+
+
+#define _GLIBCXX_USE_CXX11_ABI 1
+
+
+
+namespace std
+{
+  inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { }
+}
+namespace __gnu_cxx
+{
+  inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { }
+}
+#define _GLIBCXX_NAMESPACE_CXX11 __cxx11::
+#define _GLIBCXX_BEGIN_NAMESPACE_CXX11 namespace __cxx11 {
+#define _GLIBCXX_END_NAMESPACE_CXX11 }
+#define _GLIBCXX_DEFAULT_ABI_TAG _GLIBCXX_ABI_TAG_CXX11
+# 300 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++config.h" 3
+#define _GLIBCXX_INLINE_VERSION 0
+# 330 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++config.h" 3
+#define _GLIBCXX_BEGIN_NAMESPACE_VERSION 
+#define _GLIBCXX_END_NAMESPACE_VERSION 
+# 389 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++config.h" 3
+#define _GLIBCXX_STD_C std
+#define _GLIBCXX_BEGIN_NAMESPACE_CONTAINER 
+#define _GLIBCXX_END_NAMESPACE_CONTAINER 
+# 400 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++config.h" 3
+#define _GLIBCXX_STD_A std
+#define _GLIBCXX_BEGIN_NAMESPACE_ALGO 
+#define _GLIBCXX_END_NAMESPACE_ALGO 
+
+
+
+
+#undef _GLIBCXX_LONG_DOUBLE_COMPAT
+# 419 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++config.h" 3
+#define _GLIBCXX_NAMESPACE_LDBL 
+#define _GLIBCXX_BEGIN_NAMESPACE_LDBL 
+#define _GLIBCXX_END_NAMESPACE_LDBL 
+
+
+#define _GLIBCXX_NAMESPACE_LDBL_OR_CXX11 _GLIBCXX_NAMESPACE_CXX11
+#define _GLIBCXX_BEGIN_NAMESPACE_LDBL_OR_CXX11 _GLIBCXX_BEGIN_NAMESPACE_CXX11
+#define _GLIBCXX_END_NAMESPACE_LDBL_OR_CXX11 _GLIBCXX_END_NAMESPACE_CXX11
+# 472 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++config.h" 3
+#define __glibcxx_assert(_Condition) 
+# 497 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++config.h" 3
+#define _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(A) 
+
+
+#define _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(A) 
+
+
+
+#define _GLIBCXX_BEGIN_EXTERN_C extern "C" {
+#define _GLIBCXX_END_EXTERN_C }
+
+#define _GLIBCXX_USE_ALLOCATOR_NEW 1
+# 518 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++config.h" 3
+# 1 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/os_defines.h" 1 3
+# 31 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/os_defines.h" 3
+#define _GLIBCXX_OS_DEFINES 1
+
+
+
+
+
+#define __NO_CTYPE 1
+
+# 1 "/usr/include/features.h" 1 3 4
+# 19 "/usr/include/features.h" 3 4
+#define _FEATURES_H 1
+# 120 "/usr/include/features.h" 3 4
+#undef __USE_ISOC11
+#undef __USE_ISOC99
+#undef __USE_ISOC95
+#undef __USE_ISOCXX11
+#undef __USE_POSIX
+#undef __USE_POSIX2
+#undef __USE_POSIX199309
+#undef __USE_POSIX199506
+#undef __USE_XOPEN
+#undef __USE_XOPEN_EXTENDED
+#undef __USE_UNIX98
+#undef __USE_XOPEN2K
+#undef __USE_XOPEN2KXSI
+#undef __USE_XOPEN2K8
+#undef __USE_XOPEN2K8XSI
+#undef __USE_LARGEFILE
+#undef __USE_LARGEFILE64
+#undef __USE_FILE_OFFSET64
+#undef __USE_MISC
+#undef __USE_ATFILE
+#undef __USE_GNU
+#undef __USE_FORTIFY_LEVEL
+#undef __KERNEL_STRICT_NAMES
+#undef __GLIBC_USE_ISOC2X
+#undef __GLIBC_USE_DEPRECATED_GETS
+#undef __GLIBC_USE_DEPRECATED_SCANF
+
+
+
+
+#define __KERNEL_STRICT_NAMES 
+# 161 "/usr/include/features.h" 3 4
+#define __GNUC_PREREQ(maj,min) ((__GNUC__ << 16) + __GNUC_MINOR__ >= ((maj) << 16) + (min))
+# 175 "/usr/include/features.h" 3 4
+#define __glibc_clang_prereq(maj,min) 0
+
+
+
+#define __GLIBC_USE(F) __GLIBC_USE_ ## F
+# 194 "/usr/include/features.h" 3 4
+#undef _ISOC95_SOURCE
+#define _ISOC95_SOURCE 1
+#undef _ISOC99_SOURCE
+#define _ISOC99_SOURCE 1
+#undef _ISOC11_SOURCE
+#define _ISOC11_SOURCE 1
+#undef _ISOC2X_SOURCE
+#define _ISOC2X_SOURCE 1
+#undef _POSIX_SOURCE
+#define _POSIX_SOURCE 1
+#undef _POSIX_C_SOURCE
+#define _POSIX_C_SOURCE 200809L
+#undef _XOPEN_SOURCE
+#define _XOPEN_SOURCE 700
+#undef _XOPEN_SOURCE_EXTENDED
+#define _XOPEN_SOURCE_EXTENDED 1
+#undef _LARGEFILE64_SOURCE
+#define _LARGEFILE64_SOURCE 1
+#undef _DEFAULT_SOURCE
+#define _DEFAULT_SOURCE 1
+#undef _ATFILE_SOURCE
+#define _ATFILE_SOURCE 1
+# 226 "/usr/include/features.h" 3 4
+#undef _DEFAULT_SOURCE
+#define _DEFAULT_SOURCE 1
+
+
+
+
+
+#define __GLIBC_USE_ISOC2X 1
+
+
+
+
+
+
+
+#define __USE_ISOC11 1
+
+
+
+
+
+
+#define __USE_ISOC99 1
+
+
+
+
+
+
+#define __USE_ISOC95 1
+
+
+
+
+
+#define __USE_ISOC11 1
+
+
+
+
+#define __USE_ISOCXX11 1
+#define __USE_ISOC99 1
+# 278 "/usr/include/features.h" 3 4
+#undef _POSIX_SOURCE
+#define _POSIX_SOURCE 1
+#undef _POSIX_C_SOURCE
+#define _POSIX_C_SOURCE 200809L
+# 316 "/usr/include/features.h" 3 4
+#define __USE_POSIX 1
+
+
+
+#define __USE_POSIX2 1
+
+
+
+#define __USE_POSIX199309 1
+
+
+
+#define __USE_POSIX199506 1
+
+
+
+#define __USE_XOPEN2K 1
+#undef __USE_ISOC95
+#define __USE_ISOC95 1
+#undef __USE_ISOC99
+#define __USE_ISOC99 1
+
+
+
+#define __USE_XOPEN2K8 1
+#undef _ATFILE_SOURCE
+#define _ATFILE_SOURCE 1
+
+
+
+#define __USE_XOPEN 1
+
+#define __USE_XOPEN_EXTENDED 1
+#define __USE_UNIX98 1
+#undef _LARGEFILE_SOURCE
+#define _LARGEFILE_SOURCE 1
+
+
+#define __USE_XOPEN2K8 1
+#define __USE_XOPEN2K8XSI 1
+
+#define __USE_XOPEN2K 1
+#define __USE_XOPEN2KXSI 1
+#undef __USE_ISOC95
+#define __USE_ISOC95 1
+#undef __USE_ISOC99
+#define __USE_ISOC99 1
+# 372 "/usr/include/features.h" 3 4
+#define __USE_LARGEFILE 1
+
+
+
+#define __USE_LARGEFILE64 1
+
+
+
+
+
+
+
+#define __USE_MISC 1
+
+
+
+#define __USE_ATFILE 1
+
+
+
+#define __USE_GNU 1
+# 407 "/usr/include/features.h" 3 4
+#define __USE_FORTIFY_LEVEL 0
+
+
+
+
+
+
+
+#define __GLIBC_USE_DEPRECATED_GETS 0
+# 438 "/usr/include/features.h" 3 4
+#define __GLIBC_USE_DEPRECATED_SCANF 0
+# 451 "/usr/include/features.h" 3 4
+#undef __GNU_LIBRARY__
+#define __GNU_LIBRARY__ 6
+
+
+
+#define __GLIBC__ 2
+#define __GLIBC_MINOR__ 32
+
+#define __GLIBC_PREREQ(maj,min) ((__GLIBC__ << 16) + __GLIBC_MINOR__ >= ((maj) << 16) + (min))
+
+
+
+
+
+# 1 "/usr/include/sys/cdefs.h" 1 3 4
+# 19 "/usr/include/sys/cdefs.h" 3 4
+#define _SYS_CDEFS_H 1
+# 34 "/usr/include/sys/cdefs.h" 3 4
+#undef __P
+#undef __PMT
+
+
+
+
+
+
+#define __LEAF , __leaf__
+#define __LEAF_ATTR __attribute__ ((__leaf__))
+# 61 "/usr/include/sys/cdefs.h" 3 4
+#define __THROW throw ()
+#define __THROWNL throw ()
+#define __NTH(fct) __LEAF_ATTR fct throw ()
+#define __NTHNL(fct) fct throw ()
+# 94 "/usr/include/sys/cdefs.h" 3 4
+#define __glibc_clang_has_extension(ext) 0
+
+
+
+
+#define __P(args) args
+#define __PMT(args) args
+
+
+
+
+#define __CONCAT(x,y) x ## y
+#define __STRING(x) #x
+
+
+#define __ptr_t void *
+
+
+
+
+#define __BEGIN_DECLS extern "C" {
+#define __END_DECLS }
+
+
+
+
+
+
+
+#define __bos(ptr) __builtin_object_size (ptr, __USE_FORTIFY_LEVEL > 1)
+#define __bos0(ptr) __builtin_object_size (ptr, 0)
+
+
+#define __warndecl(name,msg) extern void name (void) __attribute__((__warning__ (msg)))
+
+#define __warnattr(msg) __attribute__((__warning__ (msg)))
+#define __errordecl(name,msg) extern void name (void) __attribute__((__error__ (msg)))
+# 148 "/usr/include/sys/cdefs.h" 3 4
+#define __flexarr []
+#define __glibc_c99_flexarr_available 1
+# 174 "/usr/include/sys/cdefs.h" 3 4
+#define __REDIRECT(name,proto,alias) name proto __asm__ (__ASMNAME (#alias))
+
+#define __REDIRECT_NTH(name,proto,alias) name proto __THROW __asm__ (__ASMNAME (#alias))
+
+#define __REDIRECT_NTHNL(name,proto,alias) name proto __THROWNL __asm__ (__ASMNAME (#alias))
+
+
+
+
+
+
+
+#define __ASMNAME(cname) __ASMNAME2 (__USER_LABEL_PREFIX__, cname)
+#define __ASMNAME2(prefix,cname) __STRING (prefix) cname
+# 208 "/usr/include/sys/cdefs.h" 3 4
+#define __attribute_malloc__ __attribute__ ((__malloc__))
+
+
+
+
+
+
+
+#define __attribute_alloc_size__(params) __attribute__ ((__alloc_size__ params))
+# 226 "/usr/include/sys/cdefs.h" 3 4
+#define __attribute_pure__ __attribute__ ((__pure__))
+
+
+
+
+
+
+#define __attribute_const__ __attribute__ ((__const__))
+# 242 "/usr/include/sys/cdefs.h" 3 4
+#define __attribute_used__ __attribute__ ((__used__))
+#define __attribute_noinline__ __attribute__ ((__noinline__))
+
+
+
+
+
+
+
+#define __attribute_deprecated__ __attribute__ ((__deprecated__))
+# 261 "/usr/include/sys/cdefs.h" 3 4
+#define __attribute_deprecated_msg__(msg) __attribute__ ((__deprecated__ (msg)))
+# 274 "/usr/include/sys/cdefs.h" 3 4
+#define __attribute_format_arg__(x) __attribute__ ((__format_arg__ (x)))
+# 284 "/usr/include/sys/cdefs.h" 3 4
+#define __attribute_format_strfmon__(a,b) __attribute__ ((__format__ (__strfmon__, a, b)))
+# 293 "/usr/include/sys/cdefs.h" 3 4
+#define __nonnull(params) __attribute__ ((__nonnull__ params))
+
+
+
+
+
+
+
+#define __attribute_warn_unused_result__ __attribute__ ((__warn_unused_result__))
+# 310 "/usr/include/sys/cdefs.h" 3 4
+#define __wur 
+
+
+
+
+
+
+
+#undef __always_inline
+#define __always_inline __inline __attribute__ ((__always_inline__))
+# 328 "/usr/include/sys/cdefs.h" 3 4
+#define __attribute_artificial__ __attribute__ ((__artificial__))
+# 346 "/usr/include/sys/cdefs.h" 3 4
+#define __extern_inline extern __inline __attribute__ ((__gnu_inline__))
+#define __extern_always_inline extern __always_inline __attribute__ ((__gnu_inline__))
+# 356 "/usr/include/sys/cdefs.h" 3 4
+#define __fortify_function __extern_always_inline __attribute_artificial__
+
+
+
+
+
+#define __va_arg_pack() __builtin_va_arg_pack ()
+#define __va_arg_pack_len() __builtin_va_arg_pack_len ()
+# 390 "/usr/include/sys/cdefs.h" 3 4
+#define __restrict_arr 
+# 402 "/usr/include/sys/cdefs.h" 3 4
+#define __glibc_unlikely(cond) __builtin_expect ((cond), 0)
+#define __glibc_likely(cond) __builtin_expect ((cond), 1)
+
+
+
+
+
+
+#define __glibc_has_attribute(attr) __has_attribute (attr)
+# 429 "/usr/include/sys/cdefs.h" 3 4
+#define __attribute_nonstring__ __attribute__ ((__nonstring__))
+
+
+
+
+
+#undef __attribute_copy__
+
+
+
+#define __attribute_copy__(arg) __attribute__ ((__copy__ (arg)))
+# 452 "/usr/include/sys/cdefs.h" 3 4
+# 1 "/usr/include/bits/wordsize.h" 1 3 4
+
+
+
+#define __WORDSIZE 64
+
+
+
+
+
+
+
+#define __WORDSIZE_TIME64_COMPAT32 1
+
+#define __SYSCALL_WORDSIZE 64
+# 453 "/usr/include/sys/cdefs.h" 2 3 4
+# 1 "/usr/include/bits/long-double.h" 1 3 4
+# 21 "/usr/include/bits/long-double.h" 3 4
+#define __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI 0
+# 454 "/usr/include/sys/cdefs.h" 2 3 4
+# 508 "/usr/include/sys/cdefs.h" 3 4
+#define __LDBL_REDIR1(name,proto,alias) name proto
+#define __LDBL_REDIR(name,proto) name proto
+#define __LDBL_REDIR1_NTH(name,proto,alias) name proto __THROW
+#define __LDBL_REDIR_NTH(name,proto) name proto __THROW
+#define __LDBL_REDIR2_DECL(name) 
+#define __LDBL_REDIR_DECL(name) 
+
+#define __REDIRECT_LDBL(name,proto,alias) __REDIRECT (name, proto, alias)
+#define __REDIRECT_NTH_LDBL(name,proto,alias) __REDIRECT_NTH (name, proto, alias)
+# 527 "/usr/include/sys/cdefs.h" 3 4
+#define __glibc_macro_warning1(message) _Pragma (#message)
+#define __glibc_macro_warning(message) __glibc_macro_warning1 (GCC warning message)
+# 548 "/usr/include/sys/cdefs.h" 3 4
+#define __HAVE_GENERIC_SELECTION 0
+# 557 "/usr/include/sys/cdefs.h" 3 4
+#define __attr_access(x) __attribute__ ((__access__ x))
+# 466 "/usr/include/features.h" 2 3 4
+# 489 "/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
+# 10 "/usr/include/gnu/stubs-64.h" 3 4
+#define __stub___compat_bdflush 
+#define __stub_chflags 
+#define __stub_fchflags 
+#define __stub_gtty 
+#define __stub_revoke 
+#define __stub_setlogin 
+#define __stub_sigreturn 
+#define __stub_stty 
+# 11 "/usr/include/gnu/stubs.h" 2 3 4
+# 490 "/usr/include/features.h" 2 3 4
+# 40 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/os_defines.h" 2 3
+
+
+
+
+
+#undef _GLIBCXX_HAVE_GETS
+
+
+
+
+#define _GLIBCXX_NO_OBSOLETE_ISINF_ISNAN_DYNAMIC __GLIBC_PREREQ(2,23)
+# 519 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++config.h" 2 3
+
+
+# 1 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/cpu_defines.h" 1 3
+# 31 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/cpu_defines.h" 3
+#define _GLIBCXX_CPU_DEFINES 1
+# 522 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++config.h" 2 3
+
+
+
+
+#define _GLIBCXX_PSEUDO_VISIBILITY(V) 
+
+
+
+
+
+
+#define _GLIBCXX_WEAK_DEFINITION 
+
+
+
+
+
+
+
+#define _GLIBCXX_USE_WEAK_REF __GXX_WEAK__
+# 554 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++config.h" 3
+#define _GLIBCXX_TXN_SAFE 
+#define _GLIBCXX_TXN_SAFE_DYN 
+
+
+
+
+#define _GLIBCXX_USE_STD_SPEC_FUNCS 1
+# 573 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++config.h" 3
+#define _GLIBCXX_FAST_MATH 0
+
+
+
+
+
+
+#define __N(msgid) (msgid)
+
+
+#undef min
+#undef max
+
+
+
+
+
+#define _GLIBCXX_USE_C99_MATH _GLIBCXX11_USE_C99_MATH
+
+
+#define _GLIBCXX_USE_C99_COMPLEX _GLIBCXX11_USE_C99_COMPLEX
+
+
+#define _GLIBCXX_USE_C99_STDIO _GLIBCXX11_USE_C99_STDIO
+
+
+#define _GLIBCXX_USE_C99_STDLIB _GLIBCXX11_USE_C99_STDLIB
+
+
+#define _GLIBCXX_USE_C99_WCHAR _GLIBCXX11_USE_C99_WCHAR
+# 635 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++config.h" 3
+#define _GLIBCXX_USE_FLOAT128 1
+
+
+
+
+#define _GLIBCXX_HAVE_BUILTIN_HAS_UNIQ_OBJ_REP 1
+#define _GLIBCXX_HAVE_BUILTIN_IS_AGGREGATE 1
+#define _GLIBCXX_HAVE_BUILTIN_LAUNDER 1
+#define _GLIBCXX_BUILTIN_IS_SAME_AS(T,U) __is_same_as(T, U)
+
+#define _GLIBCXX_HAVE_BUILTIN_IS_CONSTANT_EVALUATED 1
+# 676 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++config.h" 3
+#define _GLIBCXX_USE_TBB_PAR_BACKEND __has_include(<tbb/tbb.h>)
+
+
+
+#define _PSTL_PAR_BACKEND_TBB 
+
+
+
+
+#define _PSTL_ASSERT(_Condition) __glibcxx_assert(_Condition)
+#define _PSTL_ASSERT_MSG(_Condition,_Message) __glibcxx_assert(_Condition)
+
+# 1 "/usr/include/c++/10.2.0/pstl/pstl_config.h" 1 3
+# 11 "/usr/include/c++/10.2.0/pstl/pstl_config.h" 3
+#define _PSTL_CONFIG_H 
+
+
+#define _PSTL_VERSION 9000
+#define _PSTL_VERSION_MAJOR (_PSTL_VERSION / 1000)
+#define _PSTL_VERSION_MINOR ((_PSTL_VERSION % 1000) / 10)
+#define _PSTL_VERSION_PATCH (_PSTL_VERSION % 10)
+# 29 "/usr/include/c++/10.2.0/pstl/pstl_config.h" 3
+#define _PSTL_USAGE_WARNINGS 0
+
+
+
+
+
+
+#define _PSTL_PRAGMA(x) _Pragma(#x)
+
+
+#define _PSTL_STRING_AUX(x) #x
+#define _PSTL_STRING(x) _PSTL_STRING_AUX(x)
+#define _PSTL_STRING_CONCAT(x,y) x #y
+
+
+
+#define _PSTL_GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
+# 54 "/usr/include/c++/10.2.0/pstl/pstl_config.h" 3
+#define _PSTL_PRAGMA_SIMD _PSTL_PRAGMA(omp simd)
+#define _PSTL_PRAGMA_DECLARE_SIMD _PSTL_PRAGMA(omp declare simd)
+#define _PSTL_PRAGMA_SIMD_REDUCTION(PRM) _PSTL_PRAGMA(omp simd reduction(PRM))
+# 70 "/usr/include/c++/10.2.0/pstl/pstl_config.h" 3
+#define _PSTL_PRAGMA_FORCEINLINE 
+
+
+
+#define _PSTL_PRAGMA_SIMD_SCAN(PRM) _PSTL_PRAGMA(omp simd reduction(inscan, PRM))
+#define _PSTL_PRAGMA_SIMD_INCLUSIVE_SCAN(PRM) _PSTL_PRAGMA(omp scan inclusive(PRM))
+#define _PSTL_PRAGMA_SIMD_EXCLUSIVE_SCAN(PRM) _PSTL_PRAGMA(omp scan exclusive(PRM))
+
+
+
+
+
+
+
+#define _PSTL_CPP17_EXECUTION_POLICIES_PRESENT (_MSC_VER >= 1912)
+
+#define _PSTL_CPP14_2RANGE_MISMATCH_EQUAL_PRESENT (_MSC_VER >= 1900 || __cplusplus >= 201300L || __cpp_lib_robust_nonmodifying_seq_ops == 201304)
+
+#define _PSTL_CPP14_MAKE_REVERSE_ITERATOR_PRESENT (_MSC_VER >= 1900 || __cplusplus >= 201402L || __cpp_lib_make_reverse_iterator == 201402)
+
+#define _PSTL_CPP14_INTEGER_SEQUENCE_PRESENT (_MSC_VER >= 1900 || __cplusplus >= 201402L)
+#define _PSTL_CPP14_VARIABLE_TEMPLATES_PRESENT (!__INTEL_COMPILER || __INTEL_COMPILER >= 1700) && (_MSC_FULL_VER >= 190023918 || __cplusplus >= 201402L)
+
+
+#define _PSTL_EARLYEXIT_PRESENT (__INTEL_COMPILER >= 1800)
+#define _PSTL_MONOTONIC_PRESENT (__INTEL_COMPILER >= 1800)
+
+
+#define _PSTL_UDR_PRESENT 1
+
+
+
+
+
+#define _PSTL_UDS_PRESENT 1
+
+
+
+
+
+
+
+#define _PSTL_PRAGMA_SIMD_EARLYEXIT 
+
+
+
+
+
+
+#define _PSTL_PRAGMA_SIMD_ORDERED_MONOTONIC(PRM) 
+#define _PSTL_PRAGMA_SIMD_ORDERED_MONOTONIC_2ARGS(PRM1,PRM2) 
+# 130 "/usr/include/c++/10.2.0/pstl/pstl_config.h" 3
+#define _PSTL_PRAGMA_DECLARE_REDUCTION(NAME,OP) _PSTL_PRAGMA(omp declare reduction(NAME:OP : omp_out(omp_in)) initializer(omp_priv = omp_orig))
+
+
+
+
+
+#define _PSTL_PRAGMA_VECTOR_UNALIGNED 
+
+
+
+
+
+
+#define _PSTL_USE_NONTEMPORAL_STORES_IF_ALLOWED 
+
+
+
+
+
+#define _PSTL_PRAGMA_LOCATION " [Parallel STL message]: "
+
+
+#define _PSTL_PRAGMA_MESSAGE_IMPL(x) _PSTL_PRAGMA(message(_PSTL_STRING_CONCAT(_PSTL_PRAGMA_LOCATION, x)))
+
+
+
+
+
+#define _PSTL_PRAGMA_MESSAGE(x) 
+#define _PSTL_PRAGMA_MESSAGE_POLICIES(x) 
+
+
+
+#define _PSTL_CPP11_STD_ROTATE_BROKEN ((__GLIBCXX__ && __GLIBCXX__ < 20150716) || (_MSC_VER && _MSC_VER < 1800))
+
+#define _PSTL_ICC_18_OMP_SIMD_BROKEN (__INTEL_COMPILER == 1800)
+# 689 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++config.h" 2 3
+# 697 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++config.h" 3
+#define _GLIBCXX_HAVE_ACOSF 1
+
+
+#define _GLIBCXX_HAVE_ACOSL 1
+
+
+#define _GLIBCXX_HAVE_ALIGNED_ALLOC 1
+
+
+#define _GLIBCXX_HAVE_ARPA_INET_H 1
+
+
+#define _GLIBCXX_HAVE_ASINF 1
+
+
+#define _GLIBCXX_HAVE_ASINL 1
+
+
+#define _GLIBCXX_HAVE_AS_SYMVER_DIRECTIVE 1
+
+
+#define _GLIBCXX_HAVE_ATAN2F 1
+
+
+#define _GLIBCXX_HAVE_ATAN2L 1
+
+
+#define _GLIBCXX_HAVE_ATANF 1
+
+
+#define _GLIBCXX_HAVE_ATANL 1
+
+
+#define _GLIBCXX_HAVE_ATOMIC_LOCK_POLICY 1
+
+
+#define _GLIBCXX_HAVE_AT_QUICK_EXIT 1
+
+
+
+
+
+#define _GLIBCXX_HAVE_CEILF 1
+
+
+#define _GLIBCXX_HAVE_CEILL 1
+
+
+#define _GLIBCXX_HAVE_COMPLEX_H 1
+
+
+#define _GLIBCXX_HAVE_COSF 1
+
+
+#define _GLIBCXX_HAVE_COSHF 1
+
+
+#define _GLIBCXX_HAVE_COSHL 1
+
+
+#define _GLIBCXX_HAVE_COSL 1
+
+
+#define _GLIBCXX_HAVE_DIRENT_H 1
+
+
+#define _GLIBCXX_HAVE_DLFCN_H 1
+
+
+#define _GLIBCXX_HAVE_EBADMSG 1
+
+
+#define _GLIBCXX_HAVE_ECANCELED 1
+
+
+#define _GLIBCXX_HAVE_ECHILD 1
+
+
+#define _GLIBCXX_HAVE_EIDRM 1
+
+
+#define _GLIBCXX_HAVE_ENDIAN_H 1
+
+
+#define _GLIBCXX_HAVE_ENODATA 1
+
+
+#define _GLIBCXX_HAVE_ENOLINK 1
+
+
+#define _GLIBCXX_HAVE_ENOSPC 1
+
+
+#define _GLIBCXX_HAVE_ENOSR 1
+
+
+#define _GLIBCXX_HAVE_ENOSTR 1
+
+
+#define _GLIBCXX_HAVE_ENOTRECOVERABLE 1
+
+
+#define _GLIBCXX_HAVE_ENOTSUP 1
+
+
+#define _GLIBCXX_HAVE_EOVERFLOW 1
+
+
+#define _GLIBCXX_HAVE_EOWNERDEAD 1
+
+
+#define _GLIBCXX_HAVE_EPERM 1
+
+
+#define _GLIBCXX_HAVE_EPROTO 1
+
+
+#define _GLIBCXX_HAVE_ETIME 1
+
+
+#define _GLIBCXX_HAVE_ETIMEDOUT 1
+
+
+#define _GLIBCXX_HAVE_ETXTBSY 1
+
+
+#define _GLIBCXX_HAVE_EWOULDBLOCK 1
+
+
+#define _GLIBCXX_HAVE_EXCEPTION_PTR_SINCE_GCC46 1
+
+
+#define _GLIBCXX_HAVE_EXECINFO_H 1
+
+
+#define _GLIBCXX_HAVE_EXPF 1
+
+
+#define _GLIBCXX_HAVE_EXPL 1
+
+
+#define _GLIBCXX_HAVE_FABSF 1
+
+
+#define _GLIBCXX_HAVE_FABSL 1
+
+
+#define _GLIBCXX_HAVE_FCNTL_H 1
+
+
+#define _GLIBCXX_HAVE_FENV_H 1
+
+
+#define _GLIBCXX_HAVE_FINITE 1
+
+
+#define _GLIBCXX_HAVE_FINITEF 1
+
+
+#define _GLIBCXX_HAVE_FINITEL 1
+
+
+#define _GLIBCXX_HAVE_FLOAT_H 1
+
+
+#define _GLIBCXX_HAVE_FLOORF 1
+
+
+#define _GLIBCXX_HAVE_FLOORL 1
+
+
+#define _GLIBCXX_HAVE_FMODF 1
+
+
+#define _GLIBCXX_HAVE_FMODL 1
+# 880 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++config.h" 3
+#define _GLIBCXX_HAVE_FREXPF 1
+
+
+#define _GLIBCXX_HAVE_FREXPL 1
+
+
+#define _GLIBCXX_HAVE_GETIPINFO 1
+
+
+#define _GLIBCXX_HAVE_GETS 1
+
+
+#define _GLIBCXX_HAVE_HYPOT 1
+
+
+#define _GLIBCXX_HAVE_HYPOTF 1
+
+
+#define _GLIBCXX_HAVE_HYPOTL 1
+
+
+#define _GLIBCXX_HAVE_ICONV 1
+
+
+
+
+
+#define _GLIBCXX_HAVE_INT64_T 1
+
+
+#define _GLIBCXX_HAVE_INT64_T_LONG 1
+
+
+
+
+
+#define _GLIBCXX_HAVE_INTTYPES_H 1
+
+
+
+
+
+#define _GLIBCXX_HAVE_ISINFF 1
+
+
+#define _GLIBCXX_HAVE_ISINFL 1
+
+
+
+
+
+#define _GLIBCXX_HAVE_ISNANF 1
+
+
+#define _GLIBCXX_HAVE_ISNANL 1
+
+
+#define _GLIBCXX_HAVE_ISWBLANK 1
+
+
+#define _GLIBCXX_HAVE_LC_MESSAGES 1
+
+
+#define _GLIBCXX_HAVE_LDEXPF 1
+
+
+#define _GLIBCXX_HAVE_LDEXPL 1
+
+
+#define _GLIBCXX_HAVE_LIBINTL_H 1
+
+
+#define _GLIBCXX_HAVE_LIMIT_AS 1
+
+
+#define _GLIBCXX_HAVE_LIMIT_DATA 1
+
+
+#define _GLIBCXX_HAVE_LIMIT_FSIZE 1
+
+
+#define _GLIBCXX_HAVE_LIMIT_RSS 1
+
+
+#define _GLIBCXX_HAVE_LIMIT_VMEM 0
+
+
+#define _GLIBCXX_HAVE_LINK 1
+
+
+#define _GLIBCXX_HAVE_LINUX_FUTEX 1
+
+
+#define _GLIBCXX_HAVE_LINUX_RANDOM_H 1
+
+
+#define _GLIBCXX_HAVE_LINUX_TYPES_H 1
+
+
+#define _GLIBCXX_HAVE_LOCALE_H 1
+
+
+#define _GLIBCXX_HAVE_LOG10F 1
+
+
+#define _GLIBCXX_HAVE_LOG10L 1
+
+
+#define _GLIBCXX_HAVE_LOGF 1
+
+
+#define _GLIBCXX_HAVE_LOGL 1
+# 1000 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++config.h" 3
+#define _GLIBCXX_HAVE_MBSTATE_T 1
+
+
+#define _GLIBCXX_HAVE_MEMALIGN 1
+
+
+#define _GLIBCXX_HAVE_MEMORY_H 1
+
+
+#define _GLIBCXX_HAVE_MODF 1
+
+
+#define _GLIBCXX_HAVE_MODFF 1
+
+
+#define _GLIBCXX_HAVE_MODFL 1
+
+
+
+
+
+#define _GLIBCXX_HAVE_NETDB_H 1
+
+
+#define _GLIBCXX_HAVE_NETINET_IN_H 1
+
+
+#define _GLIBCXX_HAVE_NETINET_TCP_H 1
+# 1036 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++config.h" 3
+#define _GLIBCXX_HAVE_POLL 1
+
+
+#define _GLIBCXX_HAVE_POLL_H 1
+
+
+#define _GLIBCXX_HAVE_POSIX_MEMALIGN 1
+
+
+#define _GLIBCXX_HAVE_POWF 1
+
+
+#define _GLIBCXX_HAVE_POWL 1
+
+
+
+
+
+#define _GLIBCXX_HAVE_QUICK_EXIT 1
+
+
+#define _GLIBCXX_HAVE_READLINK 1
+
+
+#define _GLIBCXX_HAVE_SETENV 1
+
+
+#define _GLIBCXX_HAVE_SINCOS 1
+
+
+#define _GLIBCXX_HAVE_SINCOSF 1
+
+
+#define _GLIBCXX_HAVE_SINCOSL 1
+
+
+#define _GLIBCXX_HAVE_SINF 1
+
+
+#define _GLIBCXX_HAVE_SINHF 1
+
+
+#define _GLIBCXX_HAVE_SINHL 1
+
+
+#define _GLIBCXX_HAVE_SINL 1
+
+
+
+
+
+#define _GLIBCXX_HAVE_SOCKATMARK 1
+
+
+#define _GLIBCXX_HAVE_SQRTF 1
+
+
+#define _GLIBCXX_HAVE_SQRTL 1
+
+
+#define _GLIBCXX_HAVE_STDALIGN_H 1
+
+
+#define _GLIBCXX_HAVE_STDBOOL_H 1
+
+
+#define _GLIBCXX_HAVE_STDINT_H 1
+
+
+#define _GLIBCXX_HAVE_STDLIB_H 1
+
+
+#define _GLIBCXX_HAVE_STRERROR_L 1
+
+
+#define _GLIBCXX_HAVE_STRERROR_R 1
+
+
+#define _GLIBCXX_HAVE_STRINGS_H 1
+
+
+#define _GLIBCXX_HAVE_STRING_H 1
+
+
+#define _GLIBCXX_HAVE_STRTOF 1
+
+
+#define _GLIBCXX_HAVE_STRTOLD 1
+
+
+#define _GLIBCXX_HAVE_STRUCT_DIRENT_D_TYPE 1
+
+
+#define _GLIBCXX_HAVE_STRXFRM_L 1
+
+
+#define _GLIBCXX_HAVE_SYMLINK 1
+
+
+
+#define _GLIBCXX_HAVE_SYMVER_SYMBOL_RENAMING_RUNTIME_SUPPORT 1
+
+
+
+
+
+#define _GLIBCXX_HAVE_SYS_IOCTL_H 1
+
+
+#define _GLIBCXX_HAVE_SYS_IPC_H 1
+# 1154 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++config.h" 3
+#define _GLIBCXX_HAVE_SYS_PARAM_H 1
+
+
+#define _GLIBCXX_HAVE_SYS_RESOURCE_H 1
+
+
+#define _GLIBCXX_HAVE_SYS_SDT_H 1
+
+
+#define _GLIBCXX_HAVE_SYS_SEM_H 1
+
+
+#define _GLIBCXX_HAVE_SYS_SOCKET_H 1
+
+
+#define _GLIBCXX_HAVE_SYS_STATVFS_H 1
+
+
+#define _GLIBCXX_HAVE_SYS_STAT_H 1
+
+
+#define _GLIBCXX_HAVE_SYS_SYSINFO_H 1
+
+
+#define _GLIBCXX_HAVE_SYS_TIME_H 1
+
+
+#define _GLIBCXX_HAVE_SYS_TYPES_H 1
+
+
+#define _GLIBCXX_HAVE_SYS_UIO_H 1
+
+
+
+
+
+#define _GLIBCXX_HAVE_S_ISREG 1
+
+
+#define _GLIBCXX_HAVE_TANF 1
+
+
+#define _GLIBCXX_HAVE_TANHF 1
+
+
+#define _GLIBCXX_HAVE_TANHL 1
+
+
+#define _GLIBCXX_HAVE_TANL 1
+
+
+#define _GLIBCXX_HAVE_TGMATH_H 1
+
+
+#define _GLIBCXX_HAVE_TIMESPEC_GET 1
+
+
+#define _GLIBCXX_HAVE_TLS 1
+
+
+#define _GLIBCXX_HAVE_TRUNCATE 1
+
+
+#define _GLIBCXX_HAVE_UCHAR_H 1
+
+
+#define _GLIBCXX_HAVE_UNISTD_H 1
+
+
+
+
+
+#define _GLIBCXX_HAVE_UTIME_H 1
+
+
+#define _GLIBCXX_HAVE_VFWSCANF 1
+
+
+#define _GLIBCXX_HAVE_VSWSCANF 1
+
+
+#define _GLIBCXX_HAVE_VWSCANF 1
+
+
+#define _GLIBCXX_HAVE_WCHAR_H 1
+
+
+#define _GLIBCXX_HAVE_WCSTOF 1
+
+
+#define _GLIBCXX_HAVE_WCTYPE_H 1
+
+
+
+
+
+#define _GLIBCXX_HAVE_WRITEV 1
+# 1448 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++config.h" 3
+#define _GLIBCXX_HAVE___CXA_THREAD_ATEXIT_IMPL 1
+
+
+#define _GLIBCXX_ICONV_CONST 
+
+
+
+#define LT_OBJDIR ".libs/"
+
+
+
+
+
+#define _GLIBCXX_PACKAGE_BUGREPORT ""
+
+
+#define _GLIBCXX_PACKAGE_NAME "package-unused"
+
+
+#define _GLIBCXX_PACKAGE_STRING "package-unused version-unused"
+
+
+#define _GLIBCXX_PACKAGE_TARNAME "libstdc++"
+
+
+#define _GLIBCXX_PACKAGE_URL ""
+
+
+#define _GLIBCXX_PACKAGE__GLIBCXX_VERSION "version-unused"
+# 1494 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++config.h" 3
+#define STDC_HEADERS 1
+
+
+
+
+
+
+#define _GLIBCXX_DARWIN_USE_64_BIT_INODE 1
+# 1510 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++config.h" 3
+#define _GLIBCXX11_USE_C99_COMPLEX 1
+
+
+
+#define _GLIBCXX11_USE_C99_MATH 1
+
+
+
+#define _GLIBCXX11_USE_C99_STDIO 1
+
+
+
+#define _GLIBCXX11_USE_C99_STDLIB 1
+
+
+
+#define _GLIBCXX11_USE_C99_WCHAR 1
+
+
+
+
+#define _GLIBCXX98_USE_C99_COMPLEX 1
+
+
+
+#define _GLIBCXX98_USE_C99_MATH 1
+
+
+
+#define _GLIBCXX98_USE_C99_STDIO 1
+
+
+
+#define _GLIBCXX98_USE_C99_STDLIB 1
+
+
+
+#define _GLIBCXX98_USE_C99_WCHAR 1
+
+
+#define _GLIBCXX_ATOMIC_BUILTINS 1
+
+
+
+
+
+
+#define _GLIBCXX_FULLY_DYNAMIC_STRING 0
+
+
+#define _GLIBCXX_HAS_GTHREADS 1
+
+
+#define _GLIBCXX_HOSTED 1
+
+
+
+
+#define _GLIBCXX_MANGLE_SIZE_T m
+# 1577 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++config.h" 3
+#define _GLIBCXX_RES_LIMITS 1
+
+
+
+
+
+#define _GLIBCXX_STDIO_EOF -1
+
+
+#define _GLIBCXX_STDIO_SEEK_CUR 1
+
+
+#define _GLIBCXX_STDIO_SEEK_END 2
+
+
+#define _GLIBCXX_SYMVER 1
+
+
+
+
+
+#define _GLIBCXX_SYMVER_GNU 1
+# 1608 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++config.h" 3
+#define _GLIBCXX_USE_C11_UCHAR_CXX11 1
+
+
+
+#define _GLIBCXX_USE_C99 1
+
+
+
+
+#define _GLIBCXX_USE_C99_COMPLEX_TR1 1
+
+
+
+#define _GLIBCXX_USE_C99_CTYPE_TR1 1
+
+
+
+#define _GLIBCXX_USE_C99_FENV_TR1 1
+
+
+
+#define _GLIBCXX_USE_C99_INTTYPES_TR1 1
+
+
+
+#define _GLIBCXX_USE_C99_INTTYPES_WCHAR_T_TR1 1
+
+
+
+#define _GLIBCXX_USE_C99_MATH_TR1 1
+
+
+
+#define _GLIBCXX_USE_C99_STDINT_TR1 1
+
+
+
+
+
+
+#define _GLIBCXX_USE_CLOCK_MONOTONIC 1
+
+
+#define _GLIBCXX_USE_CLOCK_REALTIME 1
+
+
+
+#define _GLIBCXX_USE_DECIMAL_FLOAT 1
+
+
+
+#define _GLIBCXX_USE_DEV_RANDOM 1
+
+
+#define _GLIBCXX_USE_FCHMOD 1
+
+
+#define _GLIBCXX_USE_FCHMODAT 1
+
+
+#define _GLIBCXX_USE_GETTIMEOFDAY 1
+
+
+#define _GLIBCXX_USE_GET_NPROCS 1
+
+
+#define _GLIBCXX_USE_INT128 1
+
+
+#define _GLIBCXX_USE_LFS 1
+
+
+#define _GLIBCXX_USE_LONG_LONG 1
+
+
+#define _GLIBCXX_USE_LSTAT 1
+
+
+#define _GLIBCXX_USE_NANOSLEEP 1
+
+
+#define _GLIBCXX_USE_NLS 1
+
+
+
+
+
+#define _GLIBCXX_USE_PTHREAD_COND_CLOCKWAIT 1
+
+
+#define _GLIBCXX_USE_PTHREAD_MUTEX_CLOCKLOCK 1
+
+
+
+#define _GLIBCXX_USE_PTHREAD_RWLOCK_CLOCKLOCK 1
+
+
+#define _GLIBCXX_USE_PTHREAD_RWLOCK_T 1
+
+
+
+#define _GLIBCXX_USE_RANDOM_TR1 1
+
+
+#define _GLIBCXX_USE_REALPATH 1
+
+
+#define _GLIBCXX_USE_SCHED_YIELD 1
+
+
+#define _GLIBCXX_USE_SC_NPROCESSORS_ONLN 1
+
+
+
+
+
+#define _GLIBCXX_USE_SENDFILE 1
+
+
+#define _GLIBCXX_USE_ST_MTIM 1
+
+
+
+
+
+#define _GLIBCXX_USE_TMPNAM 1
+
+
+#define _GLIBCXX_USE_UTIME 1
+
+
+
+#define _GLIBCXX_USE_UTIMENSAT 1
+
+
+#define _GLIBCXX_USE_WCHAR_T 1
+
+
+#define _GLIBCXX_VERBOSE 1
+
+
+#define _GLIBCXX_X86_RDRAND 1
+
+
+#define _GLIBCXX_X86_RDSEED 1
+
+
+#define _GTHREAD_USE_MUTEX_TIMEDLOCK 1
+# 50 "/usr/include/c++/10.2.0/cstddef" 2 3
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 1 3 4
+# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#define _STDDEF_H 
+#define _STDDEF_H_ 
+
+#define _ANSI_STDDEF_H 
+# 131 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#define _PTRDIFF_T 
+#define _T_PTRDIFF_ 
+#define _T_PTRDIFF 
+#define __PTRDIFF_T 
+#define _PTRDIFF_T_ 
+#define _BSD_PTRDIFF_T_ 
+#define ___int_ptrdiff_t_h 
+#define _GCC_PTRDIFF_T 
+#define _PTRDIFF_T_DECLARED 
+
+
+
+typedef long int ptrdiff_t;
+# 155 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef __need_ptrdiff_t
+# 181 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#define __size_t__ 
+#define __SIZE_T__ 
+#define _SIZE_T 
+#define _SYS_SIZE_T_H 
+#define _T_SIZE_ 
+#define _T_SIZE 
+#define __SIZE_T 
+#define _SIZE_T_ 
+#define _BSD_SIZE_T_ 
+#define _SIZE_T_DEFINED_ 
+#define _SIZE_T_DEFINED 
+#define _BSD_SIZE_T_DEFINED_ 
+#define _SIZE_T_DECLARED 
+#define ___int_size_t_h 
+#define _GCC_SIZE_T 
+#define _SIZET_ 
+
+
+
+
+
+
+#define __size_t 
+
+
+
+
+
+typedef long unsigned int size_t;
+# 231 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef __need_size_t
+# 260 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#define __wchar_t__ 
+#define __WCHAR_T__ 
+#define _WCHAR_T 
+#define _T_WCHAR_ 
+#define _T_WCHAR 
+#define __WCHAR_T 
+#define _WCHAR_T_ 
+#define _BSD_WCHAR_T_ 
+#define _WCHAR_T_DEFINED_ 
+#define _WCHAR_T_DEFINED 
+#define _WCHAR_T_H 
+#define ___int_wchar_t_h 
+#define __INT_WCHAR_T_H 
+#define _GCC_WCHAR_T 
+#define _WCHAR_T_DECLARED 
+# 287 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef _BSD_WCHAR_T_
+# 340 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef __need_wchar_t
+# 390 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef NULL
+
+#define NULL __null
+# 401 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef __need_NULL
+
+
+
+
+#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
+
+
+
+
+#define _GCC_MAX_ALIGN_T 
+
+
+
+typedef struct {
+  long long __max_align_ll __attribute__((__aligned__(__alignof__(long long))));
+  long double __max_align_ld __attribute__((__aligned__(__alignof__(long double))));
+# 426 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+} max_align_t;
+
+
+
+
+
+#define _GXX_NULLPTR_T 
+  typedef decltype(nullptr) nullptr_t;
+# 51 "/usr/include/c++/10.2.0/cstddef" 2 3
+
+extern "C++"
+{
+
+namespace std
+{
+
+  using ::max_align_t;
+}
+
+
+
+namespace std
+{
+
+#define __cpp_lib_byte 201603
+
+
+  enum class byte : unsigned char {};
+
+  template<typename _IntegerType> struct __byte_operand { };
+  template<> struct __byte_operand<bool> { using __type = byte; };
+  template<> struct __byte_operand<char> { using __type = byte; };
+  template<> struct __byte_operand<signed char> { using __type = byte; };
+  template<> struct __byte_operand<unsigned char> { using __type = byte; };
+
+  template<> struct __byte_operand<wchar_t> { using __type = byte; };
+
+
+
+
+  template<> struct __byte_operand<char16_t> { using __type = byte; };
+  template<> struct __byte_operand<char32_t> { using __type = byte; };
+  template<> struct __byte_operand<short> { using __type = byte; };
+  template<> struct __byte_operand<unsigned short> { using __type = byte; };
+  template<> struct __byte_operand<int> { using __type = byte; };
+  template<> struct __byte_operand<unsigned int> { using __type = byte; };
+  template<> struct __byte_operand<long> { using __type = byte; };
+  template<> struct __byte_operand<unsigned long> { using __type = byte; };
+  template<> struct __byte_operand<long long> { using __type = byte; };
+  template<> struct __byte_operand<unsigned long long> { using __type = byte; };
+# 110 "/usr/include/c++/10.2.0/cstddef" 3
+  template<typename _IntegerType>
+    struct __byte_operand<const _IntegerType>
+    : __byte_operand<_IntegerType> { };
+  template<typename _IntegerType>
+    struct __byte_operand<volatile _IntegerType>
+    : __byte_operand<_IntegerType> { };
+  template<typename _IntegerType>
+    struct __byte_operand<const volatile _IntegerType>
+    : __byte_operand<_IntegerType> { };
+
+  template<typename _IntegerType>
+    using __byte_op_t = typename __byte_operand<_IntegerType>::__type;
+
+  template<typename _IntegerType>
+    constexpr __byte_op_t<_IntegerType>
+    operator<<(byte __b, _IntegerType __shift) noexcept
+    { return (byte)(unsigned char)((unsigned)__b << __shift); }
+
+  template<typename _IntegerType>
+    constexpr __byte_op_t<_IntegerType>
+    operator>>(byte __b, _IntegerType __shift) noexcept
+    { return (byte)(unsigned char)((unsigned)__b >> __shift); }
+
+  constexpr byte
+  operator|(byte __l, byte __r) noexcept
+  { return (byte)(unsigned char)((unsigned)__l | (unsigned)__r); }
+
+  constexpr byte
+  operator&(byte __l, byte __r) noexcept
+  { return (byte)(unsigned char)((unsigned)__l & (unsigned)__r); }
+
+  constexpr byte
+  operator^(byte __l, byte __r) noexcept
+  { return (byte)(unsigned char)((unsigned)__l ^ (unsigned)__r); }
+
+  constexpr byte
+  operator~(byte __b) noexcept
+  { return (byte)(unsigned char)~(unsigned)__b; }
+
+  template<typename _IntegerType>
+    constexpr __byte_op_t<_IntegerType>&
+    operator<<=(byte& __b, _IntegerType __shift) noexcept
+    { return __b = __b << __shift; }
+
+  template<typename _IntegerType>
+    constexpr __byte_op_t<_IntegerType>&
+    operator>>=(byte& __b, _IntegerType __shift) noexcept
+    { return __b = __b >> __shift; }
+
+  constexpr byte&
+  operator|=(byte& __l, byte __r) noexcept
+  { return __l = __l | __r; }
+
+  constexpr byte&
+  operator&=(byte& __l, byte __r) noexcept
+  { return __l = __l & __r; }
+
+  constexpr byte&
+  operator^=(byte& __l, byte __r) noexcept
+  { return __l = __l ^ __r; }
+
+  template<typename _IntegerType>
+    constexpr _IntegerType
+    to_integer(__byte_op_t<_IntegerType> __b) noexcept
+    { return _IntegerType(__b); }
+
+
+}
+
+}
+# 166 "/usr/include/boost/config/compiler/gcc.hpp" 2 3 4
+# 179 "/usr/include/boost/config/compiler/gcc.hpp" 3 4
+#define BOOST_HAS_DECLTYPE 
+#define BOOST_HAS_RVALUE_REFS 
+#define BOOST_HAS_STATIC_ASSERT 
+#define BOOST_HAS_VARIADIC_TMPL 
+# 309 "/usr/include/boost/config/compiler/gcc.hpp" 3 4
+#define BOOST_FALLTHROUGH __attribute__((fallthrough))
+# 322 "/usr/include/boost/config/compiler/gcc.hpp" 3 4
+#define BOOST_ATTRIBUTE_UNUSED __attribute__((__unused__))
+
+
+
+#define BOOST_MAY_ALIAS __attribute__((__may_alias__))
+
+
+
+
+#define BOOST_UNREACHABLE_RETURN(x) __builtin_unreachable();
+
+
+
+#define BOOST_COMPILER "GNU C++ version " __VERSION__
+# 40 "/usr/include/boost/config.hpp" 2 3 4
+
+
+
+
+# 1 "/usr/include/boost/config/detail/select_stdlib_config.hpp" 1 3 4
+# 59 "/usr/include/boost/config/detail/select_stdlib_config.hpp" 3 4
+#define BOOST_STDLIB_CONFIG "boost/config/stdlib/libstdcpp3.hpp"
+# 45 "/usr/include/boost/config.hpp" 2 3 4
+
+
+
+# 1 "/usr/include/boost/config/stdlib/libstdcpp3.hpp" 1 3 4
+# 12 "/usr/include/boost/config/stdlib/libstdcpp3.hpp" 3 4
+#define BOOST_GNU_STDLIB 1
+
+
+#define BOOST_STDLIB "GNU libstdc++ version " BOOST_STRINGIZE(__GLIBCXX__)
+# 46 "/usr/include/boost/config/stdlib/libstdcpp3.hpp" 3 4
+#define BOOST_HAS_THREADS 
+# 78 "/usr/include/boost/config/stdlib/libstdcpp3.hpp" 3 4
+# 1 "/usr/include/unistd.h" 1 3 4
+# 23 "/usr/include/unistd.h" 3 4
+#define _UNISTD_H 1
+
+
+
+extern "C" {
+
+
+
+
+
+
+#define _POSIX_VERSION 200809L
+# 53 "/usr/include/unistd.h" 3 4
+#define __POSIX2_THIS_VERSION 200809L
+# 67 "/usr/include/unistd.h" 3 4
+#define _POSIX2_VERSION __POSIX2_THIS_VERSION
+
+
+#define _POSIX2_C_VERSION __POSIX2_THIS_VERSION
+
+
+
+#define _POSIX2_C_BIND __POSIX2_THIS_VERSION
+
+
+
+#define _POSIX2_C_DEV __POSIX2_THIS_VERSION
+
+
+
+#define _POSIX2_SW_DEV __POSIX2_THIS_VERSION
+
+
+
+#define _POSIX2_LOCALEDEF __POSIX2_THIS_VERSION
+
+
+
+#define _XOPEN_VERSION 700
+# 100 "/usr/include/unistd.h" 3 4
+#define _XOPEN_XCU_VERSION 4
+
+
+#define _XOPEN_XPG2 1
+#define _XOPEN_XPG3 1
+#define _XOPEN_XPG4 1
+
+
+#define _XOPEN_UNIX 1
+
+
+
+#define _XOPEN_ENH_I18N 1
+
+
+#define _XOPEN_LEGACY 1
+# 202 "/usr/include/unistd.h" 3 4
+# 1 "/usr/include/bits/posix_opt.h" 1 3 4
+# 20 "/usr/include/bits/posix_opt.h" 3 4
+#define _BITS_POSIX_OPT_H 1
+
+
+#define _POSIX_JOB_CONTROL 1
+
+
+#define _POSIX_SAVED_IDS 1
+
+
+
+
+
+#define _POSIX_PRIORITY_SCHEDULING 200809L
+
+
+#define _POSIX_SYNCHRONIZED_IO 200809L
+
+
+#define _POSIX_FSYNC 200809L
+
+
+#define _POSIX_MAPPED_FILES 200809L
+
+
+#define _POSIX_MEMLOCK 200809L
+
+
+#define _POSIX_MEMLOCK_RANGE 200809L
+
+
+#define _POSIX_MEMORY_PROTECTION 200809L
+
+
+#define _POSIX_CHOWN_RESTRICTED 0
+
+
+
+#define _POSIX_VDISABLE '\0'
+
+
+#define _POSIX_NO_TRUNC 1
+
+
+#define _XOPEN_REALTIME 1
+
+
+#define _XOPEN_REALTIME_THREADS 1
+
+
+#define _XOPEN_SHM 1
+
+
+#define _POSIX_THREADS 200809L
+
+
+#define _POSIX_REENTRANT_FUNCTIONS 1
+#define _POSIX_THREAD_SAFE_FUNCTIONS 200809L
+
+
+#define _POSIX_THREAD_PRIORITY_SCHEDULING 200809L
+
+
+#define _POSIX_THREAD_ATTR_STACKSIZE 200809L
+
+
+#define _POSIX_THREAD_ATTR_STACKADDR 200809L
+
+
+#define _POSIX_THREAD_PRIO_INHERIT 200809L
+
+
+
+#define _POSIX_THREAD_PRIO_PROTECT 200809L
+
+
+
+#define _POSIX_THREAD_ROBUST_PRIO_INHERIT 200809L
+
+
+#define _POSIX_THREAD_ROBUST_PRIO_PROTECT -1
+
+
+
+#define _POSIX_SEMAPHORES 200809L
+
+
+#define _POSIX_REALTIME_SIGNALS 200809L
+
+
+#define _POSIX_ASYNCHRONOUS_IO 200809L
+#define _POSIX_ASYNC_IO 1
+
+#define _LFS_ASYNCHRONOUS_IO 1
+
+#define _POSIX_PRIORITIZED_IO 200809L
+
+
+#define _LFS64_ASYNCHRONOUS_IO 1
+
+
+#define _LFS_LARGEFILE 1
+#define _LFS64_LARGEFILE 1
+#define _LFS64_STDIO 1
+
+
+#define _POSIX_SHARED_MEMORY_OBJECTS 200809L
+
+
+#define _POSIX_CPUTIME 0
+
+
+#define _POSIX_THREAD_CPUTIME 0
+
+
+#define _POSIX_REGEXP 1
+
+
+#define _POSIX_READER_WRITER_LOCKS 200809L
+
+
+#define _POSIX_SHELL 1
+
+
+#define _POSIX_TIMEOUTS 200809L
+
+
+#define _POSIX_SPIN_LOCKS 200809L
+
+
+#define _POSIX_SPAWN 200809L
+
+
+#define _POSIX_TIMERS 200809L
+
+
+#define _POSIX_BARRIERS 200809L
+
+
+#define _POSIX_MESSAGE_PASSING 200809L
+
+
+#define _POSIX_THREAD_PROCESS_SHARED 200809L
+
+
+#define _POSIX_MONOTONIC_CLOCK 0
+
+
+#define _POSIX_CLOCK_SELECTION 200809L
+
+
+#define _POSIX_ADVISORY_INFO 200809L
+
+
+#define _POSIX_IPV6 200809L
+
+
+#define _POSIX_RAW_SOCKETS 200809L
+
+
+#define _POSIX2_CHAR_TERM 200809L
+
+
+#define _POSIX_SPORADIC_SERVER -1
+#define _POSIX_THREAD_SPORADIC_SERVER -1
+
+
+#define _POSIX_TRACE -1
+#define _POSIX_TRACE_EVENT_FILTER -1
+#define _POSIX_TRACE_INHERIT -1
+#define _POSIX_TRACE_LOG -1
+
+
+#define _POSIX_TYPED_MEMORY_OBJECTS -1
+# 203 "/usr/include/unistd.h" 2 3 4
+
+
+
+# 1 "/usr/include/bits/environments.h" 1 3 4
+# 22 "/usr/include/bits/environments.h" 3 4
+# 1 "/usr/include/bits/wordsize.h" 1 3 4
+
+
+
+#define __WORDSIZE 64
+
+
+
+
+
+
+
+#define __WORDSIZE_TIME64_COMPAT32 1
+
+#define __SYSCALL_WORDSIZE 64
+# 23 "/usr/include/bits/environments.h" 2 3 4
+# 56 "/usr/include/bits/environments.h" 3 4
+#define _POSIX_V7_LPBIG_OFFBIG -1
+#define _POSIX_V6_LPBIG_OFFBIG -1
+#define _XBS5_LPBIG_OFFBIG -1
+
+
+#define _POSIX_V7_LP64_OFF64 1
+#define _POSIX_V6_LP64_OFF64 1
+#define _XBS5_LP64_OFF64 1
+# 95 "/usr/include/bits/environments.h" 3 4
+#define __ILP32_OFF32_CFLAGS "-m32"
+#define __ILP32_OFF32_LDFLAGS "-m32"
+
+
+
+
+#define __ILP32_OFFBIG_CFLAGS "-m32 -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64"
+#define __ILP32_OFFBIG_LDFLAGS "-m32"
+
+#define __LP64_OFF64_CFLAGS "-m64"
+#define __LP64_OFF64_LDFLAGS "-m64"
+# 207 "/usr/include/unistd.h" 2 3 4
+
+
+
+#define STDIN_FILENO 0
+#define STDOUT_FILENO 1
+#define STDERR_FILENO 2
+
+
+
+
+# 1 "/usr/include/bits/types.h" 1 3 4
+# 24 "/usr/include/bits/types.h" 3 4
+#define _BITS_TYPES_H 1
+
+
+# 1 "/usr/include/bits/wordsize.h" 1 3 4
+
+
+
+#define __WORDSIZE 64
+
+
+
+
+
+
+
+#define __WORDSIZE_TIME64_COMPAT32 1
+
+#define __SYSCALL_WORDSIZE 64
+# 28 "/usr/include/bits/types.h" 2 3 4
+# 1 "/usr/include/bits/timesize.h" 1 3 4
+# 24 "/usr/include/bits/timesize.h" 3 4
+#define __TIMESIZE __WORDSIZE
+# 29 "/usr/include/bits/types.h" 2 3 4
+
+
+typedef unsigned char __u_char;
+typedef unsigned short int __u_short;
+typedef unsigned int __u_int;
+typedef unsigned long int __u_long;
+
+
+typedef signed char __int8_t;
+typedef unsigned char __uint8_t;
+typedef signed short int __int16_t;
+typedef unsigned short int __uint16_t;
+typedef signed int __int32_t;
+typedef unsigned int __uint32_t;
+
+typedef signed long int __int64_t;
+typedef unsigned long int __uint64_t;
+
+
+
+
+
+
+typedef __int8_t __int_least8_t;
+typedef __uint8_t __uint_least8_t;
+typedef __int16_t __int_least16_t;
+typedef __uint16_t __uint_least16_t;
+typedef __int32_t __int_least32_t;
+typedef __uint32_t __uint_least32_t;
+typedef __int64_t __int_least64_t;
+typedef __uint64_t __uint_least64_t;
+
+
+
+typedef long int __quad_t;
+typedef unsigned long int __u_quad_t;
+
+
+
+
+
+
+
+typedef long int __intmax_t;
+typedef unsigned long int __uintmax_t;
+# 109 "/usr/include/bits/types.h" 3 4
+#define __S16_TYPE short int
+#define __U16_TYPE unsigned short int
+#define __S32_TYPE int
+#define __U32_TYPE unsigned int
+#define __SLONGWORD_TYPE long int
+#define __ULONGWORD_TYPE unsigned long int
+# 128 "/usr/include/bits/types.h" 3 4
+#define __SQUAD_TYPE long int
+#define __UQUAD_TYPE unsigned long int
+#define __SWORD_TYPE long int
+#define __UWORD_TYPE unsigned long int
+#define __SLONG32_TYPE int
+#define __ULONG32_TYPE unsigned int
+#define __S64_TYPE long int
+#define __U64_TYPE unsigned long int
+
+#define __STD_TYPE typedef
+
+
+
+# 1 "/usr/include/bits/typesizes.h" 1 3 4
+# 24 "/usr/include/bits/typesizes.h" 3 4
+#define _BITS_TYPESIZES_H 1
+# 34 "/usr/include/bits/typesizes.h" 3 4
+#define __SYSCALL_SLONG_TYPE __SLONGWORD_TYPE
+#define __SYSCALL_ULONG_TYPE __ULONGWORD_TYPE
+
+
+#define __DEV_T_TYPE __UQUAD_TYPE
+#define __UID_T_TYPE __U32_TYPE
+#define __GID_T_TYPE __U32_TYPE
+#define __INO_T_TYPE __SYSCALL_ULONG_TYPE
+#define __INO64_T_TYPE __UQUAD_TYPE
+#define __MODE_T_TYPE __U32_TYPE
+
+#define __NLINK_T_TYPE __SYSCALL_ULONG_TYPE
+#define __FSWORD_T_TYPE __SYSCALL_SLONG_TYPE
+
+
+
+
+#define __OFF_T_TYPE __SYSCALL_SLONG_TYPE
+#define __OFF64_T_TYPE __SQUAD_TYPE
+#define __PID_T_TYPE __S32_TYPE
+#define __RLIM_T_TYPE __SYSCALL_ULONG_TYPE
+#define __RLIM64_T_TYPE __UQUAD_TYPE
+#define __BLKCNT_T_TYPE __SYSCALL_SLONG_TYPE
+#define __BLKCNT64_T_TYPE __SQUAD_TYPE
+#define __FSBLKCNT_T_TYPE __SYSCALL_ULONG_TYPE
+#define __FSBLKCNT64_T_TYPE __UQUAD_TYPE
+#define __FSFILCNT_T_TYPE __SYSCALL_ULONG_TYPE
+#define __FSFILCNT64_T_TYPE __UQUAD_TYPE
+#define __ID_T_TYPE __U32_TYPE
+#define __CLOCK_T_TYPE __SYSCALL_SLONG_TYPE
+#define __TIME_T_TYPE __SYSCALL_SLONG_TYPE
+#define __USECONDS_T_TYPE __U32_TYPE
+#define __SUSECONDS_T_TYPE __SYSCALL_SLONG_TYPE
+#define __SUSECONDS64_T_TYPE __SQUAD_TYPE
+#define __DADDR_T_TYPE __S32_TYPE
+#define __KEY_T_TYPE __S32_TYPE
+#define __CLOCKID_T_TYPE __S32_TYPE
+#define __TIMER_T_TYPE void *
+#define __BLKSIZE_T_TYPE __SYSCALL_SLONG_TYPE
+#define __FSID_T_TYPE struct { int __val[2]; }
+#define __SSIZE_T_TYPE __SWORD_TYPE
+#define __CPU_MASK_TYPE __SYSCALL_ULONG_TYPE
+
+
+
+
+
+#define __OFF_T_MATCHES_OFF64_T 1
+
+
+#define __INO_T_MATCHES_INO64_T 1
+
+
+#define __RLIM_T_MATCHES_RLIM64_T 1
+
+
+#define __STATFS_MATCHES_STATFS64 1
+
+
+#define __KERNEL_OLD_TIMEVAL_MATCHES_TIMEVAL64 1
+# 103 "/usr/include/bits/typesizes.h" 3 4
+#define __FD_SETSIZE 1024
+# 142 "/usr/include/bits/types.h" 2 3 4
+# 1 "/usr/include/bits/time64.h" 1 3 4
+# 24 "/usr/include/bits/time64.h" 3 4
+#define _BITS_TIME64_H 1
+
+
+
+
+
+#define __TIME64_T_TYPE __TIME_T_TYPE
+# 143 "/usr/include/bits/types.h" 2 3 4
+
+
+typedef unsigned long int __dev_t;
+typedef unsigned int __uid_t;
+typedef unsigned int __gid_t;
+typedef unsigned long int __ino_t;
+typedef unsigned long int __ino64_t;
+typedef unsigned int __mode_t;
+typedef unsigned long int __nlink_t;
+typedef long int __off_t;
+typedef long int __off64_t;
+typedef int __pid_t;
+typedef struct { int __val[2]; } __fsid_t;
+typedef long int __clock_t;
+typedef unsigned long int __rlim_t;
+typedef unsigned long int __rlim64_t;
+typedef unsigned int __id_t;
+typedef long int __time_t;
+typedef unsigned int __useconds_t;
+typedef long int __suseconds_t;
+typedef long int __suseconds64_t;
+
+typedef int __daddr_t;
+typedef int __key_t;
+
+
+typedef int __clockid_t;
+
+
+typedef void * __timer_t;
+
+
+typedef long int __blksize_t;
+
+
+
+
+typedef long int __blkcnt_t;
+typedef long int __blkcnt64_t;
+
+
+typedef unsigned long int __fsblkcnt_t;
+typedef unsigned long int __fsblkcnt64_t;
+
+
+typedef unsigned long int __fsfilcnt_t;
+typedef unsigned long int __fsfilcnt64_t;
+
+
+typedef long int __fsword_t;
+
+typedef long int __ssize_t;
+
+
+typedef long int __syscall_slong_t;
+
+typedef unsigned long int __syscall_ulong_t;
+
+
+
+typedef __off64_t __loff_t;
+typedef char *__caddr_t;
+
+
+typedef long int __intptr_t;
+
+
+typedef unsigned int __socklen_t;
+
+
+
+
+typedef int __sig_atomic_t;
+# 226 "/usr/include/bits/types.h" 3 4
+#undef __STD_TYPE
+# 218 "/usr/include/unistd.h" 2 3 4
+
+
+typedef __ssize_t ssize_t;
+#define __ssize_t_defined 
+
+
+#define __need_size_t 
+#define __need_NULL 
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 1 3 4
+# 155 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef __need_ptrdiff_t
+# 231 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef __need_size_t
+# 340 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef __need_wchar_t
+# 390 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef NULL
+
+#define NULL __null
+# 401 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef __need_NULL
+
+
+
+
+#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
+# 227 "/usr/include/unistd.h" 2 3 4
+
+
+
+
+
+typedef __gid_t gid_t;
+#define __gid_t_defined 
+
+
+
+typedef __uid_t uid_t;
+#define __uid_t_defined 
+
+
+
+
+typedef __off_t off_t;
+
+
+
+#define __off_t_defined 
+
+
+typedef __off64_t off64_t;
+#define __off64_t_defined 
+
+
+
+typedef __useconds_t useconds_t;
+#define __useconds_t_defined 
+
+
+
+typedef __pid_t pid_t;
+#define __pid_t_defined 
+
+
+
+
+
+typedef __intptr_t intptr_t;
+#define __intptr_t_defined 
+
+
+
+
+
+typedef __socklen_t socklen_t;
+#define __socklen_t_defined 
+
+
+
+
+
+#define R_OK 4
+#define W_OK 2
+#define X_OK 1
+#define F_OK 0
+
+
+extern int access (const char *__name, int __type) throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+extern int euidaccess (const char *__name, int __type)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int eaccess (const char *__name, int __type)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+extern int faccessat (int __fd, const char *__file, int __type, int __flag)
+     throw () __attribute__ ((__nonnull__ (2))) ;
+
+
+
+
+
+#define SEEK_SET 0
+#define SEEK_CUR 1
+#define SEEK_END 2
+
+#define SEEK_DATA 3
+#define SEEK_HOLE 4
+
+
+
+
+
+#define L_SET SEEK_SET
+#define L_INCR SEEK_CUR
+#define L_XTND SEEK_END
+# 334 "/usr/include/unistd.h" 3 4
+extern __off_t lseek (int __fd, __off_t __offset, int __whence) throw ();
+# 345 "/usr/include/unistd.h" 3 4
+extern __off64_t lseek64 (int __fd, __off64_t __offset, int __whence)
+     throw ();
+
+
+
+
+
+
+extern int close (int __fd);
+
+
+
+
+
+
+extern ssize_t read (int __fd, void *__buf, size_t __nbytes)
+    __attribute__ ((__access__ (__write_only__, 2, 3)));
+
+
+
+
+
+extern ssize_t write (int __fd, const void *__buf, size_t __n)
+    __attribute__ ((__access__ (__read_only__, 2, 3)));
+# 378 "/usr/include/unistd.h" 3 4
+extern ssize_t pread (int __fd, void *__buf, size_t __nbytes,
+        __off_t __offset)
+    __attribute__ ((__access__ (__write_only__, 2, 3)));
+
+
+
+
+
+
+extern ssize_t pwrite (int __fd, const void *__buf, size_t __n,
+         __off_t __offset)
+    __attribute__ ((__access__ (__read_only__, 2, 3)));
+# 411 "/usr/include/unistd.h" 3 4
+extern ssize_t pread64 (int __fd, void *__buf, size_t __nbytes,
+   __off64_t __offset)
+    __attribute__ ((__access__ (__write_only__, 2, 3)));
+
+
+extern ssize_t pwrite64 (int __fd, const void *__buf, size_t __n,
+    __off64_t __offset)
+    __attribute__ ((__access__ (__read_only__, 2, 3)));
+
+
+
+
+
+
+
+extern int pipe (int __pipedes[2]) throw () ;
+
+
+
+
+extern int pipe2 (int __pipedes[2], int __flags) throw () ;
+# 441 "/usr/include/unistd.h" 3 4
+extern unsigned int alarm (unsigned int __seconds) throw ();
+# 453 "/usr/include/unistd.h" 3 4
+extern unsigned int sleep (unsigned int __seconds);
+
+
+
+
+
+
+
+extern __useconds_t ualarm (__useconds_t __value, __useconds_t __interval)
+     throw ();
+
+
+
+
+
+
+extern int usleep (__useconds_t __useconds);
+# 478 "/usr/include/unistd.h" 3 4
+extern int pause (void);
+
+
+
+extern int chown (const char *__file, __uid_t __owner, __gid_t __group)
+     throw () __attribute__ ((__nonnull__ (1))) ;
+
+
+
+extern int fchown (int __fd, __uid_t __owner, __gid_t __group) throw () ;
+
+
+
+
+extern int lchown (const char *__file, __uid_t __owner, __gid_t __group)
+     throw () __attribute__ ((__nonnull__ (1))) ;
+
+
+
+
+
+
+extern int fchownat (int __fd, const char *__file, __uid_t __owner,
+       __gid_t __group, int __flag)
+     throw () __attribute__ ((__nonnull__ (2))) ;
+
+
+
+extern int chdir (const char *__path) throw () __attribute__ ((__nonnull__ (1))) ;
+
+
+
+extern int fchdir (int __fd) throw () ;
+# 520 "/usr/include/unistd.h" 3 4
+extern char *getcwd (char *__buf, size_t __size) throw ()
+    __attribute__ ((__access__ (__write_only__, 1, 2)));
+
+
+
+
+
+extern char *get_current_dir_name (void) throw ();
+
+
+
+
+
+
+
+extern char *getwd (char *__buf)
+     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__))
+    __attribute__ ((__access__ (__write_only__, 1)));
+
+
+
+
+extern int dup (int __fd) throw () ;
+
+
+extern int dup2 (int __fd, int __fd2) throw ();
+
+
+
+
+extern int dup3 (int __fd, int __fd2, int __flags) throw ();
+
+
+
+extern char **__environ;
+
+extern char **environ;
+
+
+
+
+
+extern int execve (const char *__path, char *const __argv[],
+     char *const __envp[]) throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+extern int fexecve (int __fd, char *const __argv[], char *const __envp[])
+     throw () __attribute__ ((__nonnull__ (2)));
+
+
+
+
+extern int execv (const char *__path, char *const __argv[])
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+extern int execle (const char *__path, const char *__arg, ...)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+extern int execl (const char *__path, const char *__arg, ...)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+extern int execvp (const char *__file, char *const __argv[])
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+extern int execlp (const char *__file, const char *__arg, ...)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+extern int execvpe (const char *__file, char *const __argv[],
+      char *const __envp[])
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+
+extern int nice (int __inc) throw () ;
+
+
+
+
+extern void _exit (int __status) __attribute__ ((__noreturn__));
+
+
+
+
+
+# 1 "/usr/include/bits/confname.h" 1 3 4
+# 24 "/usr/include/bits/confname.h" 3 4
+enum
+  {
+    _PC_LINK_MAX,
+#define _PC_LINK_MAX _PC_LINK_MAX
+    _PC_MAX_CANON,
+#define _PC_MAX_CANON _PC_MAX_CANON
+    _PC_MAX_INPUT,
+#define _PC_MAX_INPUT _PC_MAX_INPUT
+    _PC_NAME_MAX,
+#define _PC_NAME_MAX _PC_NAME_MAX
+    _PC_PATH_MAX,
+#define _PC_PATH_MAX _PC_PATH_MAX
+    _PC_PIPE_BUF,
+#define _PC_PIPE_BUF _PC_PIPE_BUF
+    _PC_CHOWN_RESTRICTED,
+#define _PC_CHOWN_RESTRICTED _PC_CHOWN_RESTRICTED
+    _PC_NO_TRUNC,
+#define _PC_NO_TRUNC _PC_NO_TRUNC
+    _PC_VDISABLE,
+#define _PC_VDISABLE _PC_VDISABLE
+    _PC_SYNC_IO,
+#define _PC_SYNC_IO _PC_SYNC_IO
+    _PC_ASYNC_IO,
+#define _PC_ASYNC_IO _PC_ASYNC_IO
+    _PC_PRIO_IO,
+#define _PC_PRIO_IO _PC_PRIO_IO
+    _PC_SOCK_MAXBUF,
+#define _PC_SOCK_MAXBUF _PC_SOCK_MAXBUF
+    _PC_FILESIZEBITS,
+#define _PC_FILESIZEBITS _PC_FILESIZEBITS
+    _PC_REC_INCR_XFER_SIZE,
+#define _PC_REC_INCR_XFER_SIZE _PC_REC_INCR_XFER_SIZE
+    _PC_REC_MAX_XFER_SIZE,
+#define _PC_REC_MAX_XFER_SIZE _PC_REC_MAX_XFER_SIZE
+    _PC_REC_MIN_XFER_SIZE,
+#define _PC_REC_MIN_XFER_SIZE _PC_REC_MIN_XFER_SIZE
+    _PC_REC_XFER_ALIGN,
+#define _PC_REC_XFER_ALIGN _PC_REC_XFER_ALIGN
+    _PC_ALLOC_SIZE_MIN,
+#define _PC_ALLOC_SIZE_MIN _PC_ALLOC_SIZE_MIN
+    _PC_SYMLINK_MAX,
+#define _PC_SYMLINK_MAX _PC_SYMLINK_MAX
+    _PC_2_SYMLINKS
+#define _PC_2_SYMLINKS _PC_2_SYMLINKS
+  };
+
+
+enum
+  {
+    _SC_ARG_MAX,
+#define _SC_ARG_MAX _SC_ARG_MAX
+    _SC_CHILD_MAX,
+#define _SC_CHILD_MAX _SC_CHILD_MAX
+    _SC_CLK_TCK,
+#define _SC_CLK_TCK _SC_CLK_TCK
+    _SC_NGROUPS_MAX,
+#define _SC_NGROUPS_MAX _SC_NGROUPS_MAX
+    _SC_OPEN_MAX,
+#define _SC_OPEN_MAX _SC_OPEN_MAX
+    _SC_STREAM_MAX,
+#define _SC_STREAM_MAX _SC_STREAM_MAX
+    _SC_TZNAME_MAX,
+#define _SC_TZNAME_MAX _SC_TZNAME_MAX
+    _SC_JOB_CONTROL,
+#define _SC_JOB_CONTROL _SC_JOB_CONTROL
+    _SC_SAVED_IDS,
+#define _SC_SAVED_IDS _SC_SAVED_IDS
+    _SC_REALTIME_SIGNALS,
+#define _SC_REALTIME_SIGNALS _SC_REALTIME_SIGNALS
+    _SC_PRIORITY_SCHEDULING,
+#define _SC_PRIORITY_SCHEDULING _SC_PRIORITY_SCHEDULING
+    _SC_TIMERS,
+#define _SC_TIMERS _SC_TIMERS
+    _SC_ASYNCHRONOUS_IO,
+#define _SC_ASYNCHRONOUS_IO _SC_ASYNCHRONOUS_IO
+    _SC_PRIORITIZED_IO,
+#define _SC_PRIORITIZED_IO _SC_PRIORITIZED_IO
+    _SC_SYNCHRONIZED_IO,
+#define _SC_SYNCHRONIZED_IO _SC_SYNCHRONIZED_IO
+    _SC_FSYNC,
+#define _SC_FSYNC _SC_FSYNC
+    _SC_MAPPED_FILES,
+#define _SC_MAPPED_FILES _SC_MAPPED_FILES
+    _SC_MEMLOCK,
+#define _SC_MEMLOCK _SC_MEMLOCK
+    _SC_MEMLOCK_RANGE,
+#define _SC_MEMLOCK_RANGE _SC_MEMLOCK_RANGE
+    _SC_MEMORY_PROTECTION,
+#define _SC_MEMORY_PROTECTION _SC_MEMORY_PROTECTION
+    _SC_MESSAGE_PASSING,
+#define _SC_MESSAGE_PASSING _SC_MESSAGE_PASSING
+    _SC_SEMAPHORES,
+#define _SC_SEMAPHORES _SC_SEMAPHORES
+    _SC_SHARED_MEMORY_OBJECTS,
+#define _SC_SHARED_MEMORY_OBJECTS _SC_SHARED_MEMORY_OBJECTS
+    _SC_AIO_LISTIO_MAX,
+#define _SC_AIO_LISTIO_MAX _SC_AIO_LISTIO_MAX
+    _SC_AIO_MAX,
+#define _SC_AIO_MAX _SC_AIO_MAX
+    _SC_AIO_PRIO_DELTA_MAX,
+#define _SC_AIO_PRIO_DELTA_MAX _SC_AIO_PRIO_DELTA_MAX
+    _SC_DELAYTIMER_MAX,
+#define _SC_DELAYTIMER_MAX _SC_DELAYTIMER_MAX
+    _SC_MQ_OPEN_MAX,
+#define _SC_MQ_OPEN_MAX _SC_MQ_OPEN_MAX
+    _SC_MQ_PRIO_MAX,
+#define _SC_MQ_PRIO_MAX _SC_MQ_PRIO_MAX
+    _SC_VERSION,
+#define _SC_VERSION _SC_VERSION
+    _SC_PAGESIZE,
+#define _SC_PAGESIZE _SC_PAGESIZE
+#define _SC_PAGE_SIZE _SC_PAGESIZE
+    _SC_RTSIG_MAX,
+#define _SC_RTSIG_MAX _SC_RTSIG_MAX
+    _SC_SEM_NSEMS_MAX,
+#define _SC_SEM_NSEMS_MAX _SC_SEM_NSEMS_MAX
+    _SC_SEM_VALUE_MAX,
+#define _SC_SEM_VALUE_MAX _SC_SEM_VALUE_MAX
+    _SC_SIGQUEUE_MAX,
+#define _SC_SIGQUEUE_MAX _SC_SIGQUEUE_MAX
+    _SC_TIMER_MAX,
+#define _SC_TIMER_MAX _SC_TIMER_MAX
+
+
+
+    _SC_BC_BASE_MAX,
+#define _SC_BC_BASE_MAX _SC_BC_BASE_MAX
+    _SC_BC_DIM_MAX,
+#define _SC_BC_DIM_MAX _SC_BC_DIM_MAX
+    _SC_BC_SCALE_MAX,
+#define _SC_BC_SCALE_MAX _SC_BC_SCALE_MAX
+    _SC_BC_STRING_MAX,
+#define _SC_BC_STRING_MAX _SC_BC_STRING_MAX
+    _SC_COLL_WEIGHTS_MAX,
+#define _SC_COLL_WEIGHTS_MAX _SC_COLL_WEIGHTS_MAX
+    _SC_EQUIV_CLASS_MAX,
+#define _SC_EQUIV_CLASS_MAX _SC_EQUIV_CLASS_MAX
+    _SC_EXPR_NEST_MAX,
+#define _SC_EXPR_NEST_MAX _SC_EXPR_NEST_MAX
+    _SC_LINE_MAX,
+#define _SC_LINE_MAX _SC_LINE_MAX
+    _SC_RE_DUP_MAX,
+#define _SC_RE_DUP_MAX _SC_RE_DUP_MAX
+    _SC_CHARCLASS_NAME_MAX,
+#define _SC_CHARCLASS_NAME_MAX _SC_CHARCLASS_NAME_MAX
+
+    _SC_2_VERSION,
+#define _SC_2_VERSION _SC_2_VERSION
+    _SC_2_C_BIND,
+#define _SC_2_C_BIND _SC_2_C_BIND
+    _SC_2_C_DEV,
+#define _SC_2_C_DEV _SC_2_C_DEV
+    _SC_2_FORT_DEV,
+#define _SC_2_FORT_DEV _SC_2_FORT_DEV
+    _SC_2_FORT_RUN,
+#define _SC_2_FORT_RUN _SC_2_FORT_RUN
+    _SC_2_SW_DEV,
+#define _SC_2_SW_DEV _SC_2_SW_DEV
+    _SC_2_LOCALEDEF,
+#define _SC_2_LOCALEDEF _SC_2_LOCALEDEF
+
+    _SC_PII,
+#define _SC_PII _SC_PII
+    _SC_PII_XTI,
+#define _SC_PII_XTI _SC_PII_XTI
+    _SC_PII_SOCKET,
+#define _SC_PII_SOCKET _SC_PII_SOCKET
+    _SC_PII_INTERNET,
+#define _SC_PII_INTERNET _SC_PII_INTERNET
+    _SC_PII_OSI,
+#define _SC_PII_OSI _SC_PII_OSI
+    _SC_POLL,
+#define _SC_POLL _SC_POLL
+    _SC_SELECT,
+#define _SC_SELECT _SC_SELECT
+    _SC_UIO_MAXIOV,
+#define _SC_UIO_MAXIOV _SC_UIO_MAXIOV
+    _SC_IOV_MAX = _SC_UIO_MAXIOV,
+#define _SC_IOV_MAX _SC_IOV_MAX
+    _SC_PII_INTERNET_STREAM,
+#define _SC_PII_INTERNET_STREAM _SC_PII_INTERNET_STREAM
+    _SC_PII_INTERNET_DGRAM,
+#define _SC_PII_INTERNET_DGRAM _SC_PII_INTERNET_DGRAM
+    _SC_PII_OSI_COTS,
+#define _SC_PII_OSI_COTS _SC_PII_OSI_COTS
+    _SC_PII_OSI_CLTS,
+#define _SC_PII_OSI_CLTS _SC_PII_OSI_CLTS
+    _SC_PII_OSI_M,
+#define _SC_PII_OSI_M _SC_PII_OSI_M
+    _SC_T_IOV_MAX,
+#define _SC_T_IOV_MAX _SC_T_IOV_MAX
+
+
+    _SC_THREADS,
+#define _SC_THREADS _SC_THREADS
+    _SC_THREAD_SAFE_FUNCTIONS,
+#define _SC_THREAD_SAFE_FUNCTIONS _SC_THREAD_SAFE_FUNCTIONS
+    _SC_GETGR_R_SIZE_MAX,
+#define _SC_GETGR_R_SIZE_MAX _SC_GETGR_R_SIZE_MAX
+    _SC_GETPW_R_SIZE_MAX,
+#define _SC_GETPW_R_SIZE_MAX _SC_GETPW_R_SIZE_MAX
+    _SC_LOGIN_NAME_MAX,
+#define _SC_LOGIN_NAME_MAX _SC_LOGIN_NAME_MAX
+    _SC_TTY_NAME_MAX,
+#define _SC_TTY_NAME_MAX _SC_TTY_NAME_MAX
+    _SC_THREAD_DESTRUCTOR_ITERATIONS,
+#define _SC_THREAD_DESTRUCTOR_ITERATIONS _SC_THREAD_DESTRUCTOR_ITERATIONS
+    _SC_THREAD_KEYS_MAX,
+#define _SC_THREAD_KEYS_MAX _SC_THREAD_KEYS_MAX
+    _SC_THREAD_STACK_MIN,
+#define _SC_THREAD_STACK_MIN _SC_THREAD_STACK_MIN
+    _SC_THREAD_THREADS_MAX,
+#define _SC_THREAD_THREADS_MAX _SC_THREAD_THREADS_MAX
+    _SC_THREAD_ATTR_STACKADDR,
+#define _SC_THREAD_ATTR_STACKADDR _SC_THREAD_ATTR_STACKADDR
+    _SC_THREAD_ATTR_STACKSIZE,
+#define _SC_THREAD_ATTR_STACKSIZE _SC_THREAD_ATTR_STACKSIZE
+    _SC_THREAD_PRIORITY_SCHEDULING,
+#define _SC_THREAD_PRIORITY_SCHEDULING _SC_THREAD_PRIORITY_SCHEDULING
+    _SC_THREAD_PRIO_INHERIT,
+#define _SC_THREAD_PRIO_INHERIT _SC_THREAD_PRIO_INHERIT
+    _SC_THREAD_PRIO_PROTECT,
+#define _SC_THREAD_PRIO_PROTECT _SC_THREAD_PRIO_PROTECT
+    _SC_THREAD_PROCESS_SHARED,
+#define _SC_THREAD_PROCESS_SHARED _SC_THREAD_PROCESS_SHARED
+
+    _SC_NPROCESSORS_CONF,
+#define _SC_NPROCESSORS_CONF _SC_NPROCESSORS_CONF
+    _SC_NPROCESSORS_ONLN,
+#define _SC_NPROCESSORS_ONLN _SC_NPROCESSORS_ONLN
+    _SC_PHYS_PAGES,
+#define _SC_PHYS_PAGES _SC_PHYS_PAGES
+    _SC_AVPHYS_PAGES,
+#define _SC_AVPHYS_PAGES _SC_AVPHYS_PAGES
+    _SC_ATEXIT_MAX,
+#define _SC_ATEXIT_MAX _SC_ATEXIT_MAX
+    _SC_PASS_MAX,
+#define _SC_PASS_MAX _SC_PASS_MAX
+
+    _SC_XOPEN_VERSION,
+#define _SC_XOPEN_VERSION _SC_XOPEN_VERSION
+    _SC_XOPEN_XCU_VERSION,
+#define _SC_XOPEN_XCU_VERSION _SC_XOPEN_XCU_VERSION
+    _SC_XOPEN_UNIX,
+#define _SC_XOPEN_UNIX _SC_XOPEN_UNIX
+    _SC_XOPEN_CRYPT,
+#define _SC_XOPEN_CRYPT _SC_XOPEN_CRYPT
+    _SC_XOPEN_ENH_I18N,
+#define _SC_XOPEN_ENH_I18N _SC_XOPEN_ENH_I18N
+    _SC_XOPEN_SHM,
+#define _SC_XOPEN_SHM _SC_XOPEN_SHM
+
+    _SC_2_CHAR_TERM,
+#define _SC_2_CHAR_TERM _SC_2_CHAR_TERM
+    _SC_2_C_VERSION,
+#define _SC_2_C_VERSION _SC_2_C_VERSION
+    _SC_2_UPE,
+#define _SC_2_UPE _SC_2_UPE
+
+    _SC_XOPEN_XPG2,
+#define _SC_XOPEN_XPG2 _SC_XOPEN_XPG2
+    _SC_XOPEN_XPG3,
+#define _SC_XOPEN_XPG3 _SC_XOPEN_XPG3
+    _SC_XOPEN_XPG4,
+#define _SC_XOPEN_XPG4 _SC_XOPEN_XPG4
+
+    _SC_CHAR_BIT,
+#define _SC_CHAR_BIT _SC_CHAR_BIT
+    _SC_CHAR_MAX,
+#define _SC_CHAR_MAX _SC_CHAR_MAX
+    _SC_CHAR_MIN,
+#define _SC_CHAR_MIN _SC_CHAR_MIN
+    _SC_INT_MAX,
+#define _SC_INT_MAX _SC_INT_MAX
+    _SC_INT_MIN,
+#define _SC_INT_MIN _SC_INT_MIN
+    _SC_LONG_BIT,
+#define _SC_LONG_BIT _SC_LONG_BIT
+    _SC_WORD_BIT,
+#define _SC_WORD_BIT _SC_WORD_BIT
+    _SC_MB_LEN_MAX,
+#define _SC_MB_LEN_MAX _SC_MB_LEN_MAX
+    _SC_NZERO,
+#define _SC_NZERO _SC_NZERO
+    _SC_SSIZE_MAX,
+#define _SC_SSIZE_MAX _SC_SSIZE_MAX
+    _SC_SCHAR_MAX,
+#define _SC_SCHAR_MAX _SC_SCHAR_MAX
+    _SC_SCHAR_MIN,
+#define _SC_SCHAR_MIN _SC_SCHAR_MIN
+    _SC_SHRT_MAX,
+#define _SC_SHRT_MAX _SC_SHRT_MAX
+    _SC_SHRT_MIN,
+#define _SC_SHRT_MIN _SC_SHRT_MIN
+    _SC_UCHAR_MAX,
+#define _SC_UCHAR_MAX _SC_UCHAR_MAX
+    _SC_UINT_MAX,
+#define _SC_UINT_MAX _SC_UINT_MAX
+    _SC_ULONG_MAX,
+#define _SC_ULONG_MAX _SC_ULONG_MAX
+    _SC_USHRT_MAX,
+#define _SC_USHRT_MAX _SC_USHRT_MAX
+
+    _SC_NL_ARGMAX,
+#define _SC_NL_ARGMAX _SC_NL_ARGMAX
+    _SC_NL_LANGMAX,
+#define _SC_NL_LANGMAX _SC_NL_LANGMAX
+    _SC_NL_MSGMAX,
+#define _SC_NL_MSGMAX _SC_NL_MSGMAX
+    _SC_NL_NMAX,
+#define _SC_NL_NMAX _SC_NL_NMAX
+    _SC_NL_SETMAX,
+#define _SC_NL_SETMAX _SC_NL_SETMAX
+    _SC_NL_TEXTMAX,
+#define _SC_NL_TEXTMAX _SC_NL_TEXTMAX
+
+    _SC_XBS5_ILP32_OFF32,
+#define _SC_XBS5_ILP32_OFF32 _SC_XBS5_ILP32_OFF32
+    _SC_XBS5_ILP32_OFFBIG,
+#define _SC_XBS5_ILP32_OFFBIG _SC_XBS5_ILP32_OFFBIG
+    _SC_XBS5_LP64_OFF64,
+#define _SC_XBS5_LP64_OFF64 _SC_XBS5_LP64_OFF64
+    _SC_XBS5_LPBIG_OFFBIG,
+#define _SC_XBS5_LPBIG_OFFBIG _SC_XBS5_LPBIG_OFFBIG
+
+    _SC_XOPEN_LEGACY,
+#define _SC_XOPEN_LEGACY _SC_XOPEN_LEGACY
+    _SC_XOPEN_REALTIME,
+#define _SC_XOPEN_REALTIME _SC_XOPEN_REALTIME
+    _SC_XOPEN_REALTIME_THREADS,
+#define _SC_XOPEN_REALTIME_THREADS _SC_XOPEN_REALTIME_THREADS
+
+    _SC_ADVISORY_INFO,
+#define _SC_ADVISORY_INFO _SC_ADVISORY_INFO
+    _SC_BARRIERS,
+#define _SC_BARRIERS _SC_BARRIERS
+    _SC_BASE,
+#define _SC_BASE _SC_BASE
+    _SC_C_LANG_SUPPORT,
+#define _SC_C_LANG_SUPPORT _SC_C_LANG_SUPPORT
+    _SC_C_LANG_SUPPORT_R,
+#define _SC_C_LANG_SUPPORT_R _SC_C_LANG_SUPPORT_R
+    _SC_CLOCK_SELECTION,
+#define _SC_CLOCK_SELECTION _SC_CLOCK_SELECTION
+    _SC_CPUTIME,
+#define _SC_CPUTIME _SC_CPUTIME
+    _SC_THREAD_CPUTIME,
+#define _SC_THREAD_CPUTIME _SC_THREAD_CPUTIME
+    _SC_DEVICE_IO,
+#define _SC_DEVICE_IO _SC_DEVICE_IO
+    _SC_DEVICE_SPECIFIC,
+#define _SC_DEVICE_SPECIFIC _SC_DEVICE_SPECIFIC
+    _SC_DEVICE_SPECIFIC_R,
+#define _SC_DEVICE_SPECIFIC_R _SC_DEVICE_SPECIFIC_R
+    _SC_FD_MGMT,
+#define _SC_FD_MGMT _SC_FD_MGMT
+    _SC_FIFO,
+#define _SC_FIFO _SC_FIFO
+    _SC_PIPE,
+#define _SC_PIPE _SC_PIPE
+    _SC_FILE_ATTRIBUTES,
+#define _SC_FILE_ATTRIBUTES _SC_FILE_ATTRIBUTES
+    _SC_FILE_LOCKING,
+#define _SC_FILE_LOCKING _SC_FILE_LOCKING
+    _SC_FILE_SYSTEM,
+#define _SC_FILE_SYSTEM _SC_FILE_SYSTEM
+    _SC_MONOTONIC_CLOCK,
+#define _SC_MONOTONIC_CLOCK _SC_MONOTONIC_CLOCK
+    _SC_MULTI_PROCESS,
+#define _SC_MULTI_PROCESS _SC_MULTI_PROCESS
+    _SC_SINGLE_PROCESS,
+#define _SC_SINGLE_PROCESS _SC_SINGLE_PROCESS
+    _SC_NETWORKING,
+#define _SC_NETWORKING _SC_NETWORKING
+    _SC_READER_WRITER_LOCKS,
+#define _SC_READER_WRITER_LOCKS _SC_READER_WRITER_LOCKS
+    _SC_SPIN_LOCKS,
+#define _SC_SPIN_LOCKS _SC_SPIN_LOCKS
+    _SC_REGEXP,
+#define _SC_REGEXP _SC_REGEXP
+    _SC_REGEX_VERSION,
+#define _SC_REGEX_VERSION _SC_REGEX_VERSION
+    _SC_SHELL,
+#define _SC_SHELL _SC_SHELL
+    _SC_SIGNALS,
+#define _SC_SIGNALS _SC_SIGNALS
+    _SC_SPAWN,
+#define _SC_SPAWN _SC_SPAWN
+    _SC_SPORADIC_SERVER,
+#define _SC_SPORADIC_SERVER _SC_SPORADIC_SERVER
+    _SC_THREAD_SPORADIC_SERVER,
+#define _SC_THREAD_SPORADIC_SERVER _SC_THREAD_SPORADIC_SERVER
+    _SC_SYSTEM_DATABASE,
+#define _SC_SYSTEM_DATABASE _SC_SYSTEM_DATABASE
+    _SC_SYSTEM_DATABASE_R,
+#define _SC_SYSTEM_DATABASE_R _SC_SYSTEM_DATABASE_R
+    _SC_TIMEOUTS,
+#define _SC_TIMEOUTS _SC_TIMEOUTS
+    _SC_TYPED_MEMORY_OBJECTS,
+#define _SC_TYPED_MEMORY_OBJECTS _SC_TYPED_MEMORY_OBJECTS
+    _SC_USER_GROUPS,
+#define _SC_USER_GROUPS _SC_USER_GROUPS
+    _SC_USER_GROUPS_R,
+#define _SC_USER_GROUPS_R _SC_USER_GROUPS_R
+    _SC_2_PBS,
+#define _SC_2_PBS _SC_2_PBS
+    _SC_2_PBS_ACCOUNTING,
+#define _SC_2_PBS_ACCOUNTING _SC_2_PBS_ACCOUNTING
+    _SC_2_PBS_LOCATE,
+#define _SC_2_PBS_LOCATE _SC_2_PBS_LOCATE
+    _SC_2_PBS_MESSAGE,
+#define _SC_2_PBS_MESSAGE _SC_2_PBS_MESSAGE
+    _SC_2_PBS_TRACK,
+#define _SC_2_PBS_TRACK _SC_2_PBS_TRACK
+    _SC_SYMLOOP_MAX,
+#define _SC_SYMLOOP_MAX _SC_SYMLOOP_MAX
+    _SC_STREAMS,
+#define _SC_STREAMS _SC_STREAMS
+    _SC_2_PBS_CHECKPOINT,
+#define _SC_2_PBS_CHECKPOINT _SC_2_PBS_CHECKPOINT
+
+    _SC_V6_ILP32_OFF32,
+#define _SC_V6_ILP32_OFF32 _SC_V6_ILP32_OFF32
+    _SC_V6_ILP32_OFFBIG,
+#define _SC_V6_ILP32_OFFBIG _SC_V6_ILP32_OFFBIG
+    _SC_V6_LP64_OFF64,
+#define _SC_V6_LP64_OFF64 _SC_V6_LP64_OFF64
+    _SC_V6_LPBIG_OFFBIG,
+#define _SC_V6_LPBIG_OFFBIG _SC_V6_LPBIG_OFFBIG
+
+    _SC_HOST_NAME_MAX,
+#define _SC_HOST_NAME_MAX _SC_HOST_NAME_MAX
+    _SC_TRACE,
+#define _SC_TRACE _SC_TRACE
+    _SC_TRACE_EVENT_FILTER,
+#define _SC_TRACE_EVENT_FILTER _SC_TRACE_EVENT_FILTER
+    _SC_TRACE_INHERIT,
+#define _SC_TRACE_INHERIT _SC_TRACE_INHERIT
+    _SC_TRACE_LOG,
+#define _SC_TRACE_LOG _SC_TRACE_LOG
+
+    _SC_LEVEL1_ICACHE_SIZE,
+#define _SC_LEVEL1_ICACHE_SIZE _SC_LEVEL1_ICACHE_SIZE
+    _SC_LEVEL1_ICACHE_ASSOC,
+#define _SC_LEVEL1_ICACHE_ASSOC _SC_LEVEL1_ICACHE_ASSOC
+    _SC_LEVEL1_ICACHE_LINESIZE,
+#define _SC_LEVEL1_ICACHE_LINESIZE _SC_LEVEL1_ICACHE_LINESIZE
+    _SC_LEVEL1_DCACHE_SIZE,
+#define _SC_LEVEL1_DCACHE_SIZE _SC_LEVEL1_DCACHE_SIZE
+    _SC_LEVEL1_DCACHE_ASSOC,
+#define _SC_LEVEL1_DCACHE_ASSOC _SC_LEVEL1_DCACHE_ASSOC
+    _SC_LEVEL1_DCACHE_LINESIZE,
+#define _SC_LEVEL1_DCACHE_LINESIZE _SC_LEVEL1_DCACHE_LINESIZE
+    _SC_LEVEL2_CACHE_SIZE,
+#define _SC_LEVEL2_CACHE_SIZE _SC_LEVEL2_CACHE_SIZE
+    _SC_LEVEL2_CACHE_ASSOC,
+#define _SC_LEVEL2_CACHE_ASSOC _SC_LEVEL2_CACHE_ASSOC
+    _SC_LEVEL2_CACHE_LINESIZE,
+#define _SC_LEVEL2_CACHE_LINESIZE _SC_LEVEL2_CACHE_LINESIZE
+    _SC_LEVEL3_CACHE_SIZE,
+#define _SC_LEVEL3_CACHE_SIZE _SC_LEVEL3_CACHE_SIZE
+    _SC_LEVEL3_CACHE_ASSOC,
+#define _SC_LEVEL3_CACHE_ASSOC _SC_LEVEL3_CACHE_ASSOC
+    _SC_LEVEL3_CACHE_LINESIZE,
+#define _SC_LEVEL3_CACHE_LINESIZE _SC_LEVEL3_CACHE_LINESIZE
+    _SC_LEVEL4_CACHE_SIZE,
+#define _SC_LEVEL4_CACHE_SIZE _SC_LEVEL4_CACHE_SIZE
+    _SC_LEVEL4_CACHE_ASSOC,
+#define _SC_LEVEL4_CACHE_ASSOC _SC_LEVEL4_CACHE_ASSOC
+    _SC_LEVEL4_CACHE_LINESIZE,
+#define _SC_LEVEL4_CACHE_LINESIZE _SC_LEVEL4_CACHE_LINESIZE
+
+
+    _SC_IPV6 = _SC_LEVEL1_ICACHE_SIZE + 50,
+#define _SC_IPV6 _SC_IPV6
+    _SC_RAW_SOCKETS,
+#define _SC_RAW_SOCKETS _SC_RAW_SOCKETS
+
+    _SC_V7_ILP32_OFF32,
+#define _SC_V7_ILP32_OFF32 _SC_V7_ILP32_OFF32
+    _SC_V7_ILP32_OFFBIG,
+#define _SC_V7_ILP32_OFFBIG _SC_V7_ILP32_OFFBIG
+    _SC_V7_LP64_OFF64,
+#define _SC_V7_LP64_OFF64 _SC_V7_LP64_OFF64
+    _SC_V7_LPBIG_OFFBIG,
+#define _SC_V7_LPBIG_OFFBIG _SC_V7_LPBIG_OFFBIG
+
+    _SC_SS_REPL_MAX,
+#define _SC_SS_REPL_MAX _SC_SS_REPL_MAX
+
+    _SC_TRACE_EVENT_NAME_MAX,
+#define _SC_TRACE_EVENT_NAME_MAX _SC_TRACE_EVENT_NAME_MAX
+    _SC_TRACE_NAME_MAX,
+#define _SC_TRACE_NAME_MAX _SC_TRACE_NAME_MAX
+    _SC_TRACE_SYS_MAX,
+#define _SC_TRACE_SYS_MAX _SC_TRACE_SYS_MAX
+    _SC_TRACE_USER_EVENT_MAX,
+#define _SC_TRACE_USER_EVENT_MAX _SC_TRACE_USER_EVENT_MAX
+
+    _SC_XOPEN_STREAMS,
+#define _SC_XOPEN_STREAMS _SC_XOPEN_STREAMS
+
+    _SC_THREAD_ROBUST_PRIO_INHERIT,
+#define _SC_THREAD_ROBUST_PRIO_INHERIT _SC_THREAD_ROBUST_PRIO_INHERIT
+    _SC_THREAD_ROBUST_PRIO_PROTECT
+#define _SC_THREAD_ROBUST_PRIO_PROTECT _SC_THREAD_ROBUST_PRIO_PROTECT
+  };
+
+
+enum
+  {
+    _CS_PATH,
+#define _CS_PATH _CS_PATH
+
+    _CS_V6_WIDTH_RESTRICTED_ENVS,
+#define _CS_V6_WIDTH_RESTRICTED_ENVS _CS_V6_WIDTH_RESTRICTED_ENVS
+#define _CS_POSIX_V6_WIDTH_RESTRICTED_ENVS _CS_V6_WIDTH_RESTRICTED_ENVS
+
+    _CS_GNU_LIBC_VERSION,
+#define _CS_GNU_LIBC_VERSION _CS_GNU_LIBC_VERSION
+    _CS_GNU_LIBPTHREAD_VERSION,
+#define _CS_GNU_LIBPTHREAD_VERSION _CS_GNU_LIBPTHREAD_VERSION
+
+    _CS_V5_WIDTH_RESTRICTED_ENVS,
+#define _CS_V5_WIDTH_RESTRICTED_ENVS _CS_V5_WIDTH_RESTRICTED_ENVS
+#define _CS_POSIX_V5_WIDTH_RESTRICTED_ENVS _CS_V5_WIDTH_RESTRICTED_ENVS
+
+    _CS_V7_WIDTH_RESTRICTED_ENVS,
+#define _CS_V7_WIDTH_RESTRICTED_ENVS _CS_V7_WIDTH_RESTRICTED_ENVS
+#define _CS_POSIX_V7_WIDTH_RESTRICTED_ENVS _CS_V7_WIDTH_RESTRICTED_ENVS
+
+    _CS_LFS_CFLAGS = 1000,
+#define _CS_LFS_CFLAGS _CS_LFS_CFLAGS
+    _CS_LFS_LDFLAGS,
+#define _CS_LFS_LDFLAGS _CS_LFS_LDFLAGS
+    _CS_LFS_LIBS,
+#define _CS_LFS_LIBS _CS_LFS_LIBS
+    _CS_LFS_LINTFLAGS,
+#define _CS_LFS_LINTFLAGS _CS_LFS_LINTFLAGS
+    _CS_LFS64_CFLAGS,
+#define _CS_LFS64_CFLAGS _CS_LFS64_CFLAGS
+    _CS_LFS64_LDFLAGS,
+#define _CS_LFS64_LDFLAGS _CS_LFS64_LDFLAGS
+    _CS_LFS64_LIBS,
+#define _CS_LFS64_LIBS _CS_LFS64_LIBS
+    _CS_LFS64_LINTFLAGS,
+#define _CS_LFS64_LINTFLAGS _CS_LFS64_LINTFLAGS
+
+    _CS_XBS5_ILP32_OFF32_CFLAGS = 1100,
+#define _CS_XBS5_ILP32_OFF32_CFLAGS _CS_XBS5_ILP32_OFF32_CFLAGS
+    _CS_XBS5_ILP32_OFF32_LDFLAGS,
+#define _CS_XBS5_ILP32_OFF32_LDFLAGS _CS_XBS5_ILP32_OFF32_LDFLAGS
+    _CS_XBS5_ILP32_OFF32_LIBS,
+#define _CS_XBS5_ILP32_OFF32_LIBS _CS_XBS5_ILP32_OFF32_LIBS
+    _CS_XBS5_ILP32_OFF32_LINTFLAGS,
+#define _CS_XBS5_ILP32_OFF32_LINTFLAGS _CS_XBS5_ILP32_OFF32_LINTFLAGS
+    _CS_XBS5_ILP32_OFFBIG_CFLAGS,
+#define _CS_XBS5_ILP32_OFFBIG_CFLAGS _CS_XBS5_ILP32_OFFBIG_CFLAGS
+    _CS_XBS5_ILP32_OFFBIG_LDFLAGS,
+#define _CS_XBS5_ILP32_OFFBIG_LDFLAGS _CS_XBS5_ILP32_OFFBIG_LDFLAGS
+    _CS_XBS5_ILP32_OFFBIG_LIBS,
+#define _CS_XBS5_ILP32_OFFBIG_LIBS _CS_XBS5_ILP32_OFFBIG_LIBS
+    _CS_XBS5_ILP32_OFFBIG_LINTFLAGS,
+#define _CS_XBS5_ILP32_OFFBIG_LINTFLAGS _CS_XBS5_ILP32_OFFBIG_LINTFLAGS
+    _CS_XBS5_LP64_OFF64_CFLAGS,
+#define _CS_XBS5_LP64_OFF64_CFLAGS _CS_XBS5_LP64_OFF64_CFLAGS
+    _CS_XBS5_LP64_OFF64_LDFLAGS,
+#define _CS_XBS5_LP64_OFF64_LDFLAGS _CS_XBS5_LP64_OFF64_LDFLAGS
+    _CS_XBS5_LP64_OFF64_LIBS,
+#define _CS_XBS5_LP64_OFF64_LIBS _CS_XBS5_LP64_OFF64_LIBS
+    _CS_XBS5_LP64_OFF64_LINTFLAGS,
+#define _CS_XBS5_LP64_OFF64_LINTFLAGS _CS_XBS5_LP64_OFF64_LINTFLAGS
+    _CS_XBS5_LPBIG_OFFBIG_CFLAGS,
+#define _CS_XBS5_LPBIG_OFFBIG_CFLAGS _CS_XBS5_LPBIG_OFFBIG_CFLAGS
+    _CS_XBS5_LPBIG_OFFBIG_LDFLAGS,
+#define _CS_XBS5_LPBIG_OFFBIG_LDFLAGS _CS_XBS5_LPBIG_OFFBIG_LDFLAGS
+    _CS_XBS5_LPBIG_OFFBIG_LIBS,
+#define _CS_XBS5_LPBIG_OFFBIG_LIBS _CS_XBS5_LPBIG_OFFBIG_LIBS
+    _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS,
+#define _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS
+
+    _CS_POSIX_V6_ILP32_OFF32_CFLAGS,
+#define _CS_POSIX_V6_ILP32_OFF32_CFLAGS _CS_POSIX_V6_ILP32_OFF32_CFLAGS
+    _CS_POSIX_V6_ILP32_OFF32_LDFLAGS,
+#define _CS_POSIX_V6_ILP32_OFF32_LDFLAGS _CS_POSIX_V6_ILP32_OFF32_LDFLAGS
+    _CS_POSIX_V6_ILP32_OFF32_LIBS,
+#define _CS_POSIX_V6_ILP32_OFF32_LIBS _CS_POSIX_V6_ILP32_OFF32_LIBS
+    _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS,
+#define _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS
+    _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS,
+#define _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS
+    _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS,
+#define _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS
+    _CS_POSIX_V6_ILP32_OFFBIG_LIBS,
+#define _CS_POSIX_V6_ILP32_OFFBIG_LIBS _CS_POSIX_V6_ILP32_OFFBIG_LIBS
+    _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS,
+#define _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS
+    _CS_POSIX_V6_LP64_OFF64_CFLAGS,
+#define _CS_POSIX_V6_LP64_OFF64_CFLAGS _CS_POSIX_V6_LP64_OFF64_CFLAGS
+    _CS_POSIX_V6_LP64_OFF64_LDFLAGS,
+#define _CS_POSIX_V6_LP64_OFF64_LDFLAGS _CS_POSIX_V6_LP64_OFF64_LDFLAGS
+    _CS_POSIX_V6_LP64_OFF64_LIBS,
+#define _CS_POSIX_V6_LP64_OFF64_LIBS _CS_POSIX_V6_LP64_OFF64_LIBS
+    _CS_POSIX_V6_LP64_OFF64_LINTFLAGS,
+#define _CS_POSIX_V6_LP64_OFF64_LINTFLAGS _CS_POSIX_V6_LP64_OFF64_LINTFLAGS
+    _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS,
+#define _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS
+    _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS,
+#define _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS
+    _CS_POSIX_V6_LPBIG_OFFBIG_LIBS,
+#define _CS_POSIX_V6_LPBIG_OFFBIG_LIBS _CS_POSIX_V6_LPBIG_OFFBIG_LIBS
+    _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS,
+#define _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS
+
+    _CS_POSIX_V7_ILP32_OFF32_CFLAGS,
+#define _CS_POSIX_V7_ILP32_OFF32_CFLAGS _CS_POSIX_V7_ILP32_OFF32_CFLAGS
+    _CS_POSIX_V7_ILP32_OFF32_LDFLAGS,
+#define _CS_POSIX_V7_ILP32_OFF32_LDFLAGS _CS_POSIX_V7_ILP32_OFF32_LDFLAGS
+    _CS_POSIX_V7_ILP32_OFF32_LIBS,
+#define _CS_POSIX_V7_ILP32_OFF32_LIBS _CS_POSIX_V7_ILP32_OFF32_LIBS
+    _CS_POSIX_V7_ILP32_OFF32_LINTFLAGS,
+#define _CS_POSIX_V7_ILP32_OFF32_LINTFLAGS _CS_POSIX_V7_ILP32_OFF32_LINTFLAGS
+    _CS_POSIX_V7_ILP32_OFFBIG_CFLAGS,
+#define _CS_POSIX_V7_ILP32_OFFBIG_CFLAGS _CS_POSIX_V7_ILP32_OFFBIG_CFLAGS
+    _CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS,
+#define _CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS _CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS
+    _CS_POSIX_V7_ILP32_OFFBIG_LIBS,
+#define _CS_POSIX_V7_ILP32_OFFBIG_LIBS _CS_POSIX_V7_ILP32_OFFBIG_LIBS
+    _CS_POSIX_V7_ILP32_OFFBIG_LINTFLAGS,
+#define _CS_POSIX_V7_ILP32_OFFBIG_LINTFLAGS _CS_POSIX_V7_ILP32_OFFBIG_LINTFLAGS
+    _CS_POSIX_V7_LP64_OFF64_CFLAGS,
+#define _CS_POSIX_V7_LP64_OFF64_CFLAGS _CS_POSIX_V7_LP64_OFF64_CFLAGS
+    _CS_POSIX_V7_LP64_OFF64_LDFLAGS,
+#define _CS_POSIX_V7_LP64_OFF64_LDFLAGS _CS_POSIX_V7_LP64_OFF64_LDFLAGS
+    _CS_POSIX_V7_LP64_OFF64_LIBS,
+#define _CS_POSIX_V7_LP64_OFF64_LIBS _CS_POSIX_V7_LP64_OFF64_LIBS
+    _CS_POSIX_V7_LP64_OFF64_LINTFLAGS,
+#define _CS_POSIX_V7_LP64_OFF64_LINTFLAGS _CS_POSIX_V7_LP64_OFF64_LINTFLAGS
+    _CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS,
+#define _CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS _CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS
+    _CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS,
+#define _CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS _CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS
+    _CS_POSIX_V7_LPBIG_OFFBIG_LIBS,
+#define _CS_POSIX_V7_LPBIG_OFFBIG_LIBS _CS_POSIX_V7_LPBIG_OFFBIG_LIBS
+    _CS_POSIX_V7_LPBIG_OFFBIG_LINTFLAGS,
+#define _CS_POSIX_V7_LPBIG_OFFBIG_LINTFLAGS _CS_POSIX_V7_LPBIG_OFFBIG_LINTFLAGS
+
+    _CS_V6_ENV,
+#define _CS_V6_ENV _CS_V6_ENV
+    _CS_V7_ENV
+#define _CS_V7_ENV _CS_V7_ENV
+  };
+# 621 "/usr/include/unistd.h" 2 3 4
+
+
+extern long int pathconf (const char *__path, int __name)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern long int fpathconf (int __fd, int __name) throw ();
+
+
+extern long int sysconf (int __name) throw ();
+
+
+
+extern size_t confstr (int __name, char *__buf, size_t __len) throw ()
+    __attribute__ ((__access__ (__write_only__, 2, 3)));
+
+
+
+
+extern __pid_t getpid (void) throw ();
+
+
+extern __pid_t getppid (void) throw ();
+
+
+extern __pid_t getpgrp (void) throw ();
+
+
+extern __pid_t __getpgid (__pid_t __pid) throw ();
+
+extern __pid_t getpgid (__pid_t __pid) throw ();
+
+
+
+
+
+
+extern int setpgid (__pid_t __pid, __pid_t __pgid) throw ();
+# 672 "/usr/include/unistd.h" 3 4
+extern int setpgrp (void) throw ();
+
+
+
+
+
+
+extern __pid_t setsid (void) throw ();
+
+
+
+extern __pid_t getsid (__pid_t __pid) throw ();
+
+
+
+extern __uid_t getuid (void) throw ();
+
+
+extern __uid_t geteuid (void) throw ();
+
+
+extern __gid_t getgid (void) throw ();
+
+
+extern __gid_t getegid (void) throw ();
+
+
+
+
+extern int getgroups (int __size, __gid_t __list[]) throw ()
+    __attribute__ ((__access__ (__write_only__, 2, 1)));
+
+
+extern int group_member (__gid_t __gid) throw ();
+
+
+
+
+
+
+extern int setuid (__uid_t __uid) throw () ;
+
+
+
+
+extern int setreuid (__uid_t __ruid, __uid_t __euid) throw () ;
+
+
+
+
+extern int seteuid (__uid_t __uid) throw () ;
+
+
+
+
+
+
+extern int setgid (__gid_t __gid) throw () ;
+
+
+
+
+extern int setregid (__gid_t __rgid, __gid_t __egid) throw () ;
+
+
+
+
+extern int setegid (__gid_t __gid) throw () ;
+
+
+
+
+
+extern int getresuid (__uid_t *__ruid, __uid_t *__euid, __uid_t *__suid)
+     throw ();
+
+
+
+extern int getresgid (__gid_t *__rgid, __gid_t *__egid, __gid_t *__sgid)
+     throw ();
+
+
+
+extern int setresuid (__uid_t __ruid, __uid_t __euid, __uid_t __suid)
+     throw () ;
+
+
+
+extern int setresgid (__gid_t __rgid, __gid_t __egid, __gid_t __sgid)
+     throw () ;
+
+
+
+
+
+
+extern __pid_t fork (void) throw ();
+
+
+
+
+
+
+
+extern __pid_t vfork (void) throw ();
+
+
+
+
+
+extern char *ttyname (int __fd) throw ();
+
+
+
+extern int ttyname_r (int __fd, char *__buf, size_t __buflen)
+     throw () __attribute__ ((__nonnull__ (2))) __attribute__ ((__access__ (__write_only__, 2, 3)));
+
+
+
+extern int isatty (int __fd) throw ();
+
+
+
+
+extern int ttyslot (void) throw ();
+
+
+
+
+extern int link (const char *__from, const char *__to)
+     throw () __attribute__ ((__nonnull__ (1, 2))) ;
+
+
+
+
+extern int linkat (int __fromfd, const char *__from, int __tofd,
+     const char *__to, int __flags)
+     throw () __attribute__ ((__nonnull__ (2, 4))) ;
+
+
+
+
+extern int symlink (const char *__from, const char *__to)
+     throw () __attribute__ ((__nonnull__ (1, 2))) ;
+
+
+
+
+extern ssize_t readlink (const char *__restrict __path,
+    char *__restrict __buf, size_t __len)
+     throw () __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__access__ (__write_only__, 2, 3)));
+
+
+
+
+
+extern int symlinkat (const char *__from, int __tofd,
+        const char *__to) throw () __attribute__ ((__nonnull__ (1, 3))) ;
+
+
+extern ssize_t readlinkat (int __fd, const char *__restrict __path,
+      char *__restrict __buf, size_t __len)
+     throw () __attribute__ ((__nonnull__ (2, 3))) __attribute__ ((__access__ (__read_only__, 3, 4)));
+
+
+
+extern int unlink (const char *__name) throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int unlinkat (int __fd, const char *__name, int __flag)
+     throw () __attribute__ ((__nonnull__ (2)));
+
+
+
+extern int rmdir (const char *__path) throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern __pid_t tcgetpgrp (int __fd) throw ();
+
+
+extern int tcsetpgrp (int __fd, __pid_t __pgrp_id) throw ();
+
+
+
+
+
+
+extern char *getlogin (void);
+
+
+
+
+
+
+
+extern int getlogin_r (char *__name, size_t __name_len) __attribute__ ((__nonnull__ (1)))
+    __attribute__ ((__access__ (__write_only__, 1, 2)));
+
+
+
+
+extern int setlogin (const char *__name) throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+
+# 1 "/usr/include/bits/getopt_posix.h" 1 3 4
+# 21 "/usr/include/bits/getopt_posix.h" 3 4
+#define _GETOPT_POSIX_H 1
+
+
+
+
+
+# 1 "/usr/include/bits/getopt_core.h" 1 3 4
+# 21 "/usr/include/bits/getopt_core.h" 3 4
+#define _GETOPT_CORE_H 1
+
+
+
+
+
+
+extern "C" {
+
+
+
+
+
+
+
+extern char *optarg;
+# 50 "/usr/include/bits/getopt_core.h" 3 4
+extern int optind;
+
+
+
+
+extern int opterr;
+
+
+
+extern int optopt;
+# 91 "/usr/include/bits/getopt_core.h" 3 4
+extern int getopt (int ___argc, char *const *___argv, const char *__shortopts)
+       throw () __attribute__ ((__nonnull__ (2, 3)));
+
+}
+# 28 "/usr/include/bits/getopt_posix.h" 2 3 4
+
+extern "C" {
+# 49 "/usr/include/bits/getopt_posix.h" 3 4
+}
+# 884 "/usr/include/unistd.h" 2 3 4
+
+
+
+
+
+
+
+extern int gethostname (char *__name, size_t __len) throw () __attribute__ ((__nonnull__ (1)))
+    __attribute__ ((__access__ (__write_only__, 1, 2)));
+
+
+
+
+
+
+extern int sethostname (const char *__name, size_t __len)
+     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__access__ (__read_only__, 1, 2)));
+
+
+
+extern int sethostid (long int __id) throw () ;
+
+
+
+
+
+extern int getdomainname (char *__name, size_t __len)
+     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__access__ (__write_only__, 1, 2)));
+extern int setdomainname (const char *__name, size_t __len)
+     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__access__ (__read_only__, 1, 2)));
+
+
+
+
+extern int vhangup (void) throw ();
+
+
+extern int revoke (const char *__file) throw () __attribute__ ((__nonnull__ (1))) ;
+
+
+
+
+
+
+
+extern int profil (unsigned short int *__sample_buffer, size_t __size,
+     size_t __offset, unsigned int __scale)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+extern int acct (const char *__name) throw ();
+
+
+
+extern char *getusershell (void) throw ();
+extern void endusershell (void) throw ();
+extern void setusershell (void) throw ();
+
+
+
+
+
+extern int daemon (int __nochdir, int __noclose) throw () ;
+
+
+
+
+
+
+extern int chroot (const char *__path) throw () __attribute__ ((__nonnull__ (1))) ;
+
+
+
+extern char *getpass (const char *__prompt) __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+
+extern int fsync (int __fd);
+
+
+
+
+
+extern int syncfs (int __fd) throw ();
+
+
+
+
+
+
+extern long int gethostid (void);
+
+
+extern void sync (void) throw ();
+
+
+
+
+
+extern int getpagesize (void) throw () __attribute__ ((__const__));
+
+
+
+
+extern int getdtablesize (void) throw ();
+# 1005 "/usr/include/unistd.h" 3 4
+extern int truncate (const char *__file, __off_t __length)
+     throw () __attribute__ ((__nonnull__ (1))) ;
+# 1017 "/usr/include/unistd.h" 3 4
+extern int truncate64 (const char *__file, __off64_t __length)
+     throw () __attribute__ ((__nonnull__ (1))) ;
+# 1028 "/usr/include/unistd.h" 3 4
+extern int ftruncate (int __fd, __off_t __length) throw () ;
+# 1038 "/usr/include/unistd.h" 3 4
+extern int ftruncate64 (int __fd, __off64_t __length) throw () ;
+# 1049 "/usr/include/unistd.h" 3 4
+extern int brk (void *__addr) throw () ;
+
+
+
+
+
+extern void *sbrk (intptr_t __delta) throw ();
+# 1070 "/usr/include/unistd.h" 3 4
+extern long int syscall (long int __sysno, ...) throw ();
+# 1087 "/usr/include/unistd.h" 3 4
+#define F_ULOCK 0
+#define F_LOCK 1
+#define F_TLOCK 2
+#define F_TEST 3
+
+
+extern int lockf (int __fd, int __cmd, __off_t __len) ;
+# 1103 "/usr/include/unistd.h" 3 4
+extern int lockf64 (int __fd, int __cmd, __off64_t __len) ;
+# 1113 "/usr/include/unistd.h" 3 4
+#define TEMP_FAILURE_RETRY(expression) (__extension__ ({ long int __result; do __result = (long int) (expression); while (__result == -1L && errno == EINTR); __result; }))
+
+
+
+
+
+
+
+ssize_t copy_file_range (int __infd, __off64_t *__pinoff,
+    int __outfd, __off64_t *__poutoff,
+    size_t __length, unsigned int __flags);
+
+
+
+
+
+extern int fdatasync (int __fildes);
+# 1138 "/usr/include/unistd.h" 3 4
+extern char *crypt (const char *__key, const char *__salt)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+
+
+
+extern void swab (const void *__restrict __from, void *__restrict __to,
+    ssize_t __n) throw () __attribute__ ((__nonnull__ (1, 2)))
+    __attribute__ ((__access__ (__read_only__, 1, 3)))
+    __attribute__ ((__access__ (__write_only__, 2, 3)));
+# 1177 "/usr/include/unistd.h" 3 4
+int getentropy (void *__buffer, size_t __length)
+    __attribute__ ((__access__ (__write_only__, 1, 2)));
+# 1187 "/usr/include/unistd.h" 3 4
+# 1 "/usr/include/bits/unistd_ext.h" 1 3 4
+# 34 "/usr/include/bits/unistd_ext.h" 3 4
+extern __pid_t gettid (void) throw ();
+# 1188 "/usr/include/unistd.h" 2 3 4
+
+}
+# 79 "/usr/include/boost/config/stdlib/libstdcpp3.hpp" 2 3 4
+
+
+
+
+#define BOOST_STD_EXTENSION_NAMESPACE __gnu_cxx
+#define BOOST_HAS_SLIST 
+#define BOOST_HAS_HASH 
+#define BOOST_SLIST_HEADER <ext/slist>
+
+
+
+
+#define BOOST_HASH_SET_HEADER <backward/hash_set>
+#define BOOST_HASH_MAP_HEADER <backward/hash_map>
+# 101 "/usr/include/boost/config/stdlib/libstdcpp3.hpp" 3 4
+#define BOOST_LIBSTDCXX11 
+# 205 "/usr/include/boost/config/stdlib/libstdcpp3.hpp" 3 4
+#define BOOST_LIBSTDCXX_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
+# 242 "/usr/include/boost/config/stdlib/libstdcpp3.hpp" 3 4
+#define BOOST_HAS_TR1_COMPLEX_INVERSE_TRIG 
+#define BOOST_HAS_TR1_COMPLEX_OVERLOADS 
+# 49 "/usr/include/boost/config.hpp" 2 3 4
+
+
+
+
+# 1 "/usr/include/boost/config/detail/select_platform_config.hpp" 1 3 4
+# 18 "/usr/include/boost/config/detail/select_platform_config.hpp" 3 4
+#define BOOST_PLATFORM_CONFIG "boost/config/platform/linux.hpp"
+# 54 "/usr/include/boost/config.hpp" 2 3 4
+
+
+
+# 1 "/usr/include/boost/config/platform/linux.hpp" 1 3 4
+# 11 "/usr/include/boost/config/platform/linux.hpp" 3 4
+#define BOOST_PLATFORM "linux"
+
+
+
+# 1 "/usr/include/c++/10.2.0/cstdlib" 1 3 4
+# 39 "/usr/include/c++/10.2.0/cstdlib" 3 4
+       
+# 40 "/usr/include/c++/10.2.0/cstdlib" 3
+
+
+
+
+#define _GLIBCXX_CSTDLIB 1
+# 74 "/usr/include/c++/10.2.0/cstdlib" 3
+#define _GLIBCXX_INCLUDE_NEXT_C_HEADERS 
+# 1 "/usr/include/stdlib.h" 1 3 4
+# 24 "/usr/include/stdlib.h" 3 4
+#define __GLIBC_INTERNAL_STARTING_HEADER_IMPLEMENTATION 
+# 1 "/usr/include/bits/libc-header-start.h" 1 3 4
+# 31 "/usr/include/bits/libc-header-start.h" 3 4
+#undef __GLIBC_INTERNAL_STARTING_HEADER_IMPLEMENTATION
+
+
+
+
+
+#undef __GLIBC_USE_LIB_EXT2
+
+
+#define __GLIBC_USE_LIB_EXT2 1
+# 49 "/usr/include/bits/libc-header-start.h" 3 4
+#undef __GLIBC_USE_IEC_60559_BFP_EXT
+
+#define __GLIBC_USE_IEC_60559_BFP_EXT 1
+
+
+
+#undef __GLIBC_USE_IEC_60559_BFP_EXT_C2X
+
+#define __GLIBC_USE_IEC_60559_BFP_EXT_C2X 1
+# 66 "/usr/include/bits/libc-header-start.h" 3 4
+#undef __GLIBC_USE_IEC_60559_FUNCS_EXT
+
+#define __GLIBC_USE_IEC_60559_FUNCS_EXT 1
+
+
+
+#undef __GLIBC_USE_IEC_60559_FUNCS_EXT_C2X
+
+#define __GLIBC_USE_IEC_60559_FUNCS_EXT_C2X 1
+
+
+
+
+
+
+#undef __GLIBC_USE_IEC_60559_TYPES_EXT
+
+#define __GLIBC_USE_IEC_60559_TYPES_EXT 1
+# 26 "/usr/include/stdlib.h" 2 3 4
+
+
+#define __need_size_t 
+#define __need_wchar_t 
+#define __need_NULL 
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 1 3 4
+# 155 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef __need_ptrdiff_t
+# 231 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef __need_size_t
+# 340 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef __need_wchar_t
+# 390 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef NULL
+
+#define NULL __null
+# 401 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef __need_NULL
+
+
+
+
+#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
+# 32 "/usr/include/stdlib.h" 2 3 4
+
+extern "C" {
+
+#define _STDLIB_H 1
+
+
+
+# 1 "/usr/include/bits/waitflags.h" 1 3 4
+# 25 "/usr/include/bits/waitflags.h" 3 4
+#define WNOHANG 1
+#define WUNTRACED 2
+
+
+
+#define WSTOPPED 2
+#define WEXITED 4
+#define WCONTINUED 8
+#define WNOWAIT 0x01000000
+
+
+#define __WNOTHREAD 0x20000000
+
+#define __WALL 0x40000000
+#define __WCLONE 0x80000000
+# 40 "/usr/include/stdlib.h" 2 3 4
+# 1 "/usr/include/bits/waitstatus.h" 1 3 4
+# 28 "/usr/include/bits/waitstatus.h" 3 4
+#define __WEXITSTATUS(status) (((status) & 0xff00) >> 8)
+
+
+#define __WTERMSIG(status) ((status) & 0x7f)
+
+
+#define __WSTOPSIG(status) __WEXITSTATUS(status)
+
+
+#define __WIFEXITED(status) (__WTERMSIG(status) == 0)
+
+
+#define __WIFSIGNALED(status) (((signed char) (((status) & 0x7f) + 1) >> 1) > 0)
+
+
+
+#define __WIFSTOPPED(status) (((status) & 0xff) == 0x7f)
+
+
+
+
+#define __WIFCONTINUED(status) ((status) == __W_CONTINUED)
+
+
+
+#define __WCOREDUMP(status) ((status) & __WCOREFLAG)
+
+
+#define __W_EXITCODE(ret,sig) ((ret) << 8 | (sig))
+#define __W_STOPCODE(sig) ((sig) << 8 | 0x7f)
+#define __W_CONTINUED 0xffff
+#define __WCOREFLAG 0x80
+# 41 "/usr/include/stdlib.h" 2 3 4
+
+
+#define WEXITSTATUS(status) __WEXITSTATUS (status)
+#define WTERMSIG(status) __WTERMSIG (status)
+#define WSTOPSIG(status) __WSTOPSIG (status)
+#define WIFEXITED(status) __WIFEXITED (status)
+#define WIFSIGNALED(status) __WIFSIGNALED (status)
+#define WIFSTOPPED(status) __WIFSTOPPED (status)
+
+#define WIFCONTINUED(status) __WIFCONTINUED (status)
+
+
+
+
+# 1 "/usr/include/bits/floatn.h" 1 3 4
+# 20 "/usr/include/bits/floatn.h" 3 4
+#define _BITS_FLOATN_H 
+# 32 "/usr/include/bits/floatn.h" 3 4
+#define __HAVE_FLOAT128 1
+
+
+
+
+
+
+
+#define __HAVE_DISTINCT_FLOAT128 1
+
+
+
+
+
+
+
+#define __HAVE_FLOAT64X 1
+
+
+
+
+
+#define __HAVE_FLOAT64X_LONG_DOUBLE 1
+# 63 "/usr/include/bits/floatn.h" 3 4
+#define __f128(x) x ##q
+# 74 "/usr/include/bits/floatn.h" 3 4
+typedef _Complex float __cfloat128 __attribute__ ((__mode__ (__TC__)));
+#define __CFLOAT128 __cfloat128
+# 86 "/usr/include/bits/floatn.h" 3 4
+typedef __float128 _Float128;
+# 119 "/usr/include/bits/floatn.h" 3 4
+# 1 "/usr/include/bits/floatn-common.h" 1 3 4
+# 21 "/usr/include/bits/floatn-common.h" 3 4
+#define _BITS_FLOATN_COMMON_H 
+
+
+# 1 "/usr/include/bits/long-double.h" 1 3 4
+# 21 "/usr/include/bits/long-double.h" 3 4
+#define __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI 0
+# 25 "/usr/include/bits/floatn-common.h" 2 3 4
+# 34 "/usr/include/bits/floatn-common.h" 3 4
+#define __HAVE_FLOAT16 0
+#define __HAVE_FLOAT32 1
+#define __HAVE_FLOAT64 1
+#define __HAVE_FLOAT32X 1
+#define __HAVE_FLOAT128X 0
+# 52 "/usr/include/bits/floatn-common.h" 3 4
+#define __HAVE_DISTINCT_FLOAT16 __HAVE_FLOAT16
+#define __HAVE_DISTINCT_FLOAT32 0
+#define __HAVE_DISTINCT_FLOAT64 0
+#define __HAVE_DISTINCT_FLOAT32X 0
+#define __HAVE_DISTINCT_FLOAT64X 0
+#define __HAVE_DISTINCT_FLOAT128X __HAVE_FLOAT128X
+
+
+
+
+
+#define __HAVE_FLOAT128_UNLIKE_LDBL (__HAVE_DISTINCT_FLOAT128 && __LDBL_MANT_DIG__ != 113)
+# 72 "/usr/include/bits/floatn-common.h" 3 4
+#define __HAVE_FLOATN_NOT_TYPEDEF 0
+# 91 "/usr/include/bits/floatn-common.h" 3 4
+#define __f32(x) x ##f
+# 102 "/usr/include/bits/floatn-common.h" 3 4
+#define __f64(x) x
+# 111 "/usr/include/bits/floatn-common.h" 3 4
+#define __f32x(x) x
+# 120 "/usr/include/bits/floatn-common.h" 3 4
+#define __f64x(x) x ##l
+# 149 "/usr/include/bits/floatn-common.h" 3 4
+#define __CFLOAT32 _Complex float
+# 160 "/usr/include/bits/floatn-common.h" 3 4
+#define __CFLOAT64 _Complex double
+# 169 "/usr/include/bits/floatn-common.h" 3 4
+#define __CFLOAT32X _Complex double
+# 178 "/usr/include/bits/floatn-common.h" 3 4
+#define __CFLOAT64X _Complex long double
+# 214 "/usr/include/bits/floatn-common.h" 3 4
+typedef float _Float32;
+# 251 "/usr/include/bits/floatn-common.h" 3 4
+typedef double _Float64;
+# 268 "/usr/include/bits/floatn-common.h" 3 4
+typedef double _Float32x;
+# 285 "/usr/include/bits/floatn-common.h" 3 4
+typedef long double _Float64x;
+# 120 "/usr/include/bits/floatn.h" 2 3 4
+# 56 "/usr/include/stdlib.h" 2 3 4
+
+
+typedef struct
+  {
+    int quot;
+    int rem;
+  } div_t;
+
+
+
+typedef struct
+  {
+    long int quot;
+    long int rem;
+  } ldiv_t;
+#define __ldiv_t_defined 1
+
+
+
+
+__extension__ typedef struct
+  {
+    long long int quot;
+    long long int rem;
+  } lldiv_t;
+#define __lldiv_t_defined 1
+
+
+
+
+#define RAND_MAX 2147483647
+
+
+
+
+#define EXIT_FAILURE 1
+#define EXIT_SUCCESS 0
+
+
+
+#define MB_CUR_MAX (__ctype_get_mb_cur_max ())
+extern size_t __ctype_get_mb_cur_max (void) throw () ;
+
+
+
+extern double atof (const char *__nptr)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
+
+extern int atoi (const char *__nptr)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
+
+extern long int atol (const char *__nptr)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
+
+
+
+__extension__ extern long long int atoll (const char *__nptr)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
+
+
+
+extern double strtod (const char *__restrict __nptr,
+        char **__restrict __endptr)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern float strtof (const char *__restrict __nptr,
+       char **__restrict __endptr) throw () __attribute__ ((__nonnull__ (1)));
+
+extern long double strtold (const char *__restrict __nptr,
+       char **__restrict __endptr)
+     throw () __attribute__ ((__nonnull__ (1)));
+# 140 "/usr/include/stdlib.h" 3 4
+extern _Float32 strtof32 (const char *__restrict __nptr,
+     char **__restrict __endptr)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern _Float64 strtof64 (const char *__restrict __nptr,
+     char **__restrict __endptr)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern _Float128 strtof128 (const char *__restrict __nptr,
+       char **__restrict __endptr)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern _Float32x strtof32x (const char *__restrict __nptr,
+       char **__restrict __endptr)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern _Float64x strtof64x (const char *__restrict __nptr,
+       char **__restrict __endptr)
+     throw () __attribute__ ((__nonnull__ (1)));
+# 176 "/usr/include/stdlib.h" 3 4
+extern long int strtol (const char *__restrict __nptr,
+   char **__restrict __endptr, int __base)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+extern unsigned long int strtoul (const char *__restrict __nptr,
+      char **__restrict __endptr, int __base)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+__extension__
+extern long long int strtoq (const char *__restrict __nptr,
+        char **__restrict __endptr, int __base)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+__extension__
+extern unsigned long long int strtouq (const char *__restrict __nptr,
+           char **__restrict __endptr, int __base)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+__extension__
+extern long long int strtoll (const char *__restrict __nptr,
+         char **__restrict __endptr, int __base)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+__extension__
+extern unsigned long long int strtoull (const char *__restrict __nptr,
+     char **__restrict __endptr, int __base)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+extern int strfromd (char *__dest, size_t __size, const char *__format,
+       double __f)
+     throw () __attribute__ ((__nonnull__ (3)));
+
+extern int strfromf (char *__dest, size_t __size, const char *__format,
+       float __f)
+     throw () __attribute__ ((__nonnull__ (3)));
+
+extern int strfroml (char *__dest, size_t __size, const char *__format,
+       long double __f)
+     throw () __attribute__ ((__nonnull__ (3)));
+# 232 "/usr/include/stdlib.h" 3 4
+extern int strfromf32 (char *__dest, size_t __size, const char * __format,
+         _Float32 __f)
+     throw () __attribute__ ((__nonnull__ (3)));
+
+
+
+extern int strfromf64 (char *__dest, size_t __size, const char * __format,
+         _Float64 __f)
+     throw () __attribute__ ((__nonnull__ (3)));
+
+
+
+extern int strfromf128 (char *__dest, size_t __size, const char * __format,
+   _Float128 __f)
+     throw () __attribute__ ((__nonnull__ (3)));
+
+
+
+extern int strfromf32x (char *__dest, size_t __size, const char * __format,
+   _Float32x __f)
+     throw () __attribute__ ((__nonnull__ (3)));
+
+
+
+extern int strfromf64x (char *__dest, size_t __size, const char * __format,
+   _Float64x __f)
+     throw () __attribute__ ((__nonnull__ (3)));
+# 272 "/usr/include/stdlib.h" 3 4
+# 1 "/usr/include/bits/types/locale_t.h" 1 3 4
+# 20 "/usr/include/bits/types/locale_t.h" 3 4
+#define _BITS_TYPES_LOCALE_T_H 1
+
+# 1 "/usr/include/bits/types/__locale_t.h" 1 3 4
+# 21 "/usr/include/bits/types/__locale_t.h" 3 4
+#define _BITS_TYPES___LOCALE_T_H 1
+
+
+
+
+
+
+struct __locale_struct
+{
+
+  struct __locale_data *__locales[13];
+
+
+  const unsigned short int *__ctype_b;
+  const int *__ctype_tolower;
+  const int *__ctype_toupper;
+
+
+  const char *__names[13];
+};
+
+typedef struct __locale_struct *__locale_t;
+# 23 "/usr/include/bits/types/locale_t.h" 2 3 4
+
+typedef __locale_t locale_t;
+# 273 "/usr/include/stdlib.h" 2 3 4
+
+extern long int strtol_l (const char *__restrict __nptr,
+     char **__restrict __endptr, int __base,
+     locale_t __loc) throw () __attribute__ ((__nonnull__ (1, 4)));
+
+extern unsigned long int strtoul_l (const char *__restrict __nptr,
+        char **__restrict __endptr,
+        int __base, locale_t __loc)
+     throw () __attribute__ ((__nonnull__ (1, 4)));
+
+__extension__
+extern long long int strtoll_l (const char *__restrict __nptr,
+    char **__restrict __endptr, int __base,
+    locale_t __loc)
+     throw () __attribute__ ((__nonnull__ (1, 4)));
+
+__extension__
+extern unsigned long long int strtoull_l (const char *__restrict __nptr,
+       char **__restrict __endptr,
+       int __base, locale_t __loc)
+     throw () __attribute__ ((__nonnull__ (1, 4)));
+
+extern double strtod_l (const char *__restrict __nptr,
+   char **__restrict __endptr, locale_t __loc)
+     throw () __attribute__ ((__nonnull__ (1, 3)));
+
+extern float strtof_l (const char *__restrict __nptr,
+         char **__restrict __endptr, locale_t __loc)
+     throw () __attribute__ ((__nonnull__ (1, 3)));
+
+extern long double strtold_l (const char *__restrict __nptr,
+         char **__restrict __endptr,
+         locale_t __loc)
+     throw () __attribute__ ((__nonnull__ (1, 3)));
+# 316 "/usr/include/stdlib.h" 3 4
+extern _Float32 strtof32_l (const char *__restrict __nptr,
+       char **__restrict __endptr,
+       locale_t __loc)
+     throw () __attribute__ ((__nonnull__ (1, 3)));
+
+
+
+extern _Float64 strtof64_l (const char *__restrict __nptr,
+       char **__restrict __endptr,
+       locale_t __loc)
+     throw () __attribute__ ((__nonnull__ (1, 3)));
+
+
+
+extern _Float128 strtof128_l (const char *__restrict __nptr,
+         char **__restrict __endptr,
+         locale_t __loc)
+     throw () __attribute__ ((__nonnull__ (1, 3)));
+
+
+
+extern _Float32x strtof32x_l (const char *__restrict __nptr,
+         char **__restrict __endptr,
+         locale_t __loc)
+     throw () __attribute__ ((__nonnull__ (1, 3)));
+
+
+
+extern _Float64x strtof64x_l (const char *__restrict __nptr,
+         char **__restrict __endptr,
+         locale_t __loc)
+     throw () __attribute__ ((__nonnull__ (1, 3)));
+# 385 "/usr/include/stdlib.h" 3 4
+extern char *l64a (long int __n) throw () ;
+
+
+extern long int a64l (const char *__s)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
+
+
+
+
+# 1 "/usr/include/sys/types.h" 1 3 4
+# 23 "/usr/include/sys/types.h" 3 4
+#define _SYS_TYPES_H 1
+
+
+
+extern "C" {
+
+
+
+
+
+typedef __u_char u_char;
+typedef __u_short u_short;
+typedef __u_int u_int;
+typedef __u_long u_long;
+typedef __quad_t quad_t;
+typedef __u_quad_t u_quad_t;
+typedef __fsid_t fsid_t;
+#define __u_char_defined 
+
+typedef __loff_t loff_t;
+
+
+
+
+typedef __ino_t ino_t;
+
+
+
+#define __ino_t_defined 
+
+
+typedef __ino64_t ino64_t;
+#define __ino64_t_defined 
+
+
+
+typedef __dev_t dev_t;
+#define __dev_t_defined 
+# 69 "/usr/include/sys/types.h" 3 4
+typedef __mode_t mode_t;
+#define __mode_t_defined 
+
+
+
+typedef __nlink_t nlink_t;
+#define __nlink_t_defined 
+# 103 "/usr/include/sys/types.h" 3 4
+typedef __id_t id_t;
+#define __id_t_defined 
+# 114 "/usr/include/sys/types.h" 3 4
+typedef __daddr_t daddr_t;
+typedef __caddr_t caddr_t;
+#define __daddr_t_defined 
+
+
+
+
+typedef __key_t key_t;
+#define __key_t_defined 
+
+
+
+# 1 "/usr/include/bits/types/clock_t.h" 1 3 4
+
+#define __clock_t_defined 1
+
+
+
+
+typedef __clock_t clock_t;
+# 127 "/usr/include/sys/types.h" 2 3 4
+
+# 1 "/usr/include/bits/types/clockid_t.h" 1 3 4
+
+#define __clockid_t_defined 1
+
+
+
+
+typedef __clockid_t clockid_t;
+# 129 "/usr/include/sys/types.h" 2 3 4
+# 1 "/usr/include/bits/types/time_t.h" 1 3 4
+
+#define __time_t_defined 1
+
+
+
+
+typedef __time_t time_t;
+# 130 "/usr/include/sys/types.h" 2 3 4
+# 1 "/usr/include/bits/types/timer_t.h" 1 3 4
+
+#define __timer_t_defined 1
+
+
+
+
+typedef __timer_t timer_t;
+# 131 "/usr/include/sys/types.h" 2 3 4
+
+
+
+
+
+
+
+typedef __suseconds_t suseconds_t;
+#define __suseconds_t_defined 
+
+
+
+#define __need_size_t 
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 1 3 4
+# 155 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef __need_ptrdiff_t
+# 231 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef __need_size_t
+# 340 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef __need_wchar_t
+# 390 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef NULL
+
+#define NULL __null
+# 401 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef __need_NULL
+
+
+
+
+#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
+# 145 "/usr/include/sys/types.h" 2 3 4
+
+
+
+typedef unsigned long int ulong;
+typedef unsigned short int ushort;
+typedef unsigned int uint;
+
+
+
+
+# 1 "/usr/include/bits/stdint-intn.h" 1 3 4
+# 20 "/usr/include/bits/stdint-intn.h" 3 4
+#define _BITS_STDINT_INTN_H 1
+
+
+
+typedef __int8_t int8_t;
+typedef __int16_t int16_t;
+typedef __int32_t int32_t;
+typedef __int64_t int64_t;
+# 156 "/usr/include/sys/types.h" 2 3 4
+
+
+typedef __uint8_t u_int8_t;
+typedef __uint16_t u_int16_t;
+typedef __uint32_t u_int32_t;
+typedef __uint64_t u_int64_t;
+
+
+typedef int register_t __attribute__ ((__mode__ (__word__)));
+
+
+
+
+
+
+#define __BIT_TYPES_DEFINED__ 1
+
+
+
+
+# 1 "/usr/include/endian.h" 1 3 4
+# 19 "/usr/include/endian.h" 3 4
+#define _ENDIAN_H 1
+
+
+
+
+# 1 "/usr/include/bits/endian.h" 1 3 4
+# 20 "/usr/include/bits/endian.h" 3 4
+#define _BITS_ENDIAN_H 1
+# 30 "/usr/include/bits/endian.h" 3 4
+#define __LITTLE_ENDIAN 1234
+#define __BIG_ENDIAN 4321
+#define __PDP_ENDIAN 3412
+
+
+# 1 "/usr/include/bits/endianness.h" 1 3 4
+
+#define _BITS_ENDIANNESS_H 1
+
+
+
+
+
+
+#define __BYTE_ORDER __LITTLE_ENDIAN
+# 36 "/usr/include/bits/endian.h" 2 3 4
+
+
+
+
+#define __FLOAT_WORD_ORDER __BYTE_ORDER
+
+
+
+#define __LONG_LONG_PAIR(HI,LO) LO, HI
+# 25 "/usr/include/endian.h" 2 3 4
+
+
+#define LITTLE_ENDIAN __LITTLE_ENDIAN
+#define BIG_ENDIAN __BIG_ENDIAN
+#define PDP_ENDIAN __PDP_ENDIAN
+#define BYTE_ORDER __BYTE_ORDER
+
+
+
+
+# 1 "/usr/include/bits/byteswap.h" 1 3 4
+# 24 "/usr/include/bits/byteswap.h" 3 4
+#define _BITS_BYTESWAP_H 1
+
+
+
+
+
+#define __bswap_constant_16(x) ((__uint16_t) ((((x) >> 8) & 0xff) | (((x) & 0xff) << 8)))
+
+
+static __inline __uint16_t
+__bswap_16 (__uint16_t __bsx)
+{
+
+  return __builtin_bswap16 (__bsx);
+
+
+
+}
+
+
+#define __bswap_constant_32(x) ((((x) & 0xff000000u) >> 24) | (((x) & 0x00ff0000u) >> 8) | (((x) & 0x0000ff00u) << 8) | (((x) & 0x000000ffu) << 24))
+
+
+
+static __inline __uint32_t
+__bswap_32 (__uint32_t __bsx)
+{
+
+  return __builtin_bswap32 (__bsx);
+
+
+
+}
+
+
+#define __bswap_constant_64(x) ((((x) & 0xff00000000000000ull) >> 56) | (((x) & 0x00ff000000000000ull) >> 40) | (((x) & 0x0000ff0000000000ull) >> 24) | (((x) & 0x000000ff00000000ull) >> 8) | (((x) & 0x00000000ff000000ull) << 8) | (((x) & 0x0000000000ff0000ull) << 24) | (((x) & 0x000000000000ff00ull) << 40) | (((x) & 0x00000000000000ffull) << 56))
+# 69 "/usr/include/bits/byteswap.h" 3 4
+__extension__ static __inline __uint64_t
+__bswap_64 (__uint64_t __bsx)
+{
+
+  return __builtin_bswap64 (__bsx);
+
+
+
+}
+# 36 "/usr/include/endian.h" 2 3 4
+# 1 "/usr/include/bits/uintn-identity.h" 1 3 4
+# 24 "/usr/include/bits/uintn-identity.h" 3 4
+#define _BITS_UINTN_IDENTITY_H 1
+
+
+
+
+
+
+
+static __inline __uint16_t
+__uint16_identity (__uint16_t __x)
+{
+  return __x;
+}
+
+static __inline __uint32_t
+__uint32_identity (__uint32_t __x)
+{
+  return __x;
+}
+
+static __inline __uint64_t
+__uint64_identity (__uint64_t __x)
+{
+  return __x;
+}
+# 37 "/usr/include/endian.h" 2 3 4
+
+
+#define htobe16(x) __bswap_16 (x)
+#define htole16(x) __uint16_identity (x)
+#define be16toh(x) __bswap_16 (x)
+#define le16toh(x) __uint16_identity (x)
+
+#define htobe32(x) __bswap_32 (x)
+#define htole32(x) __uint32_identity (x)
+#define be32toh(x) __bswap_32 (x)
+#define le32toh(x) __uint32_identity (x)
+
+#define htobe64(x) __bswap_64 (x)
+#define htole64(x) __uint64_identity (x)
+#define be64toh(x) __bswap_64 (x)
+#define le64toh(x) __uint64_identity (x)
+# 177 "/usr/include/sys/types.h" 2 3 4
+
+
+# 1 "/usr/include/sys/select.h" 1 3 4
+# 22 "/usr/include/sys/select.h" 3 4
+#define _SYS_SELECT_H 1
+
+
+
+
+
+
+
+# 1 "/usr/include/bits/select.h" 1 3 4
+# 25 "/usr/include/bits/select.h" 3 4
+#define __FD_ZERO(s) do { unsigned int __i; fd_set *__arr = (s); for (__i = 0; __i < sizeof (fd_set) / sizeof (__fd_mask); ++__i) __FDS_BITS (__arr)[__i] = 0; } while (0)
+
+
+
+
+
+
+#define __FD_SET(d,s) ((void) (__FDS_BITS (s)[__FD_ELT(d)] |= __FD_MASK(d)))
+
+#define __FD_CLR(d,s) ((void) (__FDS_BITS (s)[__FD_ELT(d)] &= ~__FD_MASK(d)))
+
+#define __FD_ISSET(d,s) ((__FDS_BITS (s)[__FD_ELT (d)] & __FD_MASK (d)) != 0)
+# 31 "/usr/include/sys/select.h" 2 3 4
+
+
+# 1 "/usr/include/bits/types/sigset_t.h" 1 3 4
+
+#define __sigset_t_defined 1
+
+# 1 "/usr/include/bits/types/__sigset_t.h" 1 3 4
+
+#define ____sigset_t_defined 
+
+#define _SIGSET_NWORDS (1024 / (8 * sizeof (unsigned long int)))
+typedef struct
+{
+  unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))];
+} __sigset_t;
+# 5 "/usr/include/bits/types/sigset_t.h" 2 3 4
+
+
+typedef __sigset_t sigset_t;
+# 34 "/usr/include/sys/select.h" 2 3 4
+
+
+
+# 1 "/usr/include/bits/types/struct_timeval.h" 1 3 4
+
+#define __timeval_defined 1
+
+
+
+
+
+struct timeval
+{
+  __time_t tv_sec;
+  __suseconds_t tv_usec;
+};
+# 38 "/usr/include/sys/select.h" 2 3 4
+
+# 1 "/usr/include/bits/types/struct_timespec.h" 1 3 4
+
+
+#define _STRUCT_TIMESPEC 1
+
+
+
+
+
+
+struct timespec
+{
+  __time_t tv_sec;
+
+
+
+  __syscall_slong_t tv_nsec;
+# 26 "/usr/include/bits/types/struct_timespec.h" 3 4
+};
+# 40 "/usr/include/sys/select.h" 2 3 4
+# 49 "/usr/include/sys/select.h" 3 4
+typedef long int __fd_mask;
+
+
+#undef __NFDBITS
+
+#define __NFDBITS (8 * (int) sizeof (__fd_mask))
+#define __FD_ELT(d) ((d) / __NFDBITS)
+#define __FD_MASK(d) ((__fd_mask) (1UL << ((d) % __NFDBITS)))
+
+
+typedef struct
+  {
+
+
+
+    __fd_mask fds_bits[1024 / (8 * (int) sizeof (__fd_mask))];
+#define __FDS_BITS(set) ((set)->fds_bits)
+
+
+
+
+  } fd_set;
+
+
+#define FD_SETSIZE __FD_SETSIZE
+
+
+
+typedef __fd_mask fd_mask;
+
+
+#define NFDBITS __NFDBITS
+
+
+
+
+#define FD_SET(fd,fdsetp) __FD_SET (fd, fdsetp)
+#define FD_CLR(fd,fdsetp) __FD_CLR (fd, fdsetp)
+#define FD_ISSET(fd,fdsetp) __FD_ISSET (fd, fdsetp)
+#define FD_ZERO(fdsetp) __FD_ZERO (fdsetp)
+
+
+extern "C" {
+# 101 "/usr/include/sys/select.h" 3 4
+extern int select (int __nfds, fd_set *__restrict __readfds,
+     fd_set *__restrict __writefds,
+     fd_set *__restrict __exceptfds,
+     struct timeval *__restrict __timeout);
+# 113 "/usr/include/sys/select.h" 3 4
+extern int pselect (int __nfds, fd_set *__restrict __readfds,
+      fd_set *__restrict __writefds,
+      fd_set *__restrict __exceptfds,
+      const struct timespec *__restrict __timeout,
+      const __sigset_t *__restrict __sigmask);
+# 126 "/usr/include/sys/select.h" 3 4
+}
+# 180 "/usr/include/sys/types.h" 2 3 4
+
+
+
+
+
+typedef __blksize_t blksize_t;
+#define __blksize_t_defined 
+
+
+
+
+
+typedef __blkcnt_t blkcnt_t;
+#define __blkcnt_t_defined 
+
+
+typedef __fsblkcnt_t fsblkcnt_t;
+#define __fsblkcnt_t_defined 
+
+
+typedef __fsfilcnt_t fsfilcnt_t;
+#define __fsfilcnt_t_defined 
+# 219 "/usr/include/sys/types.h" 3 4
+typedef __blkcnt64_t blkcnt64_t;
+typedef __fsblkcnt64_t fsblkcnt64_t;
+typedef __fsfilcnt64_t fsfilcnt64_t;
+
+
+
+
+
+# 1 "/usr/include/bits/pthreadtypes.h" 1 3 4
+# 20 "/usr/include/bits/pthreadtypes.h" 3 4
+#define _BITS_PTHREADTYPES_COMMON_H 1
+
+
+# 1 "/usr/include/bits/thread-shared-types.h" 1 3 4
+# 20 "/usr/include/bits/thread-shared-types.h" 3 4
+#define _THREAD_SHARED_TYPES_H 1
+# 44 "/usr/include/bits/thread-shared-types.h" 3 4
+# 1 "/usr/include/bits/pthreadtypes-arch.h" 1 3 4
+# 19 "/usr/include/bits/pthreadtypes-arch.h" 3 4
+#define _BITS_PTHREADTYPES_ARCH_H 1
+
+# 1 "/usr/include/bits/wordsize.h" 1 3 4
+
+
+
+#define __WORDSIZE 64
+
+
+
+
+
+
+
+#define __WORDSIZE_TIME64_COMPAT32 1
+
+#define __SYSCALL_WORDSIZE 64
+# 22 "/usr/include/bits/pthreadtypes-arch.h" 2 3 4
+
+
+
+#define __SIZEOF_PTHREAD_MUTEX_T 40
+#define __SIZEOF_PTHREAD_ATTR_T 56
+#define __SIZEOF_PTHREAD_RWLOCK_T 56
+#define __SIZEOF_PTHREAD_BARRIER_T 32
+# 41 "/usr/include/bits/pthreadtypes-arch.h" 3 4
+#define __SIZEOF_PTHREAD_MUTEXATTR_T 4
+#define __SIZEOF_PTHREAD_COND_T 48
+#define __SIZEOF_PTHREAD_CONDATTR_T 4
+#define __SIZEOF_PTHREAD_RWLOCKATTR_T 8
+#define __SIZEOF_PTHREAD_BARRIERATTR_T 4
+
+#define __LOCK_ALIGNMENT 
+#define __ONCE_ALIGNMENT 
+# 45 "/usr/include/bits/thread-shared-types.h" 2 3 4
+
+
+
+
+typedef struct __pthread_internal_list
+{
+  struct __pthread_internal_list *__prev;
+  struct __pthread_internal_list *__next;
+} __pthread_list_t;
+
+typedef struct __pthread_internal_slist
+{
+  struct __pthread_internal_slist *__next;
+} __pthread_slist_t;
+# 74 "/usr/include/bits/thread-shared-types.h" 3 4
+# 1 "/usr/include/bits/struct_mutex.h" 1 3 4
+# 20 "/usr/include/bits/struct_mutex.h" 3 4
+#define _THREAD_MUTEX_INTERNAL_H 1
+
+struct __pthread_mutex_s
+{
+  int __lock;
+  unsigned int __count;
+  int __owner;
+
+  unsigned int __nusers;
+
+
+
+  int __kind;
+
+  short __spins;
+  short __elision;
+  __pthread_list_t __list;
+#define __PTHREAD_MUTEX_HAVE_PREV 1
+# 53 "/usr/include/bits/struct_mutex.h" 3 4
+};
+
+
+#define __PTHREAD_MUTEX_INITIALIZER(__kind) 0, 0, 0, 0, __kind, 0, 0, { 0, 0 }
+# 75 "/usr/include/bits/thread-shared-types.h" 2 3 4
+# 87 "/usr/include/bits/thread-shared-types.h" 3 4
+# 1 "/usr/include/bits/struct_rwlock.h" 1 3 4
+# 21 "/usr/include/bits/struct_rwlock.h" 3 4
+#define _RWLOCK_INTERNAL_H 
+
+struct __pthread_rwlock_arch_t
+{
+  unsigned int __readers;
+  unsigned int __writers;
+  unsigned int __wrphase_futex;
+  unsigned int __writers_futex;
+  unsigned int __pad3;
+  unsigned int __pad4;
+
+  int __cur_writer;
+  int __shared;
+  signed char __rwelision;
+
+
+
+
+  unsigned char __pad1[7];
+#define __PTHREAD_RWLOCK_ELISION_EXTRA 0, { 0, 0, 0, 0, 0, 0, 0 }
+
+  unsigned long int __pad2;
+
+
+  unsigned int __flags;
+# 55 "/usr/include/bits/struct_rwlock.h" 3 4
+};
+
+
+#define __PTHREAD_RWLOCK_INITIALIZER(__flags) 0, 0, 0, 0, 0, 0, 0, 0, __PTHREAD_RWLOCK_ELISION_EXTRA, 0, __flags
+# 88 "/usr/include/bits/thread-shared-types.h" 2 3 4
+
+
+
+
+struct __pthread_cond_s
+{
+  __extension__ union
+  {
+    __extension__ unsigned long long int __wseq;
+    struct
+    {
+      unsigned int __low;
+      unsigned int __high;
+    } __wseq32;
+  };
+  __extension__ union
+  {
+    __extension__ unsigned long long int __g1_start;
+    struct
+    {
+      unsigned int __low;
+      unsigned int __high;
+    } __g1_start32;
+  };
+  unsigned int __g_refs[2] ;
+  unsigned int __g_size[2];
+  unsigned int __g1_orig_size;
+  unsigned int __wrefs;
+  unsigned int __g_signals[2];
+};
+
+typedef unsigned int __tss_t;
+typedef unsigned long int __thrd_t;
+
+typedef struct
+{
+  int __data ;
+} __once_flag;
+
+#define __ONCE_FLAG_INIT { 0 }
+# 24 "/usr/include/bits/pthreadtypes.h" 2 3 4
+
+
+
+typedef unsigned long int pthread_t;
+
+
+
+
+typedef union
+{
+  char __size[4];
+  int __align;
+} pthread_mutexattr_t;
+
+
+
+
+typedef union
+{
+  char __size[4];
+  int __align;
+} pthread_condattr_t;
+
+
+
+typedef unsigned int pthread_key_t;
+
+
+
+typedef int pthread_once_t;
+
+
+union pthread_attr_t
+{
+  char __size[56];
+  long int __align;
+};
+
+typedef union pthread_attr_t pthread_attr_t;
+#define __have_pthread_attr_t 1
+
+
+
+typedef union
+{
+  struct __pthread_mutex_s __data;
+  char __size[40];
+  long int __align;
+} pthread_mutex_t;
+
+
+typedef union
+{
+  struct __pthread_cond_s __data;
+  char __size[48];
+  __extension__ long long int __align;
+} pthread_cond_t;
+
+
+
+
+
+typedef union
+{
+  struct __pthread_rwlock_arch_t __data;
+  char __size[56];
+  long int __align;
+} pthread_rwlock_t;
+
+typedef union
+{
+  char __size[8];
+  long int __align;
+} pthread_rwlockattr_t;
+
+
+
+
+
+typedef volatile int pthread_spinlock_t;
+
+
+
+
+typedef union
+{
+  char __size[32];
+  long int __align;
+} pthread_barrier_t;
+
+typedef union
+{
+  char __size[4];
+  int __align;
+} pthread_barrierattr_t;
+# 228 "/usr/include/sys/types.h" 2 3 4
+
+
+}
+# 395 "/usr/include/stdlib.h" 2 3 4
+
+
+
+
+
+
+extern long int random (void) throw ();
+
+
+extern void srandom (unsigned int __seed) throw ();
+
+
+
+
+
+extern char *initstate (unsigned int __seed, char *__statebuf,
+   size_t __statelen) throw () __attribute__ ((__nonnull__ (2)));
+
+
+
+extern char *setstate (char *__statebuf) throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+
+struct random_data
+  {
+    int32_t *fptr;
+    int32_t *rptr;
+    int32_t *state;
+    int rand_type;
+    int rand_deg;
+    int rand_sep;
+    int32_t *end_ptr;
+  };
+
+extern int random_r (struct random_data *__restrict __buf,
+       int32_t *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));
+
+extern int srandom_r (unsigned int __seed, struct random_data *__buf)
+     throw () __attribute__ ((__nonnull__ (2)));
+
+extern int initstate_r (unsigned int __seed, char *__restrict __statebuf,
+   size_t __statelen,
+   struct random_data *__restrict __buf)
+     throw () __attribute__ ((__nonnull__ (2, 4)));
+
+extern int setstate_r (char *__restrict __statebuf,
+         struct random_data *__restrict __buf)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+
+extern int rand (void) throw ();
+
+extern void srand (unsigned int __seed) throw ();
+
+
+
+extern int rand_r (unsigned int *__seed) throw ();
+
+
+
+
+
+
+
+extern double drand48 (void) throw ();
+extern double erand48 (unsigned short int __xsubi[3]) throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern long int lrand48 (void) throw ();
+extern long int nrand48 (unsigned short int __xsubi[3])
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern long int mrand48 (void) throw ();
+extern long int jrand48 (unsigned short int __xsubi[3])
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern void srand48 (long int __seedval) throw ();
+extern unsigned short int *seed48 (unsigned short int __seed16v[3])
+     throw () __attribute__ ((__nonnull__ (1)));
+extern void lcong48 (unsigned short int __param[7]) throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+struct drand48_data
+  {
+    unsigned short int __x[3];
+    unsigned short int __old_x[3];
+    unsigned short int __c;
+    unsigned short int __init;
+    __extension__ unsigned long long int __a;
+
+  };
+
+
+extern int drand48_r (struct drand48_data *__restrict __buffer,
+        double *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int erand48_r (unsigned short int __xsubi[3],
+        struct drand48_data *__restrict __buffer,
+        double *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int lrand48_r (struct drand48_data *__restrict __buffer,
+        long int *__restrict __result)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int nrand48_r (unsigned short int __xsubi[3],
+        struct drand48_data *__restrict __buffer,
+        long int *__restrict __result)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int mrand48_r (struct drand48_data *__restrict __buffer,
+        long int *__restrict __result)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int jrand48_r (unsigned short int __xsubi[3],
+        struct drand48_data *__restrict __buffer,
+        long int *__restrict __result)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int srand48_r (long int __seedval, struct drand48_data *__buffer)
+     throw () __attribute__ ((__nonnull__ (2)));
+
+extern int seed48_r (unsigned short int __seed16v[3],
+       struct drand48_data *__buffer) throw () __attribute__ ((__nonnull__ (1, 2)));
+
+extern int lcong48_r (unsigned short int __param[7],
+        struct drand48_data *__buffer)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+extern void *malloc (size_t __size) throw () __attribute__ ((__malloc__))
+     __attribute__ ((__alloc_size__ (1))) ;
+
+extern void *calloc (size_t __nmemb, size_t __size)
+     throw () __attribute__ ((__malloc__)) __attribute__ ((__alloc_size__ (1, 2))) ;
+
+
+
+
+
+
+extern void *realloc (void *__ptr, size_t __size)
+     throw () __attribute__ ((__warn_unused_result__)) __attribute__ ((__alloc_size__ (2)));
+
+
+
+
+
+
+
+extern void *reallocarray (void *__ptr, size_t __nmemb, size_t __size)
+     throw () __attribute__ ((__warn_unused_result__))
+     __attribute__ ((__alloc_size__ (2, 3)));
+
+
+
+extern void free (void *__ptr) throw ();
+
+
+# 1 "/usr/include/alloca.h" 1 3 4
+# 19 "/usr/include/alloca.h" 3 4
+#define _ALLOCA_H 1
+
+
+
+#define __need_size_t 
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 1 3 4
+# 155 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef __need_ptrdiff_t
+# 231 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef __need_size_t
+# 340 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef __need_wchar_t
+# 390 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef NULL
+
+#define NULL __null
+# 401 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef __need_NULL
+
+
+
+
+#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
+# 25 "/usr/include/alloca.h" 2 3 4
+
+extern "C" {
+
+
+#undef alloca
+
+
+extern void *alloca (size_t __size) throw ();
+
+
+#define alloca(size) __builtin_alloca (size)
+
+
+}
+# 569 "/usr/include/stdlib.h" 2 3 4
+
+
+
+
+
+extern void *valloc (size_t __size) throw () __attribute__ ((__malloc__))
+     __attribute__ ((__alloc_size__ (1))) ;
+
+
+
+
+extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size)
+     throw () __attribute__ ((__nonnull__ (1))) ;
+
+
+
+
+extern void *aligned_alloc (size_t __alignment, size_t __size)
+     throw () __attribute__ ((__malloc__)) __attribute__ ((__alloc_size__ (2))) ;
+
+
+
+extern void abort (void) throw () __attribute__ ((__noreturn__));
+
+
+
+extern int atexit (void (*__func) (void)) throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+extern "C++" int at_quick_exit (void (*__func) (void))
+     throw () __asm ("at_quick_exit") __attribute__ ((__nonnull__ (1)));
+# 610 "/usr/include/stdlib.h" 3 4
+extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+extern void exit (int __status) throw () __attribute__ ((__noreturn__));
+
+
+
+
+
+extern void quick_exit (int __status) throw () __attribute__ ((__noreturn__));
+
+
+
+
+
+extern void _Exit (int __status) throw () __attribute__ ((__noreturn__));
+
+
+
+
+extern char *getenv (const char *__name) throw () __attribute__ ((__nonnull__ (1))) ;
+
+
+
+
+extern char *secure_getenv (const char *__name)
+     throw () __attribute__ ((__nonnull__ (1))) ;
+
+
+
+
+
+
+extern int putenv (char *__string) throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+extern int setenv (const char *__name, const char *__value, int __replace)
+     throw () __attribute__ ((__nonnull__ (2)));
+
+
+extern int unsetenv (const char *__name) throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+extern int clearenv (void) throw ();
+# 675 "/usr/include/stdlib.h" 3 4
+extern char *mktemp (char *__template) throw () __attribute__ ((__nonnull__ (1)));
+# 688 "/usr/include/stdlib.h" 3 4
+extern int mkstemp (char *__template) __attribute__ ((__nonnull__ (1))) ;
+# 698 "/usr/include/stdlib.h" 3 4
+extern int mkstemp64 (char *__template) __attribute__ ((__nonnull__ (1))) ;
+# 710 "/usr/include/stdlib.h" 3 4
+extern int mkstemps (char *__template, int __suffixlen) __attribute__ ((__nonnull__ (1))) ;
+# 720 "/usr/include/stdlib.h" 3 4
+extern int mkstemps64 (char *__template, int __suffixlen)
+     __attribute__ ((__nonnull__ (1))) ;
+# 731 "/usr/include/stdlib.h" 3 4
+extern char *mkdtemp (char *__template) throw () __attribute__ ((__nonnull__ (1))) ;
+# 742 "/usr/include/stdlib.h" 3 4
+extern int mkostemp (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ;
+# 752 "/usr/include/stdlib.h" 3 4
+extern int mkostemp64 (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ;
+# 762 "/usr/include/stdlib.h" 3 4
+extern int mkostemps (char *__template, int __suffixlen, int __flags)
+     __attribute__ ((__nonnull__ (1))) ;
+# 774 "/usr/include/stdlib.h" 3 4
+extern int mkostemps64 (char *__template, int __suffixlen, int __flags)
+     __attribute__ ((__nonnull__ (1))) ;
+# 784 "/usr/include/stdlib.h" 3 4
+extern int system (const char *__command) ;
+
+
+
+
+
+extern char *canonicalize_file_name (const char *__name)
+     throw () __attribute__ ((__nonnull__ (1))) ;
+# 800 "/usr/include/stdlib.h" 3 4
+extern char *realpath (const char *__restrict __name,
+         char *__restrict __resolved) throw () ;
+
+
+
+
+
+#define __COMPAR_FN_T 
+typedef int (*__compar_fn_t) (const void *, const void *);
+
+
+typedef __compar_fn_t comparison_fn_t;
+
+
+
+typedef int (*__compar_d_fn_t) (const void *, const void *, void *);
+
+
+
+
+extern void *bsearch (const void *__key, const void *__base,
+        size_t __nmemb, size_t __size, __compar_fn_t __compar)
+     __attribute__ ((__nonnull__ (1, 2, 5))) ;
+
+
+
+
+
+
+
+extern void qsort (void *__base, size_t __nmemb, size_t __size,
+     __compar_fn_t __compar) __attribute__ ((__nonnull__ (1, 4)));
+
+extern void qsort_r (void *__base, size_t __nmemb, size_t __size,
+       __compar_d_fn_t __compar, void *__arg)
+  __attribute__ ((__nonnull__ (1, 4)));
+
+
+
+
+extern int abs (int __x) throw () __attribute__ ((__const__)) ;
+extern long int labs (long int __x) throw () __attribute__ ((__const__)) ;
+
+
+__extension__ extern long long int llabs (long long int __x)
+     throw () __attribute__ ((__const__)) ;
+
+
+
+
+
+
+extern div_t div (int __numer, int __denom)
+     throw () __attribute__ ((__const__)) ;
+extern ldiv_t ldiv (long int __numer, long int __denom)
+     throw () __attribute__ ((__const__)) ;
+
+
+__extension__ extern lldiv_t lldiv (long long int __numer,
+        long long int __denom)
+     throw () __attribute__ ((__const__)) ;
+# 872 "/usr/include/stdlib.h" 3 4
+extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt,
+     int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4))) ;
+
+
+
+
+extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt,
+     int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4))) ;
+
+
+
+
+extern char *gcvt (double __value, int __ndigit, char *__buf)
+     throw () __attribute__ ((__nonnull__ (3))) ;
+
+
+
+
+extern char *qecvt (long double __value, int __ndigit,
+      int *__restrict __decpt, int *__restrict __sign)
+     throw () __attribute__ ((__nonnull__ (3, 4))) ;
+extern char *qfcvt (long double __value, int __ndigit,
+      int *__restrict __decpt, int *__restrict __sign)
+     throw () __attribute__ ((__nonnull__ (3, 4))) ;
+extern char *qgcvt (long double __value, int __ndigit, char *__buf)
+     throw () __attribute__ ((__nonnull__ (3))) ;
+
+
+
+
+extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt,
+     int *__restrict __sign, char *__restrict __buf,
+     size_t __len) throw () __attribute__ ((__nonnull__ (3, 4, 5)));
+extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt,
+     int *__restrict __sign, char *__restrict __buf,
+     size_t __len) throw () __attribute__ ((__nonnull__ (3, 4, 5)));
+
+extern int qecvt_r (long double __value, int __ndigit,
+      int *__restrict __decpt, int *__restrict __sign,
+      char *__restrict __buf, size_t __len)
+     throw () __attribute__ ((__nonnull__ (3, 4, 5)));
+extern int qfcvt_r (long double __value, int __ndigit,
+      int *__restrict __decpt, int *__restrict __sign,
+      char *__restrict __buf, size_t __len)
+     throw () __attribute__ ((__nonnull__ (3, 4, 5)));
+
+
+
+
+
+extern int mblen (const char *__s, size_t __n) throw ();
+
+
+extern int mbtowc (wchar_t *__restrict __pwc,
+     const char *__restrict __s, size_t __n) throw ();
+
+
+extern int wctomb (char *__s, wchar_t __wchar) throw ();
+
+
+
+extern size_t mbstowcs (wchar_t *__restrict __pwcs,
+   const char *__restrict __s, size_t __n) throw ()
+    __attribute__ ((__access__ (__read_only__, 2)));
+
+extern size_t wcstombs (char *__restrict __s,
+   const wchar_t *__restrict __pwcs, size_t __n)
+     throw ()
+  __attribute__ ((__access__ (__write_only__, 1, 3))) __attribute__ ((__access__ (__read_only__, 2)));
+
+
+
+
+
+
+extern int rpmatch (const char *__response) throw () __attribute__ ((__nonnull__ (1))) ;
+# 958 "/usr/include/stdlib.h" 3 4
+extern int getsubopt (char **__restrict __optionp,
+        char *const *__restrict __tokens,
+        char **__restrict __valuep)
+     throw () __attribute__ ((__nonnull__ (1, 2, 3))) ;
+
+
+
+
+
+
+
+extern int posix_openpt (int __oflag) ;
+
+
+
+
+
+
+
+extern int grantpt (int __fd) throw ();
+
+
+
+extern int unlockpt (int __fd) throw ();
+
+
+
+
+extern char *ptsname (int __fd) throw () ;
+
+
+
+
+
+
+extern int ptsname_r (int __fd, char *__buf, size_t __buflen)
+     throw () __attribute__ ((__nonnull__ (2))) __attribute__ ((__access__ (__write_only__, 2, 3)));
+
+
+extern int getpt (void);
+
+
+
+
+
+
+extern int getloadavg (double __loadavg[], int __nelem)
+     throw () __attribute__ ((__nonnull__ (1)));
+# 1014 "/usr/include/stdlib.h" 3 4
+# 1 "/usr/include/bits/stdlib-float.h" 1 3 4
+# 1015 "/usr/include/stdlib.h" 2 3 4
+# 1026 "/usr/include/stdlib.h" 3 4
+}
+# 76 "/usr/include/c++/10.2.0/cstdlib" 2 3
+#undef _GLIBCXX_INCLUDE_NEXT_C_HEADERS
+# 1 "/usr/include/c++/10.2.0/bits/std_abs.h" 1 3
+# 31 "/usr/include/c++/10.2.0/bits/std_abs.h" 3
+#define _GLIBCXX_BITS_STD_ABS_H 
+
+       
+# 34 "/usr/include/c++/10.2.0/bits/std_abs.h" 3
+
+
+
+#define _GLIBCXX_INCLUDE_NEXT_C_HEADERS 
+
+
+
+
+#undef _GLIBCXX_INCLUDE_NEXT_C_HEADERS
+
+#undef abs
+
+extern "C++"
+{
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  using ::abs;
+
+
+  inline long
+  abs(long __i) { return __builtin_labs(__i); }
+
+
+
+  inline long long
+  abs(long long __x) { return __builtin_llabs (__x); }
+# 70 "/usr/include/c++/10.2.0/bits/std_abs.h" 3
+  inline constexpr double
+  abs(double __x)
+  { return __builtin_fabs(__x); }
+
+  inline constexpr float
+  abs(float __x)
+  { return __builtin_fabsf(__x); }
+
+  inline constexpr long double
+  abs(long double __x)
+  { return __builtin_fabsl(__x); }
+# 107 "/usr/include/c++/10.2.0/bits/std_abs.h" 3
+
+}
+}
+# 78 "/usr/include/c++/10.2.0/cstdlib" 2 3
+
+
+#undef abort
+
+#undef aligned_alloc
+
+#undef atexit
+
+
+#undef at_quick_exit
+
+
+#undef atof
+#undef atoi
+#undef atol
+#undef bsearch
+#undef calloc
+#undef div
+#undef exit
+#undef free
+#undef getenv
+#undef labs
+#undef ldiv
+#undef malloc
+#undef mblen
+#undef mbstowcs
+#undef mbtowc
+#undef qsort
+
+
+#undef quick_exit
+
+
+#undef rand
+#undef realloc
+#undef srand
+#undef strtod
+#undef strtol
+#undef strtoul
+#undef system
+#undef wcstombs
+#undef wctomb
+
+extern "C++"
+{
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  using ::div_t;
+  using ::ldiv_t;
+
+  using ::abort;
+
+  using ::aligned_alloc;
+
+  using ::atexit;
+
+
+  using ::at_quick_exit;
+
+
+  using ::atof;
+  using ::atoi;
+  using ::atol;
+  using ::bsearch;
+  using ::calloc;
+  using ::div;
+  using ::exit;
+  using ::free;
+  using ::getenv;
+  using ::labs;
+  using ::ldiv;
+  using ::malloc;
+
+  using ::mblen;
+  using ::mbstowcs;
+  using ::mbtowc;
+
+  using ::qsort;
+
+
+  using ::quick_exit;
+
+
+  using ::rand;
+  using ::realloc;
+  using ::srand;
+  using ::strtod;
+  using ::strtol;
+  using ::strtoul;
+  using ::system;
+
+  using ::wcstombs;
+  using ::wctomb;
+
+
+
+  inline ldiv_t
+  div(long __i, long __j) { return ldiv(__i, __j); }
+
+
+
+
+}
+
+
+
+#undef _Exit
+#undef llabs
+#undef lldiv
+#undef atoll
+#undef strtoll
+#undef strtoull
+#undef strtof
+#undef strtold
+
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+  using ::lldiv_t;
+
+
+
+
+
+  using ::_Exit;
+
+
+
+  using ::llabs;
+
+  inline lldiv_t
+  div(long long __n, long long __d)
+  { lldiv_t __q; __q.quot = __n / __d; __q.rem = __n % __d; return __q; }
+
+  using ::lldiv;
+# 227 "/usr/include/c++/10.2.0/cstdlib" 3
+  using ::atoll;
+  using ::strtoll;
+  using ::strtoull;
+
+  using ::strtof;
+  using ::strtold;
+
+
+}
+
+namespace std
+{
+
+  using ::__gnu_cxx::lldiv_t;
+
+  using ::__gnu_cxx::_Exit;
+
+  using ::__gnu_cxx::llabs;
+  using ::__gnu_cxx::div;
+  using ::__gnu_cxx::lldiv;
+
+  using ::__gnu_cxx::atoll;
+  using ::__gnu_cxx::strtof;
+  using ::__gnu_cxx::strtoll;
+  using ::__gnu_cxx::strtoull;
+  using ::__gnu_cxx::strtold;
+}
+
+
+
+}
+# 16 "/usr/include/boost/config/platform/linux.hpp" 2 3 4
+# 30 "/usr/include/boost/config/platform/linux.hpp" 3 4
+#define BOOST_HAS_STDINT_H 
+# 55 "/usr/include/boost/config/platform/linux.hpp" 3 4
+#define BOOST_HAS_GETTIMEOFDAY 
+
+
+
+#define BOOST_HAS_NANOSLEEP 
+# 74 "/usr/include/boost/config/platform/linux.hpp" 3 4
+#define BOOST_HAS_UNISTD_H 
+# 1 "/usr/include/boost/config/detail/posix_features.hpp" 1 3 4
+# 22 "/usr/include/boost/config/detail/posix_features.hpp" 3 4
+#define BOOST_HAS_NL_TYPES_H 
+
+
+
+
+#define BOOST_HAS_STDINT_H 
+
+
+
+
+#define BOOST_HAS_DIRENT_H 
+
+
+
+
+#define BOOST_HAS_SIGACTION 
+# 46 "/usr/include/boost/config/detail/posix_features.hpp" 3 4
+#define BOOST_HAS_PTHREADS 
+
+
+
+
+
+
+#define BOOST_HAS_NANOSLEEP 
+
+
+
+
+
+
+
+#define BOOST_HAS_CLOCK_GETTIME 
+# 70 "/usr/include/boost/config/detail/posix_features.hpp" 3 4
+#define BOOST_HAS_SCHED_YIELD 
+# 79 "/usr/include/boost/config/detail/posix_features.hpp" 3 4
+#define BOOST_HAS_GETTIMEOFDAY 
+
+#define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE 
+
+
+#define BOOST_HAS_LOG1P 
+
+
+#define BOOST_HAS_EXPM1 
+# 76 "/usr/include/boost/config/platform/linux.hpp" 2 3 4
+
+#define BOOST_HAS_PTHREAD_YIELD 
+# 58 "/usr/include/boost/config.hpp" 2 3 4
+
+
+
+# 1 "/usr/include/boost/config/detail/suffix.hpp" 1 3 4
+# 27 "/usr/include/boost/config/detail/suffix.hpp" 3 4
+#define BOOST_CONFIG_SUFFIX_HPP 
+
+
+
+
+
+
+       
+# 35 "/usr/include/boost/config/detail/suffix.hpp" 3
+# 112 "/usr/include/boost/config/detail/suffix.hpp" 3
+#define BOOST_NO_MS_INT64_NUMERIC_LIMITS 
+# 121 "/usr/include/boost/config/detail/suffix.hpp" 3
+#define BOOST_MSVC6_MEMBER_TEMPLATES 
+# 195 "/usr/include/boost/config/detail/suffix.hpp" 3
+#define BOOST_HAS_PARTIAL_STD_ALLOCATOR 
+# 358 "/usr/include/boost/config/detail/suffix.hpp" 3
+#define BOOST_PREVENT_MACRO_SUBSTITUTION 
+
+
+#define BOOST_USING_STD_MIN() using std::min
+
+
+
+#define BOOST_USING_STD_MAX() using std::max
+# 394 "/usr/include/boost/config/detail/suffix.hpp" 3
+#define BOOST_STATIC_CONSTANT(type,assignment) static const type assignment
+# 422 "/usr/include/boost/config/detail/suffix.hpp" 3
+#define BOOST_USE_FACET(Type,loc) std::use_facet< Type >(loc)
+#define BOOST_HAS_FACET(Type,loc) std::has_facet< Type >(loc)
+# 437 "/usr/include/boost/config/detail/suffix.hpp" 3
+#define BOOST_NESTED_TEMPLATE template
+# 467 "/usr/include/boost/config/detail/suffix.hpp" 3
+#define BOOST_DEDUCED_TYPENAME typename
+
+
+
+
+
+#define BOOST_CTOR_TYPENAME typename
+# 484 "/usr/include/boost/config/detail/suffix.hpp" 3
+namespace boost{
+
+   __extension__ typedef long long long_long_type;
+   __extension__ typedef unsigned long long ulong_long_type;
+
+
+
+
+}
+
+
+
+namespace boost{
+
+   __extension__ typedef __int128 int128_type;
+   __extension__ typedef unsigned __int128 uint128_type;
+
+
+
+
+}
+# 521 "/usr/include/boost/config/detail/suffix.hpp" 3
+#define BOOST_EXPLICIT_TEMPLATE_TYPE(t) 
+#define BOOST_EXPLICIT_TEMPLATE_TYPE_SPEC(t) 
+#define BOOST_EXPLICIT_TEMPLATE_NON_TYPE(t,v) 
+#define BOOST_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t,v) 
+
+#define BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(t) 
+#define BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE_SPEC(t) 
+#define BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(t,v) 
+#define BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t,v) 
+# 543 "/usr/include/boost/config/detail/suffix.hpp" 3
+# 1 "/usr/include/boost/config/helper_macros.hpp" 1 3 4
+
+#define BOOST_CONFIG_HELPER_MACROS_HPP_INCLUDED 
+# 22 "/usr/include/boost/config/helper_macros.hpp" 3 4
+#define BOOST_STRINGIZE(X) BOOST_DO_STRINGIZE(X)
+#define BOOST_DO_STRINGIZE(X) #X
+# 33 "/usr/include/boost/config/helper_macros.hpp" 3 4
+#define BOOST_JOIN(X,Y) BOOST_DO_JOIN(X, Y)
+#define BOOST_DO_JOIN(X,Y) BOOST_DO_JOIN2(X,Y)
+#define BOOST_DO_JOIN2(X,Y) X ##Y
+# 544 "/usr/include/boost/config/detail/suffix.hpp" 2 3
+# 568 "/usr/include/boost/config/detail/suffix.hpp" 3
+#define BOOST_GPU_ENABLED 
+# 581 "/usr/include/boost/config/detail/suffix.hpp" 3
+#define BOOST_RESTRICT __restrict__
+# 605 "/usr/include/boost/config/detail/suffix.hpp" 3
+#define BOOST_FORCEINLINE inline __attribute__ ((__always_inline__))
+# 623 "/usr/include/boost/config/detail/suffix.hpp" 3
+#define BOOST_NOINLINE __attribute__ ((__noinline__))
+# 638 "/usr/include/boost/config/detail/suffix.hpp" 3
+#define BOOST_NORETURN __attribute__ ((__noreturn__))
+# 674 "/usr/include/boost/config/detail/suffix.hpp" 3
+#define BOOST_ALIGNMENT(x) alignas(x)
+# 715 "/usr/include/boost/config/detail/suffix.hpp" 3
+#define BOOST_DEFAULTED_FUNCTION(fun,body) fun = default;
+
+
+
+
+
+#define BOOST_DELETED_FUNCTION(fun) fun = delete;
+# 950 "/usr/include/boost/config/detail/suffix.hpp" 3
+#define BOOST_FINAL final
+# 965 "/usr/include/boost/config/detail/suffix.hpp" 3
+#define BOOST_NOEXCEPT noexcept
+#define BOOST_NOEXCEPT_OR_NOTHROW noexcept
+#define BOOST_NOEXCEPT_IF(Predicate) noexcept((Predicate))
+#define BOOST_NOEXCEPT_EXPR(Expression) noexcept((Expression))
+# 988 "/usr/include/boost/config/detail/suffix.hpp" 3
+#define BOOST_CONSTEXPR constexpr
+#define BOOST_CONSTEXPR_OR_CONST constexpr
+
+
+
+
+#define BOOST_CXX14_CONSTEXPR constexpr
+
+
+
+
+
+
+#define BOOST_INLINE_VARIABLE inline
+# 1018 "/usr/include/boost/config/detail/suffix.hpp" 3
+#define BOOST_ATTRIBUTE_NODISCARD [[nodiscard]]
+
+
+#define BOOST_ATTRIBUTE_NO_UNIQUE_ADDRESS [[no_unique_address]]
+# 1031 "/usr/include/boost/config/detail/suffix.hpp" 3
+#define BOOST_STATIC_CONSTEXPR static BOOST_CONSTEXPR_OR_CONST
+# 62 "/usr/include/boost/config.hpp" 2 3 4
+
+
+       
+# 17 "/usr/include/boost/test/detail/config.hpp" 2 3 4
+# 1 "/usr/include/boost/detail/workaround.hpp" 1 3 4
+
+
+
+
+
+#define WORKAROUND_DWA2002126_HPP 
+
+# 1 "/usr/include/boost/config/workaround.hpp" 1 3 4
+
+
+
+
+
+#define BOOST_CONFIG_WORKAROUND_HPP 
+# 44 "/usr/include/boost/config/workaround.hpp" 3 4
+#define __BORLANDC___WORKAROUND_GUARD 1
+
+
+
+
+#define __CODEGEARC___WORKAROUND_GUARD 1
+
+
+
+
+#define _MSC_VER_WORKAROUND_GUARD 1
+
+
+
+
+#define _MSC_FULL_VER_WORKAROUND_GUARD 1
+
+
+
+
+#define BOOST_MSVC_WORKAROUND_GUARD 1
+
+
+
+
+#define BOOST_MSVC_FULL_VER_WORKAROUND_GUARD 1
+
+
+
+
+
+
+#define __GNUC___WORKAROUND_GUARD 0
+
+
+
+
+#define __GNUC_MINOR___WORKAROUND_GUARD 0
+
+
+
+
+#define __GNUC_PATCHLEVEL___WORKAROUND_GUARD 0
+
+
+
+
+
+#define BOOST_GCC_WORKAROUND_GUARD 0
+#define BOOST_GCC_VERSION_WORKAROUND_GUARD 0
+
+
+#define BOOST_XLCPP_ZOS_WORKAROUND_GUARD 1
+
+
+
+
+#define __IBMCPP___WORKAROUND_GUARD 1
+
+
+
+
+#define __SUNPRO_CC_WORKAROUND_GUARD 1
+
+
+
+
+#define __DECCXX_VER_WORKAROUND_GUARD 1
+
+
+
+
+#define __MWERKS___WORKAROUND_GUARD 1
+
+
+
+
+#define __EDG___WORKAROUND_GUARD 1
+
+
+
+
+#define __EDG_VERSION___WORKAROUND_GUARD 1
+
+
+
+
+#define __HP_aCC_WORKAROUND_GUARD 1
+
+
+
+
+#define __hpxstd98_WORKAROUND_GUARD 1
+
+
+
+
+#define _CRAYC_WORKAROUND_GUARD 1
+
+
+
+
+#define __DMC___WORKAROUND_GUARD 1
+
+
+
+
+#define MPW_CPLUS_WORKAROUND_GUARD 1
+
+
+
+
+#define __COMO___WORKAROUND_GUARD 1
+
+
+
+
+#define __COMO_VERSION___WORKAROUND_GUARD 1
+
+
+
+
+#define __INTEL_COMPILER_WORKAROUND_GUARD 1
+
+
+
+
+#define __ICL_WORKAROUND_GUARD 1
+
+
+
+
+#define _COMPILER_VERSION_WORKAROUND_GUARD 1
+
+
+
+
+
+#define _RWSTD_VER_WORKAROUND_GUARD 1
+
+
+
+
+#define BOOST_RWSTD_VER_WORKAROUND_GUARD 1
+
+
+
+
+#define __GLIBCPP___WORKAROUND_GUARD 1
+
+
+
+
+#define _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC_WORKAROUND_GUARD 1
+
+
+
+
+#define __SGI_STL_PORT_WORKAROUND_GUARD 1
+
+
+
+
+#define _STLPORT_VERSION_WORKAROUND_GUARD 1
+
+
+
+
+#define __LIBCOMO_VERSION___WORKAROUND_GUARD 1
+
+
+
+
+#define _CPPLIB_VER_WORKAROUND_GUARD 1
+
+
+
+
+
+#define BOOST_INTEL_CXX_VERSION_WORKAROUND_GUARD 1
+
+
+
+
+#define BOOST_INTEL_WIN_WORKAROUND_GUARD 1
+
+
+
+
+#define BOOST_DINKUMWARE_STDLIB_WORKAROUND_GUARD 1
+
+
+
+
+#define BOOST_INTEL_WORKAROUND_GUARD 1
+
+
+
+
+#define BOOST_MPL_CFG_GCC_WORKAROUND_GUARD 0
+
+#define BOOST_WORKAROUND(symbol,test) ((symbol ## _WORKAROUND_GUARD + 0 == 0) && (symbol != 0) && (1 % (( (symbol test) ) + 1)))
+# 270 "/usr/include/boost/config/workaround.hpp" 3 4
+#define BOOST_TESTED_AT(value) != ((value)-(value))
+# 9 "/usr/include/boost/detail/workaround.hpp" 2 3 4
+# 18 "/usr/include/boost/test/detail/config.hpp" 2 3 4
+# 44 "/usr/include/boost/test/detail/config.hpp" 3 4
+#define BOOST_TEST_CALL_DECL 
+
+
+
+
+
+#define BOOST_TEST_USE_STD_LOCALE 1
+# 68 "/usr/include/boost/test/detail/config.hpp" 3 4
+#define BOOST_TEST_PROTECTED_VIRTUAL virtual
+
+
+
+
+
+
+
+#define BOOST_TEST_SUPPORT_TOKEN_ITERATOR 1
+# 85 "/usr/include/boost/test/detail/config.hpp" 3 4
+#define BOOST_TEST_ENUM_SYMBOL_VISIBLE BOOST_SYMBOL_VISIBLE
+# 103 "/usr/include/boost/test/detail/config.hpp" 3 4
+#undef BOOST_TEST_DYN_LINK
+# 115 "/usr/include/boost/test/detail/config.hpp" 3 4
+#define BOOST_TEST_DECL BOOST_SYMBOL_VISIBLE
+# 139 "/usr/include/boost/test/detail/config.hpp" 3 4
+#define BOOST_PP_VARIADICS 1
+# 151 "/usr/include/boost/test/detail/config.hpp" 3 4
+#define BOOST_TEST_STRING_VIEW 
+# 20 "/usr/include/boost/test/utils/basic_cstring/basic_cstring_fwd.hpp" 2 3 4
+
+
+namespace boost {
+
+namespace unit_test {
+
+template<typename CharT> class __attribute__((__visibility__("default"))) basic_cstring;
+typedef basic_cstring<char const> const_string;
+
+
+
+typedef const_string const literal_string;
+
+
+typedef char const* const c_literal_string;
+
+
+template <class CharT, class string_view_t>
+class __attribute__((__visibility__("default"))) stringview_cstring_helper;
+
+
+
+}
+
+}
+# 21 "/usr/include/boost/test/utils/basic_cstring/basic_cstring.hpp" 2 3 4
+# 1 "/usr/include/boost/test/utils/basic_cstring/bcs_char_traits.hpp" 1 3 4
+# 16 "/usr/include/boost/test/utils/basic_cstring/bcs_char_traits.hpp" 3 4
+#define BOOST_TEST_UTILS_BCS_CHAR_TRAITS_HPP 
+
+
+
+
+
+# 1 "/usr/include/boost/type_traits/add_const.hpp" 1 3 4
+# 11 "/usr/include/boost/type_traits/add_const.hpp" 3 4
+#define BOOST_TT_ADD_CONST_HPP_INCLUDED 
+
+# 1 "/usr/include/boost/type_traits/detail/config.hpp" 1 3 4
+# 10 "/usr/include/boost/type_traits/detail/config.hpp" 3 4
+#define BOOST_TT_CONFIG_HPP_INCLUDED 
+
+
+
+
+# 1 "/usr/include/boost/version.hpp" 1 3 4
+# 10 "/usr/include/boost/version.hpp" 3 4
+#define BOOST_VERSION_HPP 
+# 22 "/usr/include/boost/version.hpp" 3 4
+#define BOOST_VERSION 107200
+
+
+
+
+
+
+
+#define BOOST_LIB_VERSION "1_72"
+# 16 "/usr/include/boost/type_traits/detail/config.hpp" 2 3 4
+# 26 "/usr/include/boost/type_traits/detail/config.hpp" 3 4
+#define BOOST_TT_DECL 
+# 43 "/usr/include/boost/type_traits/detail/config.hpp" 3 4
+#define BOOST_TT_HAS_CONFORMING_IS_CLASS_IMPLEMENTATION 1
+# 67 "/usr/include/boost/type_traits/detail/config.hpp" 3 4
+#define BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(x) 
+#define BOOST_TT_BROKEN_COMPILER_SPEC(x) 
+
+
+
+
+
+#define BOOST_TT_HAS_ACCURATE_BINARY_OPERATOR_DETECTION 
+# 86 "/usr/include/boost/type_traits/detail/config.hpp" 3 4
+#define BOOST_TT_HAS_ASCCURATE_IS_FUNCTION 
+# 14 "/usr/include/boost/type_traits/add_const.hpp" 2 3 4
+
+namespace boost {
+# 30 "/usr/include/boost/type_traits/add_const.hpp" 3 4
+   template <class T> struct add_const
+   {
+      typedef T const type;
+   };
+
+
+
+
+
+   template <class T> struct add_const<T&>
+   {
+      typedef T& type;
+   };
+
+
+
+   template <class T> using add_const_t = typename add_const<T>::type;
+
+
+
+}
+# 23 "/usr/include/boost/test/utils/basic_cstring/bcs_char_traits.hpp" 2 3 4
+
+
+# 1 "/usr/include/c++/10.2.0/string" 1 3 4
+# 34 "/usr/include/c++/10.2.0/string" 3 4
+#define _GLIBCXX_STRING 1
+
+       
+# 37 "/usr/include/c++/10.2.0/string" 3
+
+
+# 1 "/usr/include/c++/10.2.0/bits/stringfwd.h" 1 3
+# 35 "/usr/include/c++/10.2.0/bits/stringfwd.h" 3
+#define _STRINGFWD_H 1
+
+       
+# 38 "/usr/include/c++/10.2.0/bits/stringfwd.h" 3
+
+
+# 1 "/usr/include/c++/10.2.0/bits/memoryfwd.h" 1 3
+# 44 "/usr/include/c++/10.2.0/bits/memoryfwd.h" 3
+#define _MEMORYFWD_H 1
+
+       
+# 47 "/usr/include/c++/10.2.0/bits/memoryfwd.h" 3
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 63 "/usr/include/c++/10.2.0/bits/memoryfwd.h" 3
+  template<typename>
+    class allocator;
+
+
+  template<>
+    class allocator<void>;
+
+
+
+
+  template<typename, typename>
+    struct uses_allocator;
+
+
+
+
+
+}
+# 41 "/usr/include/c++/10.2.0/bits/stringfwd.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+
+
+
+  template<class _CharT>
+    struct char_traits;
+
+  template<> struct char_traits<char>;
+
+
+  template<> struct char_traits<wchar_t>;
+
+
+
+
+
+
+
+  template<> struct char_traits<char16_t>;
+  template<> struct char_traits<char32_t>;
+
+
+namespace __cxx11 {
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT>,
+           typename _Alloc = allocator<_CharT> >
+    class basic_string;
+
+}
+
+
+  typedef basic_string<char> string;
+
+
+
+  typedef basic_string<wchar_t> wstring;
+# 93 "/usr/include/c++/10.2.0/bits/stringfwd.h" 3
+  typedef basic_string<char16_t> u16string;
+
+
+  typedef basic_string<char32_t> u32string;
+
+
+
+
+
+}
+# 40 "/usr/include/c++/10.2.0/string" 2 3
+# 1 "/usr/include/c++/10.2.0/bits/char_traits.h" 1 3
+# 35 "/usr/include/c++/10.2.0/bits/char_traits.h" 3
+#define _CHAR_TRAITS_H 1
+
+       
+# 38 "/usr/include/c++/10.2.0/bits/char_traits.h" 3
+
+# 1 "/usr/include/c++/10.2.0/bits/stl_algobase.h" 1 3
+# 57 "/usr/include/c++/10.2.0/bits/stl_algobase.h" 3
+#define _STL_ALGOBASE_H 1
+
+
+# 1 "/usr/include/c++/10.2.0/bits/functexcept.h" 1 3
+# 37 "/usr/include/c++/10.2.0/bits/functexcept.h" 3
+#define _FUNCTEXCEPT_H 1
+
+
+# 1 "/usr/include/c++/10.2.0/bits/exception_defines.h" 1 3
+# 31 "/usr/include/c++/10.2.0/bits/exception_defines.h" 3
+#define _EXCEPTION_DEFINES_H 1
+# 40 "/usr/include/c++/10.2.0/bits/exception_defines.h" 3
+#define __try try
+#define __catch(X) catch(X)
+#define __throw_exception_again throw
+# 41 "/usr/include/c++/10.2.0/bits/functexcept.h" 2 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_ios_failure(const char*, int) __attribute__((__noreturn__));
+
+
+  void
+  __throw_system_error(int) __attribute__((__noreturn__));
+
+
+  void
+  __throw_future_error(int) __attribute__((__noreturn__));
+
+
+  void
+  __throw_bad_function_call() __attribute__((__noreturn__));
+
+
+}
+# 61 "/usr/include/c++/10.2.0/bits/stl_algobase.h" 2 3
+# 1 "/usr/include/c++/10.2.0/bits/cpp_type_traits.h" 1 3
+# 33 "/usr/include/c++/10.2.0/bits/cpp_type_traits.h" 3
+#define _CPP_TYPE_TRAITS_H 1
+
+       
+# 36 "/usr/include/c++/10.2.0/bits/cpp_type_traits.h" 3
+# 67 "/usr/include/c++/10.2.0/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;
+    };
+# 184 "/usr/include/c++/10.2.0/bits/cpp_type_traits.h" 3
+  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;
+    };
+
+#define __INT_N(TYPE) template<> struct __is_integer<TYPE> { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_integer<unsigned TYPE> { enum { __value = 1 }; typedef __true_type __type; };
+# 282 "/usr/include/c++/10.2.0/bits/cpp_type_traits.h" 3
+#undef __INT_N
+
+
+
+
+  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;
+    };
+
+
+  enum class byte : unsigned char;
+
+  template<>
+    struct __is_byte<byte>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+# 423 "/usr/include/c++/10.2.0/bits/cpp_type_traits.h" 3
+  template<typename> struct iterator_traits;
+
+
+  template<typename _Tp>
+    struct __is_nonvolatile_trivially_copyable
+    {
+      enum { __value = __is_trivially_copyable(_Tp) };
+    };
+
+
+
+
+  template<typename _Tp>
+    struct __is_nonvolatile_trivially_copyable<volatile _Tp>
+    {
+      enum { __value = 0 };
+    };
+
+
+  template<typename _OutputIter, typename _InputIter>
+    struct __memcpyable
+    {
+      enum { __value = 0 };
+    };
+
+  template<typename _Tp>
+    struct __memcpyable<_Tp*, _Tp*>
+    : __is_nonvolatile_trivially_copyable<_Tp>
+    { };
+
+  template<typename _Tp>
+    struct __memcpyable<_Tp*, const _Tp*>
+    : __is_nonvolatile_trivially_copyable<_Tp>
+    { };
+
+
+
+
+
+
+  template<typename _Iter1, typename _Iter2>
+    struct __memcmpable
+    {
+      enum { __value = 0 };
+    };
+
+
+  template<typename _Tp>
+    struct __memcmpable<_Tp*, _Tp*>
+    : __is_nonvolatile_trivially_copyable<_Tp>
+    { };
+
+  template<typename _Tp>
+    struct __memcmpable<const _Tp*, _Tp*>
+    : __is_nonvolatile_trivially_copyable<_Tp>
+    { };
+
+  template<typename _Tp>
+    struct __memcmpable<_Tp*, const _Tp*>
+    : __is_nonvolatile_trivially_copyable<_Tp>
+    { };
+
+
+
+
+  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 "/usr/include/c++/10.2.0/bits/stl_algobase.h" 2 3
+# 1 "/usr/include/c++/10.2.0/ext/type_traits.h" 1 3
+# 30 "/usr/include/c++/10.2.0/ext/type_traits.h" 3
+#define _EXT_TYPE_TRAITS 1
+
+       
+# 33 "/usr/include/c++/10.2.0/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 "/usr/include/c++/10.2.0/bits/stl_algobase.h" 2 3
+# 1 "/usr/include/c++/10.2.0/ext/numeric_traits.h" 1 3
+# 30 "/usr/include/c++/10.2.0/ext/numeric_traits.h" 3
+#define _EXT_NUMERIC_TRAITS 1
+
+       
+# 33 "/usr/include/c++/10.2.0/ext/numeric_traits.h" 3
+
+
+
+
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+#define __glibcxx_signed(_Tp) ((_Tp)(-1) < 0)
+#define __glibcxx_digits(_Tp) (sizeof(_Tp) * __CHAR_BIT__ - __glibcxx_signed(_Tp))
+
+
+#define __glibcxx_min(_Tp) (__glibcxx_signed(_Tp) ? -__glibcxx_max(_Tp) - 1 : (_Tp)0)
+
+
+#define __glibcxx_max(_Tp) (__glibcxx_signed(_Tp) ? (((((_Tp)1 << (__glibcxx_digits(_Tp) - 1)) - 1) << 1) + 1) : ~(_Tp)0)
+
+
+
+  template<typename _Value>
+    struct __numeric_traits_integer
+    {
+
+      static const _Value __min = (((_Value)(-1) < 0) ? -(((_Value)(-1) < 0) ? (((((_Value)1 << ((sizeof(_Value) * 8 - ((_Value)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(_Value)0) - 1 : (_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;
+
+#undef __glibcxx_signed
+#undef __glibcxx_digits
+#undef __glibcxx_min
+#undef __glibcxx_max
+
+#define __glibcxx_floating(_Tp,_Fval,_Dval,_LDval) (std::__are_same<_Tp, float>::__value ? _Fval : std::__are_same<_Tp, double>::__value ? _Dval : _LDval)
+
+
+
+#define __glibcxx_max_digits10(_Tp) (2 + __glibcxx_floating(_Tp, __FLT_MANT_DIG__, __DBL_MANT_DIG__, __LDBL_MANT_DIG__) * 643L / 2136)
+
+
+
+#define __glibcxx_digits10(_Tp) __glibcxx_floating(_Tp, __FLT_DIG__, __DBL_DIG__, __LDBL_DIG__)
+
+
+#define __glibcxx_max_exponent10(_Tp) __glibcxx_floating(_Tp, __FLT_MAX_10_EXP__, __DBL_MAX_10_EXP__, __LDBL_MAX_10_EXP__)
+
+
+
+  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
+    { };
+
+
+}
+
+#undef __glibcxx_floating
+#undef __glibcxx_max_digits10
+#undef __glibcxx_digits10
+#undef __glibcxx_max_exponent10
+# 64 "/usr/include/c++/10.2.0/bits/stl_algobase.h" 2 3
+# 1 "/usr/include/c++/10.2.0/bits/stl_pair.h" 1 3
+# 57 "/usr/include/c++/10.2.0/bits/stl_pair.h" 3
+#define _STL_PAIR_H 1
+
+# 1 "/usr/include/c++/10.2.0/bits/move.h" 1 3
+# 31 "/usr/include/c++/10.2.0/bits/move.h" 3
+#define _MOVE_H 1
+
+
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+
+
+  template<typename _Tp>
+    inline constexpr _Tp*
+    __addressof(_Tp& __r) noexcept
+    { return __builtin_addressof(__r); }
+
+
+
+
+}
+
+# 1 "/usr/include/c++/10.2.0/type_traits" 1 3
+# 30 "/usr/include/c++/10.2.0/type_traits" 3
+#define _GLIBCXX_TYPE_TRAITS 1
+
+       
+# 33 "/usr/include/c++/10.2.0/type_traits" 3
+
+
+
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 56 "/usr/include/c++/10.2.0/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; }
+
+
+#define __cpp_lib_integral_constant_callable 201304
+
+      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>;
+
+
+#define __cpp_lib_bool_constant 201505
+  template<bool __v>
+    using bool_constant = integral_constant<bool, __v>;
+
+
+
+
+  template<bool, typename, typename>
+    struct conditional;
+
+  template <typename _Type>
+    struct __type_identity
+    { using type = _Type; };
+
+  template<typename _Tp>
+    using __type_identity_t = typename __type_identity<_Tp>::type;
+
+  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)>
+    { };
+
+
+
+  template<typename... _Bn>
+    inline constexpr bool __or_v = __or_<_Bn...>::value;
+  template<typename... _Bn>
+    inline constexpr bool __and_v = __and_<_Bn...>::value;
+
+#define __cpp_lib_logical_traits 201510
+
+  template<typename... _Bn>
+    struct conjunction
+    : __and_<_Bn...>
+    { };
+
+  template<typename... _Bn>
+    struct disjunction
+    : __or_<_Bn...>
+    { };
+
+  template<typename _Pp>
+    struct negation
+    : __not_<_Pp>
+    { };
+
+  template<typename... _Bn>
+    inline constexpr bool conjunction_v = conjunction<_Bn...>::value;
+
+  template<typename... _Bn>
+    inline constexpr bool disjunction_v = disjunction<_Bn...>::value;
+
+  template<typename _Pp>
+    inline constexpr bool negation_v = negation<_Pp>::value;
+
+
+
+
+  template<typename>
+    struct is_reference;
+  template<typename>
+    struct is_function;
+  template<typename>
+    struct is_void;
+  template<typename>
+    struct __is_array_unknown_bounds;
+
+
+
+
+  template <typename _Tp, size_t = sizeof(_Tp)>
+    constexpr true_type __is_complete_or_unbounded(__type_identity<_Tp>)
+    { return {}; }
+
+  template <typename _TypeIdentity,
+      typename _NestedType = typename _TypeIdentity::type>
+    constexpr typename __or_<
+      is_reference<_NestedType>,
+      is_function<_NestedType>,
+      is_void<_NestedType>,
+      __is_array_unknown_bounds<_NestedType>
+    >::type __is_complete_or_unbounded(_TypeIdentity)
+    { return {}; }
+
+
+
+
+
+
+  template<typename _Tp>
+    struct __success_type
+    { typedef _Tp type; };
+
+  struct __failure_type
+  { };
+
+  template<typename>
+    struct remove_cv;
+
+
+  template<typename _Tp>
+    using __remove_cv_t = typename remove_cv<_Tp>::type;
+
+  template<typename>
+    struct is_const;
+
+
+
+  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<__remove_cv_t<_Tp>>::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 { };
+# 284 "/usr/include/c++/10.2.0/type_traits" 3
+  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 { };
+# 364 "/usr/include/c++/10.2.0/type_traits" 3
+  template<typename _Tp>
+    struct is_integral
+    : public __is_integral_helper<__remove_cv_t<_Tp>>::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 { };
+# 392 "/usr/include/c++/10.2.0/type_traits" 3
+  template<typename _Tp>
+    struct is_floating_point
+    : public __is_floating_point_helper<__remove_cv_t<_Tp>>::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<__remove_cv_t<_Tp>>::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_member_object_pointer_helper
+    : public false_type { };
+
+  template<typename _Tp, typename _Cp>
+    struct __is_member_object_pointer_helper<_Tp _Cp::*>
+    : public __not_<is_function<_Tp>>::type { };
+
+
+  template<typename _Tp>
+    struct is_member_object_pointer
+    : public __is_member_object_pointer_helper<__remove_cv_t<_Tp>>::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 is_function<_Tp>::type { };
+
+
+  template<typename _Tp>
+    struct is_member_function_pointer
+    : public __is_member_function_pointer_helper<__remove_cv_t<_Tp>>::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 _Tp>
+    struct is_function
+    : public __bool_constant<!is_const<const _Tp>::value> { };
+
+  template<typename _Tp>
+    struct is_function<_Tp&>
+    : public false_type { };
+
+  template<typename _Tp>
+    struct is_function<_Tp&&>
+    : public false_type { };
+
+#define __cpp_lib_is_null_pointer 201309
+
+  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<__remove_cv_t<_Tp>>::type
+    { };
+
+
+  template<typename _Tp>
+    struct __is_nullptr_t
+    : public is_null_pointer<_Tp>
+    { } __attribute__ ((__deprecated__));
+
+
+
+
+  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 __not_<is_fundamental<_Tp>>::type { };
+
+  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<__remove_cv_t<_Tp>>::type
+    { };
+
+  template<typename, typename>
+    struct is_same;
+
+  template<typename _Tp, typename... _Types>
+    using __is_one_of = __or_<is_same<_Tp, _Types>...>;
+
+
+  template<typename _Tp>
+    using __is_signed_integer = __is_one_of<__remove_cv_t<_Tp>,
+   signed char, signed short, signed int, signed long,
+   signed long long
+# 604 "/usr/include/c++/10.2.0/type_traits" 3
+   >;
+
+
+  template<typename _Tp>
+    using __is_unsigned_integer = __is_one_of<__remove_cv_t<_Tp>,
+   unsigned char, unsigned short, unsigned int, unsigned long,
+   unsigned long long
+# 623 "/usr/include/c++/10.2.0/type_traits" 3
+   >;
+
+
+  template<typename _Tp>
+    using __is_standard_integer
+      = __or_<__is_signed_integer<_Tp>, __is_unsigned_integer<_Tp>>;
+
+
+  template<typename...> using __void_t = void;
+
+
+
+  template<typename _Tp, typename = void>
+    struct __is_referenceable
+    : public false_type
+    { };
+
+  template<typename _Tp>
+    struct __is_referenceable<_Tp, __void_t<_Tp&>>
+    : 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)>
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+
+  template<typename _Tp>
+    struct is_trivially_copyable
+    : public integral_constant<bool, __is_trivially_copyable(_Tp)>
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+
+  template<typename _Tp>
+    struct is_standard_layout
+    : public integral_constant<bool, __is_standard_layout(_Tp)>
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+
+
+  template<typename _Tp>
+    struct
+   
+    is_pod
+    : public integral_constant<bool, __is_pod(_Tp)>
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+
+  template<typename _Tp>
+    struct is_literal_type
+    : public integral_constant<bool, __is_literal_type(_Tp)>
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+
+  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)>
+    { };
+
+
+#define __cpp_lib_is_final 201402L
+
+  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>>>
+    { };
+# 770 "/usr/include/c++/10.2.0/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
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+
+
+
+
+  struct __do_is_nt_destructible_impl
+  {
+    template<typename _Tp>
+      static __bool_constant<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
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+  template<typename _Tp, typename... _Args>
+    struct __is_constructible_impl
+    : public __bool_constant<__is_constructible(_Tp, _Args...)>
+    { };
+
+
+  template<typename _Tp, typename... _Args>
+    struct is_constructible
+      : public __is_constructible_impl<_Tp, _Args...>
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+
+  template<typename _Tp>
+    struct is_default_constructible
+    : public __is_constructible_impl<_Tp>::type
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+  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_impl<_Tp, const _Tp&>
+    { };
+
+
+  template<typename _Tp>
+    struct is_copy_constructible
+    : public __is_copy_constructible_impl<_Tp>
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+  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_impl<_Tp, _Tp&&>
+    { };
+
+
+  template<typename _Tp>
+    struct is_move_constructible
+    : public __is_move_constructible_impl<_Tp>
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+  template<bool, typename _Tp, typename... _Args>
+    struct __is_nt_constructible_impl
+    : public false_type
+    { };
+
+  template<typename _Tp, typename... _Args>
+    struct __is_nt_constructible_impl<true, _Tp, _Args...>
+    : public __bool_constant<noexcept(_Tp(std::declval<_Args>()...))>
+    { };
+
+  template<typename _Tp, typename _Arg>
+    struct __is_nt_constructible_impl<true, _Tp, _Arg>
+    : public __bool_constant<noexcept(static_cast<_Tp>(std::declval<_Arg>()))>
+    { };
+
+  template<typename _Tp>
+    struct __is_nt_constructible_impl<true, _Tp>
+    : public __bool_constant<noexcept(_Tp())>
+    { };
+
+  template<typename _Tp, size_t _Num>
+    struct __is_nt_constructible_impl<true, _Tp[_Num]>
+    : public __bool_constant<noexcept(typename remove_all_extents<_Tp>::type())>
+    { };
+# 1001 "/usr/include/c++/10.2.0/type_traits" 3
+  template<typename _Tp, typename... _Args>
+    using __is_nothrow_constructible_impl
+      = __is_nt_constructible_impl<__is_constructible(_Tp, _Args...),
+       _Tp, _Args...>;
+
+
+  template<typename _Tp, typename... _Args>
+    struct is_nothrow_constructible
+    : public __is_nothrow_constructible_impl<_Tp, _Args...>::type
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+
+  template<typename _Tp>
+    struct is_nothrow_default_constructible
+    : public __is_nothrow_constructible_impl<_Tp>::type
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+
+  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_impl<_Tp, const _Tp&>
+    { };
+
+
+  template<typename _Tp>
+    struct is_nothrow_copy_constructible
+    : public __is_nothrow_copy_constructible_impl<_Tp>::type
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+  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_impl<_Tp, _Tp&&>
+    { };
+
+
+  template<typename _Tp>
+    struct is_nothrow_move_constructible
+    : public __is_nothrow_move_constructible_impl<_Tp>::type
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+
+  template<typename _Tp, typename _Up>
+    struct is_assignable
+    : public __bool_constant<__is_assignable(_Tp, _Up)>
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+  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 __bool_constant<__is_assignable(_Tp&, const _Tp&)>
+    { };
+
+
+  template<typename _Tp>
+    struct is_copy_assignable
+    : public __is_copy_assignable_impl<_Tp>::type
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+  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 __bool_constant<__is_assignable(_Tp&, _Tp&&)>
+    { };
+
+
+  template<typename _Tp>
+    struct is_move_assignable
+    : public __is_move_assignable_impl<_Tp>::type
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+  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_impl
+    : public __and_<__bool_constant<__is_assignable(_Tp, _Up)>,
+      __is_nt_assignable_impl<_Tp, _Up>>
+    { };
+
+
+  template<typename _Tp, typename _Up>
+    struct is_nothrow_assignable
+    : public __is_nothrow_assignable_impl<_Tp, _Up>
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+  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_impl<_Tp&, const _Tp&>
+    { };
+
+
+  template<typename _Tp>
+    struct is_nothrow_copy_assignable
+    : public __is_nt_copy_assignable_impl<_Tp>
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+  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_impl<_Tp&, _Tp&&>
+    { };
+
+
+  template<typename _Tp>
+    struct is_nothrow_move_assignable
+    : public __is_nt_move_assignable_impl<_Tp>
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+
+  template<typename _Tp, typename... _Args>
+    struct is_trivially_constructible
+    : public __bool_constant<__is_trivially_constructible(_Tp, _Args...)>
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+
+  template<typename _Tp>
+    struct is_trivially_default_constructible
+    : public __bool_constant<__is_trivially_constructible(_Tp)>
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+  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_constructible_impl<_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_impl<_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>
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+  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_impl<_Tp>,
+      integral_constant<bool,
+   __is_trivially_constructible(_Tp, _Tp&&)>>
+    { };
+
+
+  template<typename _Tp>
+    struct is_trivially_move_constructible
+    : public __is_trivially_move_constructible_impl<_Tp>
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+
+  template<typename _Tp, typename _Up>
+    struct is_trivially_assignable
+    : public __bool_constant<__is_trivially_assignable(_Tp, _Up)>
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+  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 __bool_constant<__is_trivially_assignable(_Tp&, const _Tp&)>
+    { };
+
+
+  template<typename _Tp>
+    struct is_trivially_copy_assignable
+    : public __is_trivially_copy_assignable_impl<_Tp>
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+  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 __bool_constant<__is_trivially_assignable(_Tp&, _Tp&&)>
+    { };
+
+
+  template<typename _Tp>
+    struct is_trivially_move_assignable
+    : public __is_trivially_move_assignable_impl<_Tp>
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+
+  template<typename _Tp>
+    struct is_trivially_destructible
+    : public __and_<__is_destructible_safe<_Tp>,
+      __bool_constant<__has_trivial_destructor(_Tp)>>
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+
+
+  template<typename _Tp>
+    struct has_virtual_destructor
+    : public integral_constant<bool, __has_virtual_destructor(_Tp)>
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+
+
+
+
+  template<typename _Tp>
+    struct alignment_of
+    : public integral_constant<std::size_t, alignof(_Tp)>
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+
+  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 _Tp, typename _Up>
+    struct is_same
+
+    : public integral_constant<bool, __is_same_as(_Tp, _Up)>
+
+
+
+    { };
+# 1410 "/usr/include/c++/10.2.0/type_traits" 3
+  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;
+    };
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wctor-dtor-privacy"
+  template<typename _From, typename _To>
+    class __is_convertible_helper<_From, _To, false>
+    {
+      template<typename _To1>
+ static void __test_aux(_To1) noexcept;
+
+      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;
+    };
+#pragma GCC diagnostic pop
+
+
+  template<typename _From, typename _To>
+    struct is_convertible
+    : public __is_convertible_helper<_From, _To>::type
+    { };
+
+
+  template<typename _ToElementType, typename _FromElementType>
+    using __is_array_convertible
+      = is_convertible<_FromElementType(*)[], _ToElementType(*)[]>;
+
+  template<typename _From, typename _To,
+           bool = __or_<is_void<_From>, is_function<_To>,
+                        is_array<_To>>::value>
+    struct __is_nt_convertible_helper
+    : is_void<_To>
+    { };
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wctor-dtor-privacy"
+  template<typename _From, typename _To>
+    class __is_nt_convertible_helper<_From, _To, false>
+    {
+      template<typename _To1>
+ static void __test_aux(_To1) noexcept;
+
+      template<typename _From1, typename _To1>
+ static
+ __bool_constant<noexcept(__test_aux<_To1>(std::declval<_From1>()))>
+ __test(int);
+
+      template<typename, typename>
+ static false_type
+ __test(...);
+
+    public:
+      using type = decltype(__test<_From, _To>(0));
+    };
+#pragma GCC diagnostic pop
+
+
+  template<typename _From, typename _To>
+    struct __is_nothrow_convertible
+    : public __is_nt_convertible_helper<_From, _To>::type
+    { };
+# 1508 "/usr/include/c++/10.2.0/type_traits" 3
+  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
+    { using type = _Tp; };
+
+  template<typename _Tp>
+    struct remove_cv<const _Tp>
+    { using type = _Tp; };
+
+  template<typename _Tp>
+    struct remove_cv<volatile _Tp>
+    { using type = _Tp; };
+
+  template<typename _Tp>
+    struct remove_cv<const volatile _Tp>
+    { using type = _Tp; };
+
+
+  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;
+    };
+
+
+
+#define __cpp_lib_transformation_trait_aliases 201304
+
+
+  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; };
+# 1730 "/usr/include/c++/10.2.0/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>
+    {
+      using __unsigned_type
+ = typename __make_unsigned<__remove_cv_t<_Tp>>::__type;
+
+    public:
+      using __type
+ = typename __match_cv_qualifiers<_Tp, __unsigned_type>::__type;
+    };
+
+  class __make_unsigned_selector_base
+  {
+  protected:
+    template<typename...> struct _List { };
+
+    template<typename _Tp, typename... _Up>
+      struct _List<_Tp, _Up...> : _List<_Up...>
+      { static constexpr size_t __size = sizeof(_Tp); };
+
+    template<size_t _Sz, typename _Tp, bool = (_Sz <= _Tp::__size)>
+      struct __select;
+
+    template<size_t _Sz, typename _Uint, typename... _UInts>
+      struct __select<_Sz, _List<_Uint, _UInts...>, true>
+      { using __type = _Uint; };
+
+    template<size_t _Sz, typename _Uint, typename... _UInts>
+      struct __select<_Sz, _List<_Uint, _UInts...>, false>
+      : __select<_Sz, _List<_UInts...>>
+      { };
+  };
+
+
+  template<typename _Tp>
+    class __make_unsigned_selector<_Tp, false, true>
+    : __make_unsigned_selector_base
+    {
+
+      using _UInts = _List<unsigned char, unsigned short, unsigned int,
+      unsigned long, unsigned long long>;
+
+      using __unsigned_type = typename __select<sizeof(_Tp), _UInts>::__type;
+
+    public:
+      using __type
+ = typename __match_cv_qualifiers<_Tp, __unsigned_type>::__type;
+    };
+
+
+
+
+
+
+  template<>
+    struct __make_unsigned<wchar_t>
+    {
+      using __type
+ = typename __make_unsigned_selector<wchar_t, false, true>::__type;
+    };
+# 1806 "/usr/include/c++/10.2.0/type_traits" 3
+  template<>
+    struct __make_unsigned<char16_t>
+    {
+      using __type
+ = typename __make_unsigned_selector<char16_t, false, true>::__type;
+    };
+
+  template<>
+    struct __make_unsigned<char32_t>
+    {
+      using __type
+ = typename __make_unsigned_selector<char32_t, false, true>::__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; };
+# 1884 "/usr/include/c++/10.2.0/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>
+    {
+      using __signed_type
+ = typename __make_signed<__remove_cv_t<_Tp>>::__type;
+
+    public:
+      using __type
+ = typename __match_cv_qualifiers<_Tp, __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<>
+    struct __make_signed<wchar_t>
+    {
+      using __type
+ = typename __make_signed_selector<wchar_t, false, true>::__type;
+    };
+# 1932 "/usr/include/c++/10.2.0/type_traits" 3
+  template<>
+    struct __make_signed<char16_t>
+    {
+      using __type
+ = typename __make_signed_selector<char16_t, false, true>::__type;
+    };
+
+  template<>
+    struct __make_signed<char32_t>
+    {
+      using __type
+ = typename __make_signed_selector<char32_t, false, true>::__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, __remove_cv_t<_Tp>>
+    { };
+
+
+  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;
+      };
+    };
+# 2067 "/usr/include/c++/10.2.0/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;
+    };
+# 2106 "/usr/include/c++/10.2.0/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 __remove_cv_t<_Up> __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>
+    using __decay_t = typename decay<_Tp>::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>
+    using __decay_and_strip = __strip_reference_wrapper<__decay_t<_Tp>>;
+
+
+
+
+  template<bool, typename _Tp = void>
+    struct enable_if
+    { };
+
+
+  template<typename _Tp>
+    struct enable_if<true, _Tp>
+    { typedef _Tp type; };
+
+
+  template<bool _Cond, typename _Tp = void>
+    using __enable_if_t = typename enable_if<_Cond, _Tp>::type;
+
+  template<typename... _Cond>
+    using _Require = __enable_if_t<__and_<_Cond...>::value>;
+
+
+
+  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>
+    using __remove_cvref_t
+     = typename remove_cv<typename remove_reference<_Tp>::type>::type;
+
+
+  template<typename... _Tp>
+    struct common_type;
+
+
+
+  struct __do_common_type_impl
+  {
+    template<typename _Tp, typename _Up>
+      using __cond_t
+ = decltype(true ? std::declval<_Tp>() : std::declval<_Up>());
+
+
+
+    template<typename _Tp, typename _Up>
+      static __success_type<__decay_t<__cond_t<_Tp, _Up>>>
+      _S_test(int);
+# 2239 "/usr/include/c++/10.2.0/type_traits" 3
+    template<typename, typename>
+      static __failure_type
+      _S_test_2(...);
+
+    template<typename _Tp, typename _Up>
+      static decltype(_S_test_2<_Tp, _Up>(0))
+      _S_test(...);
+  };
+
+
+  template<>
+    struct common_type<>
+    { };
+
+
+  template<typename _Tp0>
+    struct common_type<_Tp0>
+    : public common_type<_Tp0, _Tp0>
+    { };
+
+
+  template<typename _Tp1, typename _Tp2,
+    typename _Dp1 = __decay_t<_Tp1>, typename _Dp2 = __decay_t<_Tp2>>
+    struct __common_type_impl
+    {
+
+
+      using type = common_type<_Dp1, _Dp2>;
+    };
+
+  template<typename _Tp1, typename _Tp2>
+    struct __common_type_impl<_Tp1, _Tp2, _Tp1, _Tp2>
+    : private __do_common_type_impl
+    {
+
+
+      using type = decltype(_S_test<_Tp1, _Tp2>(0));
+    };
+
+
+  template<typename _Tp1, typename _Tp2>
+    struct common_type<_Tp1, _Tp2>
+    : public __common_type_impl<_Tp1, _Tp2>::type
+    { };
+
+  template<typename...>
+    struct __common_type_pack
+    { };
+
+  template<typename, typename, typename = void>
+    struct __common_type_fold;
+
+
+  template<typename _Tp1, typename _Tp2, typename... _Rp>
+    struct common_type<_Tp1, _Tp2, _Rp...>
+    : public __common_type_fold<common_type<_Tp1, _Tp2>,
+    __common_type_pack<_Rp...>>
+    { };
+
+
+
+
+  template<typename _CTp, typename... _Rp>
+    struct __common_type_fold<_CTp, __common_type_pack<_Rp...>,
+         __void_t<typename _CTp::type>>
+    : public common_type<typename _CTp::type, _Rp...>
+    { };
+
+
+  template<typename _CTp, typename _Rp>
+    struct __common_type_fold<_CTp, _Rp, void>
+    { };
+
+  template<typename _Tp, bool = is_enum<_Tp>::value>
+    struct __underlying_type_impl
+    {
+      using type = __underlying_type(_Tp);
+    };
+
+  template<typename _Tp>
+    struct __underlying_type_impl<_Tp, false>
+    { };
+
+
+  template<typename _Tp>
+    struct underlying_type
+    : public __underlying_type_impl<_Tp>
+    { };
+
+  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;
+
+
+
+#define __cpp_lib_result_of_sfinae 201210
+
+  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 __remove_cvref_t<_Arg> _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_reference<_Arg>::type _Argval;
+      typedef _Res _Class::* _MemPtr;
+      typedef typename conditional<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 = __remove_cvref_t<_Tp>>
+    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<__decay_t<_MemPtr>,
+    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<__decay_t<_MemPtr>,
+    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;
+
+
+
+#define __cpp_lib_void_t 201411
+
+  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;
+
+
+
+
+
+
+
+#define _GLIBCXX_HAS_NESTED_TYPE(_NTYPE) template<typename _Tp, typename = __void_t<>> struct __has_ ##_NTYPE : false_type { }; template<typename _Tp> struct __has_ ##_NTYPE<_Tp, __void_t<typename _Tp::_NTYPE>> : true_type { };
+# 2624 "/usr/include/c++/10.2.0/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<__remove_cvref_t<_Tp>>::type
+    { };
+
+  template<typename _Tp>
+   
+    inline
+    _Require<__not_<__is_tuple_like<_Tp>>,
+      is_move_constructible<_Tp>,
+      is_move_assignable<_Tp>>
+    swap(_Tp&, _Tp&)
+    noexcept(__and_<is_nothrow_move_constructible<_Tp>,
+             is_nothrow_move_assignable<_Tp>>::value);
+
+  template<typename _Tp, size_t _Nm>
+   
+    inline
+    __enable_if_t<__is_swappable<_Tp>::value>
+    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
+    { };
+
+
+#define __cpp_lib_is_swappable 201603
+
+
+
+  template<typename _Tp>
+    struct is_swappable
+    : public __is_swappable_impl<_Tp>::type
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+
+  template<typename _Tp>
+    struct is_nothrow_swappable
+    : public __is_nothrow_swappable_impl<_Tp>::type
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+
+
+  template<typename _Tp>
+    inline constexpr bool is_swappable_v =
+      is_swappable<_Tp>::value;
+
+
+  template<typename _Tp>
+    inline 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>
+    inline constexpr bool is_swappable_with_v =
+      is_swappable_with<_Tp, _Up>::value;
+
+
+  template<typename _Tp, typename _Up>
+    inline constexpr bool is_nothrow_swappable_with_v =
+      is_nothrow_swappable_with<_Tp, _Up>::value;
+
+
+
+
+
+
+
+  template<typename _Result, typename _Ret,
+    bool = is_void<_Ret>::value, typename = void>
+    struct __is_invocable_impl : false_type { };
+
+
+  template<typename _Result, typename _Ret>
+    struct __is_invocable_impl<_Result, _Ret,
+                                true,
+          __void_t<typename _Result::type>>
+    : true_type
+    { };
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wctor-dtor-privacy"
+
+  template<typename _Result, typename _Ret>
+    struct __is_invocable_impl<_Result, _Ret,
+                                false,
+          __void_t<typename _Result::type>>
+    {
+    private:
+
+
+      static typename _Result::type _S_get();
+
+      template<typename _Tp>
+ static void _S_conv(_Tp);
+
+
+      template<typename _Tp, typename = decltype(_S_conv<_Tp>(_S_get()))>
+ static true_type
+ _S_test(int);
+
+      template<typename _Tp>
+ static false_type
+ _S_test(...);
+
+    public:
+      using type = decltype(_S_test<_Ret>(1));
+    };
+#pragma GCC diagnostic pop
+
+  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
+    { };
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wctor-dtor-privacy"
+  struct __nonesuchbase {};
+  struct __nonesuch : private __nonesuchbase {
+    ~__nonesuch() = delete;
+    __nonesuch(__nonesuch const&) = delete;
+    void operator=(__nonesuch const&) = delete;
+  };
+#pragma GCC diagnostic pop
+
+
+#define __cpp_lib_is_invocable 201703
+
+
+  template<typename _Functor, typename... _ArgTypes>
+    struct invoke_result
+    : public __invoke_result<_Functor, _ArgTypes...>
+    { };
+
+
+  template<typename _Fn, typename... _Args>
+    using invoke_result_t = typename invoke_result<_Fn, _Args...>::type;
+
+
+  template<typename _Fn, typename... _ArgTypes>
+    struct is_invocable
+    : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}),
+ "_Fn must be a complete class or an unbounded array");
+    };
+
+
+  template<typename _Ret, typename _Fn, typename... _ArgTypes>
+    struct is_invocable_r
+    : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>::type
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}),
+ "_Fn must be a complete class or an unbounded array");
+    };
+
+
+  template<typename _Fn, typename... _ArgTypes>
+    struct is_nothrow_invocable
+    : __and_<__is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>,
+      __call_is_nothrow_<_Fn, _ArgTypes...>>::type
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}),
+ "_Fn must be a complete class or an unbounded array");
+    };
+
+  template<typename _Result, typename _Ret, typename = void>
+    struct __is_nt_invocable_impl : false_type { };
+
+  template<typename _Result, typename _Ret>
+    struct __is_nt_invocable_impl<_Result, _Ret,
+      __void_t<typename _Result::type>>
+    : __or_<is_void<_Ret>,
+     __is_nothrow_convertible<typename _Result::type, _Ret>>
+    { };
+
+
+  template<typename _Ret, typename _Fn, typename... _ArgTypes>
+    struct is_nothrow_invocable_r
+    : __and_<__is_nt_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>,
+             __call_is_nothrow_<_Fn, _ArgTypes...>>::type
+    { };
+
+
+  template<typename _Fn, typename... _Args>
+    inline constexpr bool is_invocable_v = is_invocable<_Fn, _Args...>::value;
+
+
+  template<typename _Fn, typename... _Args>
+    inline constexpr bool is_nothrow_invocable_v
+      = is_nothrow_invocable<_Fn, _Args...>::value;
+
+
+  template<typename _Ret, typename _Fn, typename... _Args>
+    inline constexpr bool is_invocable_r_v
+      = is_invocable_r<_Ret, _Fn, _Args...>::value;
+
+
+  template<typename _Ret, typename _Fn, typename... _Args>
+    inline constexpr bool is_nothrow_invocable_r_v
+      = is_nothrow_invocable_r<_Ret, _Fn, _Args...>::value;
+
+
+
+#define __cpp_lib_type_trait_variable_templates 201510L
+template <typename _Tp>
+  inline constexpr bool is_void_v = is_void<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_null_pointer_v = is_null_pointer<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_integral_v = is_integral<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_floating_point_v = is_floating_point<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_array_v = is_array<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_pointer_v = is_pointer<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_lvalue_reference_v =
+    is_lvalue_reference<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_rvalue_reference_v =
+    is_rvalue_reference<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_member_object_pointer_v =
+    is_member_object_pointer<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_member_function_pointer_v =
+    is_member_function_pointer<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_enum_v = is_enum<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_union_v = is_union<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_class_v = is_class<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_function_v = is_function<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_reference_v = is_reference<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_arithmetic_v = is_arithmetic<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_fundamental_v = is_fundamental<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_object_v = is_object<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_scalar_v = is_scalar<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_compound_v = is_compound<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_member_pointer_v = is_member_pointer<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_const_v = is_const<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_volatile_v = is_volatile<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_trivial_v = is_trivial<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_trivially_copyable_v =
+    is_trivially_copyable<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_standard_layout_v = is_standard_layout<_Tp>::value;
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+template <typename _Tp>
+ 
+  inline constexpr bool is_pod_v = is_pod<_Tp>::value;
+#pragma GCC diagnostic pop
+template <typename _Tp>
+  inline constexpr bool is_literal_type_v = is_literal_type<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_empty_v = is_empty<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_polymorphic_v = is_polymorphic<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_abstract_v = is_abstract<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_final_v = is_final<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_signed_v = is_signed<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_unsigned_v = is_unsigned<_Tp>::value;
+template <typename _Tp, typename... _Args>
+  inline constexpr bool is_constructible_v =
+    is_constructible<_Tp, _Args...>::value;
+template <typename _Tp>
+  inline constexpr bool is_default_constructible_v =
+    is_default_constructible<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_copy_constructible_v =
+    is_copy_constructible<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_move_constructible_v =
+    is_move_constructible<_Tp>::value;
+template <typename _Tp, typename _Up>
+  inline constexpr bool is_assignable_v = is_assignable<_Tp, _Up>::value;
+template <typename _Tp>
+  inline constexpr bool is_copy_assignable_v = is_copy_assignable<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_move_assignable_v = is_move_assignable<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_destructible_v = is_destructible<_Tp>::value;
+template <typename _Tp, typename... _Args>
+  inline constexpr bool is_trivially_constructible_v =
+    is_trivially_constructible<_Tp, _Args...>::value;
+template <typename _Tp>
+  inline constexpr bool is_trivially_default_constructible_v =
+    is_trivially_default_constructible<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_trivially_copy_constructible_v =
+    is_trivially_copy_constructible<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_trivially_move_constructible_v =
+    is_trivially_move_constructible<_Tp>::value;
+template <typename _Tp, typename _Up>
+  inline constexpr bool is_trivially_assignable_v =
+    is_trivially_assignable<_Tp, _Up>::value;
+template <typename _Tp>
+  inline constexpr bool is_trivially_copy_assignable_v =
+    is_trivially_copy_assignable<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_trivially_move_assignable_v =
+    is_trivially_move_assignable<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_trivially_destructible_v =
+    is_trivially_destructible<_Tp>::value;
+template <typename _Tp, typename... _Args>
+  inline constexpr bool is_nothrow_constructible_v =
+    is_nothrow_constructible<_Tp, _Args...>::value;
+template <typename _Tp>
+  inline constexpr bool is_nothrow_default_constructible_v =
+    is_nothrow_default_constructible<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_nothrow_copy_constructible_v =
+    is_nothrow_copy_constructible<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_nothrow_move_constructible_v =
+    is_nothrow_move_constructible<_Tp>::value;
+template <typename _Tp, typename _Up>
+  inline constexpr bool is_nothrow_assignable_v =
+    is_nothrow_assignable<_Tp, _Up>::value;
+template <typename _Tp>
+  inline constexpr bool is_nothrow_copy_assignable_v =
+    is_nothrow_copy_assignable<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_nothrow_move_assignable_v =
+    is_nothrow_move_assignable<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_nothrow_destructible_v =
+    is_nothrow_destructible<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool has_virtual_destructor_v =
+    has_virtual_destructor<_Tp>::value;
+template <typename _Tp>
+  inline constexpr size_t alignment_of_v = alignment_of<_Tp>::value;
+template <typename _Tp>
+  inline constexpr size_t rank_v = rank<_Tp>::value;
+template <typename _Tp, unsigned _Idx = 0>
+  inline constexpr size_t extent_v = extent<_Tp, _Idx>::value;
+
+template <typename _Tp, typename _Up>
+  inline constexpr bool is_same_v = __is_same_as(_Tp, _Up);
+
+
+
+
+template <typename _Base, typename _Derived>
+  inline constexpr bool is_base_of_v = is_base_of<_Base, _Derived>::value;
+template <typename _From, typename _To>
+  inline constexpr bool is_convertible_v = is_convertible<_From, _To>::value;
+
+
+#define __cpp_lib_has_unique_object_representations 201606
+
+  template<typename _Tp>
+    struct has_unique_object_representations
+    : bool_constant<__has_unique_object_representations(
+      remove_cv_t<remove_all_extents_t<_Tp>>
+      )>
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+  template<typename _Tp>
+    inline constexpr bool has_unique_object_representations_v
+      = has_unique_object_representations<_Tp>::value;
+
+
+
+#define __cpp_lib_is_aggregate 201703
+
+  template<typename _Tp>
+    struct is_aggregate
+    : bool_constant<__is_aggregate(remove_cv_t<_Tp>)>
+    { };
+
+
+  template<typename _Tp>
+    inline constexpr bool is_aggregate_v = is_aggregate<_Tp>::value;
+# 3455 "/usr/include/c++/10.2.0/type_traits" 3
+
+}
+# 58 "/usr/include/c++/10.2.0/bits/move.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 74 "/usr/include/c++/10.2.0/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 { };
+# 118 "/usr/include/c++/10.2.0/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); }
+
+
+
+
+
+
+#define __cpp_lib_addressof_constexpr 201603
+# 138 "/usr/include/c++/10.2.0/bits/move.h" 3
+  template<typename _Tp>
+    inline constexpr _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;
+    }
+
+
+
+#define _GLIBCXX_MOVE(__val) std::move(__val)
+#define _GLIBCXX_FORWARD(_Tp,__val) std::forward<_Tp>(__val)
+# 179 "/usr/include/c++/10.2.0/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 "/usr/include/c++/10.2.0/bits/stl_pair.h" 2 3
+# 69 "/usr/include/c++/10.2.0/bits/stl_pair.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 80 "/usr/include/c++/10.2.0/bits/stl_pair.h" 3
+  struct piecewise_construct_t { explicit piecewise_construct_t() = default; };
+
+
+  inline 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;
+      }
+  };
+
+
+  template<typename _U1, typename _U2> class __pair_base
+  {
+
+    template<typename _T1, typename _T2> friend struct pair;
+    __pair_base() = default;
+    ~__pair_base() = default;
+    __pair_base(const __pair_base&) = default;
+    __pair_base& operator=(const __pair_base&) = delete;
+
+  };
+# 210 "/usr/include/c++/10.2.0/bits/stl_pair.h" 3
+  template<typename _T1, typename _T2>
+    struct pair
+    : private __pair_base<_T1, _T2>
+    {
+      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() { }
+# 256 "/usr/include/c++/10.2.0/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) { }
+# 288 "/usr/include/c++/10.2.0/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&>::type __p)
+      {
+ first = __p.first;
+ second = __p.second;
+ return *this;
+      }
+
+      pair&
+      operator=(typename conditional<
+  __and_<is_move_assignable<_T1>,
+         is_move_assignable<_T2>>::value,
+  pair&&, __nonesuch&&>::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> pair(_T1, _T2) -> pair<_T1, _T2>;
+
+
+
+  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; }
+# 487 "/usr/include/c++/10.2.0/bits/stl_pair.h" 3
+  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); }
+# 524 "/usr/include/c++/10.2.0/bits/stl_pair.h" 3
+  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;
+# 564 "/usr/include/c++/10.2.0/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));
+    }
+# 583 "/usr/include/c++/10.2.0/bits/stl_pair.h" 3
+
+}
+# 65 "/usr/include/c++/10.2.0/bits/stl_algobase.h" 2 3
+# 1 "/usr/include/c++/10.2.0/bits/stl_iterator_base_types.h" 1 3
+# 60 "/usr/include/c++/10.2.0/bits/stl_iterator_base_types.h" 3
+#define _STL_ITERATOR_BASE_TYPES_H 1
+
+       
+# 63 "/usr/include/c++/10.2.0/bits/stl_iterator_base_types.h" 3
+# 74 "/usr/include/c++/10.2.0/bits/stl_iterator_base_types.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 93 "/usr/include/c++/10.2.0/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 { };
+# 125 "/usr/include/c++/10.2.0/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;
+    };
+# 149 "/usr/include/c++/10.2.0/bits/stl_iterator_base_types.h" 3
+  template<typename _Iterator>
+    struct iterator_traits;
+
+
+
+
+  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> { };
+# 209 "/usr/include/c++/10.2.0/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(); }
+
+
+
+
+  template<typename _Iter>
+    using __iterator_category_t
+      = typename iterator_traits<_Iter>::iterator_category;
+
+  template<typename _InIter>
+    using _RequireInputIter =
+      __enable_if_t<is_convertible<__iterator_category_t<_InIter>,
+       input_iterator_tag>::value>;
+
+  template<typename _It,
+    typename _Cat = __iterator_category_t<_It>>
+    struct __is_random_access_iter
+      : is_base_of<random_access_iterator_tag, _Cat>
+    {
+      typedef is_base_of<random_access_iterator_tag, _Cat> _Base;
+      enum { __value = _Base::value };
+    };
+
+
+
+
+
+
+
+
+}
+# 66 "/usr/include/c++/10.2.0/bits/stl_algobase.h" 2 3
+# 1 "/usr/include/c++/10.2.0/bits/stl_iterator_base_funcs.h" 1 3
+# 60 "/usr/include/c++/10.2.0/bits/stl_iterator_base_funcs.h" 3
+#define _STL_ITERATOR_BASE_FUNCS_H 1
+
+       
+# 63 "/usr/include/c++/10.2.0/bits/stl_iterator_base_funcs.h" 3
+
+# 1 "/usr/include/c++/10.2.0/bits/concept_check.h" 1 3
+# 31 "/usr/include/c++/10.2.0/bits/concept_check.h" 3
+#define _CONCEPT_CHECK_H 1
+
+       
+# 34 "/usr/include/c++/10.2.0/bits/concept_check.h" 3
+# 48 "/usr/include/c++/10.2.0/bits/concept_check.h" 3
+#define __glibcxx_function_requires(...) 
+#define __glibcxx_class_requires(_a,_b) 
+#define __glibcxx_class_requires2(_a,_b,_c) 
+#define __glibcxx_class_requires3(_a,_b,_c,_d) 
+#define __glibcxx_class_requires4(_a,_b,_c,_d,_e) 
+# 65 "/usr/include/c++/10.2.0/bits/stl_iterator_base_funcs.h" 2 3
+# 1 "/usr/include/c++/10.2.0/debug/assertions.h" 1 3
+# 30 "/usr/include/c++/10.2.0/debug/assertions.h" 3
+#define _GLIBCXX_DEBUG_ASSERTIONS_H 1
+
+
+
+#define _GLIBCXX_DEBUG_ASSERT(_Condition) 
+#define _GLIBCXX_DEBUG_PEDASSERT(_Condition) 
+#define _GLIBCXX_DEBUG_ONLY(_Statement) 
+
+
+
+
+#define __glibcxx_requires_non_empty_range(_First,_Last) 
+#define __glibcxx_requires_nonempty() 
+#define __glibcxx_requires_subscript(_N) 
+# 66 "/usr/include/c++/10.2.0/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 "/usr/include/c++/10.2.0/bits/stl_iterator_base_funcs.h" 3
+  template<typename _InputIterator>
+    inline constexpr
+    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 "/usr/include/c++/10.2.0/bits/stl_iterator_base_funcs.h" 3
+  template<typename _InputIterator, typename _Distance>
+    inline constexpr 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 constexpr _InputIterator
+    next(_InputIterator __x, typename
+  iterator_traits<_InputIterator>::difference_type __n = 1)
+    {
+
+     
+      std::advance(__x, __n);
+      return __x;
+    }
+
+  template<typename _BidirectionalIterator>
+    inline constexpr _BidirectionalIterator
+    prev(_BidirectionalIterator __x, typename
+  iterator_traits<_BidirectionalIterator>::difference_type __n = 1)
+    {
+
+     
+
+      std::advance(__x, -__n);
+      return __x;
+    }
+
+
+
+
+}
+# 67 "/usr/include/c++/10.2.0/bits/stl_algobase.h" 2 3
+# 1 "/usr/include/c++/10.2.0/bits/stl_iterator.h" 1 3
+# 61 "/usr/include/c++/10.2.0/bits/stl_iterator.h" 3
+#define _STL_ITERATOR_H 1
+
+
+
+
+# 1 "/usr/include/c++/10.2.0/bits/ptr_traits.h" 1 3
+# 31 "/usr/include/c++/10.2.0/bits/ptr_traits.h" 3
+#define _PTR_TRAITS_H 1
+# 42 "/usr/include/c++/10.2.0/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->()); }
+# 210 "/usr/include/c++/10.2.0/bits/ptr_traits.h" 3
+
+}
+# 67 "/usr/include/c++/10.2.0/bits/stl_iterator.h" 2 3
+# 76 "/usr/include/c++/10.2.0/bits/stl_iterator.h" 3
+#define __cpp_lib_array_constexpr 201803L
+# 85 "/usr/include/c++/10.2.0/bits/stl_iterator.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 124 "/usr/include/c++/10.2.0/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;
+# 160 "/usr/include/c++/10.2.0/bits/stl_iterator.h" 3
+      constexpr
+      reverse_iterator() : current() { }
+
+
+
+
+      explicit constexpr
+      reverse_iterator(iterator_type __x) : current(__x) { }
+
+
+
+
+      constexpr
+      reverse_iterator(const reverse_iterator& __x)
+      : current(__x.current) { }
+
+
+      reverse_iterator& operator=(const reverse_iterator&) = default;
+
+
+
+
+
+
+      template<typename _Iter>
+ constexpr
+        reverse_iterator(const reverse_iterator<_Iter>& __x)
+ : current(__x.base()) { }
+
+
+
+
+      constexpr iterator_type
+      base() const
+      { return current; }
+# 206 "/usr/include/c++/10.2.0/bits/stl_iterator.h" 3
+      constexpr reference
+      operator*() const
+      {
+ _Iterator __tmp = current;
+ return *--__tmp;
+      }
+
+
+
+
+
+
+      constexpr pointer
+      operator->() const
+
+
+
+
+      {
+
+
+ _Iterator __tmp = current;
+ --__tmp;
+ return _S_to_pointer(__tmp);
+      }
+
+
+
+
+
+
+      constexpr reverse_iterator&
+      operator++()
+      {
+ --current;
+ return *this;
+      }
+
+
+
+
+
+
+      constexpr reverse_iterator
+      operator++(int)
+      {
+ reverse_iterator __tmp = *this;
+ --current;
+ return __tmp;
+      }
+
+
+
+
+
+
+      constexpr reverse_iterator&
+      operator--()
+      {
+ ++current;
+ return *this;
+      }
+
+
+
+
+
+
+      constexpr reverse_iterator
+      operator--(int)
+      {
+ reverse_iterator __tmp = *this;
+ ++current;
+ return __tmp;
+      }
+
+
+
+
+
+
+      constexpr reverse_iterator
+      operator+(difference_type __n) const
+      { return reverse_iterator(current - __n); }
+
+
+
+
+
+
+
+      constexpr reverse_iterator&
+      operator+=(difference_type __n)
+      {
+ current -= __n;
+ return *this;
+      }
+
+
+
+
+
+
+      constexpr reverse_iterator
+      operator-(difference_type __n) const
+      { return reverse_iterator(current + __n); }
+
+
+
+
+
+
+
+      constexpr reverse_iterator&
+      operator-=(difference_type __n)
+      {
+ current += __n;
+ return *this;
+      }
+
+
+
+
+
+
+      constexpr reference
+      operator[](difference_type __n) const
+      { return *(*this + __n); }
+
+    private:
+      template<typename _Tp>
+ static constexpr _Tp*
+ _S_to_pointer(_Tp* __p)
+        { return __p; }
+
+      template<typename _Tp>
+ static constexpr pointer
+ _S_to_pointer(_Tp __t)
+        { return __t.operator->(); }
+    };
+# 358 "/usr/include/c++/10.2.0/bits/stl_iterator.h" 3
+  template<typename _Iterator>
+    inline constexpr bool
+    operator==(const reverse_iterator<_Iterator>& __x,
+        const reverse_iterator<_Iterator>& __y)
+    { return __x.base() == __y.base(); }
+
+  template<typename _Iterator>
+    inline constexpr bool
+    operator<(const reverse_iterator<_Iterator>& __x,
+       const reverse_iterator<_Iterator>& __y)
+    { return __y.base() < __x.base(); }
+
+  template<typename _Iterator>
+    inline constexpr bool
+    operator!=(const reverse_iterator<_Iterator>& __x,
+        const reverse_iterator<_Iterator>& __y)
+    { return !(__x == __y); }
+
+  template<typename _Iterator>
+    inline constexpr bool
+    operator>(const reverse_iterator<_Iterator>& __x,
+       const reverse_iterator<_Iterator>& __y)
+    { return __y < __x; }
+
+  template<typename _Iterator>
+    inline constexpr bool
+    operator<=(const reverse_iterator<_Iterator>& __x,
+        const reverse_iterator<_Iterator>& __y)
+    { return !(__y < __x); }
+
+  template<typename _Iterator>
+    inline constexpr bool
+    operator>=(const reverse_iterator<_Iterator>& __x,
+        const reverse_iterator<_Iterator>& __y)
+    { return !(__x < __y); }
+
+
+
+  template<typename _IteratorL, typename _IteratorR>
+    inline constexpr bool
+    operator==(const reverse_iterator<_IteratorL>& __x,
+        const reverse_iterator<_IteratorR>& __y)
+    { return __x.base() == __y.base(); }
+
+  template<typename _IteratorL, typename _IteratorR>
+    inline constexpr bool
+    operator<(const reverse_iterator<_IteratorL>& __x,
+       const reverse_iterator<_IteratorR>& __y)
+    { return __y.base() < __x.base(); }
+
+  template<typename _IteratorL, typename _IteratorR>
+    inline constexpr bool
+    operator!=(const reverse_iterator<_IteratorL>& __x,
+        const reverse_iterator<_IteratorR>& __y)
+    { return !(__x == __y); }
+
+  template<typename _IteratorL, typename _IteratorR>
+    inline constexpr bool
+    operator>(const reverse_iterator<_IteratorL>& __x,
+       const reverse_iterator<_IteratorR>& __y)
+    { return __y < __x; }
+
+  template<typename _IteratorL, typename _IteratorR>
+    inline constexpr bool
+    operator<=(const reverse_iterator<_IteratorL>& __x,
+        const reverse_iterator<_IteratorR>& __y)
+    { return !(__y < __x); }
+
+  template<typename _IteratorL, typename _IteratorR>
+    inline constexpr bool
+    operator>=(const reverse_iterator<_IteratorL>& __x,
+        const reverse_iterator<_IteratorR>& __y)
+    { return !(__x < __y); }
+# 498 "/usr/include/c++/10.2.0/bits/stl_iterator.h" 3
+  template<typename _IteratorL, typename _IteratorR>
+    inline constexpr 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 constexpr 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 constexpr reverse_iterator<_Iterator>
+    __make_reverse_iterator(_Iterator __i)
+    { return reverse_iterator<_Iterator>(__i); }
+
+
+#define __cpp_lib_make_reverse_iterator 201402
+
+
+
+
+  template<typename _Iterator>
+    inline constexpr reverse_iterator<_Iterator>
+    make_reverse_iterator(_Iterator __i)
+    { return reverse_iterator<_Iterator>(__i); }
+# 539 "/usr/include/c++/10.2.0/bits/stl_iterator.h" 3
+  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())); }
+# 570 "/usr/include/c++/10.2.0/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)) { }
+# 610 "/usr/include/c++/10.2.0/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; }
+    };
+# 657 "/usr/include/c++/10.2.0/bits/stl_iterator.h" 3
+  template<typename _Container>
+   
+    inline back_insert_iterator<_Container>
+    back_inserter(_Container& __x)
+    { return back_insert_iterator<_Container>(__x); }
+# 673 "/usr/include/c++/10.2.0/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)) { }
+# 713 "/usr/include/c++/10.2.0/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; }
+    };
+# 760 "/usr/include/c++/10.2.0/bits/stl_iterator.h" 3
+  template<typename _Container>
+   
+    inline front_insert_iterator<_Container>
+    front_inserter(_Container& __x)
+    { return front_insert_iterator<_Container>(__x); }
+# 780 "/usr/include/c++/10.2.0/bits/stl_iterator.h" 3
+  template<typename _Container>
+    class insert_iterator
+    : public iterator<output_iterator_tag, void, void, void, void>
+    {
+
+
+
+
+
+
+
+      typedef typename _Container::iterator _Iter;
+
+    protected:
+      _Container* container;
+      _Iter iter;
+
+
+    public:
+
+      typedef _Container container_type;
+# 812 "/usr/include/c++/10.2.0/bits/stl_iterator.h" 3
+     
+      insert_iterator(_Container& __x, _Iter __i)
+      : container(std::__addressof(__x)), iter(__i) {}
+# 848 "/usr/include/c++/10.2.0/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; }
+    };
+# 904 "/usr/include/c++/10.2.0/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")))
+{
+
+# 929 "/usr/include/c++/10.2.0/bits/stl_iterator.h" 3
+  template<typename _Iterator, typename _Container>
+    class __normal_iterator
+    {
+    protected:
+      _Iterator _M_current;
+
+      typedef std::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; }
+    };
+# 1061 "/usr/include/c++/10.2.0/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)
+    noexcept(std::is_nothrow_copy_constructible<_Iterator>::value)
+    { return __it.base(); }
+# 1260 "/usr/include/c++/10.2.0/bits/stl_iterator.h" 3
+  template<typename _Iterator>
+    class move_iterator
+    {
+      _Iterator _M_current;
+
+      using __traits_type = iterator_traits<_Iterator>;
+
+
+
+      using __base_ref = typename __traits_type::reference;
+
+
+    public:
+      using iterator_type = _Iterator;
+# 1284 "/usr/include/c++/10.2.0/bits/stl_iterator.h" 3
+      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;
+
+
+      constexpr
+      move_iterator()
+      : _M_current() { }
+
+      explicit constexpr
+      move_iterator(iterator_type __i)
+      : _M_current(std::move(__i)) { }
+
+      template<typename _Iter>
+ constexpr
+ move_iterator(const move_iterator<_Iter>& __i)
+ : _M_current(__i.base()) { }
+
+
+      constexpr iterator_type
+      base() const
+      { return _M_current; }
+# 1326 "/usr/include/c++/10.2.0/bits/stl_iterator.h" 3
+      constexpr reference
+      operator*() const
+      { return static_cast<reference>(*_M_current); }
+
+      constexpr pointer
+      operator->() const
+      { return _M_current; }
+
+      constexpr move_iterator&
+      operator++()
+      {
+ ++_M_current;
+ return *this;
+      }
+
+      constexpr move_iterator
+      operator++(int)
+      {
+ move_iterator __tmp = *this;
+ ++_M_current;
+ return __tmp;
+      }
+
+
+
+
+
+
+
+      constexpr move_iterator&
+      operator--()
+      {
+ --_M_current;
+ return *this;
+      }
+
+      constexpr move_iterator
+      operator--(int)
+      {
+ move_iterator __tmp = *this;
+ --_M_current;
+ return __tmp;
+      }
+
+      constexpr move_iterator
+      operator+(difference_type __n) const
+      { return move_iterator(_M_current + __n); }
+
+      constexpr move_iterator&
+      operator+=(difference_type __n)
+      {
+ _M_current += __n;
+ return *this;
+      }
+
+      constexpr move_iterator
+      operator-(difference_type __n) const
+      { return move_iterator(_M_current - __n); }
+
+      constexpr move_iterator&
+      operator-=(difference_type __n)
+      {
+ _M_current -= __n;
+ return *this;
+      }
+
+      constexpr reference
+      operator[](difference_type __n) const
+      { return std::move(_M_current[__n]); }
+# 1423 "/usr/include/c++/10.2.0/bits/stl_iterator.h" 3
+    };
+
+  template<typename _IteratorL, typename _IteratorR>
+    inline constexpr bool
+    operator==(const move_iterator<_IteratorL>& __x,
+        const move_iterator<_IteratorR>& __y)
+
+
+
+    { return __x.base() == __y.base(); }
+# 1442 "/usr/include/c++/10.2.0/bits/stl_iterator.h" 3
+  template<typename _IteratorL, typename _IteratorR>
+    inline constexpr bool
+    operator!=(const move_iterator<_IteratorL>& __x,
+        const move_iterator<_IteratorR>& __y)
+    { return !(__x == __y); }
+
+
+  template<typename _IteratorL, typename _IteratorR>
+    inline constexpr bool
+    operator<(const move_iterator<_IteratorL>& __x,
+       const move_iterator<_IteratorR>& __y)
+
+
+
+    { return __x.base() < __y.base(); }
+
+  template<typename _IteratorL, typename _IteratorR>
+    inline constexpr bool
+    operator<=(const move_iterator<_IteratorL>& __x,
+        const move_iterator<_IteratorR>& __y)
+
+
+
+    { return !(__y < __x); }
+
+  template<typename _IteratorL, typename _IteratorR>
+    inline constexpr bool
+    operator>(const move_iterator<_IteratorL>& __x,
+       const move_iterator<_IteratorR>& __y)
+
+
+
+    { return __y < __x; }
+
+  template<typename _IteratorL, typename _IteratorR>
+    inline constexpr bool
+    operator>=(const move_iterator<_IteratorL>& __x,
+        const move_iterator<_IteratorR>& __y)
+
+
+
+    { return !(__x < __y); }
+# 1493 "/usr/include/c++/10.2.0/bits/stl_iterator.h" 3
+  template<typename _Iterator>
+    inline constexpr bool
+    operator==(const move_iterator<_Iterator>& __x,
+        const move_iterator<_Iterator>& __y)
+    { return __x.base() == __y.base(); }
+
+  template<typename _Iterator>
+    inline constexpr bool
+    operator!=(const move_iterator<_Iterator>& __x,
+        const move_iterator<_Iterator>& __y)
+    { return !(__x == __y); }
+
+  template<typename _Iterator>
+    inline constexpr bool
+    operator<(const move_iterator<_Iterator>& __x,
+       const move_iterator<_Iterator>& __y)
+    { return __x.base() < __y.base(); }
+
+  template<typename _Iterator>
+    inline constexpr bool
+    operator<=(const move_iterator<_Iterator>& __x,
+        const move_iterator<_Iterator>& __y)
+    { return !(__y < __x); }
+
+  template<typename _Iterator>
+    inline constexpr bool
+    operator>(const move_iterator<_Iterator>& __x,
+       const move_iterator<_Iterator>& __y)
+    { return __y < __x; }
+
+  template<typename _Iterator>
+    inline constexpr bool
+    operator>=(const move_iterator<_Iterator>& __x,
+        const move_iterator<_Iterator>& __y)
+    { return !(__x < __y); }
+
+
+
+  template<typename _IteratorL, typename _IteratorR>
+    inline constexpr 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 constexpr move_iterator<_Iterator>
+    operator+(typename move_iterator<_Iterator>::difference_type __n,
+       const move_iterator<_Iterator>& __x)
+    { return __x + __n; }
+
+  template<typename _Iterator>
+    inline constexpr move_iterator<_Iterator>
+    make_move_iterator(_Iterator __i)
+    { return move_iterator<_Iterator>(std::move(__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 constexpr _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 constexpr _ReturnType
+    __make_move_if_noexcept_iterator(_Tp* __i)
+    { return _ReturnType(__i); }
+# 2154 "/usr/include/c++/10.2.0/bits/stl_iterator.h" 3
+  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()); }
+
+#define _GLIBCXX_MAKE_MOVE_ITERATOR(_Iter) std::make_move_iterator(_Iter)
+#define _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(_Iter) std::__make_move_if_noexcept_iterator(_Iter)
+# 2184 "/usr/include/c++/10.2.0/bits/stl_iterator.h" 3
+  template<typename _InputIterator>
+    using __iter_key_t = remove_const_t<
+    typename iterator_traits<_InputIterator>::value_type::first_type>;
+
+  template<typename _InputIterator>
+    using __iter_val_t =
+    typename iterator_traits<_InputIterator>::value_type::second_type;
+
+  template<typename _T1, typename _T2>
+    struct pair;
+
+  template<typename _InputIterator>
+    using __iter_to_alloc_t =
+    pair<add_const_t<__iter_key_t<_InputIterator>>,
+  __iter_val_t<_InputIterator>>;
+
+
+
+}
+# 68 "/usr/include/c++/10.2.0/bits/stl_algobase.h" 2 3
+
+# 1 "/usr/include/c++/10.2.0/debug/debug.h" 1 3
+# 30 "/usr/include/c++/10.2.0/debug/debug.h" 3
+#define _GLIBCXX_DEBUG_MACRO_SWITCH_H 1
+# 48 "/usr/include/c++/10.2.0/debug/debug.h" 3
+namespace std
+{
+  namespace __debug { }
+}
+
+
+
+
+namespace __gnu_debug
+{
+  using namespace std::__debug;
+
+  template<typename _Ite, typename _Seq, typename _Cat>
+    struct _Safe_iterator;
+}
+
+
+
+#define __glibcxx_requires_cond(_Cond,_Msg) 
+#define __glibcxx_requires_valid_range(_First,_Last) 
+#define __glibcxx_requires_can_increment(_First,_Size) 
+#define __glibcxx_requires_can_increment_range(_First1,_Last1,_First2) 
+#define __glibcxx_requires_can_decrement_range(_First1,_Last1,_First2) 
+#define __glibcxx_requires_sorted(_First,_Last) 
+#define __glibcxx_requires_sorted_pred(_First,_Last,_Pred) 
+#define __glibcxx_requires_sorted_set(_First1,_Last1,_First2) 
+#define __glibcxx_requires_sorted_set_pred(_First1,_Last1,_First2,_Pred) 
+#define __glibcxx_requires_partitioned_lower(_First,_Last,_Value) 
+#define __glibcxx_requires_partitioned_upper(_First,_Last,_Value) 
+#define __glibcxx_requires_partitioned_lower_pred(_First,_Last,_Value,_Pred) 
+#define __glibcxx_requires_partitioned_upper_pred(_First,_Last,_Value,_Pred) 
+#define __glibcxx_requires_heap(_First,_Last) 
+#define __glibcxx_requires_heap_pred(_First,_Last,_Pred) 
+#define __glibcxx_requires_string(_String) 
+#define __glibcxx_requires_string_len(_String,_Len) 
+#define __glibcxx_requires_irreflexive(_First,_Last) 
+#define __glibcxx_requires_irreflexive2(_First,_Last) 
+#define __glibcxx_requires_irreflexive_pred(_First,_Last,_Pred) 
+#define __glibcxx_requires_irreflexive_pred2(_First,_Last,_Pred) 
+# 70 "/usr/include/c++/10.2.0/bits/stl_algobase.h" 2 3
+
+# 1 "/usr/include/c++/10.2.0/bits/predefined_ops.h" 1 3
+# 31 "/usr/include/c++/10.2.0/bits/predefined_ops.h" 3
+#define _GLIBCXX_PREDEFINED_OPS_H 1
+
+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 "/usr/include/c++/10.2.0/bits/stl_algobase.h" 2 3
+
+
+
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+
+  template<typename _Tp, typename _Up>
+    constexpr
+    inline int
+    __memcmp(const _Tp* __first1, const _Up* __first2, size_t __num)
+    {
+
+      static_assert(sizeof(_Tp) == sizeof(_Up), "can be compared with memcmp");
+# 105 "/usr/include/c++/10.2.0/bits/stl_algobase.h" 3
+ return __builtin_memcmp(__first1, __first2, sizeof(_Tp) * __num);
+    }
+# 149 "/usr/include/c++/10.2.0/bits/stl_algobase.h" 3
+  template<typename _ForwardIterator1, typename _ForwardIterator2>
+   
+    inline void
+    iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
+    {
+
+     
+
+     
+# 182 "/usr/include/c++/10.2.0/bits/stl_algobase.h" 3
+      swap(*__a, *__b);
+
+    }
+# 198 "/usr/include/c++/10.2.0/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;
+    }
+# 227 "/usr/include/c++/10.2.0/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;
+    }
+# 251 "/usr/include/c++/10.2.0/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;
+    }
+# 275 "/usr/include/c++/10.2.0/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;
+    }
+# 297 "/usr/include/c++/10.2.0/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)
+    noexcept(std::is_nothrow_copy_constructible<_Iterator>::value)
+    { return __it; }
+
+
+
+
+  template<typename _From, typename _To>
+   
+    inline _From
+    __niter_wrap(_From __from, _To __res)
+    { return __from + (__res - std::__niter_base(__from)); }
+
+
+  template<typename _Iterator>
+   
+    inline _Iterator
+    __niter_wrap(const _Iterator&, _Iterator __res)
+    { return __res; }
+
+
+
+
+
+
+
+  template<bool _IsMove, bool _IsSimple, typename _Category>
+    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<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)
+    {
+      typedef typename iterator_traits<_II>::iterator_category _Category;
+
+
+
+
+
+      return std::__copy_move<_IsMove, __memcpyable<_OI, _II>::__value,
+         _Category>::__copy_m(__first, __last, __result);
+    }
+
+
+
+  template<typename _Tp, typename _Ref, typename _Ptr>
+    struct _Deque_iterator;
+
+
+
+  template<bool _IsMove,
+    typename _Tp, typename _Ref, typename _Ptr, typename _OI>
+    _OI
+    __copy_move_a1(std::_Deque_iterator<_Tp, _Ref, _Ptr>,
+     std::_Deque_iterator<_Tp, _Ref, _Ptr>,
+     _OI);
+
+  template<bool _IsMove,
+    typename _ITp, typename _IRef, typename _IPtr, typename _OTp>
+    std::_Deque_iterator<_OTp, _OTp&, _OTp*>
+    __copy_move_a1(std::_Deque_iterator<_ITp, _IRef, _IPtr>,
+     std::_Deque_iterator<_ITp, _IRef, _IPtr>,
+     std::_Deque_iterator<_OTp, _OTp&, _OTp*>);
+
+  template<bool _IsMove, typename _II, typename _Tp>
+    typename __gnu_cxx::__enable_if<
+      __is_random_access_iter<_II>::__value,
+      std::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type
+    __copy_move_a1(_II, _II, std::_Deque_iterator<_Tp, _Tp&, _Tp*>);
+
+  template<bool _IsMove, typename _II, typename _OI>
+   
+    inline _OI
+    __copy_move_a1(_II __first, _II __last, _OI __result)
+    { return std::__copy_move_a2<_IsMove>(__first, __last, __result); }
+
+  template<bool _IsMove, typename _II, typename _OI>
+   
+    inline _OI
+    __copy_move_a(_II __first, _II __last, _OI __result)
+    {
+      return std::__niter_wrap(__result,
+  std::__copy_move_a1<_IsMove>(std::__niter_base(__first),
+          std::__niter_base(__last),
+          std::__niter_base(__result)));
+    }
+
+  template<bool _IsMove,
+    typename _Ite, typename _Seq, typename _Cat, typename _OI>
+    _OI
+    __copy_move_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&,
+    const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&,
+    _OI);
+
+  template<bool _IsMove,
+    typename _II, typename _Ite, typename _Seq, typename _Cat>
+    __gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>
+    __copy_move_a(_II, _II,
+    const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&);
+
+  template<bool _IsMove,
+    typename _IIte, typename _ISeq, typename _ICat,
+    typename _OIte, typename _OSeq, typename _OCat>
+    ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat>
+    __copy_move_a(const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&,
+    const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&,
+    const ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat>&);
+# 557 "/usr/include/c++/10.2.0/bits/stl_algobase.h" 3
+  template<typename _II, typename _OI>
+   
+    inline _OI
+    copy(_II __first, _II __last, _OI __result)
+    {
+
+     
+     
+
+      ;
+
+      return std::__copy_move_a<__is_move_iterator<_II>::__value>
+      (std::__miter_base(__first), std::__miter_base(__last), __result);
+    }
+# 590 "/usr/include/c++/10.2.0/bits/stl_algobase.h" 3
+  template<typename _II, typename _OI>
+   
+    inline _OI
+    move(_II __first, _II __last, _OI __result)
+    {
+
+     
+     
+
+      ;
+
+      return std::__copy_move_a<true>(std::__miter_base(__first),
+          std::__miter_base(__last), __result);
+    }
+
+#define _GLIBCXX_MOVE3(_Tp,_Up,_Vp) std::move(_Tp, _Up, _Vp)
+
+
+
+
+  template<bool _IsMove, bool _IsSimple, typename _Category>
+    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 = __last - __first;
+   for (; __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 = __last - __first;
+   for (; __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_a2(_BI1 __first, _BI1 __last, _BI2 __result)
+    {
+      typedef typename iterator_traits<_BI1>::iterator_category _Category;
+
+
+
+
+
+      return std::__copy_move_backward<_IsMove,
+           __memcpyable<_BI2, _BI1>::__value,
+           _Category>::__copy_move_b(__first,
+         __last,
+         __result);
+    }
+
+  template<bool _IsMove, typename _BI1, typename _BI2>
+   
+    inline _BI2
+    __copy_move_backward_a1(_BI1 __first, _BI1 __last, _BI2 __result)
+    { return std::__copy_move_backward_a2<_IsMove>(__first, __last, __result); }
+
+  template<bool _IsMove,
+    typename _Tp, typename _Ref, typename _Ptr, typename _OI>
+    _OI
+    __copy_move_backward_a1(std::_Deque_iterator<_Tp, _Ref, _Ptr>,
+       std::_Deque_iterator<_Tp, _Ref, _Ptr>,
+       _OI);
+
+  template<bool _IsMove,
+    typename _ITp, typename _IRef, typename _IPtr, typename _OTp>
+    std::_Deque_iterator<_OTp, _OTp&, _OTp*>
+    __copy_move_backward_a1(
+   std::_Deque_iterator<_ITp, _IRef, _IPtr>,
+   std::_Deque_iterator<_ITp, _IRef, _IPtr>,
+   std::_Deque_iterator<_OTp, _OTp&, _OTp*>);
+
+  template<bool _IsMove, typename _II, typename _Tp>
+    typename __gnu_cxx::__enable_if<
+      __is_random_access_iter<_II>::__value,
+      std::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type
+    __copy_move_backward_a1(_II, _II,
+       std::_Deque_iterator<_Tp, _Tp&, _Tp*>);
+
+  template<bool _IsMove, typename _II, typename _OI>
+   
+    inline _OI
+    __copy_move_backward_a(_II __first, _II __last, _OI __result)
+    {
+      return std::__niter_wrap(__result,
+  std::__copy_move_backward_a1<_IsMove>
+    (std::__niter_base(__first), std::__niter_base(__last),
+     std::__niter_base(__result)));
+    }
+
+  template<bool _IsMove,
+    typename _Ite, typename _Seq, typename _Cat, typename _OI>
+    _OI
+    __copy_move_backward_a(
+  const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&,
+  const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&,
+  _OI);
+
+  template<bool _IsMove,
+    typename _II, typename _Ite, typename _Seq, typename _Cat>
+    __gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>
+    __copy_move_backward_a(_II, _II,
+  const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&);
+
+  template<bool _IsMove,
+    typename _IIte, typename _ISeq, typename _ICat,
+    typename _OIte, typename _OSeq, typename _OCat>
+    ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat>
+    __copy_move_backward_a(
+  const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&,
+  const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&,
+  const ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat>&);
+# 794 "/usr/include/c++/10.2.0/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_a<__is_move_iterator<_BI1>::__value>
+      (std::__miter_base(__first), std::__miter_base(__last), __result);
+    }
+# 830 "/usr/include/c++/10.2.0/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_a<true>(std::__miter_base(__first),
+            std::__miter_base(__last),
+            __result);
+    }
+
+#define _GLIBCXX_MOVE_BACKWARD3(_Tp,_Up,_Vp) std::move_backward(_Tp, _Up, _Vp)
+
+
+
+
+  template<typename _ForwardIterator, typename _Tp>
+   
+    inline typename
+    __gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value, void>::__type
+    __fill_a1(_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_a1(_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_a1(_Tp* __first, _Tp* __last, const _Tp& __c)
+    {
+      const _Tp __tmp = __c;
+# 892 "/usr/include/c++/10.2.0/bits/stl_algobase.h" 3
+      if (const size_t __len = __last - __first)
+ __builtin_memset(__first, static_cast<unsigned char>(__tmp), __len);
+    }
+
+  template<typename _Ite, typename _Cont, typename _Tp>
+   
+    inline void
+    __fill_a1(::__gnu_cxx::__normal_iterator<_Ite, _Cont> __first,
+       ::__gnu_cxx::__normal_iterator<_Ite, _Cont> __last,
+       const _Tp& __value)
+    { std::__fill_a1(__first.base(), __last.base(), __value); }
+
+  template<typename _Tp, typename _VTp>
+    void
+    __fill_a1(const std::_Deque_iterator<_Tp, _Tp&, _Tp*>&,
+       const std::_Deque_iterator<_Tp, _Tp&, _Tp*>&,
+       const _VTp&);
+
+  template<typename _FIte, typename _Tp>
+   
+    inline void
+    __fill_a(_FIte __first, _FIte __last, const _Tp& __value)
+    { std::__fill_a1(__first, __last, __value); }
+
+  template<typename _Ite, typename _Seq, typename _Cat, typename _Tp>
+    void
+    __fill_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&,
+      const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&,
+      const _Tp&);
+# 934 "/usr/include/c++/10.2.0/bits/stl_algobase.h" 3
+  template<typename _ForwardIterator, typename _Tp>
+   
+    inline void
+    fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
+    {
+
+     
+
+      ;
+
+      std::__fill_a(__first, __last, __value);
+    }
+
+
+  inline constexpr int
+  __size_to_integer(int __n) { return __n; }
+  inline constexpr unsigned
+  __size_to_integer(unsigned __n) { return __n; }
+  inline constexpr long
+  __size_to_integer(long __n) { return __n; }
+  inline constexpr unsigned long
+  __size_to_integer(unsigned long __n) { return __n; }
+  inline constexpr long long
+  __size_to_integer(long long __n) { return __n; }
+  inline constexpr unsigned long long
+  __size_to_integer(unsigned long long __n) { return __n; }
+# 986 "/usr/include/c++/10.2.0/bits/stl_algobase.h" 3
+  inline constexpr long long
+  __size_to_integer(float __n) { return __n; }
+  inline constexpr long long
+  __size_to_integer(double __n) { return __n; }
+  inline constexpr long long
+  __size_to_integer(long double __n) { return __n; }
+
+
+
+
+
+  template<typename _OutputIterator, typename _Size, typename _Tp>
+   
+    inline typename
+    __gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value, _OutputIterator>::__type
+    __fill_n_a1(_OutputIterator __first, _Size __n, const _Tp& __value)
+    {
+      for (; __n > 0; --__n, (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_a1(_OutputIterator __first, _Size __n, const _Tp& __value)
+    {
+      const _Tp __tmp = __value;
+      for (; __n > 0; --__n, (void) ++__first)
+ *__first = __tmp;
+      return __first;
+    }
+
+  template<typename _Ite, typename _Seq, typename _Cat, typename _Size,
+    typename _Tp>
+    ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>
+    __fill_n_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>& __first,
+        _Size __n, const _Tp& __value,
+        std::input_iterator_tag);
+
+  template<typename _OutputIterator, typename _Size, typename _Tp>
+   
+    inline _OutputIterator
+    __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value,
+        std::output_iterator_tag)
+    {
+
+      static_assert(is_integral<_Size>{}, "fill_n must pass integral size");
+
+      return __fill_n_a1(__first, __n, __value);
+    }
+
+  template<typename _OutputIterator, typename _Size, typename _Tp>
+   
+    inline _OutputIterator
+    __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value,
+        std::input_iterator_tag)
+    {
+
+      static_assert(is_integral<_Size>{}, "fill_n must pass integral size");
+
+      return __fill_n_a1(__first, __n, __value);
+    }
+
+  template<typename _OutputIterator, typename _Size, typename _Tp>
+   
+    inline _OutputIterator
+    __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value,
+        std::random_access_iterator_tag)
+    {
+
+      static_assert(is_integral<_Size>{}, "fill_n must pass integral size");
+
+      if (__n <= 0)
+ return __first;
+
+      ;
+
+      std::__fill_a(__first, __first + __n, __value);
+      return __first + __n;
+    }
+# 1086 "/usr/include/c++/10.2.0/bits/stl_algobase.h" 3
+  template<typename _OI, typename _Size, typename _Tp>
+   
+    inline _OI
+    fill_n(_OI __first, _Size __n, const _Tp& __value)
+    {
+
+     
+
+      return std::__fill_n_a(__first, std::__size_to_integer(__n), __value,
+          std::__iterator_category(__first));
+    }
+
+  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 !std::__memcmp(__first1, __first2, __len);
+   return true;
+ }
+    };
+
+  template<typename _Tp, typename _Ref, typename _Ptr, typename _II>
+    typename __gnu_cxx::__enable_if<
+      __is_random_access_iter<_II>::__value, bool>::__type
+    __equal_aux1(std::_Deque_iterator<_Tp, _Ref, _Ptr>,
+   std::_Deque_iterator<_Tp, _Ref, _Ptr>,
+   _II);
+
+  template<typename _Tp1, typename _Ref1, typename _Ptr1,
+    typename _Tp2, typename _Ref2, typename _Ptr2>
+    bool
+    __equal_aux1(std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>,
+   std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>,
+   std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>);
+
+  template<typename _II, typename _Tp, typename _Ref, typename _Ptr>
+    typename __gnu_cxx::__enable_if<
+      __is_random_access_iter<_II>::__value, bool>::__type
+    __equal_aux1(_II, _II,
+  std::_Deque_iterator<_Tp, _Ref, _Ptr>);
+
+  template<typename _II1, typename _II2>
+   
+    inline bool
+    __equal_aux1(_II1 __first1, _II1 __last1, _II2 __first2)
+    {
+      typedef typename iterator_traits<_II1>::value_type _ValueType1;
+      const bool __simple = ((__is_integer<_ValueType1>::__value
+         || __is_pointer<_ValueType1>::__value)
+        && __memcmpable<_II1, _II2>::__value);
+      return std::__equal<__simple>::equal(__first1, __last1, __first2);
+    }
+
+  template<typename _II1, typename _II2>
+   
+    inline bool
+    __equal_aux(_II1 __first1, _II1 __last1, _II2 __first2)
+    {
+      return std::__equal_aux1(std::__niter_base(__first1),
+          std::__niter_base(__last1),
+          std::__niter_base(__first2));
+    }
+
+  template<typename _II1, typename _Seq1, typename _Cat1, typename _II2>
+    bool
+    __equal_aux(const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&,
+  const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&,
+  _II2);
+
+  template<typename _II1, typename _II2, typename _Seq2, typename _Cat2>
+    bool
+    __equal_aux(_II1, _II1,
+  const ::__gnu_debug::_Safe_iterator<_II2, _Seq2, _Cat2>&);
+
+  template<typename _II1, typename _Seq1, typename _Cat1,
+    typename _II2, typename _Seq2, typename _Cat2>
+    bool
+    __equal_aux(const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&,
+  const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&,
+  const ::__gnu_debug::_Safe_iterator<_II2, _Seq2, _Cat2>&);
+
+  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 __first1, _II1 __last1, _II2 __first2, _II2 __last2)
+ {
+   using __gnu_cxx::__ops::__iter_less_iter;
+   return std::__lexicographical_compare_impl(__first1, __last1,
+           __first2, __last2,
+           __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 = std::__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;
+    }
+# 1347 "/usr/include/c++/10.2.0/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 (int)sizeof(int) * 8 - 1 - __builtin_clz(__n); }
+
+  inline constexpr unsigned
+  __lg(unsigned __n)
+  { return (int)sizeof(int) * 8 - 1 - __builtin_clz(__n); }
+
+  inline constexpr long
+  __lg(long __n)
+  { return (int)sizeof(long) * 8 - 1 - __builtin_clzl(__n); }
+
+  inline constexpr unsigned long
+  __lg(unsigned long __n)
+  { return (int)sizeof(long) * 8 - 1 - __builtin_clzl(__n); }
+
+  inline constexpr long long
+  __lg(long long __n)
+  { return (int)sizeof(long long) * 8 - 1 - __builtin_clzll(__n); }
+
+  inline constexpr unsigned long long
+  __lg(unsigned long long __n)
+  { return (int)sizeof(long long) * 8 - 1 - __builtin_clzll(__n); }
+
+
+# 1403 "/usr/include/c++/10.2.0/bits/stl_algobase.h" 3
+  template<typename _II1, typename _II2>
+   
+    inline bool
+    equal(_II1 __first1, _II1 __last1, _II2 __first2)
+    {
+
+     
+     
+     
+
+
+      ;
+
+      return std::__equal_aux(__first1, __last1, __first2);
+    }
+# 1434 "/usr/include/c++/10.2.0/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;
+    }
+
+
+
+
+#define __cpp_lib_robust_nonmodifying_seq_ops 201304
+# 1524 "/usr/include/c++/10.2.0/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);
+    }
+# 1557 "/usr/include/c++/10.2.0/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);
+    }
+# 1589 "/usr/include/c++/10.2.0/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));
+    }
+# 1626 "/usr/include/c++/10.2.0/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));
+    }
+# 1740 "/usr/include/c++/10.2.0/bits/stl_algobase.h" 3
+  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);
+    }
+# 1768 "/usr/include/c++/10.2.0/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());
+    }
+# 1802 "/usr/include/c++/10.2.0/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);
+    }
+# 1851 "/usr/include/c++/10.2.0/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());
+    }
+# 1887 "/usr/include/c++/10.2.0/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));
+    }
+
+
+
+
+
+  template<typename _InputIterator, typename _Predicate>
+   
+    inline _InputIterator
+    __find_if(_InputIterator __first, _InputIterator __last,
+       _Predicate __pred, input_iterator_tag)
+    {
+      while (__first != __last && !__pred(__first))
+ ++__first;
+      return __first;
+    }
+
+
+  template<typename _RandomAccessIterator, typename _Predicate>
+   
+    _RandomAccessIterator
+    __find_if(_RandomAccessIterator __first, _RandomAccessIterator __last,
+       _Predicate __pred, random_access_iterator_tag)
+    {
+      typename iterator_traits<_RandomAccessIterator>::difference_type
+ __trip_count = (__last - __first) >> 2;
+
+      for (; __trip_count > 0; --__trip_count)
+ {
+   if (__pred(__first))
+     return __first;
+   ++__first;
+
+   if (__pred(__first))
+     return __first;
+   ++__first;
+
+   if (__pred(__first))
+     return __first;
+   ++__first;
+
+   if (__pred(__first))
+     return __first;
+   ++__first;
+ }
+
+      switch (__last - __first)
+ {
+ case 3:
+   if (__pred(__first))
+     return __first;
+   ++__first;
+
+ case 2:
+   if (__pred(__first))
+     return __first;
+   ++__first;
+
+ case 1:
+   if (__pred(__first))
+     return __first;
+   ++__first;
+
+ case 0:
+ default:
+   return __last;
+ }
+    }
+
+  template<typename _Iterator, typename _Predicate>
+   
+    inline _Iterator
+    __find_if(_Iterator __first, _Iterator __last, _Predicate __pred)
+    {
+      return __find_if(__first, __last, __pred,
+         std::__iterator_category(__first));
+    }
+
+  template<typename _InputIterator, typename _Predicate>
+   
+    typename iterator_traits<_InputIterator>::difference_type
+    __count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred)
+    {
+      typename iterator_traits<_InputIterator>::difference_type __n = 0;
+      for (; __first != __last; ++__first)
+ if (__pred(__first))
+   ++__n;
+      return __n;
+    }
+
+
+  template<typename _ForwardIterator1, typename _ForwardIterator2,
+    typename _BinaryPredicate>
+   
+    bool
+    __is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+       _ForwardIterator2 __first2, _BinaryPredicate __pred)
+    {
+
+
+      for (; __first1 != __last1; ++__first1, (void)++__first2)
+ if (!__pred(__first1, __first2))
+   break;
+
+      if (__first1 == __last1)
+ return true;
+
+
+
+      _ForwardIterator2 __last2 = __first2;
+      std::advance(__last2, std::distance(__first1, __last1));
+      for (_ForwardIterator1 __scan = __first1; __scan != __last1; ++__scan)
+ {
+   if (__scan != std::__find_if(__first1, __scan,
+     __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)))
+     continue;
+
+   auto __matches
+     = std::__count_if(__first2, __last2,
+   __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan));
+   if (0 == __matches ||
+       std::__count_if(__scan, __last1,
+   __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan))
+       != __matches)
+     return false;
+ }
+      return true;
+    }
+# 2044 "/usr/include/c++/10.2.0/bits/stl_algobase.h" 3
+  template<typename _ForwardIterator1, typename _ForwardIterator2>
+   
+    inline bool
+    is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+     _ForwardIterator2 __first2)
+    {
+
+     
+     
+     
+
+
+      ;
+
+      return std::__is_permutation(__first1, __last1, __first2,
+       __gnu_cxx::__ops::__iter_equal_to_iter());
+    }
+
+
+
+}
+# 40 "/usr/include/c++/10.2.0/bits/char_traits.h" 2 3
+# 1 "/usr/include/c++/10.2.0/bits/postypes.h" 1 3
+# 36 "/usr/include/c++/10.2.0/bits/postypes.h" 3
+#define _GLIBCXX_POSTYPES_H 1
+
+       
+# 39 "/usr/include/c++/10.2.0/bits/postypes.h" 3
+
+# 1 "/usr/include/c++/10.2.0/cwchar" 1 3
+# 39 "/usr/include/c++/10.2.0/cwchar" 3
+       
+# 40 "/usr/include/c++/10.2.0/cwchar" 3
+
+
+
+
+# 1 "/usr/include/wchar.h" 1 3 4
+# 24 "/usr/include/wchar.h" 3 4
+#define _WCHAR_H 1
+
+#define __GLIBC_INTERNAL_STARTING_HEADER_IMPLEMENTATION 
+# 1 "/usr/include/bits/libc-header-start.h" 1 3 4
+# 31 "/usr/include/bits/libc-header-start.h" 3 4
+#undef __GLIBC_INTERNAL_STARTING_HEADER_IMPLEMENTATION
+
+
+
+
+
+#undef __GLIBC_USE_LIB_EXT2
+
+
+#define __GLIBC_USE_LIB_EXT2 1
+# 49 "/usr/include/bits/libc-header-start.h" 3 4
+#undef __GLIBC_USE_IEC_60559_BFP_EXT
+
+#define __GLIBC_USE_IEC_60559_BFP_EXT 1
+
+
+
+#undef __GLIBC_USE_IEC_60559_BFP_EXT_C2X
+
+#define __GLIBC_USE_IEC_60559_BFP_EXT_C2X 1
+# 66 "/usr/include/bits/libc-header-start.h" 3 4
+#undef __GLIBC_USE_IEC_60559_FUNCS_EXT
+
+#define __GLIBC_USE_IEC_60559_FUNCS_EXT 1
+
+
+
+#undef __GLIBC_USE_IEC_60559_FUNCS_EXT_C2X
+
+#define __GLIBC_USE_IEC_60559_FUNCS_EXT_C2X 1
+
+
+
+
+
+
+#undef __GLIBC_USE_IEC_60559_TYPES_EXT
+
+#define __GLIBC_USE_IEC_60559_TYPES_EXT 1
+# 28 "/usr/include/wchar.h" 2 3 4
+
+
+
+
+#define __need_size_t 
+#define __need_wchar_t 
+#define __need_NULL 
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 1 3 4
+# 155 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef __need_ptrdiff_t
+# 231 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef __need_size_t
+# 340 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef __need_wchar_t
+# 390 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef NULL
+
+#define NULL __null
+# 401 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef __need_NULL
+
+
+
+
+#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
+# 36 "/usr/include/wchar.h" 2 3 4
+
+#define __need___va_list 
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stdarg.h" 1 3 4
+# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stdarg.h" 3 4
+#undef __need___va_list
+
+
+
+
+#define __GNUC_VA_LIST 
+typedef __builtin_va_list __gnuc_va_list;
+# 39 "/usr/include/wchar.h" 2 3 4
+
+# 1 "/usr/include/bits/wchar.h" 1 3 4
+# 20 "/usr/include/bits/wchar.h" 3 4
+#define _BITS_WCHAR_H 1
+# 34 "/usr/include/bits/wchar.h" 3 4
+#define __WCHAR_MAX __WCHAR_MAX__
+
+
+
+
+
+
+
+#define __WCHAR_MIN __WCHAR_MIN__
+# 41 "/usr/include/wchar.h" 2 3 4
+# 1 "/usr/include/bits/types/wint_t.h" 1 3 4
+
+#define __wint_t_defined 1
+
+
+
+
+
+
+
+#define _WINT_T 1
+# 20 "/usr/include/bits/types/wint_t.h" 3 4
+typedef unsigned int wint_t;
+# 42 "/usr/include/wchar.h" 2 3 4
+# 1 "/usr/include/bits/types/mbstate_t.h" 1 3 4
+
+#define __mbstate_t_defined 1
+
+# 1 "/usr/include/bits/types/__mbstate_t.h" 1 3 4
+
+#define ____mbstate_t_defined 1
+# 13 "/usr/include/bits/types/__mbstate_t.h" 3 4
+typedef struct
+{
+  int __count;
+  union
+  {
+    unsigned int __wch;
+    char __wchb[4];
+  } __value;
+} __mbstate_t;
+# 5 "/usr/include/bits/types/mbstate_t.h" 2 3 4
+
+typedef __mbstate_t mbstate_t;
+# 43 "/usr/include/wchar.h" 2 3 4
+# 1 "/usr/include/bits/types/__FILE.h" 1 3 4
+
+#define ____FILE_defined 1
+
+struct _IO_FILE;
+typedef struct _IO_FILE __FILE;
+# 44 "/usr/include/wchar.h" 2 3 4
+
+
+# 1 "/usr/include/bits/types/FILE.h" 1 3 4
+
+#define __FILE_defined 1
+
+struct _IO_FILE;
+
+
+typedef struct _IO_FILE FILE;
+# 47 "/usr/include/wchar.h" 2 3 4
+
+
+
+
+
+
+
+#define __CORRECT_ISO_CPP_WCHAR_H_PROTO 
+
+
+
+
+#define WCHAR_MIN __WCHAR_MIN
+#define WCHAR_MAX __WCHAR_MAX
+
+
+
+#define WEOF (0xffffffffu)
+# 79 "/usr/include/wchar.h" 3 4
+extern "C" {
+
+
+
+struct tm;
+
+
+
+extern wchar_t *wcscpy (wchar_t *__restrict __dest,
+   const wchar_t *__restrict __src)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern wchar_t *wcsncpy (wchar_t *__restrict __dest,
+    const wchar_t *__restrict __src, size_t __n)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern wchar_t *wcscat (wchar_t *__restrict __dest,
+   const wchar_t *__restrict __src)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+extern wchar_t *wcsncat (wchar_t *__restrict __dest,
+    const wchar_t *__restrict __src, size_t __n)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int wcscmp (const wchar_t *__s1, const wchar_t *__s2)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+
+extern int wcsncmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+extern int wcscasecmp (const wchar_t *__s1, const wchar_t *__s2) throw ();
+
+
+extern int wcsncasecmp (const wchar_t *__s1, const wchar_t *__s2,
+   size_t __n) throw ();
+
+
+
+extern int wcscasecmp_l (const wchar_t *__s1, const wchar_t *__s2,
+    locale_t __loc) throw ();
+
+extern int wcsncasecmp_l (const wchar_t *__s1, const wchar_t *__s2,
+     size_t __n, locale_t __loc) throw ();
+
+
+
+
+extern int wcscoll (const wchar_t *__s1, const wchar_t *__s2) throw ();
+
+
+
+extern size_t wcsxfrm (wchar_t *__restrict __s1,
+         const wchar_t *__restrict __s2, size_t __n) throw ();
+
+
+
+
+
+
+
+extern int wcscoll_l (const wchar_t *__s1, const wchar_t *__s2,
+        locale_t __loc) throw ();
+
+
+
+
+extern size_t wcsxfrm_l (wchar_t *__s1, const wchar_t *__s2,
+    size_t __n, locale_t __loc) throw ();
+
+
+extern wchar_t *wcsdup (const wchar_t *__s) throw () __attribute__ ((__malloc__));
+
+
+
+
+extern "C++" wchar_t *wcschr (wchar_t *__wcs, wchar_t __wc)
+     throw () __asm ("wcschr") __attribute__ ((__pure__));
+extern "C++" const wchar_t *wcschr (const wchar_t *__wcs, wchar_t __wc)
+     throw () __asm ("wcschr") __attribute__ ((__pure__));
+
+
+
+
+
+
+extern "C++" wchar_t *wcsrchr (wchar_t *__wcs, wchar_t __wc)
+     throw () __asm ("wcsrchr") __attribute__ ((__pure__));
+extern "C++" const wchar_t *wcsrchr (const wchar_t *__wcs, wchar_t __wc)
+     throw () __asm ("wcsrchr") __attribute__ ((__pure__));
+# 181 "/usr/include/wchar.h" 3 4
+extern wchar_t *wcschrnul (const wchar_t *__s, wchar_t __wc)
+     throw () __attribute__ ((__pure__));
+
+
+
+
+extern size_t wcscspn (const wchar_t *__wcs, const wchar_t *__reject)
+     throw () __attribute__ ((__pure__));
+
+
+extern size_t wcsspn (const wchar_t *__wcs, const wchar_t *__accept)
+     throw () __attribute__ ((__pure__));
+
+
+extern "C++" wchar_t *wcspbrk (wchar_t *__wcs, const wchar_t *__accept)
+     throw () __asm ("wcspbrk") __attribute__ ((__pure__));
+extern "C++" const wchar_t *wcspbrk (const wchar_t *__wcs,
+         const wchar_t *__accept)
+     throw () __asm ("wcspbrk") __attribute__ ((__pure__));
+
+
+
+
+
+
+extern "C++" wchar_t *wcsstr (wchar_t *__haystack, const wchar_t *__needle)
+     throw () __asm ("wcsstr") __attribute__ ((__pure__));
+extern "C++" const wchar_t *wcsstr (const wchar_t *__haystack,
+        const wchar_t *__needle)
+     throw () __asm ("wcsstr") __attribute__ ((__pure__));
+
+
+
+
+
+
+extern wchar_t *wcstok (wchar_t *__restrict __s,
+   const wchar_t *__restrict __delim,
+   wchar_t **__restrict __ptr) throw ();
+
+
+extern size_t wcslen (const wchar_t *__s) throw () __attribute__ ((__pure__));
+
+
+
+
+extern "C++" wchar_t *wcswcs (wchar_t *__haystack, const wchar_t *__needle)
+     throw () __asm ("wcswcs") __attribute__ ((__pure__));
+extern "C++" const wchar_t *wcswcs (const wchar_t *__haystack,
+        const wchar_t *__needle)
+     throw () __asm ("wcswcs") __attribute__ ((__pure__));
+# 240 "/usr/include/wchar.h" 3 4
+extern size_t wcsnlen (const wchar_t *__s, size_t __maxlen)
+     throw () __attribute__ ((__pure__));
+
+
+
+
+
+extern "C++" wchar_t *wmemchr (wchar_t *__s, wchar_t __c, size_t __n)
+     throw () __asm ("wmemchr") __attribute__ ((__pure__));
+extern "C++" const wchar_t *wmemchr (const wchar_t *__s, wchar_t __c,
+         size_t __n)
+     throw () __asm ("wmemchr") __attribute__ ((__pure__));
+
+
+
+
+
+
+extern int wmemcmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n)
+     throw () __attribute__ ((__pure__));
+
+
+extern wchar_t *wmemcpy (wchar_t *__restrict __s1,
+    const wchar_t *__restrict __s2, size_t __n) throw ();
+
+
+
+extern wchar_t *wmemmove (wchar_t *__s1, const wchar_t *__s2, size_t __n)
+     throw ();
+
+
+extern wchar_t *wmemset (wchar_t *__s, wchar_t __c, size_t __n) throw ();
+
+
+
+
+extern wchar_t *wmempcpy (wchar_t *__restrict __s1,
+     const wchar_t *__restrict __s2, size_t __n)
+     throw ();
+
+
+
+
+
+extern wint_t btowc (int __c) throw ();
+
+
+
+extern int wctob (wint_t __c) throw ();
+
+
+
+extern int mbsinit (const mbstate_t *__ps) throw () __attribute__ ((__pure__));
+
+
+
+extern size_t mbrtowc (wchar_t *__restrict __pwc,
+         const char *__restrict __s, size_t __n,
+         mbstate_t *__restrict __p) throw ();
+
+
+extern size_t wcrtomb (char *__restrict __s, wchar_t __wc,
+         mbstate_t *__restrict __ps) throw ();
+
+
+extern size_t __mbrlen (const char *__restrict __s, size_t __n,
+   mbstate_t *__restrict __ps) throw ();
+extern size_t mbrlen (const char *__restrict __s, size_t __n,
+        mbstate_t *__restrict __ps) throw ();
+# 337 "/usr/include/wchar.h" 3 4
+extern size_t mbsrtowcs (wchar_t *__restrict __dst,
+    const char **__restrict __src, size_t __len,
+    mbstate_t *__restrict __ps) throw ();
+
+
+
+extern size_t wcsrtombs (char *__restrict __dst,
+    const wchar_t **__restrict __src, size_t __len,
+    mbstate_t *__restrict __ps) throw ();
+
+
+
+
+
+extern size_t mbsnrtowcs (wchar_t *__restrict __dst,
+     const char **__restrict __src, size_t __nmc,
+     size_t __len, mbstate_t *__restrict __ps) throw ();
+
+
+
+extern size_t wcsnrtombs (char *__restrict __dst,
+     const wchar_t **__restrict __src,
+     size_t __nwc, size_t __len,
+     mbstate_t *__restrict __ps) throw ();
+
+
+
+
+
+
+extern int wcwidth (wchar_t __c) throw ();
+
+
+
+extern int wcswidth (const wchar_t *__s, size_t __n) throw ();
+
+
+
+
+
+extern double wcstod (const wchar_t *__restrict __nptr,
+        wchar_t **__restrict __endptr) throw ();
+
+
+
+extern float wcstof (const wchar_t *__restrict __nptr,
+       wchar_t **__restrict __endptr) throw ();
+extern long double wcstold (const wchar_t *__restrict __nptr,
+       wchar_t **__restrict __endptr) throw ();
+# 396 "/usr/include/wchar.h" 3 4
+extern _Float32 wcstof32 (const wchar_t *__restrict __nptr,
+     wchar_t **__restrict __endptr) throw ();
+
+
+
+extern _Float64 wcstof64 (const wchar_t *__restrict __nptr,
+     wchar_t **__restrict __endptr) throw ();
+
+
+
+extern _Float128 wcstof128 (const wchar_t *__restrict __nptr,
+       wchar_t **__restrict __endptr) throw ();
+
+
+
+extern _Float32x wcstof32x (const wchar_t *__restrict __nptr,
+       wchar_t **__restrict __endptr) throw ();
+
+
+
+extern _Float64x wcstof64x (const wchar_t *__restrict __nptr,
+       wchar_t **__restrict __endptr) throw ();
+# 428 "/usr/include/wchar.h" 3 4
+extern long int wcstol (const wchar_t *__restrict __nptr,
+   wchar_t **__restrict __endptr, int __base) throw ();
+
+
+
+extern unsigned long int wcstoul (const wchar_t *__restrict __nptr,
+      wchar_t **__restrict __endptr, int __base)
+     throw ();
+
+
+
+
+__extension__
+extern long long int wcstoll (const wchar_t *__restrict __nptr,
+         wchar_t **__restrict __endptr, int __base)
+     throw ();
+
+
+
+__extension__
+extern unsigned long long int wcstoull (const wchar_t *__restrict __nptr,
+     wchar_t **__restrict __endptr,
+     int __base) throw ();
+
+
+
+
+
+__extension__
+extern long long int wcstoq (const wchar_t *__restrict __nptr,
+        wchar_t **__restrict __endptr, int __base)
+     throw ();
+
+
+
+__extension__
+extern unsigned long long int wcstouq (const wchar_t *__restrict __nptr,
+           wchar_t **__restrict __endptr,
+           int __base) throw ();
+
+
+
+
+
+
+extern long int wcstol_l (const wchar_t *__restrict __nptr,
+     wchar_t **__restrict __endptr, int __base,
+     locale_t __loc) throw ();
+
+extern unsigned long int wcstoul_l (const wchar_t *__restrict __nptr,
+        wchar_t **__restrict __endptr,
+        int __base, locale_t __loc) throw ();
+
+__extension__
+extern long long int wcstoll_l (const wchar_t *__restrict __nptr,
+    wchar_t **__restrict __endptr,
+    int __base, locale_t __loc) throw ();
+
+__extension__
+extern unsigned long long int wcstoull_l (const wchar_t *__restrict __nptr,
+       wchar_t **__restrict __endptr,
+       int __base, locale_t __loc)
+     throw ();
+
+extern double wcstod_l (const wchar_t *__restrict __nptr,
+   wchar_t **__restrict __endptr, locale_t __loc)
+     throw ();
+
+extern float wcstof_l (const wchar_t *__restrict __nptr,
+         wchar_t **__restrict __endptr, locale_t __loc)
+     throw ();
+
+extern long double wcstold_l (const wchar_t *__restrict __nptr,
+         wchar_t **__restrict __endptr,
+         locale_t __loc) throw ();
+# 511 "/usr/include/wchar.h" 3 4
+extern _Float32 wcstof32_l (const wchar_t *__restrict __nptr,
+       wchar_t **__restrict __endptr,
+       locale_t __loc) throw ();
+
+
+
+extern _Float64 wcstof64_l (const wchar_t *__restrict __nptr,
+       wchar_t **__restrict __endptr,
+       locale_t __loc) throw ();
+
+
+
+extern _Float128 wcstof128_l (const wchar_t *__restrict __nptr,
+         wchar_t **__restrict __endptr,
+         locale_t __loc) throw ();
+
+
+
+extern _Float32x wcstof32x_l (const wchar_t *__restrict __nptr,
+         wchar_t **__restrict __endptr,
+         locale_t __loc) throw ();
+
+
+
+extern _Float64x wcstof64x_l (const wchar_t *__restrict __nptr,
+         wchar_t **__restrict __endptr,
+         locale_t __loc) throw ();
+# 551 "/usr/include/wchar.h" 3 4
+extern wchar_t *wcpcpy (wchar_t *__restrict __dest,
+   const wchar_t *__restrict __src) throw ();
+
+
+
+extern wchar_t *wcpncpy (wchar_t *__restrict __dest,
+    const wchar_t *__restrict __src, size_t __n)
+     throw ();
+# 567 "/usr/include/wchar.h" 3 4
+extern __FILE *open_wmemstream (wchar_t **__bufloc, size_t *__sizeloc) throw ();
+
+
+
+
+
+extern int fwide (__FILE *__fp, int __mode) throw ();
+
+
+
+
+
+
+extern int fwprintf (__FILE *__restrict __stream,
+       const wchar_t *__restrict __format, ...)
+                                                           ;
+
+
+
+
+extern int wprintf (const wchar_t *__restrict __format, ...)
+                                                           ;
+
+extern int swprintf (wchar_t *__restrict __s, size_t __n,
+       const wchar_t *__restrict __format, ...)
+     throw () ;
+
+
+
+
+
+extern int vfwprintf (__FILE *__restrict __s,
+        const wchar_t *__restrict __format,
+        __gnuc_va_list __arg)
+                                                           ;
+
+
+
+
+extern int vwprintf (const wchar_t *__restrict __format,
+       __gnuc_va_list __arg)
+                                                           ;
+
+
+extern int vswprintf (wchar_t *__restrict __s, size_t __n,
+        const wchar_t *__restrict __format,
+        __gnuc_va_list __arg)
+     throw () ;
+
+
+
+
+
+
+extern int fwscanf (__FILE *__restrict __stream,
+      const wchar_t *__restrict __format, ...)
+                                                          ;
+
+
+
+
+extern int wscanf (const wchar_t *__restrict __format, ...)
+                                                          ;
+
+extern int swscanf (const wchar_t *__restrict __s,
+      const wchar_t *__restrict __format, ...)
+     throw () ;
+# 642 "/usr/include/wchar.h" 3 4
+extern int fwscanf (__FILE *__restrict __stream, const wchar_t *__restrict __format, ...) __asm__ ("" "__isoc99_fwscanf")
+
+
+                                                          ;
+extern int wscanf (const wchar_t *__restrict __format, ...) __asm__ ("" "__isoc99_wscanf")
+
+                                                          ;
+extern int swscanf (const wchar_t *__restrict __s, const wchar_t *__restrict __format, ...) throw () __asm__ ("" "__isoc99_swscanf")
+
+
+                                                          ;
+# 673 "/usr/include/wchar.h" 3 4
+extern int vfwscanf (__FILE *__restrict __s,
+       const wchar_t *__restrict __format,
+       __gnuc_va_list __arg)
+                                                          ;
+
+
+
+
+extern int vwscanf (const wchar_t *__restrict __format,
+      __gnuc_va_list __arg)
+                                                          ;
+
+extern int vswscanf (const wchar_t *__restrict __s,
+       const wchar_t *__restrict __format,
+       __gnuc_va_list __arg)
+     throw () ;
+
+
+
+
+
+
+
+extern int vfwscanf (__FILE *__restrict __s, const wchar_t *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc99_vfwscanf")
+
+
+                                                          ;
+extern int vwscanf (const wchar_t *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc99_vwscanf")
+
+                                                          ;
+extern int vswscanf (const wchar_t *__restrict __s, const wchar_t *__restrict __format, __gnuc_va_list __arg) throw () __asm__ ("" "__isoc99_vswscanf")
+
+
+                                                          ;
+# 729 "/usr/include/wchar.h" 3 4
+extern wint_t fgetwc (__FILE *__stream);
+extern wint_t getwc (__FILE *__stream);
+
+
+
+
+
+extern wint_t getwchar (void);
+
+
+
+
+
+
+extern wint_t fputwc (wchar_t __wc, __FILE *__stream);
+extern wint_t putwc (wchar_t __wc, __FILE *__stream);
+
+
+
+
+
+extern wint_t putwchar (wchar_t __wc);
+
+
+
+
+
+
+
+extern wchar_t *fgetws (wchar_t *__restrict __ws, int __n,
+   __FILE *__restrict __stream);
+
+
+
+
+
+extern int fputws (const wchar_t *__restrict __ws,
+     __FILE *__restrict __stream);
+
+
+
+
+
+
+extern wint_t ungetwc (wint_t __wc, __FILE *__stream);
+# 784 "/usr/include/wchar.h" 3 4
+extern wint_t getwc_unlocked (__FILE *__stream);
+extern wint_t getwchar_unlocked (void);
+
+
+
+
+
+
+
+extern wint_t fgetwc_unlocked (__FILE *__stream);
+
+
+
+
+
+
+
+extern wint_t fputwc_unlocked (wchar_t __wc, __FILE *__stream);
+# 810 "/usr/include/wchar.h" 3 4
+extern wint_t putwc_unlocked (wchar_t __wc, __FILE *__stream);
+extern wint_t putwchar_unlocked (wchar_t __wc);
+# 820 "/usr/include/wchar.h" 3 4
+extern wchar_t *fgetws_unlocked (wchar_t *__restrict __ws, int __n,
+     __FILE *__restrict __stream);
+
+
+
+
+
+
+
+extern int fputws_unlocked (const wchar_t *__restrict __ws,
+       __FILE *__restrict __stream);
+
+
+
+
+
+
+extern size_t wcsftime (wchar_t *__restrict __s, size_t __maxsize,
+   const wchar_t *__restrict __format,
+   const struct tm *__restrict __tp) throw ();
+
+
+
+
+extern size_t wcsftime_l (wchar_t *__restrict __s, size_t __maxsize,
+     const wchar_t *__restrict __format,
+     const struct tm *__restrict __tp,
+     locale_t __loc) throw ();
+# 860 "/usr/include/wchar.h" 3 4
+}
+# 45 "/usr/include/c++/10.2.0/cwchar" 2 3
+
+
+
+#define _GLIBCXX_CWCHAR 1
+# 62 "/usr/include/c++/10.2.0/cwchar" 3
+namespace std
+{
+  using ::mbstate_t;
+}
+
+
+#undef btowc
+#undef fgetwc
+#undef fgetws
+#undef fputwc
+#undef fputws
+#undef fwide
+#undef fwprintf
+#undef fwscanf
+#undef getwc
+#undef getwchar
+#undef mbrlen
+#undef mbrtowc
+#undef mbsinit
+#undef mbsrtowcs
+#undef putwc
+#undef putwchar
+#undef swprintf
+#undef swscanf
+#undef ungetwc
+#undef vfwprintf
+
+#undef vfwscanf
+
+#undef vswprintf
+
+#undef vswscanf
+
+#undef vwprintf
+
+#undef vwscanf
+
+#undef wcrtomb
+#undef wcscat
+#undef wcschr
+#undef wcscmp
+#undef wcscoll
+#undef wcscpy
+#undef wcscspn
+#undef wcsftime
+#undef wcslen
+#undef wcsncat
+#undef wcsncmp
+#undef wcsncpy
+#undef wcspbrk
+#undef wcsrchr
+#undef wcsrtombs
+#undef wcsspn
+#undef wcsstr
+#undef wcstod
+
+#undef wcstof
+
+#undef wcstok
+#undef wcstol
+#undef wcstoul
+#undef wcsxfrm
+#undef wctob
+#undef wmemchr
+#undef wmemcmp
+#undef wmemcpy
+#undef wmemmove
+#undef wmemset
+#undef wprintf
+#undef wscanf
+
+
+
+extern "C++"
+{
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  using ::wint_t;
+
+  using ::btowc;
+  using ::fgetwc;
+  using ::fgetws;
+  using ::fputwc;
+  using ::fputws;
+  using ::fwide;
+  using ::fwprintf;
+  using ::fwscanf;
+  using ::getwc;
+  using ::getwchar;
+  using ::mbrlen;
+  using ::mbrtowc;
+  using ::mbsinit;
+  using ::mbsrtowcs;
+  using ::putwc;
+  using ::putwchar;
+
+  using ::swprintf;
+
+  using ::swscanf;
+  using ::ungetwc;
+  using ::vfwprintf;
+
+  using ::vfwscanf;
+
+
+  using ::vswprintf;
+
+
+  using ::vswscanf;
+
+  using ::vwprintf;
+
+  using ::vwscanf;
+
+  using ::wcrtomb;
+  using ::wcscat;
+  using ::wcscmp;
+  using ::wcscoll;
+  using ::wcscpy;
+  using ::wcscspn;
+  using ::wcsftime;
+  using ::wcslen;
+  using ::wcsncat;
+  using ::wcsncmp;
+  using ::wcsncpy;
+  using ::wcsrtombs;
+  using ::wcsspn;
+  using ::wcstod;
+
+  using ::wcstof;
+
+  using ::wcstok;
+  using ::wcstol;
+  using ::wcstoul;
+  using ::wcsxfrm;
+  using ::wctob;
+  using ::wmemcmp;
+  using ::wmemcpy;
+  using ::wmemmove;
+  using ::wmemset;
+  using ::wprintf;
+  using ::wscanf;
+  using ::wcschr;
+  using ::wcspbrk;
+  using ::wcsrchr;
+  using ::wcsstr;
+  using ::wmemchr;
+# 234 "/usr/include/c++/10.2.0/cwchar" 3
+
+}
+}
+
+
+
+#undef wcstold
+#undef wcstoll
+#undef wcstoull
+
+namespace __gnu_cxx
+{
+
+
+
+
+
+  using ::wcstold;
+# 260 "/usr/include/c++/10.2.0/cwchar" 3
+  using ::wcstoll;
+  using ::wcstoull;
+
+}
+
+namespace std
+{
+  using ::__gnu_cxx::wcstold;
+  using ::__gnu_cxx::wcstoll;
+  using ::__gnu_cxx::wcstoull;
+}
+# 280 "/usr/include/c++/10.2.0/cwchar" 3
+namespace std
+{
+
+  using std::wcstof;
+
+
+  using std::vfwscanf;
+
+
+  using std::vswscanf;
+
+
+  using std::vwscanf;
+
+
+
+  using std::wcstold;
+  using std::wcstoll;
+  using std::wcstoull;
+
+}
+# 41 "/usr/include/c++/10.2.0/bits/postypes.h" 2 3
+# 68 "/usr/include/c++/10.2.0/bits/postypes.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 88 "/usr/include/c++/10.2.0/bits/postypes.h" 3
+  typedef long streamoff;
+# 98 "/usr/include/c++/10.2.0/bits/postypes.h" 3
+  typedef ptrdiff_t streamsize;
+# 111 "/usr/include/c++/10.2.0/bits/postypes.h" 3
+  template<typename _StateT>
+    class fpos
+    {
+    private:
+      streamoff _M_off;
+      _StateT _M_state;
+
+    public:
+
+
+
+
+      fpos()
+      : _M_off(0), _M_state() { }
+# 133 "/usr/include/c++/10.2.0/bits/postypes.h" 3
+      fpos(streamoff __off)
+      : _M_off(__off), _M_state() { }
+
+
+      fpos(const fpos&) = default;
+      fpos& operator=(const fpos&) = default;
+      ~fpos() = default;
+
+
+
+      operator streamoff() const { return _M_off; }
+
+
+      void
+      state(_StateT __st)
+      { _M_state = __st; }
+
+
+      _StateT
+      state() const
+      { return _M_state; }
+
+
+
+
+
+      fpos&
+      operator+=(streamoff __off)
+      {
+ _M_off += __off;
+ return *this;
+      }
+
+
+
+
+
+      fpos&
+      operator-=(streamoff __off)
+      {
+ _M_off -= __off;
+ return *this;
+      }
+
+
+
+
+
+
+
+      fpos
+      operator+(streamoff __off) const
+      {
+ fpos __pos(*this);
+ __pos += __off;
+ return __pos;
+      }
+
+
+
+
+
+
+
+      fpos
+      operator-(streamoff __off) const
+      {
+ fpos __pos(*this);
+ __pos -= __off;
+ return __pos;
+      }
+
+
+
+
+
+
+      streamoff
+      operator-(const fpos& __other) const
+      { return _M_off - __other._M_off; }
+    };
+
+
+
+
+
+
+  template<typename _StateT>
+    inline bool
+    operator==(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs)
+    { return streamoff(__lhs) == streamoff(__rhs); }
+
+  template<typename _StateT>
+    inline bool
+    operator!=(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs)
+    { return streamoff(__lhs) != streamoff(__rhs); }
+
+
+
+
+
+  typedef fpos<mbstate_t> streampos;
+
+  typedef fpos<mbstate_t> wstreampos;
+# 245 "/usr/include/c++/10.2.0/bits/postypes.h" 3
+  typedef fpos<mbstate_t> u16streampos;
+
+  typedef fpos<mbstate_t> u32streampos;
+
+
+
+}
+# 41 "/usr/include/c++/10.2.0/bits/char_traits.h" 2 3
+# 1 "/usr/include/c++/10.2.0/cwchar" 1 3
+# 39 "/usr/include/c++/10.2.0/cwchar" 3
+       
+# 40 "/usr/include/c++/10.2.0/cwchar" 3
+# 42 "/usr/include/c++/10.2.0/bits/char_traits.h" 2 3
+
+
+
+
+
+#define _GLIBCXX_ALWAYS_INLINE inline __attribute__((__always_inline__))
+
+
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
+{
+
+# 64 "/usr/include/c++/10.2.0/bits/char_traits.h" 3
+  template<typename _CharT>
+    struct _Char_types
+    {
+      typedef unsigned long int_type;
+      typedef std::streampos pos_type;
+      typedef std::streamoff off_type;
+      typedef std::mbstate_t state_type;
+    };
+# 89 "/usr/include/c++/10.2.0/bits/char_traits.h" 3
+  template<typename _CharT>
+    struct char_traits
+    {
+      typedef _CharT char_type;
+      typedef typename _Char_types<_CharT>::int_type int_type;
+      typedef typename _Char_types<_CharT>::pos_type pos_type;
+      typedef typename _Char_types<_CharT>::off_type off_type;
+      typedef typename _Char_types<_CharT>::state_type state_type;
+
+
+
+
+      static constexpr void
+      assign(char_type& __c1, const char_type& __c2)
+      { __c1 = __c2; }
+
+      static constexpr bool
+      eq(const char_type& __c1, const char_type& __c2)
+      { return __c1 == __c2; }
+
+      static constexpr bool
+      lt(const char_type& __c1, const char_type& __c2)
+      { return __c1 < __c2; }
+
+      static constexpr int
+      compare(const char_type* __s1, const char_type* __s2, std::size_t __n);
+
+      static constexpr std::size_t
+      length(const char_type* __s);
+
+      static constexpr const char_type*
+      find(const char_type* __s, std::size_t __n, const char_type& __a);
+
+      static char_type*
+      move(char_type* __s1, const char_type* __s2, std::size_t __n);
+
+      static char_type*
+      copy(char_type* __s1, const char_type* __s2, std::size_t __n);
+
+      static char_type*
+      assign(char_type* __s, std::size_t __n, char_type __a);
+
+      static constexpr char_type
+      to_char_type(const int_type& __c)
+      { return static_cast<char_type>(__c); }
+
+      static constexpr int_type
+      to_int_type(const char_type& __c)
+      { return static_cast<int_type>(__c); }
+
+      static constexpr bool
+      eq_int_type(const int_type& __c1, const int_type& __c2)
+      { return __c1 == __c2; }
+
+      static constexpr int_type
+      eof()
+      { return static_cast<int_type>(-1); }
+
+      static constexpr int_type
+      not_eof(const int_type& __c)
+      { return !eq_int_type(__c, eof()) ? __c : to_int_type(char_type()); }
+    };
+
+  template<typename _CharT>
+    constexpr int
+    char_traits<_CharT>::
+    compare(const char_type* __s1, const char_type* __s2, std::size_t __n)
+    {
+      for (std::size_t __i = 0; __i < __n; ++__i)
+ if (lt(__s1[__i], __s2[__i]))
+   return -1;
+ else if (lt(__s2[__i], __s1[__i]))
+   return 1;
+      return 0;
+    }
+
+  template<typename _CharT>
+    constexpr std::size_t
+    char_traits<_CharT>::
+    length(const char_type* __p)
+    {
+      std::size_t __i = 0;
+      while (!eq(__p[__i], char_type()))
+        ++__i;
+      return __i;
+    }
+
+  template<typename _CharT>
+    constexpr const typename char_traits<_CharT>::char_type*
+    char_traits<_CharT>::
+    find(const char_type* __s, std::size_t __n, const char_type& __a)
+    {
+      for (std::size_t __i = 0; __i < __n; ++__i)
+        if (eq(__s[__i], __a))
+          return __s + __i;
+      return 0;
+    }
+
+  template<typename _CharT>
+   
+    typename char_traits<_CharT>::char_type*
+    char_traits<_CharT>::
+    move(char_type* __s1, const char_type* __s2, std::size_t __n)
+    {
+      if (__n == 0)
+ return __s1;
+# 205 "/usr/include/c++/10.2.0/bits/char_traits.h" 3
+      return static_cast<_CharT*>(__builtin_memmove(__s1, __s2,
+          __n * sizeof(char_type)));
+    }
+
+  template<typename _CharT>
+   
+    typename char_traits<_CharT>::char_type*
+    char_traits<_CharT>::
+    copy(char_type* __s1, const char_type* __s2, std::size_t __n)
+    {
+
+      std::copy(__s2, __s2 + __n, __s1);
+      return __s1;
+    }
+
+  template<typename _CharT>
+   
+    typename char_traits<_CharT>::char_type*
+    char_traits<_CharT>::
+    assign(char_type* __s, std::size_t __n, char_type __a)
+    {
+
+      std::fill_n(__s, __n, __a);
+      return __s;
+    }
+
+
+}
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+#define __cpp_lib_constexpr_char_traits 201611
+# 248 "/usr/include/c++/10.2.0/bits/char_traits.h" 3
+  template<typename _CharT>
+    static inline __attribute__((__always_inline__)) constexpr bool
+    __constant_string_p(const _CharT* __s)
+    {
+
+      (void) __s;
+
+      return __builtin_is_constant_evaluated();
+
+
+
+
+
+    }
+# 271 "/usr/include/c++/10.2.0/bits/char_traits.h" 3
+  template<typename _CharT>
+    static inline __attribute__((__always_inline__)) constexpr bool
+    __constant_char_array_p(const _CharT* __a, size_t __n)
+    {
+
+      (void) __a;
+      (void) __n;
+
+      return __builtin_is_constant_evaluated();
+
+
+
+
+
+
+    }
+# 302 "/usr/include/c++/10.2.0/bits/char_traits.h" 3
+  template<class _CharT>
+    struct char_traits : public __gnu_cxx::char_traits<_CharT>
+    { };
+
+
+
+  template<>
+    struct char_traits<char>
+    {
+      typedef char char_type;
+      typedef int int_type;
+      typedef streampos pos_type;
+      typedef streamoff off_type;
+      typedef mbstate_t state_type;
+
+
+
+
+      static constexpr void
+      assign(char_type& __c1, const char_type& __c2) noexcept
+      { __c1 = __c2; }
+
+      static constexpr bool
+      eq(const char_type& __c1, const char_type& __c2) noexcept
+      { return __c1 == __c2; }
+
+      static constexpr bool
+      lt(const char_type& __c1, const char_type& __c2) noexcept
+      {
+
+ return (static_cast<unsigned char>(__c1)
+  < static_cast<unsigned char>(__c2));
+      }
+
+      static constexpr int
+      compare(const char_type* __s1, const char_type* __s2, size_t __n)
+      {
+ if (__n == 0)
+   return 0;
+
+ if (__builtin_constant_p(__n)
+     && __constant_char_array_p(__s1, __n)
+     && __constant_char_array_p(__s2, __n))
+   return __gnu_cxx::char_traits<char_type>::compare(__s1, __s2, __n);
+
+ return __builtin_memcmp(__s1, __s2, __n);
+      }
+
+      static constexpr size_t
+      length(const char_type* __s)
+      {
+
+ if (__constant_string_p(__s))
+   return __gnu_cxx::char_traits<char_type>::length(__s);
+
+ return __builtin_strlen(__s);
+      }
+
+      static constexpr const char_type*
+      find(const char_type* __s, size_t __n, const char_type& __a)
+      {
+ if (__n == 0)
+   return 0;
+
+ if (__builtin_constant_p(__n)
+     && __builtin_constant_p(__a)
+     && __constant_char_array_p(__s, __n))
+   return __gnu_cxx::char_traits<char_type>::find(__s, __n, __a);
+
+ return static_cast<const char_type*>(__builtin_memchr(__s, __a, __n));
+      }
+
+      static char_type*
+      move(char_type* __s1, const char_type* __s2, size_t __n)
+      {
+ if (__n == 0)
+   return __s1;
+
+
+
+
+ return static_cast<char_type*>(__builtin_memmove(__s1, __s2, __n));
+      }
+
+      static char_type*
+      copy(char_type* __s1, const char_type* __s2, size_t __n)
+      {
+ if (__n == 0)
+   return __s1;
+
+
+
+
+ return static_cast<char_type*>(__builtin_memcpy(__s1, __s2, __n));
+      }
+
+      static char_type*
+      assign(char_type* __s, size_t __n, char_type __a)
+      {
+ if (__n == 0)
+   return __s;
+
+
+
+
+ return static_cast<char_type*>(__builtin_memset(__s, __a, __n));
+      }
+
+      static constexpr char_type
+      to_char_type(const int_type& __c) noexcept
+      { return static_cast<char_type>(__c); }
+
+
+
+      static constexpr int_type
+      to_int_type(const char_type& __c) noexcept
+      { return static_cast<int_type>(static_cast<unsigned char>(__c)); }
+
+      static constexpr bool
+      eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
+      { return __c1 == __c2; }
+
+      static constexpr int_type
+      eof() noexcept
+      { return static_cast<int_type>(-1); }
+
+      static constexpr int_type
+      not_eof(const int_type& __c) noexcept
+      { return (__c == eof()) ? 0 : __c; }
+  };
+
+
+
+
+  template<>
+    struct char_traits<wchar_t>
+    {
+      typedef wchar_t char_type;
+      typedef wint_t int_type;
+      typedef streamoff off_type;
+      typedef wstreampos pos_type;
+      typedef mbstate_t state_type;
+
+
+
+
+      static constexpr void
+      assign(char_type& __c1, const char_type& __c2) noexcept
+      { __c1 = __c2; }
+
+      static constexpr bool
+      eq(const char_type& __c1, const char_type& __c2) noexcept
+      { return __c1 == __c2; }
+
+      static constexpr bool
+      lt(const char_type& __c1, const char_type& __c2) noexcept
+      { return __c1 < __c2; }
+
+      static constexpr int
+      compare(const char_type* __s1, const char_type* __s2, size_t __n)
+      {
+ if (__n == 0)
+   return 0;
+
+ if (__builtin_constant_p(__n)
+     && __constant_char_array_p(__s1, __n)
+     && __constant_char_array_p(__s2, __n))
+   return __gnu_cxx::char_traits<char_type>::compare(__s1, __s2, __n);
+
+ return wmemcmp(__s1, __s2, __n);
+      }
+
+      static constexpr size_t
+      length(const char_type* __s)
+      {
+
+ if (__constant_string_p(__s))
+   return __gnu_cxx::char_traits<char_type>::length(__s);
+
+ return wcslen(__s);
+      }
+
+      static constexpr const char_type*
+      find(const char_type* __s, size_t __n, const char_type& __a)
+      {
+ if (__n == 0)
+   return 0;
+
+ if (__builtin_constant_p(__n)
+     && __builtin_constant_p(__a)
+     && __constant_char_array_p(__s, __n))
+   return __gnu_cxx::char_traits<char_type>::find(__s, __n, __a);
+
+ return wmemchr(__s, __a, __n);
+      }
+
+      static char_type*
+      move(char_type* __s1, const char_type* __s2, size_t __n)
+      {
+ if (__n == 0)
+   return __s1;
+
+
+
+
+ return wmemmove(__s1, __s2, __n);
+      }
+
+      static char_type*
+      copy(char_type* __s1, const char_type* __s2, size_t __n)
+      {
+ if (__n == 0)
+   return __s1;
+
+
+
+
+ return wmemcpy(__s1, __s2, __n);
+      }
+
+      static char_type*
+      assign(char_type* __s, size_t __n, char_type __a)
+      {
+ if (__n == 0)
+   return __s;
+
+
+
+
+ return wmemset(__s, __a, __n);
+      }
+
+      static constexpr char_type
+      to_char_type(const int_type& __c) noexcept
+      { return char_type(__c); }
+
+      static constexpr int_type
+      to_int_type(const char_type& __c) noexcept
+      { return int_type(__c); }
+
+      static constexpr bool
+      eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
+      { return __c1 == __c2; }
+
+      static constexpr int_type
+      eof() noexcept
+      { return static_cast<int_type>((0xffffffffu)); }
+
+      static constexpr int_type
+      not_eof(const int_type& __c) noexcept
+      { return eq_int_type(__c, eof()) ? 0 : __c; }
+  };
+# 680 "/usr/include/c++/10.2.0/bits/char_traits.h" 3
+
+}
+
+
+
+# 1 "/usr/include/c++/10.2.0/cstdint" 1 3
+# 30 "/usr/include/c++/10.2.0/cstdint" 3
+#define _GLIBCXX_CSTDINT 1
+
+       
+# 33 "/usr/include/c++/10.2.0/cstdint" 3
+# 41 "/usr/include/c++/10.2.0/cstdint" 3
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stdint.h" 1 3 4
+
+
+
+#undef __STDC_LIMIT_MACROS
+#define __STDC_LIMIT_MACROS 
+#undef __STDC_CONSTANT_MACROS
+#define __STDC_CONSTANT_MACROS 
+
+# 1 "/usr/include/stdint.h" 1 3 4
+# 23 "/usr/include/stdint.h" 3 4
+#define _STDINT_H 1
+
+#define __GLIBC_INTERNAL_STARTING_HEADER_IMPLEMENTATION 
+# 1 "/usr/include/bits/libc-header-start.h" 1 3 4
+# 31 "/usr/include/bits/libc-header-start.h" 3 4
+#undef __GLIBC_INTERNAL_STARTING_HEADER_IMPLEMENTATION
+
+
+
+
+
+#undef __GLIBC_USE_LIB_EXT2
+
+
+#define __GLIBC_USE_LIB_EXT2 1
+# 49 "/usr/include/bits/libc-header-start.h" 3 4
+#undef __GLIBC_USE_IEC_60559_BFP_EXT
+
+#define __GLIBC_USE_IEC_60559_BFP_EXT 1
+
+
+
+#undef __GLIBC_USE_IEC_60559_BFP_EXT_C2X
+
+#define __GLIBC_USE_IEC_60559_BFP_EXT_C2X 1
+# 66 "/usr/include/bits/libc-header-start.h" 3 4
+#undef __GLIBC_USE_IEC_60559_FUNCS_EXT
+
+#define __GLIBC_USE_IEC_60559_FUNCS_EXT 1
+
+
+
+#undef __GLIBC_USE_IEC_60559_FUNCS_EXT_C2X
+
+#define __GLIBC_USE_IEC_60559_FUNCS_EXT_C2X 1
+
+
+
+
+
+
+#undef __GLIBC_USE_IEC_60559_TYPES_EXT
+
+#define __GLIBC_USE_IEC_60559_TYPES_EXT 1
+# 27 "/usr/include/stdint.h" 2 3 4
+
+
+# 1 "/usr/include/bits/wordsize.h" 1 3 4
+
+
+
+#define __WORDSIZE 64
+
+
+
+
+
+
+
+#define __WORDSIZE_TIME64_COMPAT32 1
+
+#define __SYSCALL_WORDSIZE 64
+# 30 "/usr/include/stdint.h" 2 3 4
+
+
+
+
+
+
+
+# 1 "/usr/include/bits/stdint-uintn.h" 1 3 4
+# 20 "/usr/include/bits/stdint-uintn.h" 3 4
+#define _BITS_STDINT_UINTN_H 1
+
+
+
+typedef __uint8_t uint8_t;
+typedef __uint16_t uint16_t;
+typedef __uint32_t uint32_t;
+typedef __uint64_t uint64_t;
+# 38 "/usr/include/stdint.h" 2 3 4
+
+
+
+
+
+typedef __int_least8_t int_least8_t;
+typedef __int_least16_t int_least16_t;
+typedef __int_least32_t int_least32_t;
+typedef __int_least64_t int_least64_t;
+
+
+typedef __uint_least8_t uint_least8_t;
+typedef __uint_least16_t uint_least16_t;
+typedef __uint_least32_t uint_least32_t;
+typedef __uint_least64_t uint_least64_t;
+
+
+
+
+
+typedef signed char int_fast8_t;
+
+typedef long int int_fast16_t;
+typedef long int int_fast32_t;
+typedef long int int_fast64_t;
+# 71 "/usr/include/stdint.h" 3 4
+typedef unsigned char uint_fast8_t;
+
+typedef unsigned long int uint_fast16_t;
+typedef unsigned long int uint_fast32_t;
+typedef unsigned long int uint_fast64_t;
+# 90 "/usr/include/stdint.h" 3 4
+typedef unsigned long int uintptr_t;
+# 101 "/usr/include/stdint.h" 3 4
+typedef __intmax_t intmax_t;
+typedef __uintmax_t uintmax_t;
+
+
+
+#define __INT64_C(c) c ## L
+#define __UINT64_C(c) c ## UL
+# 116 "/usr/include/stdint.h" 3 4
+#define INT8_MIN (-128)
+#define INT16_MIN (-32767-1)
+#define INT32_MIN (-2147483647-1)
+#define INT64_MIN (-__INT64_C(9223372036854775807)-1)
+
+#define INT8_MAX (127)
+#define INT16_MAX (32767)
+#define INT32_MAX (2147483647)
+#define INT64_MAX (__INT64_C(9223372036854775807))
+
+
+#define UINT8_MAX (255)
+#define UINT16_MAX (65535)
+#define UINT32_MAX (4294967295U)
+#define UINT64_MAX (__UINT64_C(18446744073709551615))
+
+
+
+#define INT_LEAST8_MIN (-128)
+#define INT_LEAST16_MIN (-32767-1)
+#define INT_LEAST32_MIN (-2147483647-1)
+#define INT_LEAST64_MIN (-__INT64_C(9223372036854775807)-1)
+
+#define INT_LEAST8_MAX (127)
+#define INT_LEAST16_MAX (32767)
+#define INT_LEAST32_MAX (2147483647)
+#define INT_LEAST64_MAX (__INT64_C(9223372036854775807))
+
+
+#define UINT_LEAST8_MAX (255)
+#define UINT_LEAST16_MAX (65535)
+#define UINT_LEAST32_MAX (4294967295U)
+#define UINT_LEAST64_MAX (__UINT64_C(18446744073709551615))
+
+
+
+#define INT_FAST8_MIN (-128)
+
+#define INT_FAST16_MIN (-9223372036854775807L-1)
+#define INT_FAST32_MIN (-9223372036854775807L-1)
+
+
+
+
+#define INT_FAST64_MIN (-__INT64_C(9223372036854775807)-1)
+
+#define INT_FAST8_MAX (127)
+
+#define INT_FAST16_MAX (9223372036854775807L)
+#define INT_FAST32_MAX (9223372036854775807L)
+
+
+
+
+#define INT_FAST64_MAX (__INT64_C(9223372036854775807))
+
+
+#define UINT_FAST8_MAX (255)
+
+#define UINT_FAST16_MAX (18446744073709551615UL)
+#define UINT_FAST32_MAX (18446744073709551615UL)
+
+
+
+
+#define UINT_FAST64_MAX (__UINT64_C(18446744073709551615))
+
+
+
+
+#define INTPTR_MIN (-9223372036854775807L-1)
+#define INTPTR_MAX (9223372036854775807L)
+#define UINTPTR_MAX (18446744073709551615UL)
+# 197 "/usr/include/stdint.h" 3 4
+#define INTMAX_MIN (-__INT64_C(9223372036854775807)-1)
+
+#define INTMAX_MAX (__INT64_C(9223372036854775807))
+
+
+#define UINTMAX_MAX (__UINT64_C(18446744073709551615))
+
+
+
+
+
+
+#define PTRDIFF_MIN (-9223372036854775807L-1)
+#define PTRDIFF_MAX (9223372036854775807L)
+# 222 "/usr/include/stdint.h" 3 4
+#define SIG_ATOMIC_MIN (-2147483647-1)
+#define SIG_ATOMIC_MAX (2147483647)
+
+
+
+#define SIZE_MAX (18446744073709551615UL)
+# 244 "/usr/include/stdint.h" 3 4
+#define WINT_MIN (0u)
+#define WINT_MAX (4294967295u)
+
+
+#define INT8_C(c) c
+#define INT16_C(c) c
+#define INT32_C(c) c
+
+#define INT64_C(c) c ## L
+
+
+
+
+
+#define UINT8_C(c) c
+#define UINT16_C(c) c
+#define UINT32_C(c) c ## U
+
+#define UINT64_C(c) c ## UL
+
+
+
+
+
+
+#define INTMAX_C(c) c ## L
+#define UINTMAX_C(c) c ## UL
+
+
+
+
+
+
+
+#define INT8_WIDTH 8
+#define UINT8_WIDTH 8
+#define INT16_WIDTH 16
+#define UINT16_WIDTH 16
+#define INT32_WIDTH 32
+#define UINT32_WIDTH 32
+#define INT64_WIDTH 64
+#define UINT64_WIDTH 64
+
+#define INT_LEAST8_WIDTH 8
+#define UINT_LEAST8_WIDTH 8
+#define INT_LEAST16_WIDTH 16
+#define UINT_LEAST16_WIDTH 16
+#define INT_LEAST32_WIDTH 32
+#define UINT_LEAST32_WIDTH 32
+#define INT_LEAST64_WIDTH 64
+#define UINT_LEAST64_WIDTH 64
+
+#define INT_FAST8_WIDTH 8
+#define UINT_FAST8_WIDTH 8
+#define INT_FAST16_WIDTH __WORDSIZE
+#define UINT_FAST16_WIDTH __WORDSIZE
+#define INT_FAST32_WIDTH __WORDSIZE
+#define UINT_FAST32_WIDTH __WORDSIZE
+#define INT_FAST64_WIDTH 64
+#define UINT_FAST64_WIDTH 64
+
+#define INTPTR_WIDTH __WORDSIZE
+#define UINTPTR_WIDTH __WORDSIZE
+
+#define INTMAX_WIDTH 64
+#define UINTMAX_WIDTH 64
+
+#define PTRDIFF_WIDTH __WORDSIZE
+#define SIG_ATOMIC_WIDTH 32
+#define SIZE_WIDTH __WORDSIZE
+#define WCHAR_WIDTH 32
+#define WINT_WIDTH 32
+# 10 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stdint.h" 2 3 4
+
+
+
+#define _GCC_WRAP_STDINT_H 
+# 42 "/usr/include/c++/10.2.0/cstdint" 2 3
+
+
+namespace std
+{
+
+  using ::int8_t;
+  using ::int16_t;
+  using ::int32_t;
+  using ::int64_t;
+
+  using ::int_fast8_t;
+  using ::int_fast16_t;
+  using ::int_fast32_t;
+  using ::int_fast64_t;
+
+  using ::int_least8_t;
+  using ::int_least16_t;
+  using ::int_least32_t;
+  using ::int_least64_t;
+
+  using ::intmax_t;
+  using ::intptr_t;
+
+  using ::uint8_t;
+  using ::uint16_t;
+  using ::uint32_t;
+  using ::uint64_t;
+
+  using ::uint_fast8_t;
+  using ::uint_fast16_t;
+  using ::uint_fast32_t;
+  using ::uint_fast64_t;
+
+  using ::uint_least8_t;
+  using ::uint_least16_t;
+  using ::uint_least32_t;
+  using ::uint_least64_t;
+
+  using ::uintmax_t;
+  using ::uintptr_t;
+
+
+
+
+
+}
+# 686 "/usr/include/c++/10.2.0/bits/char_traits.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  template<>
+    struct char_traits<char16_t>
+    {
+      typedef char16_t char_type;
+
+      typedef uint_least16_t int_type;
+
+
+
+
+
+      typedef streamoff off_type;
+      typedef u16streampos pos_type;
+      typedef mbstate_t state_type;
+
+
+
+
+      static constexpr void
+      assign(char_type& __c1, const char_type& __c2) noexcept
+      { __c1 = __c2; }
+
+      static constexpr bool
+      eq(const char_type& __c1, const char_type& __c2) noexcept
+      { return __c1 == __c2; }
+
+      static constexpr bool
+      lt(const char_type& __c1, const char_type& __c2) noexcept
+      { return __c1 < __c2; }
+
+      static constexpr int
+      compare(const char_type* __s1, const char_type* __s2, size_t __n)
+      {
+ for (size_t __i = 0; __i < __n; ++__i)
+   if (lt(__s1[__i], __s2[__i]))
+     return -1;
+   else if (lt(__s2[__i], __s1[__i]))
+     return 1;
+ return 0;
+      }
+
+      static constexpr size_t
+      length(const char_type* __s)
+      {
+ size_t __i = 0;
+ while (!eq(__s[__i], char_type()))
+   ++__i;
+ return __i;
+      }
+
+      static constexpr const char_type*
+      find(const char_type* __s, size_t __n, const char_type& __a)
+      {
+ for (size_t __i = 0; __i < __n; ++__i)
+   if (eq(__s[__i], __a))
+     return __s + __i;
+ return 0;
+      }
+
+      static char_type*
+      move(char_type* __s1, const char_type* __s2, size_t __n)
+      {
+ if (__n == 0)
+   return __s1;
+
+
+
+
+ return (static_cast<char_type*>
+  (__builtin_memmove(__s1, __s2, __n * sizeof(char_type))));
+      }
+
+      static char_type*
+      copy(char_type* __s1, const char_type* __s2, size_t __n)
+      {
+ if (__n == 0)
+   return __s1;
+
+
+
+
+ return (static_cast<char_type*>
+  (__builtin_memcpy(__s1, __s2, __n * sizeof(char_type))));
+      }
+
+      static char_type*
+      assign(char_type* __s, size_t __n, char_type __a)
+      {
+ for (size_t __i = 0; __i < __n; ++__i)
+   assign(__s[__i], __a);
+ return __s;
+      }
+
+      static constexpr char_type
+      to_char_type(const int_type& __c) noexcept
+      { return char_type(__c); }
+
+      static constexpr int_type
+      to_int_type(const char_type& __c) noexcept
+      { return __c == eof() ? int_type(0xfffd) : int_type(__c); }
+
+      static constexpr bool
+      eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
+      { return __c1 == __c2; }
+
+      static constexpr int_type
+      eof() noexcept
+      { return static_cast<int_type>(-1); }
+
+      static constexpr int_type
+      not_eof(const int_type& __c) noexcept
+      { return eq_int_type(__c, eof()) ? 0 : __c; }
+    };
+
+  template<>
+    struct char_traits<char32_t>
+    {
+      typedef char32_t char_type;
+
+      typedef uint_least32_t int_type;
+
+
+
+
+
+      typedef streamoff off_type;
+      typedef u32streampos pos_type;
+      typedef mbstate_t state_type;
+
+
+
+
+      static constexpr void
+      assign(char_type& __c1, const char_type& __c2) noexcept
+      { __c1 = __c2; }
+
+      static constexpr bool
+      eq(const char_type& __c1, const char_type& __c2) noexcept
+      { return __c1 == __c2; }
+
+      static constexpr bool
+      lt(const char_type& __c1, const char_type& __c2) noexcept
+      { return __c1 < __c2; }
+
+      static constexpr int
+      compare(const char_type* __s1, const char_type* __s2, size_t __n)
+      {
+ for (size_t __i = 0; __i < __n; ++__i)
+   if (lt(__s1[__i], __s2[__i]))
+     return -1;
+   else if (lt(__s2[__i], __s1[__i]))
+     return 1;
+ return 0;
+      }
+
+      static constexpr size_t
+      length(const char_type* __s)
+      {
+ size_t __i = 0;
+ while (!eq(__s[__i], char_type()))
+   ++__i;
+ return __i;
+      }
+
+      static constexpr const char_type*
+      find(const char_type* __s, size_t __n, const char_type& __a)
+      {
+ for (size_t __i = 0; __i < __n; ++__i)
+   if (eq(__s[__i], __a))
+     return __s + __i;
+ return 0;
+      }
+
+      static char_type*
+      move(char_type* __s1, const char_type* __s2, size_t __n)
+      {
+ if (__n == 0)
+   return __s1;
+
+
+
+
+ return (static_cast<char_type*>
+  (__builtin_memmove(__s1, __s2, __n * sizeof(char_type))));
+      }
+
+      static char_type*
+      copy(char_type* __s1, const char_type* __s2, size_t __n)
+      {
+ if (__n == 0)
+   return __s1;
+
+
+
+
+ return (static_cast<char_type*>
+  (__builtin_memcpy(__s1, __s2, __n * sizeof(char_type))));
+      }
+
+      static char_type*
+      assign(char_type* __s, size_t __n, char_type __a)
+      {
+ for (size_t __i = 0; __i < __n; ++__i)
+   assign(__s[__i], __a);
+ return __s;
+      }
+
+      static constexpr char_type
+      to_char_type(const int_type& __c) noexcept
+      { return char_type(__c); }
+
+      static constexpr int_type
+      to_int_type(const char_type& __c) noexcept
+      { return int_type(__c); }
+
+      static constexpr bool
+      eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
+      { return __c1 == __c2; }
+
+      static constexpr int_type
+      eof() noexcept
+      { return static_cast<int_type>(-1); }
+
+      static constexpr int_type
+      not_eof(const int_type& __c) noexcept
+      { return eq_int_type(__c, eof()) ? 0 : __c; }
+    };
+# 938 "/usr/include/c++/10.2.0/bits/char_traits.h" 3
+
+}
+# 41 "/usr/include/c++/10.2.0/string" 2 3
+# 1 "/usr/include/c++/10.2.0/bits/allocator.h" 1 3
+# 44 "/usr/include/c++/10.2.0/bits/allocator.h" 3
+#define _ALLOCATOR_H 1
+
+# 1 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++allocator.h" 1 3
+# 31 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++allocator.h" 3
+#define _GLIBCXX_CXX_ALLOCATOR_H 1
+
+# 1 "/usr/include/c++/10.2.0/ext/new_allocator.h" 1 3
+# 30 "/usr/include/c++/10.2.0/ext/new_allocator.h" 3
+#define _NEW_ALLOCATOR_H 1
+
+
+# 1 "/usr/include/c++/10.2.0/new" 1 3
+# 36 "/usr/include/c++/10.2.0/new" 3
+#define _NEW 
+
+       
+# 39 "/usr/include/c++/10.2.0/new" 3
+
+
+# 1 "/usr/include/c++/10.2.0/exception" 1 3
+# 31 "/usr/include/c++/10.2.0/exception" 3
+#define __EXCEPTION__ 
+
+       
+# 34 "/usr/include/c++/10.2.0/exception" 3
+
+#pragma GCC visibility push(default)
+
+
+# 1 "/usr/include/c++/10.2.0/bits/exception.h" 1 3
+# 32 "/usr/include/c++/10.2.0/bits/exception.h" 3
+#define __EXCEPTION_H 1
+
+       
+# 35 "/usr/include/c++/10.2.0/bits/exception.h" 3
+
+#pragma GCC visibility push(default)
+
+
+
+extern "C++" {
+
+namespace std
+{
+# 60 "/usr/include/c++/10.2.0/bits/exception.h" 3
+  class exception
+  {
+  public:
+    exception() noexcept { }
+    virtual ~exception() noexcept;
+
+    exception(const exception&) = default;
+    exception& operator=(const exception&) = default;
+    exception(exception&&) = default;
+    exception& operator=(exception&&) = default;
+
+
+
+
+    virtual const char*
+    what() const noexcept;
+  };
+
+}
+
+}
+
+#pragma GCC visibility pop
+# 39 "/usr/include/c++/10.2.0/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__));
+# 105 "/usr/include/c++/10.2.0/exception" 3
+  [[__deprecated__]]
+  bool uncaught_exception() noexcept __attribute__ ((__pure__));
+
+
+#define __cpp_lib_uncaught_exceptions 201411L
+
+  int uncaught_exceptions() noexcept __attribute__ ((__pure__));
+
+
+
+}
+
+namespace __gnu_cxx
+{
+
+# 137 "/usr/include/c++/10.2.0/exception" 3
+  void __verbose_terminate_handler();
+
+
+}
+
+}
+
+#pragma GCC visibility pop
+
+
+# 1 "/usr/include/c++/10.2.0/bits/exception_ptr.h" 1 3
+# 32 "/usr/include/c++/10.2.0/bits/exception_ptr.h" 3
+#define _EXCEPTION_PTR_H 
+
+#pragma GCC visibility push(default)
+
+
+
+# 1 "/usr/include/c++/10.2.0/bits/cxxabi_init_exception.h" 1 3
+# 32 "/usr/include/c++/10.2.0/bits/cxxabi_init_exception.h" 3
+#define _CXXABI_INIT_EXCEPTION_H 1
+
+       
+# 35 "/usr/include/c++/10.2.0/bits/cxxabi_init_exception.h" 3
+
+#pragma GCC visibility push(default)
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 1 3 4
+# 39 "/usr/include/c++/10.2.0/bits/cxxabi_init_exception.h" 2 3
+
+
+
+#define _GLIBCXX_CDTOR_CALLABI 
+#define _GLIBCXX_HAVE_CDTOR_CALLABI 0
+
+
+
+
+
+
+namespace std
+{
+  class type_info;
+}
+
+namespace __cxxabiv1
+{
+  struct __cxa_refcounted_exception;
+
+  extern "C"
+    {
+
+      void*
+      __cxa_allocate_exception(size_t) noexcept;
+
+      void
+      __cxa_free_exception(void*) noexcept;
+
+
+      __cxa_refcounted_exception*
+      __cxa_init_primary_exception(void *object, std::type_info *tinfo,
+                void ( *dest) (void *)) noexcept;
+
+    }
+}
+
+
+
+#pragma GCC visibility pop
+# 39 "/usr/include/c++/10.2.0/bits/exception_ptr.h" 2 3
+# 1 "/usr/include/c++/10.2.0/typeinfo" 1 3
+# 30 "/usr/include/c++/10.2.0/typeinfo" 3
+#define _TYPEINFO 
+
+       
+# 33 "/usr/include/c++/10.2.0/typeinfo" 3
+
+
+
+# 1 "/usr/include/c++/10.2.0/bits/hash_bytes.h" 1 3
+# 31 "/usr/include/c++/10.2.0/bits/hash_bytes.h" 3
+#define _HASH_BYTES_H 1
+
+       
+# 34 "/usr/include/c++/10.2.0/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 "/usr/include/c++/10.2.0/typeinfo" 2 3
+
+
+#pragma GCC visibility push(default)
+
+extern "C++" {
+
+namespace __cxxabiv1
+{
+  class __class_type_info;
+}
+# 68 "/usr/include/c++/10.2.0/typeinfo" 3
+#define __GXX_MERGED_TYPEINFO_NAMES 0
+
+
+
+
+
+
+
+#define __GXX_TYPEINFO_EQUALITY_INLINE 1
+
+
+
+namespace std
+{
+
+
+
+
+
+
+  class type_info
+  {
+  public:
+
+
+
+
+    virtual ~type_info();
+
+
+
+    const char* name() const noexcept
+    { return __name[0] == '*' ? __name + 1 : __name; }
+# 115 "/usr/include/c++/10.2.0/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));
+    }
+# 138 "/usr/include/c++/10.2.0/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 "/usr/include/c++/10.2.0/bits/exception_ptr.h" 2 3
+# 1 "/usr/include/c++/10.2.0/new" 1 3
+# 41 "/usr/include/c++/10.2.0/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; }
+# 118 "/usr/include/c++/10.2.0/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;
+# 145 "/usr/include/c++/10.2.0/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
+    {
+
+      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>);
+      try
+ {
+          ::new (__e) _Ex(__ex);
+          return exception_ptr(__e);
+ }
+      catch(...)
+ {
+   __cxxabiv1::__cxa_free_exception(__e);
+   return current_exception();
+ }
+# 215 "/usr/include/c++/10.2.0/bits/exception_ptr.h" 3
+    }
+
+
+}
+
+}
+
+#pragma GCC visibility pop
+# 148 "/usr/include/c++/10.2.0/exception" 2 3
+# 1 "/usr/include/c++/10.2.0/bits/nested_exception.h" 1 3
+# 31 "/usr/include/c++/10.2.0/bits/nested_exception.h" 3
+#define _GLIBCXX_NESTED_EXCEPTION_H 1
+
+#pragma GCC visibility push(default)
+# 42 "/usr/include/c++/10.2.0/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
+# 149 "/usr/include/c++/10.2.0/exception" 2 3
+# 42 "/usr/include/c++/10.2.0/new" 2 3
+
+#pragma GCC visibility push(default)
+
+extern "C++" {
+
+namespace std
+{
+
+
+
+
+
+
+  class bad_alloc : public exception
+  {
+  public:
+    bad_alloc() throw() { }
+
+
+    bad_alloc(const bad_alloc&) = default;
+    bad_alloc& operator=(const bad_alloc&) = default;
+
+
+
+
+    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();
+  };
+
+
+
+  enum class align_val_t: size_t {};
+
+
+  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;
+
+}
+# 126 "/usr/include/c++/10.2.0/new" 3
+[[__nodiscard__]] void* operator new(std::size_t)
+  __attribute__((__externally_visible__));
+[[__nodiscard__]] 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__));
+
+[[__nodiscard__]] void* operator new(std::size_t, const std::nothrow_t&) noexcept
+  __attribute__((__externally_visible__, __malloc__));
+[[__nodiscard__]] void* operator new[](std::size_t, const std::nothrow_t&) noexcept
+  __attribute__((__externally_visible__, __malloc__));
+void operator delete(void*, const std::nothrow_t&) noexcept
+  __attribute__((__externally_visible__));
+void operator delete[](void*, const std::nothrow_t&) noexcept
+  __attribute__((__externally_visible__));
+
+[[__nodiscard__]] void* operator new(std::size_t, std::align_val_t)
+  __attribute__((__externally_visible__));
+[[__nodiscard__]] void* operator new(std::size_t, std::align_val_t, const std::nothrow_t&)
+  noexcept __attribute__((__externally_visible__, __malloc__));
+void operator delete(void*, std::align_val_t)
+  noexcept __attribute__((__externally_visible__));
+void operator delete(void*, std::align_val_t, const std::nothrow_t&)
+  noexcept __attribute__((__externally_visible__));
+[[__nodiscard__]] void* operator new[](std::size_t, std::align_val_t)
+  __attribute__((__externally_visible__));
+[[__nodiscard__]] void* operator new[](std::size_t, std::align_val_t, const std::nothrow_t&)
+  noexcept __attribute__((__externally_visible__, __malloc__));
+void operator delete[](void*, std::align_val_t)
+  noexcept __attribute__((__externally_visible__));
+void operator delete[](void*, std::align_val_t, const std::nothrow_t&)
+  noexcept __attribute__((__externally_visible__));
+
+void operator delete(void*, std::size_t, std::align_val_t)
+  noexcept __attribute__((__externally_visible__));
+void operator delete[](void*, std::size_t, std::align_val_t)
+  noexcept __attribute__((__externally_visible__));
+
+
+
+
+[[__nodiscard__]] inline void* operator new(std::size_t, void* __p) noexcept
+{ return __p; }
+[[__nodiscard__]] 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 { }
+
+}
+
+
+
+namespace std
+{
+#define __cpp_lib_launder 201606
+
+  template<typename _Tp>
+    [[nodiscard]] constexpr _Tp*
+    launder(_Tp* __p) noexcept
+    { return __builtin_launder(__p); }
+
+
+
+
+  template<typename _Ret, typename... _Args , bool _NE>
+    void launder(_Ret (*)(_Args...) noexcept (_NE)) = delete;
+  template<typename _Ret, typename... _Args , bool _NE>
+    void launder(_Ret (*)(_Args......) noexcept (_NE)) = delete;
+
+  void launder(void*) = delete;
+  void launder(const void*) = delete;
+  void launder(volatile void*) = delete;
+  void launder(const volatile void*) = delete;
+}
+# 230 "/usr/include/c++/10.2.0/new" 3
+#pragma GCC visibility pop
+# 34 "/usr/include/c++/10.2.0/ext/new_allocator.h" 2 3
+
+
+
+
+
+
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
+{
+
+# 54 "/usr/include/c++/10.2.0/ext/new_allocator.h" 3
+  template<typename _Tp>
+    class new_allocator
+    {
+    public:
+      typedef _Tp value_type;
+      typedef std::size_t size_type;
+      typedef std::ptrdiff_t difference_type;
+
+      typedef _Tp* pointer;
+      typedef const _Tp* const_pointer;
+      typedef _Tp& reference;
+      typedef const _Tp& const_reference;
+
+      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); }
+
+
+
+
+      [[__nodiscard__]] _Tp*
+      allocate(size_type __n, const void* = static_cast<const void*>(0))
+      {
+ if (__n > this->_M_max_size())
+   std::__throw_bad_alloc();
+
+
+ if (alignof(_Tp) > 16)
+   {
+     std::align_val_t __al = std::align_val_t(alignof(_Tp));
+     return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp), __al));
+   }
+
+ return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
+      }
+
+
+      void
+      deallocate(_Tp* __p, size_type __t)
+      {
+
+ if (alignof(_Tp) > 16)
+   {
+     ::operator delete(__p,
+
+         __t * sizeof(_Tp),
+
+         std::align_val_t(alignof(_Tp)));
+     return;
+   }
+
+ ::operator delete(__p
+
+     , __t * sizeof(_Tp)
+
+    );
+      }
+
+
+      size_type
+      max_size() const noexcept
+      { return _M_max_size(); }
+
+
+      template<typename _Up, typename... _Args>
+ void
+ construct(_Up* __p, _Args&&... __args)
+ noexcept(std::is_nothrow_constructible<_Up, _Args...>::value)
+ { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
+
+      template<typename _Up>
+ void
+ destroy(_Up* __p)
+ noexcept(std::is_nothrow_destructible<_Up>::value)
+ { __p->~_Up(); }
+# 169 "/usr/include/c++/10.2.0/ext/new_allocator.h" 3
+      template<typename _Up>
+ friend bool
+ operator==(const new_allocator&, const new_allocator<_Up>&)
+ noexcept
+ { return true; }
+
+
+      template<typename _Up>
+ friend bool
+ operator!=(const new_allocator&, const new_allocator<_Up>&)
+ noexcept
+ { return false; }
+
+
+    private:
+      constexpr size_type
+      _M_max_size() const noexcept
+      {
+
+ return std::size_t(0x7fffffffffffffffL) / sizeof(_Tp);
+
+
+
+      }
+    };
+
+
+}
+# 34 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++allocator.h" 2 3
+
+
+namespace std
+{
+# 47 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++allocator.h" 3
+  template<typename _Tp>
+    using __allocator_base = __gnu_cxx::new_allocator<_Tp>;
+}
+# 47 "/usr/include/c++/10.2.0/bits/allocator.h" 2 3
+
+
+
+
+
+#define __cpp_lib_incomplete_container_elements 201505
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+
+
+
+  template<>
+    class allocator<void>
+    {
+    public:
+      typedef void value_type;
+      typedef size_t size_type;
+      typedef ptrdiff_t difference_type;
+
+      typedef void* pointer;
+      typedef const void* const_pointer;
+
+      template<typename _Tp1>
+ struct rebind
+ { typedef allocator<_Tp1> other; };
+# 89 "/usr/include/c++/10.2.0/bits/allocator.h" 3
+      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)
+ noexcept(std::is_nothrow_constructible<_Up, _Args...>::value)
+ { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
+
+      template<typename _Up>
+ void
+ destroy(_Up* __p)
+ noexcept(std::is_nothrow_destructible<_Up>::value)
+ { __p->~_Up(); }
+
+    };
+# 115 "/usr/include/c++/10.2.0/bits/allocator.h" 3
+  template<typename _Tp>
+    class allocator : public __allocator_base<_Tp>
+    {
+    public:
+      typedef _Tp value_type;
+      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;
+
+      template<typename _Tp1>
+ struct rebind
+ { typedef allocator<_Tp1> other; };
+
+
+
+
+
+      typedef true_type propagate_on_container_move_assignment;
+
+      typedef true_type is_always_equal;
+
+
+
+
+     
+      allocator() noexcept { }
+
+     
+      allocator(const allocator& __a) noexcept
+      : __allocator_base<_Tp>(__a) { }
+
+
+
+      allocator& operator=(const allocator&) = default;
+
+
+      template<typename _Tp1>
+
+ allocator(const allocator<_Tp1>&) noexcept { }
+
+
+
+
+      ~allocator() noexcept { }
+# 191 "/usr/include/c++/10.2.0/bits/allocator.h" 3
+      friend bool
+      operator==(const allocator&, const allocator&) noexcept
+      { return true; }
+
+
+      friend bool
+      operator!=(const allocator&, const allocator&) noexcept
+      { return false; }
+
+
+
+    };
+
+  template<typename _T1, typename _T2>
+    inline bool
+    operator==(const allocator<_T1>&, const allocator<_T2>&)
+    noexcept
+    { return true; }
+
+
+  template<typename _T1, typename _T2>
+    inline bool
+    operator!=(const allocator<_T1>&, const allocator<_T2>&)
+    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>;
+
+
+
+#undef __allocator_base
+
+
+  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; }
+
+
+
+      }
+    };
+
+
+
+}
+# 42 "/usr/include/c++/10.2.0/string" 2 3
+
+# 1 "/usr/include/c++/10.2.0/bits/localefwd.h" 1 3
+# 35 "/usr/include/c++/10.2.0/bits/localefwd.h" 3
+#define _LOCALE_FWD_H 1
+
+       
+# 38 "/usr/include/c++/10.2.0/bits/localefwd.h" 3
+
+
+# 1 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++locale.h" 1 3
+# 37 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++locale.h" 3
+#define _GLIBCXX_CXX_LOCALE_H 1
+
+       
+# 40 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++locale.h" 3
+
+# 1 "/usr/include/c++/10.2.0/clocale" 1 3
+# 39 "/usr/include/c++/10.2.0/clocale" 3
+       
+# 40 "/usr/include/c++/10.2.0/clocale" 3
+
+
+# 1 "/usr/include/locale.h" 1 3 4
+# 23 "/usr/include/locale.h" 3 4
+#define _LOCALE_H 1
+
+
+
+#define __need_NULL 
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 1 3 4
+# 155 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef __need_ptrdiff_t
+# 231 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef __need_size_t
+# 340 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef __need_wchar_t
+# 390 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef NULL
+
+#define NULL __null
+# 401 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef __need_NULL
+
+
+
+
+#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
+# 29 "/usr/include/locale.h" 2 3 4
+# 1 "/usr/include/bits/locale.h" 1 3 4
+# 24 "/usr/include/bits/locale.h" 3 4
+#define _BITS_LOCALE_H 1
+
+#define __LC_CTYPE 0
+#define __LC_NUMERIC 1
+#define __LC_TIME 2
+#define __LC_COLLATE 3
+#define __LC_MONETARY 4
+#define __LC_MESSAGES 5
+#define __LC_ALL 6
+#define __LC_PAPER 7
+#define __LC_NAME 8
+#define __LC_ADDRESS 9
+#define __LC_TELEPHONE 10
+#define __LC_MEASUREMENT 11
+#define __LC_IDENTIFICATION 12
+# 30 "/usr/include/locale.h" 2 3 4
+
+extern "C" {
+
+
+
+#define LC_CTYPE __LC_CTYPE
+#define LC_NUMERIC __LC_NUMERIC
+#define LC_TIME __LC_TIME
+#define LC_COLLATE __LC_COLLATE
+#define LC_MONETARY __LC_MONETARY
+#define LC_MESSAGES __LC_MESSAGES
+#define LC_ALL __LC_ALL
+#define LC_PAPER __LC_PAPER
+#define LC_NAME __LC_NAME
+#define LC_ADDRESS __LC_ADDRESS
+#define LC_TELEPHONE __LC_TELEPHONE
+#define LC_MEASUREMENT __LC_MEASUREMENT
+#define LC_IDENTIFICATION __LC_IDENTIFICATION
+
+
+
+struct lconv
+{
+
+
+  char *decimal_point;
+  char *thousands_sep;
+
+
+
+
+
+  char *grouping;
+
+
+
+
+
+  char *int_curr_symbol;
+  char *currency_symbol;
+  char *mon_decimal_point;
+  char *mon_thousands_sep;
+  char *mon_grouping;
+  char *positive_sign;
+  char *negative_sign;
+  char int_frac_digits;
+  char frac_digits;
+
+  char p_cs_precedes;
+
+  char p_sep_by_space;
+
+  char n_cs_precedes;
+
+  char n_sep_by_space;
+
+
+
+
+
+
+  char p_sign_posn;
+  char n_sign_posn;
+
+
+  char int_p_cs_precedes;
+
+  char int_p_sep_by_space;
+
+  char int_n_cs_precedes;
+
+  char int_n_sep_by_space;
+
+
+
+
+
+
+  char int_p_sign_posn;
+  char int_n_sign_posn;
+# 118 "/usr/include/locale.h" 3 4
+};
+
+
+
+extern char *setlocale (int __category, const char *__locale) throw ();
+
+
+extern struct lconv *localeconv (void) throw ();
+# 141 "/usr/include/locale.h" 3 4
+extern locale_t newlocale (int __category_mask, const char *__locale,
+      locale_t __base) throw ();
+
+
+
+
+
+#define LC_CTYPE_MASK (1 << __LC_CTYPE)
+#define LC_NUMERIC_MASK (1 << __LC_NUMERIC)
+#define LC_TIME_MASK (1 << __LC_TIME)
+#define LC_COLLATE_MASK (1 << __LC_COLLATE)
+#define LC_MONETARY_MASK (1 << __LC_MONETARY)
+#define LC_MESSAGES_MASK (1 << __LC_MESSAGES)
+#define LC_PAPER_MASK (1 << __LC_PAPER)
+#define LC_NAME_MASK (1 << __LC_NAME)
+#define LC_ADDRESS_MASK (1 << __LC_ADDRESS)
+#define LC_TELEPHONE_MASK (1 << __LC_TELEPHONE)
+#define LC_MEASUREMENT_MASK (1 << __LC_MEASUREMENT)
+#define LC_IDENTIFICATION_MASK (1 << __LC_IDENTIFICATION)
+#define LC_ALL_MASK (LC_CTYPE_MASK | LC_NUMERIC_MASK | LC_TIME_MASK | LC_COLLATE_MASK | LC_MONETARY_MASK | LC_MESSAGES_MASK | LC_PAPER_MASK | LC_NAME_MASK | LC_ADDRESS_MASK | LC_TELEPHONE_MASK | LC_MEASUREMENT_MASK | LC_IDENTIFICATION_MASK )
+# 176 "/usr/include/locale.h" 3 4
+extern locale_t duplocale (locale_t __dataset) throw ();
+
+
+
+extern void freelocale (locale_t __dataset) throw ();
+
+
+
+
+
+
+extern locale_t uselocale (locale_t __dataset) throw ();
+
+
+
+#define LC_GLOBAL_LOCALE ((locale_t) -1L)
+
+
+
+}
+# 43 "/usr/include/c++/10.2.0/clocale" 2 3
+
+
+#define _GLIBCXX_CLOCALE 1
+
+
+#undef setlocale
+#undef localeconv
+
+namespace std
+{
+  using ::lconv;
+  using ::setlocale;
+  using ::localeconv;
+}
+# 42 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++locale.h" 2 3
+
+#define _GLIBCXX_C_LOCALE_GNU 1
+
+#define _GLIBCXX_NUM_CATEGORIES 6
+
+
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
+{
+
+
+  extern "C" __typeof(uselocale) __uselocale;
+
+
+}
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  typedef __locale_t __c_locale;
+
+
+
+
+
+  inline int
+  __convert_from_v(const __c_locale& __cloc __attribute__ ((__unused__)),
+     char* __out,
+     const int __size __attribute__ ((__unused__)),
+     const char* __fmt, ...)
+  {
+
+    __c_locale __old = __gnu_cxx::__uselocale(__cloc);
+# 88 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++locale.h" 3
+    __builtin_va_list __args;
+    __builtin_va_start(__args, __fmt);
+
+
+    const int __ret = __builtin_vsnprintf(__out, __size, __fmt, __args);
+
+
+
+
+    __builtin_va_end(__args);
+
+
+    __gnu_cxx::__uselocale(__old);
+
+
+
+
+
+
+
+    return __ret;
+  }
+
+
+}
+# 41 "/usr/include/c++/10.2.0/bits/localefwd.h" 2 3
+# 1 "/usr/include/c++/10.2.0/iosfwd" 1 3
+# 34 "/usr/include/c++/10.2.0/iosfwd" 3
+#define _GLIBCXX_IOSFWD 1
+
+       
+# 37 "/usr/include/c++/10.2.0/iosfwd" 3
+
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 74 "/usr/include/c++/10.2.0/iosfwd" 3
+  class ios_base;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_ios;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_streambuf;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_istream;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_ostream;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_iostream;
+
+
+namespace __cxx11 {
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT>,
+     typename _Alloc = allocator<_CharT> >
+    class basic_stringbuf;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT>,
+    typename _Alloc = allocator<_CharT> >
+    class basic_istringstream;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT>,
+    typename _Alloc = allocator<_CharT> >
+    class basic_ostringstream;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT>,
+    typename _Alloc = allocator<_CharT> >
+    class basic_stringstream;
+
+}
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_filebuf;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_ifstream;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_ofstream;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_fstream;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class istreambuf_iterator;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class ostreambuf_iterator;
+
+
+
+  typedef basic_ios<char> ios;
+
+
+  typedef basic_streambuf<char> streambuf;
+
+
+  typedef basic_istream<char> istream;
+
+
+  typedef basic_ostream<char> ostream;
+
+
+  typedef basic_iostream<char> iostream;
+
+
+  typedef basic_stringbuf<char> stringbuf;
+
+
+  typedef basic_istringstream<char> istringstream;
+
+
+  typedef basic_ostringstream<char> ostringstream;
+
+
+  typedef basic_stringstream<char> stringstream;
+
+
+  typedef basic_filebuf<char> filebuf;
+
+
+  typedef basic_ifstream<char> ifstream;
+
+
+  typedef basic_ofstream<char> ofstream;
+
+
+  typedef basic_fstream<char> fstream;
+
+
+
+  typedef basic_ios<wchar_t> wios;
+
+
+  typedef basic_streambuf<wchar_t> wstreambuf;
+
+
+  typedef basic_istream<wchar_t> wistream;
+
+
+  typedef basic_ostream<wchar_t> wostream;
+
+
+  typedef basic_iostream<wchar_t> wiostream;
+
+
+  typedef basic_stringbuf<wchar_t> wstringbuf;
+
+
+  typedef basic_istringstream<wchar_t> wistringstream;
+
+
+  typedef basic_ostringstream<wchar_t> wostringstream;
+
+
+  typedef basic_stringstream<wchar_t> wstringstream;
+
+
+  typedef basic_filebuf<wchar_t> wfilebuf;
+
+
+  typedef basic_ifstream<wchar_t> wifstream;
+
+
+  typedef basic_ofstream<wchar_t> wofstream;
+
+
+  typedef basic_fstream<wchar_t> wfstream;
+
+
+
+
+}
+# 42 "/usr/include/c++/10.2.0/bits/localefwd.h" 2 3
+# 1 "/usr/include/c++/10.2.0/cctype" 1 3
+# 39 "/usr/include/c++/10.2.0/cctype" 3
+       
+# 40 "/usr/include/c++/10.2.0/cctype" 3
+
+
+# 1 "/usr/include/ctype.h" 1 3 4
+# 23 "/usr/include/ctype.h" 3 4
+#define _CTYPE_H 1
+
+
+
+
+extern "C" {
+# 43 "/usr/include/ctype.h" 3 4
+#define _ISbit(bit) ((bit) < 8 ? ((1 << (bit)) << 8) : ((1 << (bit)) >> 8))
+
+
+enum
+{
+  _ISupper = ((0) < 8 ? ((1 << (0)) << 8) : ((1 << (0)) >> 8)),
+  _ISlower = ((1) < 8 ? ((1 << (1)) << 8) : ((1 << (1)) >> 8)),
+  _ISalpha = ((2) < 8 ? ((1 << (2)) << 8) : ((1 << (2)) >> 8)),
+  _ISdigit = ((3) < 8 ? ((1 << (3)) << 8) : ((1 << (3)) >> 8)),
+  _ISxdigit = ((4) < 8 ? ((1 << (4)) << 8) : ((1 << (4)) >> 8)),
+  _ISspace = ((5) < 8 ? ((1 << (5)) << 8) : ((1 << (5)) >> 8)),
+  _ISprint = ((6) < 8 ? ((1 << (6)) << 8) : ((1 << (6)) >> 8)),
+  _ISgraph = ((7) < 8 ? ((1 << (7)) << 8) : ((1 << (7)) >> 8)),
+  _ISblank = ((8) < 8 ? ((1 << (8)) << 8) : ((1 << (8)) >> 8)),
+  _IScntrl = ((9) < 8 ? ((1 << (9)) << 8) : ((1 << (9)) >> 8)),
+  _ISpunct = ((10) < 8 ? ((1 << (10)) << 8) : ((1 << (10)) >> 8)),
+  _ISalnum = ((11) < 8 ? ((1 << (11)) << 8) : ((1 << (11)) >> 8))
+};
+# 79 "/usr/include/ctype.h" 3 4
+extern const unsigned short int **__ctype_b_loc (void)
+     throw () __attribute__ ((__const__));
+extern const __int32_t **__ctype_tolower_loc (void)
+     throw () __attribute__ ((__const__));
+extern const __int32_t **__ctype_toupper_loc (void)
+     throw () __attribute__ ((__const__));
+# 99 "/usr/include/ctype.h" 3 4
+#define __isascii(c) (((c) & ~0x7f) == 0)
+#define __toascii(c) ((c) & 0x7f)
+
+#define __exctype(name) extern int name (int) __THROW
+
+
+
+
+
+extern int isalnum (int) throw ();
+extern int isalpha (int) throw ();
+extern int iscntrl (int) throw ();
+extern int isdigit (int) throw ();
+extern int islower (int) throw ();
+extern int isgraph (int) throw ();
+extern int isprint (int) throw ();
+extern int ispunct (int) throw ();
+extern int isspace (int) throw ();
+extern int isupper (int) throw ();
+extern int isxdigit (int) throw ();
+
+
+
+extern int tolower (int __c) throw ();
+
+
+extern int toupper (int __c) throw ();
+
+
+
+
+extern int isblank (int) throw ();
+
+
+
+
+extern int isctype (int __c, int __mask) throw ();
+
+
+
+
+
+
+extern int isascii (int __c) throw ();
+
+
+
+extern int toascii (int __c) throw ();
+
+
+
+extern int _toupper (int) throw ();
+extern int _tolower (int) throw ();
+
+
+
+#define __tobody(c,f,a,args) (__extension__ ({ int __res; if (sizeof (c) > 1) { if (__builtin_constant_p (c)) { int __c = (c); __res = __c < -128 || __c > 255 ? __c : (a)[__c]; } else __res = f args; } else __res = (a)[(int) (c)]; __res; }))
+# 241 "/usr/include/ctype.h" 3 4
+#define __isctype_l(c,type,locale) ((locale)->__ctype_b[(int) (c)] & (unsigned short int) type)
+
+
+#define __exctype_l(name) extern int name (int, locale_t) __THROW
+
+
+
+
+
+
+extern int isalnum_l (int, locale_t) throw ();
+extern int isalpha_l (int, locale_t) throw ();
+extern int iscntrl_l (int, locale_t) throw ();
+extern int isdigit_l (int, locale_t) throw ();
+extern int islower_l (int, locale_t) throw ();
+extern int isgraph_l (int, locale_t) throw ();
+extern int isprint_l (int, locale_t) throw ();
+extern int ispunct_l (int, locale_t) throw ();
+extern int isspace_l (int, locale_t) throw ();
+extern int isupper_l (int, locale_t) throw ();
+extern int isxdigit_l (int, locale_t) throw ();
+
+extern int isblank_l (int, locale_t) throw ();
+
+
+
+extern int __tolower_l (int __c, locale_t __l) throw ();
+extern int tolower_l (int __c, locale_t __l) throw ();
+
+
+extern int __toupper_l (int __c, locale_t __l) throw ();
+extern int toupper_l (int __c, locale_t __l) throw ();
+# 327 "/usr/include/ctype.h" 3 4
+}
+# 43 "/usr/include/c++/10.2.0/cctype" 2 3
+
+
+#define _GLIBCXX_CCTYPE 1
+
+
+#undef isalnum
+#undef isalpha
+#undef iscntrl
+#undef isdigit
+#undef isgraph
+#undef islower
+#undef isprint
+#undef ispunct
+#undef isspace
+#undef isupper
+#undef isxdigit
+#undef tolower
+#undef toupper
+
+namespace std
+{
+  using ::isalnum;
+  using ::isalpha;
+  using ::iscntrl;
+  using ::isdigit;
+  using ::isgraph;
+  using ::islower;
+  using ::isprint;
+  using ::ispunct;
+  using ::isspace;
+  using ::isupper;
+  using ::isxdigit;
+  using ::tolower;
+  using ::toupper;
+}
+
+
+
+
+
+#undef isblank
+
+namespace std
+{
+  using ::isblank;
+}
+# 43 "/usr/include/c++/10.2.0/bits/localefwd.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 55 "/usr/include/c++/10.2.0/bits/localefwd.h" 3
+  class locale;
+
+  template<typename _Facet>
+    bool
+    has_facet(const locale&) throw();
+
+  template<typename _Facet>
+    const _Facet&
+    use_facet(const locale&);
+
+
+  template<typename _CharT>
+    bool
+    isspace(_CharT, const locale&);
+
+  template<typename _CharT>
+    bool
+    isprint(_CharT, const locale&);
+
+  template<typename _CharT>
+    bool
+    iscntrl(_CharT, const locale&);
+
+  template<typename _CharT>
+    bool
+    isupper(_CharT, const locale&);
+
+  template<typename _CharT>
+    bool
+    islower(_CharT, const locale&);
+
+  template<typename _CharT>
+    bool
+    isalpha(_CharT, const locale&);
+
+  template<typename _CharT>
+    bool
+    isdigit(_CharT, const locale&);
+
+  template<typename _CharT>
+    bool
+    ispunct(_CharT, const locale&);
+
+  template<typename _CharT>
+    bool
+    isxdigit(_CharT, const locale&);
+
+  template<typename _CharT>
+    bool
+    isalnum(_CharT, const locale&);
+
+  template<typename _CharT>
+    bool
+    isgraph(_CharT, const locale&);
+
+
+  template<typename _CharT>
+    bool
+    isblank(_CharT, const locale&);
+
+
+  template<typename _CharT>
+    _CharT
+    toupper(_CharT, const locale&);
+
+  template<typename _CharT>
+    _CharT
+    tolower(_CharT, const locale&);
+
+
+  class ctype_base;
+  template<typename _CharT>
+    class ctype;
+  template<> class ctype<char>;
+
+  template<> class ctype<wchar_t>;
+
+  template<typename _CharT>
+    class ctype_byname;
+
+
+  class codecvt_base;
+  template<typename _InternT, typename _ExternT, typename _StateT>
+    class codecvt;
+  template<> class codecvt<char, char, mbstate_t>;
+
+  template<> class codecvt<wchar_t, char, mbstate_t>;
+
+
+  template<> class codecvt<char16_t, char, mbstate_t>;
+  template<> class codecvt<char32_t, char, mbstate_t>;
+
+
+
+
+
+  template<typename _InternT, typename _ExternT, typename _StateT>
+    class codecvt_byname;
+
+
+
+  template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
+    class num_get;
+  template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
+    class num_put;
+
+namespace __cxx11 {
+  template<typename _CharT> class numpunct;
+  template<typename _CharT> class numpunct_byname;
+}
+
+namespace __cxx11 {
+
+  template<typename _CharT>
+    class collate;
+  template<typename _CharT>
+    class collate_byname;
+}
+
+
+  class time_base;
+namespace __cxx11 {
+  template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
+    class time_get;
+  template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
+    class time_get_byname;
+}
+  template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
+    class time_put;
+  template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
+    class time_put_byname;
+
+
+  class money_base;
+namespace __cxx11 {
+  template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
+    class money_get;
+  template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
+    class money_put;
+}
+namespace __cxx11 {
+  template<typename _CharT, bool _Intl = false>
+    class moneypunct;
+  template<typename _CharT, bool _Intl = false>
+    class moneypunct_byname;
+}
+
+
+  class messages_base;
+namespace __cxx11 {
+  template<typename _CharT>
+    class messages;
+  template<typename _CharT>
+    class messages_byname;
+}
+
+
+}
+# 44 "/usr/include/c++/10.2.0/string" 2 3
+# 1 "/usr/include/c++/10.2.0/bits/ostream_insert.h" 1 3
+# 31 "/usr/include/c++/10.2.0/bits/ostream_insert.h" 3
+#define _OSTREAM_INSERT_H 1
+
+       
+# 34 "/usr/include/c++/10.2.0/bits/ostream_insert.h" 3
+
+
+# 1 "/usr/include/c++/10.2.0/bits/cxxabi_forced.h" 1 3
+# 32 "/usr/include/c++/10.2.0/bits/cxxabi_forced.h" 3
+#define _CXXABI_FORCED_H 1
+
+       
+# 35 "/usr/include/c++/10.2.0/bits/cxxabi_forced.h" 3
+
+#pragma GCC visibility push(default)
+
+
+namespace __cxxabiv1
+{
+
+
+
+
+
+
+
+  class __forced_unwind
+  {
+    virtual ~__forced_unwind() throw();
+
+
+    virtual void __pure_dummy() = 0;
+  };
+}
+
+
+#pragma GCC visibility pop
+# 37 "/usr/include/c++/10.2.0/bits/ostream_insert.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  template<typename _CharT, typename _Traits>
+    inline void
+    __ostream_write(basic_ostream<_CharT, _Traits>& __out,
+      const _CharT* __s, streamsize __n)
+    {
+      typedef basic_ostream<_CharT, _Traits> __ostream_type;
+      typedef typename __ostream_type::ios_base __ios_base;
+
+      const streamsize __put = __out.rdbuf()->sputn(__s, __n);
+      if (__put != __n)
+ __out.setstate(__ios_base::badbit);
+    }
+
+  template<typename _CharT, typename _Traits>
+    inline void
+    __ostream_fill(basic_ostream<_CharT, _Traits>& __out, streamsize __n)
+    {
+      typedef basic_ostream<_CharT, _Traits> __ostream_type;
+      typedef typename __ostream_type::ios_base __ios_base;
+
+      const _CharT __c = __out.fill();
+      for (; __n > 0; --__n)
+ {
+   const typename _Traits::int_type __put = __out.rdbuf()->sputc(__c);
+   if (_Traits::eq_int_type(__put, _Traits::eof()))
+     {
+       __out.setstate(__ios_base::badbit);
+       break;
+     }
+ }
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    __ostream_insert(basic_ostream<_CharT, _Traits>& __out,
+       const _CharT* __s, streamsize __n)
+    {
+      typedef basic_ostream<_CharT, _Traits> __ostream_type;
+      typedef typename __ostream_type::ios_base __ios_base;
+
+      typename __ostream_type::sentry __cerb(__out);
+      if (__cerb)
+ {
+   try
+     {
+       const streamsize __w = __out.width();
+       if (__w > __n)
+  {
+    const bool __left = ((__out.flags()
+     & __ios_base::adjustfield)
+           == __ios_base::left);
+    if (!__left)
+      __ostream_fill(__out, __w - __n);
+    if (__out.good())
+      __ostream_write(__out, __s, __n);
+    if (__left && __out.good())
+      __ostream_fill(__out, __w - __n);
+  }
+       else
+  __ostream_write(__out, __s, __n);
+       __out.width(0);
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       __out._M_setstate(__ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { __out._M_setstate(__ios_base::badbit); }
+ }
+      return __out;
+    }
+
+
+
+
+  extern template ostream& __ostream_insert(ostream&, const char*, streamsize);
+
+
+  extern template wostream& __ostream_insert(wostream&, const wchar_t*,
+          streamsize);
+
+
+
+
+}
+# 45 "/usr/include/c++/10.2.0/string" 2 3
+
+
+
+# 1 "/usr/include/c++/10.2.0/bits/stl_function.h" 1 3
+# 57 "/usr/include/c++/10.2.0/bits/stl_function.h" 3
+#define _STL_FUNCTION_H 1
+
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 104 "/usr/include/c++/10.2.0/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 "/usr/include/c++/10.2.0/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; }
+    };
+
+
+
+#define __cpp_lib_transparent_operators 201510
+
+  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 "/usr/include/c++/10.2.0/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<typename _Tp>
+    struct greater<_Tp*> : public binary_function<_Tp*, _Tp*, bool>
+    {
+      constexpr bool
+      operator()(_Tp* __x, _Tp* __y) const noexcept
+      {
+
+
+ if (__builtin_is_constant_evaluated())
+
+
+
+   return __x > __y;
+
+ return (long unsigned int)__x > (long unsigned int)__y;
+      }
+    };
+
+
+  template<typename _Tp>
+    struct less<_Tp*> : public binary_function<_Tp*, _Tp*, bool>
+    {
+      constexpr bool
+      operator()(_Tp* __x, _Tp* __y) const noexcept
+      {
+
+
+ if (__builtin_is_constant_evaluated())
+
+
+
+   return __x < __y;
+
+ return (long unsigned int)__x < (long unsigned int)__y;
+      }
+    };
+
+
+  template<typename _Tp>
+    struct greater_equal<_Tp*> : public binary_function<_Tp*, _Tp*, bool>
+    {
+      constexpr bool
+      operator()(_Tp* __x, _Tp* __y) const noexcept
+      {
+
+
+ if (__builtin_is_constant_evaluated())
+
+
+
+   return __x >= __y;
+
+ return (long unsigned int)__x >= (long unsigned int)__y;
+      }
+    };
+
+
+  template<typename _Tp>
+    struct less_equal<_Tp*> : public binary_function<_Tp*, _Tp*, bool>
+    {
+      constexpr bool
+      operator()(_Tp* __x, _Tp* __y) const noexcept
+      {
+
+
+ if (__builtin_is_constant_evaluated())
+
+
+
+   return __x <= __y;
+
+ return (long unsigned int)__x <= (long unsigned int)__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 _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u),
+   __ptr_cmp<_Tp, _Up>{});
+ }
+
+      template<typename _Tp, typename _Up>
+ constexpr bool
+ operator()(_Tp* __t, _Up* __u) const noexcept
+ { return greater<common_type_t<_Tp*, _Up*>>{}(__t, __u); }
+
+      typedef __is_transparent is_transparent;
+
+    private:
+      template <typename _Tp, typename _Up>
+ static constexpr decltype(auto)
+ _S_cmp(_Tp&& __t, _Up&& __u, false_type)
+ { return std::forward<_Tp>(__t) > std::forward<_Up>(__u); }
+
+      template <typename _Tp, typename _Up>
+ static constexpr bool
+ _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept
+ {
+   return greater<const volatile void*>{}(
+       static_cast<const volatile void*>(std::forward<_Tp>(__t)),
+       static_cast<const volatile void*>(std::forward<_Up>(__u)));
+ }
+
+
+      template<typename _Tp, typename _Up, typename = void>
+ struct __not_overloaded2 : true_type { };
+
+
+      template<typename _Tp, typename _Up>
+ struct __not_overloaded2<_Tp, _Up, __void_t<
+   decltype(std::declval<_Tp>().operator>(std::declval<_Up>()))>>
+ : false_type { };
+
+
+      template<typename _Tp, typename _Up, typename = void>
+ struct __not_overloaded : __not_overloaded2<_Tp, _Up> { };
+
+
+      template<typename _Tp, typename _Up>
+ struct __not_overloaded<_Tp, _Up, __void_t<
+   decltype(operator>(std::declval<_Tp>(), std::declval<_Up>()))>>
+ : false_type { };
+
+      template<typename _Tp, typename _Up>
+ using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>,
+       is_convertible<_Tp, const volatile void*>,
+       is_convertible<_Up, const volatile void*>>;
+    };
+
+
+  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 _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u),
+   __ptr_cmp<_Tp, _Up>{});
+ }
+
+      template<typename _Tp, typename _Up>
+ constexpr bool
+ operator()(_Tp* __t, _Up* __u) const noexcept
+ { return less<common_type_t<_Tp*, _Up*>>{}(__t, __u); }
+
+      typedef __is_transparent is_transparent;
+
+    private:
+      template <typename _Tp, typename _Up>
+ static constexpr decltype(auto)
+ _S_cmp(_Tp&& __t, _Up&& __u, false_type)
+ { return std::forward<_Tp>(__t) < std::forward<_Up>(__u); }
+
+      template <typename _Tp, typename _Up>
+ static constexpr bool
+ _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept
+ {
+   return less<const volatile void*>{}(
+       static_cast<const volatile void*>(std::forward<_Tp>(__t)),
+       static_cast<const volatile void*>(std::forward<_Up>(__u)));
+ }
+
+
+      template<typename _Tp, typename _Up, typename = void>
+ struct __not_overloaded2 : true_type { };
+
+
+      template<typename _Tp, typename _Up>
+ struct __not_overloaded2<_Tp, _Up, __void_t<
+   decltype(std::declval<_Tp>().operator<(std::declval<_Up>()))>>
+ : false_type { };
+
+
+      template<typename _Tp, typename _Up, typename = void>
+ struct __not_overloaded : __not_overloaded2<_Tp, _Up> { };
+
+
+      template<typename _Tp, typename _Up>
+ struct __not_overloaded<_Tp, _Up, __void_t<
+   decltype(operator<(std::declval<_Tp>(), std::declval<_Up>()))>>
+ : false_type { };
+
+      template<typename _Tp, typename _Up>
+ using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>,
+       is_convertible<_Tp, const volatile void*>,
+       is_convertible<_Up, const volatile void*>>;
+    };
+
+
+  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 _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u),
+   __ptr_cmp<_Tp, _Up>{});
+ }
+
+      template<typename _Tp, typename _Up>
+ constexpr bool
+ operator()(_Tp* __t, _Up* __u) const noexcept
+ { return greater_equal<common_type_t<_Tp*, _Up*>>{}(__t, __u); }
+
+      typedef __is_transparent is_transparent;
+
+    private:
+      template <typename _Tp, typename _Up>
+ static constexpr decltype(auto)
+ _S_cmp(_Tp&& __t, _Up&& __u, false_type)
+ { return std::forward<_Tp>(__t) >= std::forward<_Up>(__u); }
+
+      template <typename _Tp, typename _Up>
+ static constexpr bool
+ _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept
+ {
+   return greater_equal<const volatile void*>{}(
+       static_cast<const volatile void*>(std::forward<_Tp>(__t)),
+       static_cast<const volatile void*>(std::forward<_Up>(__u)));
+ }
+
+
+      template<typename _Tp, typename _Up, typename = void>
+ struct __not_overloaded2 : true_type { };
+
+
+      template<typename _Tp, typename _Up>
+ struct __not_overloaded2<_Tp, _Up, __void_t<
+   decltype(std::declval<_Tp>().operator>=(std::declval<_Up>()))>>
+ : false_type { };
+
+
+      template<typename _Tp, typename _Up, typename = void>
+ struct __not_overloaded : __not_overloaded2<_Tp, _Up> { };
+
+
+      template<typename _Tp, typename _Up>
+ struct __not_overloaded<_Tp, _Up, __void_t<
+   decltype(operator>=(std::declval<_Tp>(), std::declval<_Up>()))>>
+ : false_type { };
+
+      template<typename _Tp, typename _Up>
+ using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>,
+       is_convertible<_Tp, const volatile void*>,
+       is_convertible<_Up, const volatile void*>>;
+    };
+
+
+  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 _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u),
+   __ptr_cmp<_Tp, _Up>{});
+ }
+
+      template<typename _Tp, typename _Up>
+ constexpr bool
+ operator()(_Tp* __t, _Up* __u) const noexcept
+ { return less_equal<common_type_t<_Tp*, _Up*>>{}(__t, __u); }
+
+      typedef __is_transparent is_transparent;
+
+    private:
+      template <typename _Tp, typename _Up>
+ static constexpr decltype(auto)
+ _S_cmp(_Tp&& __t, _Up&& __u, false_type)
+ { return std::forward<_Tp>(__t) <= std::forward<_Up>(__u); }
+
+      template <typename _Tp, typename _Up>
+ static constexpr bool
+ _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept
+ {
+   return less_equal<const volatile void*>{}(
+       static_cast<const volatile void*>(std::forward<_Tp>(__t)),
+       static_cast<const volatile void*>(std::forward<_Up>(__u)));
+ }
+
+
+      template<typename _Tp, typename _Up, typename = void>
+ struct __not_overloaded2 : true_type { };
+
+
+      template<typename _Tp, typename _Up>
+ struct __not_overloaded2<_Tp, _Up, __void_t<
+   decltype(std::declval<_Tp>().operator<=(std::declval<_Up>()))>>
+ : false_type { };
+
+
+      template<typename _Tp, typename _Up, typename = void>
+ struct __not_overloaded : __not_overloaded2<_Tp, _Up> { };
+
+
+      template<typename _Tp, typename _Up>
+ struct __not_overloaded<_Tp, _Up, __void_t<
+   decltype(operator<=(std::declval<_Tp>(), std::declval<_Up>()))>>
+ : false_type { };
+
+      template<typename _Tp, typename _Up>
+ using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>,
+       is_convertible<_Tp, const volatile void*>,
+       is_convertible<_Up, const volatile void*>>;
+    };
+# 774 "/usr/include/c++/10.2.0/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;
+    };
+# 1002 "/usr/include/c++/10.2.0/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); }
+# 1079 "/usr/include/c++/10.2.0/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; }
+    };
+# 1202 "/usr/include/c++/10.2.0/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 "/usr/include/c++/10.2.0/backward/binders.h" 1 3
+# 57 "/usr/include/c++/10.2.0/backward/binders.h" 3
+#define _BACKWARD_BINDERS_H 1
+
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 107 "/usr/include/c++/10.2.0/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
+# 1393 "/usr/include/c++/10.2.0/bits/stl_function.h" 2 3
+# 49 "/usr/include/c++/10.2.0/string" 2 3
+
+
+
+
+
+# 1 "/usr/include/c++/10.2.0/bits/range_access.h" 1 3
+# 31 "/usr/include/c++/10.2.0/bits/range_access.h" 3
+#define _GLIBCXX_RANGE_ACCESS_H 1
+
+       
+# 34 "/usr/include/c++/10.2.0/bits/range_access.h" 3
+
+
+# 1 "/usr/include/c++/10.2.0/initializer_list" 1 3
+# 31 "/usr/include/c++/10.2.0/initializer_list" 3
+#define _INITIALIZER_LIST 
+
+       
+# 34 "/usr/include/c++/10.2.0/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
+# 37 "/usr/include/c++/10.2.0/bits/range_access.h" 2 3
+# 1 "/usr/include/c++/10.2.0/bits/iterator_concepts.h" 1 3
+# 31 "/usr/include/c++/10.2.0/bits/iterator_concepts.h" 3
+#define _ITERATOR_CONCEPTS_H 1
+
+       
+# 34 "/usr/include/c++/10.2.0/bits/iterator_concepts.h" 3
+
+# 1 "/usr/include/c++/10.2.0/concepts" 1 3
+# 31 "/usr/include/c++/10.2.0/concepts" 3
+#define _GLIBCXX_CONCEPTS 1
+# 36 "/usr/include/c++/10.2.0/bits/iterator_concepts.h" 2 3
+
+# 1 "/usr/include/c++/10.2.0/bits/range_cmp.h" 1 3
+# 31 "/usr/include/c++/10.2.0/bits/range_cmp.h" 3
+#define _RANGE_CMP_H 1
+# 38 "/usr/include/c++/10.2.0/bits/iterator_concepts.h" 2 3
+# 38 "/usr/include/c++/10.2.0/bits/range_access.h" 2 3
+# 1 "/usr/include/c++/10.2.0/bits/int_limits.h" 1 3
+# 31 "/usr/include/c++/10.2.0/bits/int_limits.h" 3
+#define _GLIBCXX_INT_LIMITS_H 1
+
+       
+# 34 "/usr/include/c++/10.2.0/bits/int_limits.h" 3
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+namespace __detail
+{
+
+
+
+
+
+
+  template<typename _Tp, bool = is_signed<_Tp>::value>
+    struct __int_limits
+    {
+      static_assert(is_integral<_Tp>::value, "unsupported specialization");
+      using _Up = typename make_unsigned<_Tp>::type;
+      static constexpr int digits = sizeof(_Tp) * 8 - 1;
+      static constexpr _Tp min() noexcept { return _Tp(_Up(1) << digits); }
+      static constexpr _Tp max() noexcept { return _Tp(_Up(~_Up(0)) >> 1); }
+    };
+
+
+  template<typename _Tp>
+    struct __int_limits<_Tp, false>
+    {
+      static_assert(is_integral<_Tp>::value, "unsupported specialization");
+      static constexpr int digits = sizeof(_Tp) * 8;
+      static constexpr _Tp min() noexcept { return 0; }
+      static constexpr _Tp max() noexcept { return _Tp(-1); }
+    };
+
+  template<> struct __int_limits<bool>;
+}
+
+}
+# 39 "/usr/include/c++/10.2.0/bits/range_access.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+
+
+  template<typename _Container>
+    inline constexpr auto
+    begin(_Container& __cont) -> decltype(__cont.begin())
+    { return __cont.begin(); }
+
+
+
+
+
+
+  template<typename _Container>
+    inline constexpr auto
+    begin(const _Container& __cont) -> decltype(__cont.begin())
+    { return __cont.begin(); }
+
+
+
+
+
+
+  template<typename _Container>
+    inline constexpr auto
+    end(_Container& __cont) -> decltype(__cont.end())
+    { return __cont.end(); }
+
+
+
+
+
+
+  template<typename _Container>
+    inline constexpr 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 constexpr auto
+    rbegin(_Container& __cont) -> decltype(__cont.rbegin())
+    { return __cont.rbegin(); }
+
+
+
+
+
+
+  template<typename _Container>
+    inline constexpr auto
+    rbegin(const _Container& __cont) -> decltype(__cont.rbegin())
+    { return __cont.rbegin(); }
+
+
+
+
+
+
+  template<typename _Container>
+    inline constexpr auto
+    rend(_Container& __cont) -> decltype(__cont.rend())
+    { return __cont.rend(); }
+
+
+
+
+
+
+  template<typename _Container>
+    inline constexpr auto
+    rend(const _Container& __cont) -> decltype(__cont.rend())
+    { return __cont.rend(); }
+
+
+
+
+
+
+  template<typename _Tp, size_t _Nm>
+    inline constexpr reverse_iterator<_Tp*>
+    rbegin(_Tp (&__arr)[_Nm])
+    { return reverse_iterator<_Tp*>(__arr + _Nm); }
+
+
+
+
+
+
+  template<typename _Tp, size_t _Nm>
+    inline constexpr reverse_iterator<_Tp*>
+    rend(_Tp (&__arr)[_Nm])
+    { return reverse_iterator<_Tp*>(__arr); }
+
+
+
+
+
+
+  template<typename _Tp>
+    inline constexpr reverse_iterator<const _Tp*>
+    rbegin(initializer_list<_Tp> __il)
+    { return reverse_iterator<const _Tp*>(__il.end()); }
+
+
+
+
+
+
+  template<typename _Tp>
+    inline constexpr reverse_iterator<const _Tp*>
+    rend(initializer_list<_Tp> __il)
+    { return reverse_iterator<const _Tp*>(__il.begin()); }
+
+
+
+
+
+
+  template<typename _Container>
+    inline constexpr auto
+    crbegin(const _Container& __cont) -> decltype(std::rbegin(__cont))
+    { return std::rbegin(__cont); }
+
+
+
+
+
+
+  template<typename _Container>
+    inline constexpr auto
+    crend(const _Container& __cont) -> decltype(std::rend(__cont))
+    { return std::rend(__cont); }
+
+
+
+
+#define __cpp_lib_nonmember_container_access 201411
+
+
+
+
+
+  template <typename _Container>
+    constexpr auto
+    size(const _Container& __cont) noexcept(noexcept(__cont.size()))
+    -> decltype(__cont.size())
+    { return __cont.size(); }
+
+
+
+
+  template <typename _Tp, size_t _Nm>
+    constexpr size_t
+    size(const _Tp (&)[_Nm]) noexcept
+    { return _Nm; }
+
+
+
+
+
+  template <typename _Container>
+    [[nodiscard]] constexpr auto
+    empty(const _Container& __cont) noexcept(noexcept(__cont.empty()))
+    -> decltype(__cont.empty())
+    { return __cont.empty(); }
+
+
+
+
+  template <typename _Tp, size_t _Nm>
+    [[nodiscard]] constexpr bool
+    empty(const _Tp (&)[_Nm]) noexcept
+    { return false; }
+
+
+
+
+
+  template <typename _Tp>
+    [[nodiscard]] constexpr bool
+    empty(initializer_list<_Tp> __il) noexcept
+    { return __il.size() == 0;}
+
+
+
+
+
+  template <typename _Container>
+    constexpr auto
+    data(_Container& __cont) noexcept(noexcept(__cont.data()))
+    -> decltype(__cont.data())
+    { return __cont.data(); }
+
+
+
+
+
+  template <typename _Container>
+    constexpr auto
+    data(const _Container& __cont) noexcept(noexcept(__cont.data()))
+    -> decltype(__cont.data())
+    { return __cont.data(); }
+
+
+
+
+
+  template <typename _Tp, size_t _Nm>
+    constexpr _Tp*
+    data(_Tp (&__array)[_Nm]) noexcept
+    { return __array; }
+
+
+
+
+
+  template <typename _Tp>
+    constexpr const _Tp*
+    data(initializer_list<_Tp> __il) noexcept
+    { return __il.begin(); }
+# 1143 "/usr/include/c++/10.2.0/bits/range_access.h" 3
+
+}
+# 55 "/usr/include/c++/10.2.0/string" 2 3
+# 1 "/usr/include/c++/10.2.0/bits/basic_string.h" 1 3
+# 35 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+#define _BASIC_STRING_H 1
+
+       
+# 38 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+
+# 1 "/usr/include/c++/10.2.0/ext/atomicity.h" 1 3
+# 30 "/usr/include/c++/10.2.0/ext/atomicity.h" 3
+#define _GLIBCXX_ATOMICITY_H 1
+
+       
+# 33 "/usr/include/c++/10.2.0/ext/atomicity.h" 3
+
+
+# 1 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/gthr.h" 1 3
+# 27 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/gthr.h" 3
+#define _GLIBCXX_GCC_GTHR_H 
+
+
+#pragma GCC visibility push(default)
+# 145 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/gthr.h" 3
+#define _GLIBCXX_GTHREAD_USE_WEAK 1
+
+
+# 1 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/gthr-default.h" 1 3
+# 27 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/gthr-default.h" 3
+#define _GLIBCXX_GCC_GTHR_POSIX_H 
+
+
+
+
+#define __GTHREADS 1
+#define __GTHREADS_CXX0X 1
+
+# 1 "/usr/include/pthread.h" 1 3 4
+# 19 "/usr/include/pthread.h" 3 4
+#define _PTHREAD_H 1
+
+
+# 1 "/usr/include/sched.h" 1 3 4
+# 20 "/usr/include/sched.h" 3 4
+#define _SCHED_H 1
+
+
+
+
+
+
+#define __need_size_t 
+#define __need_NULL 
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 1 3 4
+# 155 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef __need_ptrdiff_t
+# 231 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef __need_size_t
+# 340 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef __need_wchar_t
+# 390 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef NULL
+
+#define NULL __null
+# 401 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef __need_NULL
+
+
+
+
+#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
+# 30 "/usr/include/sched.h" 2 3 4
+# 43 "/usr/include/sched.h" 3 4
+# 1 "/usr/include/bits/sched.h" 1 3 4
+# 21 "/usr/include/bits/sched.h" 3 4
+#define _BITS_SCHED_H 1
+
+
+
+
+
+
+#define SCHED_OTHER 0
+#define SCHED_FIFO 1
+#define SCHED_RR 2
+
+#define SCHED_BATCH 3
+#define SCHED_ISO 4
+#define SCHED_IDLE 5
+#define SCHED_DEADLINE 6
+
+#define SCHED_RESET_ON_FORK 0x40000000
+
+
+
+
+#define CSIGNAL 0x000000ff
+#define CLONE_VM 0x00000100
+#define CLONE_FS 0x00000200
+#define CLONE_FILES 0x00000400
+#define CLONE_SIGHAND 0x00000800
+#define CLONE_PIDFD 0x00001000
+
+#define CLONE_PTRACE 0x00002000
+#define CLONE_VFORK 0x00004000
+
+#define CLONE_PARENT 0x00008000
+
+#define CLONE_THREAD 0x00010000
+#define CLONE_NEWNS 0x00020000
+#define CLONE_SYSVSEM 0x00040000
+#define CLONE_SETTLS 0x00080000
+#define CLONE_PARENT_SETTID 0x00100000
+
+#define CLONE_CHILD_CLEARTID 0x00200000
+
+#define CLONE_DETACHED 0x00400000
+#define CLONE_UNTRACED 0x00800000
+
+#define CLONE_CHILD_SETTID 0x01000000
+
+#define CLONE_NEWCGROUP 0x02000000
+#define CLONE_NEWUTS 0x04000000
+#define CLONE_NEWIPC 0x08000000
+#define CLONE_NEWUSER 0x10000000
+#define CLONE_NEWPID 0x20000000
+#define CLONE_NEWNET 0x40000000
+#define CLONE_IO 0x80000000
+
+
+# 1 "/usr/include/bits/types/struct_sched_param.h" 1 3 4
+# 20 "/usr/include/bits/types/struct_sched_param.h" 3 4
+#define _BITS_TYPES_STRUCT_SCHED_PARAM 1
+
+
+struct sched_param
+{
+  int sched_priority;
+};
+# 77 "/usr/include/bits/sched.h" 2 3 4
+
+extern "C" {
+
+
+
+extern int clone (int (*__fn) (void *__arg), void *__child_stack,
+    int __flags, void *__arg, ...) throw ();
+
+
+extern int unshare (int __flags) throw ();
+
+
+extern int sched_getcpu (void) throw ();
+
+
+extern int getcpu (unsigned int *, unsigned int *) throw ();
+
+
+extern int setns (int __fd, int __nstype) throw ();
+
+
+}
+# 44 "/usr/include/sched.h" 2 3 4
+# 1 "/usr/include/bits/cpu-set.h" 1 3 4
+# 21 "/usr/include/bits/cpu-set.h" 3 4
+#define _BITS_CPU_SET_H 1
+
+
+
+
+
+
+#define __CPU_SETSIZE 1024
+#define __NCPUBITS (8 * sizeof (__cpu_mask))
+
+
+typedef unsigned long int __cpu_mask;
+
+
+#define __CPUELT(cpu) ((cpu) / __NCPUBITS)
+#define __CPUMASK(cpu) ((__cpu_mask) 1 << ((cpu) % __NCPUBITS))
+
+
+typedef struct
+{
+  __cpu_mask __bits[1024 / (8 * sizeof (__cpu_mask))];
+} cpu_set_t;
+
+
+
+#define __CPU_ZERO_S(setsize,cpusetp) do __builtin_memset (cpusetp, '\0', setsize); while (0)
+# 58 "/usr/include/bits/cpu-set.h" 3 4
+#define __CPU_SET_S(cpu,setsize,cpusetp) (__extension__ ({ size_t __cpu = (cpu); __cpu / 8 < (setsize) ? (((__cpu_mask *) ((cpusetp)->__bits))[__CPUELT (__cpu)] |= __CPUMASK (__cpu)) : 0; }))
+
+
+
+
+
+
+#define __CPU_CLR_S(cpu,setsize,cpusetp) (__extension__ ({ size_t __cpu = (cpu); __cpu / 8 < (setsize) ? (((__cpu_mask *) ((cpusetp)->__bits))[__CPUELT (__cpu)] &= ~__CPUMASK (__cpu)) : 0; }))
+
+
+
+
+
+
+#define __CPU_ISSET_S(cpu,setsize,cpusetp) (__extension__ ({ size_t __cpu = (cpu); __cpu / 8 < (setsize) ? ((((const __cpu_mask *) ((cpusetp)->__bits))[__CPUELT (__cpu)] & __CPUMASK (__cpu))) != 0 : 0; }))
+
+
+
+
+
+
+
+#define __CPU_COUNT_S(setsize,cpusetp) __sched_cpucount (setsize, cpusetp)
+
+
+
+#define __CPU_EQUAL_S(setsize,cpusetp1,cpusetp2) (__builtin_memcmp (cpusetp1, cpusetp2, setsize) == 0)
+# 99 "/usr/include/bits/cpu-set.h" 3 4
+#define __CPU_OP_S(setsize,destset,srcset1,srcset2,op) (__extension__ ({ cpu_set_t *__dest = (destset); const __cpu_mask *__arr1 = (srcset1)->__bits; const __cpu_mask *__arr2 = (srcset2)->__bits; size_t __imax = (setsize) / sizeof (__cpu_mask); size_t __i; for (__i = 0; __i < __imax; ++__i) ((__cpu_mask *) __dest->__bits)[__i] = __arr1[__i] op __arr2[__i]; __dest; }))
+# 110 "/usr/include/bits/cpu-set.h" 3 4
+#define __CPU_ALLOC_SIZE(count) ((((count) + __NCPUBITS - 1) / __NCPUBITS) * sizeof (__cpu_mask))
+
+#define __CPU_ALLOC(count) __sched_cpualloc (count)
+#define __CPU_FREE(cpuset) __sched_cpufree (cpuset)
+
+extern "C" {
+
+extern int __sched_cpucount (size_t __setsize, const cpu_set_t *__setp)
+     throw ();
+extern cpu_set_t *__sched_cpualloc (size_t __count) throw () ;
+extern void __sched_cpufree (cpu_set_t *__set) throw ();
+
+}
+# 45 "/usr/include/sched.h" 2 3 4
+
+
+#define sched_priority sched_priority
+#define __sched_priority sched_priority
+
+
+extern "C" {
+
+
+extern int sched_setparam (__pid_t __pid, const struct sched_param *__param)
+     throw ();
+
+
+extern int sched_getparam (__pid_t __pid, struct sched_param *__param) throw ();
+
+
+extern int sched_setscheduler (__pid_t __pid, int __policy,
+          const struct sched_param *__param) throw ();
+
+
+extern int sched_getscheduler (__pid_t __pid) throw ();
+
+
+extern int sched_yield (void) throw ();
+
+
+extern int sched_get_priority_max (int __algorithm) throw ();
+
+
+extern int sched_get_priority_min (int __algorithm) throw ();
+
+
+extern int sched_rr_get_interval (__pid_t __pid, struct timespec *__t) throw ();
+
+
+
+
+#define CPU_SETSIZE __CPU_SETSIZE
+#define CPU_SET(cpu,cpusetp) __CPU_SET_S (cpu, sizeof (cpu_set_t), cpusetp)
+#define CPU_CLR(cpu,cpusetp) __CPU_CLR_S (cpu, sizeof (cpu_set_t), cpusetp)
+#define CPU_ISSET(cpu,cpusetp) __CPU_ISSET_S (cpu, sizeof (cpu_set_t), cpusetp)
+
+#define CPU_ZERO(cpusetp) __CPU_ZERO_S (sizeof (cpu_set_t), cpusetp)
+#define CPU_COUNT(cpusetp) __CPU_COUNT_S (sizeof (cpu_set_t), cpusetp)
+
+#define CPU_SET_S(cpu,setsize,cpusetp) __CPU_SET_S (cpu, setsize, cpusetp)
+#define CPU_CLR_S(cpu,setsize,cpusetp) __CPU_CLR_S (cpu, setsize, cpusetp)
+#define CPU_ISSET_S(cpu,setsize,cpusetp) __CPU_ISSET_S (cpu, setsize, cpusetp)
+
+#define CPU_ZERO_S(setsize,cpusetp) __CPU_ZERO_S (setsize, cpusetp)
+#define CPU_COUNT_S(setsize,cpusetp) __CPU_COUNT_S (setsize, cpusetp)
+
+#define CPU_EQUAL(cpusetp1,cpusetp2) __CPU_EQUAL_S (sizeof (cpu_set_t), cpusetp1, cpusetp2)
+
+#define CPU_EQUAL_S(setsize,cpusetp1,cpusetp2) __CPU_EQUAL_S (setsize, cpusetp1, cpusetp2)
+
+
+#define CPU_AND(destset,srcset1,srcset2) __CPU_OP_S (sizeof (cpu_set_t), destset, srcset1, srcset2, &)
+
+#define CPU_OR(destset,srcset1,srcset2) __CPU_OP_S (sizeof (cpu_set_t), destset, srcset1, srcset2, |)
+
+#define CPU_XOR(destset,srcset1,srcset2) __CPU_OP_S (sizeof (cpu_set_t), destset, srcset1, srcset2, ^)
+
+#define CPU_AND_S(setsize,destset,srcset1,srcset2) __CPU_OP_S (setsize, destset, srcset1, srcset2, &)
+
+#define CPU_OR_S(setsize,destset,srcset1,srcset2) __CPU_OP_S (setsize, destset, srcset1, srcset2, |)
+
+#define CPU_XOR_S(setsize,destset,srcset1,srcset2) __CPU_OP_S (setsize, destset, srcset1, srcset2, ^)
+
+
+#define CPU_ALLOC_SIZE(count) __CPU_ALLOC_SIZE (count)
+#define CPU_ALLOC(count) __CPU_ALLOC (count)
+#define CPU_FREE(cpuset) __CPU_FREE (cpuset)
+
+
+
+extern int sched_setaffinity (__pid_t __pid, size_t __cpusetsize,
+         const cpu_set_t *__cpuset) throw ();
+
+
+extern int sched_getaffinity (__pid_t __pid, size_t __cpusetsize,
+         cpu_set_t *__cpuset) throw ();
+
+
+}
+# 23 "/usr/include/pthread.h" 2 3 4
+# 1 "/usr/include/time.h" 1 3 4
+# 23 "/usr/include/time.h" 3 4
+#define _TIME_H 1
+
+
+
+#define __need_size_t 
+#define __need_NULL 
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 1 3 4
+# 155 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef __need_ptrdiff_t
+# 231 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef __need_size_t
+# 340 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef __need_wchar_t
+# 390 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef NULL
+
+#define NULL __null
+# 401 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef __need_NULL
+
+
+
+
+#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
+# 30 "/usr/include/time.h" 2 3 4
+
+
+
+# 1 "/usr/include/bits/time.h" 1 3 4
+# 24 "/usr/include/bits/time.h" 3 4
+#define _BITS_TIME_H 1
+# 34 "/usr/include/bits/time.h" 3 4
+#define CLOCKS_PER_SEC ((__clock_t) 1000000)
+# 46 "/usr/include/bits/time.h" 3 4
+#define CLOCK_REALTIME 0
+
+#define CLOCK_MONOTONIC 1
+
+#define CLOCK_PROCESS_CPUTIME_ID 2
+
+#define CLOCK_THREAD_CPUTIME_ID 3
+
+#define CLOCK_MONOTONIC_RAW 4
+
+#define CLOCK_REALTIME_COARSE 5
+
+#define CLOCK_MONOTONIC_COARSE 6
+
+#define CLOCK_BOOTTIME 7
+
+#define CLOCK_REALTIME_ALARM 8
+
+#define CLOCK_BOOTTIME_ALARM 9
+
+#define CLOCK_TAI 11
+
+
+#define TIMER_ABSTIME 1
+
+
+
+# 1 "/usr/include/bits/timex.h" 1 3 4
+# 19 "/usr/include/bits/timex.h" 3 4
+#define _BITS_TIMEX_H 1
+
+
+
+
+
+
+struct timex
+{
+  unsigned int modes;
+  __syscall_slong_t offset;
+  __syscall_slong_t freq;
+  __syscall_slong_t maxerror;
+  __syscall_slong_t esterror;
+  int status;
+  __syscall_slong_t constant;
+  __syscall_slong_t precision;
+  __syscall_slong_t tolerance;
+  struct timeval time;
+  __syscall_slong_t tick;
+  __syscall_slong_t ppsfreq;
+  __syscall_slong_t jitter;
+  int shift;
+  __syscall_slong_t stabil;
+  __syscall_slong_t jitcnt;
+  __syscall_slong_t calcnt;
+  __syscall_slong_t errcnt;
+  __syscall_slong_t stbcnt;
+
+  int tai;
+
+
+  int :32; int :32; int :32; int :32;
+  int :32; int :32; int :32; int :32;
+  int :32; int :32; int :32;
+};
+
+
+#define ADJ_OFFSET 0x0001
+#define ADJ_FREQUENCY 0x0002
+#define ADJ_MAXERROR 0x0004
+#define ADJ_ESTERROR 0x0008
+#define ADJ_STATUS 0x0010
+#define ADJ_TIMECONST 0x0020
+#define ADJ_TAI 0x0080
+#define ADJ_SETOFFSET 0x0100
+#define ADJ_MICRO 0x1000
+#define ADJ_NANO 0x2000
+#define ADJ_TICK 0x4000
+#define ADJ_OFFSET_SINGLESHOT 0x8001
+#define ADJ_OFFSET_SS_READ 0xa001
+
+
+#define MOD_OFFSET ADJ_OFFSET
+#define MOD_FREQUENCY ADJ_FREQUENCY
+#define MOD_MAXERROR ADJ_MAXERROR
+#define MOD_ESTERROR ADJ_ESTERROR
+#define MOD_STATUS ADJ_STATUS
+#define MOD_TIMECONST ADJ_TIMECONST
+#define MOD_CLKB ADJ_TICK
+#define MOD_CLKA ADJ_OFFSET_SINGLESHOT
+#define MOD_TAI ADJ_TAI
+#define MOD_MICRO ADJ_MICRO
+#define MOD_NANO ADJ_NANO
+
+
+
+#define STA_PLL 0x0001
+#define STA_PPSFREQ 0x0002
+#define STA_PPSTIME 0x0004
+#define STA_FLL 0x0008
+
+#define STA_INS 0x0010
+#define STA_DEL 0x0020
+#define STA_UNSYNC 0x0040
+#define STA_FREQHOLD 0x0080
+
+#define STA_PPSSIGNAL 0x0100
+#define STA_PPSJITTER 0x0200
+#define STA_PPSWANDER 0x0400
+#define STA_PPSERROR 0x0800
+
+#define STA_CLOCKERR 0x1000
+#define STA_NANO 0x2000
+#define STA_MODE 0x4000
+#define STA_CLK 0x8000
+
+
+#define STA_RONLY (STA_PPSSIGNAL | STA_PPSJITTER | STA_PPSWANDER | STA_PPSERROR | STA_CLOCKERR | STA_NANO | STA_MODE | STA_CLK)
+# 74 "/usr/include/bits/time.h" 2 3 4
+
+extern "C" {
+
+
+extern int clock_adjtime (__clockid_t __clock_id, struct timex *__utx) throw ();
+
+}
+# 34 "/usr/include/time.h" 2 3 4
+
+
+
+
+
+# 1 "/usr/include/bits/types/struct_tm.h" 1 3 4
+
+#define __struct_tm_defined 1
+
+
+
+
+struct tm
+{
+  int tm_sec;
+  int tm_min;
+  int tm_hour;
+  int tm_mday;
+  int tm_mon;
+  int tm_year;
+  int tm_wday;
+  int tm_yday;
+  int tm_isdst;
+
+
+  long int tm_gmtoff;
+  const char *tm_zone;
+
+
+
+
+};
+# 40 "/usr/include/time.h" 2 3 4
+# 48 "/usr/include/time.h" 3 4
+# 1 "/usr/include/bits/types/struct_itimerspec.h" 1 3 4
+
+#define __itimerspec_defined 1
+
+
+
+
+
+struct itimerspec
+  {
+    struct timespec it_interval;
+    struct timespec it_value;
+  };
+# 49 "/usr/include/time.h" 2 3 4
+struct sigevent;
+# 65 "/usr/include/time.h" 3 4
+#define TIME_UTC 1
+
+
+extern "C" {
+
+
+
+extern clock_t clock (void) throw ();
+
+
+extern time_t time (time_t *__timer) throw ();
+
+
+extern double difftime (time_t __time1, time_t __time0)
+     throw () __attribute__ ((__const__));
+
+
+extern time_t mktime (struct tm *__tp) throw ();
+
+
+
+
+
+extern size_t strftime (char *__restrict __s, size_t __maxsize,
+   const char *__restrict __format,
+   const struct tm *__restrict __tp) throw ();
+
+
+
+
+extern char *strptime (const char *__restrict __s,
+         const char *__restrict __fmt, struct tm *__tp)
+     throw ();
+
+
+
+
+
+
+extern size_t strftime_l (char *__restrict __s, size_t __maxsize,
+     const char *__restrict __format,
+     const struct tm *__restrict __tp,
+     locale_t __loc) throw ();
+
+
+
+extern char *strptime_l (const char *__restrict __s,
+    const char *__restrict __fmt, struct tm *__tp,
+    locale_t __loc) throw ();
+
+
+
+
+
+extern struct tm *gmtime (const time_t *__timer) throw ();
+
+
+
+extern struct tm *localtime (const time_t *__timer) throw ();
+
+
+
+
+extern struct tm *gmtime_r (const time_t *__restrict __timer,
+       struct tm *__restrict __tp) throw ();
+
+
+
+extern struct tm *localtime_r (const time_t *__restrict __timer,
+          struct tm *__restrict __tp) throw ();
+
+
+
+
+extern char *asctime (const struct tm *__tp) throw ();
+
+
+extern char *ctime (const time_t *__timer) throw ();
+
+
+
+
+
+
+extern char *asctime_r (const struct tm *__restrict __tp,
+   char *__restrict __buf) throw ();
+
+
+extern char *ctime_r (const time_t *__restrict __timer,
+        char *__restrict __buf) throw ();
+
+
+
+
+extern char *__tzname[2];
+extern int __daylight;
+extern long int __timezone;
+
+
+
+
+extern char *tzname[2];
+
+
+
+extern void tzset (void) throw ();
+
+
+
+extern int daylight;
+extern long int timezone;
+
+
+
+
+
+#define __isleap(year) ((year) % 4 == 0 && ((year) % 100 != 0 || (year) % 400 == 0))
+# 190 "/usr/include/time.h" 3 4
+extern time_t timegm (struct tm *__tp) throw ();
+
+
+extern time_t timelocal (struct tm *__tp) throw ();
+
+
+extern int dysize (int __year) throw () __attribute__ ((__const__));
+# 205 "/usr/include/time.h" 3 4
+extern int nanosleep (const struct timespec *__requested_time,
+        struct timespec *__remaining);
+
+
+
+extern int clock_getres (clockid_t __clock_id, struct timespec *__res) throw ();
+
+
+extern int clock_gettime (clockid_t __clock_id, struct timespec *__tp) throw ();
+
+
+extern int clock_settime (clockid_t __clock_id, const struct timespec *__tp)
+     throw ();
+
+
+
+
+
+
+extern int clock_nanosleep (clockid_t __clock_id, int __flags,
+       const struct timespec *__req,
+       struct timespec *__rem);
+
+
+extern int clock_getcpuclockid (pid_t __pid, clockid_t *__clock_id) throw ();
+
+
+
+
+extern int timer_create (clockid_t __clock_id,
+    struct sigevent *__restrict __evp,
+    timer_t *__restrict __timerid) throw ();
+
+
+extern int timer_delete (timer_t __timerid) throw ();
+
+
+extern int timer_settime (timer_t __timerid, int __flags,
+     const struct itimerspec *__restrict __value,
+     struct itimerspec *__restrict __ovalue) throw ();
+
+
+extern int timer_gettime (timer_t __timerid, struct itimerspec *__value)
+     throw ();
+
+
+extern int timer_getoverrun (timer_t __timerid) throw ();
+
+
+
+
+
+extern int timespec_get (struct timespec *__ts, int __base)
+     throw () __attribute__ ((__nonnull__ (1)));
+# 274 "/usr/include/time.h" 3 4
+extern int getdate_err;
+# 283 "/usr/include/time.h" 3 4
+extern struct tm *getdate (const char *__string);
+# 297 "/usr/include/time.h" 3 4
+extern int getdate_r (const char *__restrict __string,
+        struct tm *__restrict __resbufp);
+
+
+}
+# 24 "/usr/include/pthread.h" 2 3 4
+
+
+
+# 1 "/usr/include/bits/setjmp.h" 1 3 4
+# 20 "/usr/include/bits/setjmp.h" 3 4
+#define _BITS_SETJMP_H 1
+
+
+
+
+
+# 1 "/usr/include/bits/wordsize.h" 1 3 4
+
+
+
+#define __WORDSIZE 64
+
+
+
+
+
+
+
+#define __WORDSIZE_TIME64_COMPAT32 1
+
+#define __SYSCALL_WORDSIZE 64
+# 27 "/usr/include/bits/setjmp.h" 2 3 4
+
+
+
+
+typedef long int __jmp_buf[8];
+# 28 "/usr/include/pthread.h" 2 3 4
+# 1 "/usr/include/bits/wordsize.h" 1 3 4
+
+
+
+#define __WORDSIZE 64
+
+
+
+
+
+
+
+#define __WORDSIZE_TIME64_COMPAT32 1
+
+#define __SYSCALL_WORDSIZE 64
+# 29 "/usr/include/pthread.h" 2 3 4
+
+
+
+
+
+enum
+{
+  PTHREAD_CREATE_JOINABLE,
+#define PTHREAD_CREATE_JOINABLE PTHREAD_CREATE_JOINABLE
+  PTHREAD_CREATE_DETACHED
+#define PTHREAD_CREATE_DETACHED PTHREAD_CREATE_DETACHED
+};
+
+
+
+enum
+{
+  PTHREAD_MUTEX_TIMED_NP,
+  PTHREAD_MUTEX_RECURSIVE_NP,
+  PTHREAD_MUTEX_ERRORCHECK_NP,
+  PTHREAD_MUTEX_ADAPTIVE_NP
+
+  ,
+  PTHREAD_MUTEX_NORMAL = PTHREAD_MUTEX_TIMED_NP,
+  PTHREAD_MUTEX_RECURSIVE = PTHREAD_MUTEX_RECURSIVE_NP,
+  PTHREAD_MUTEX_ERRORCHECK = PTHREAD_MUTEX_ERRORCHECK_NP,
+  PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL
+
+
+
+  , PTHREAD_MUTEX_FAST_NP = PTHREAD_MUTEX_TIMED_NP
+
+};
+
+
+
+
+enum
+{
+  PTHREAD_MUTEX_STALLED,
+  PTHREAD_MUTEX_STALLED_NP = PTHREAD_MUTEX_STALLED,
+  PTHREAD_MUTEX_ROBUST,
+  PTHREAD_MUTEX_ROBUST_NP = PTHREAD_MUTEX_ROBUST
+};
+
+
+
+
+
+enum
+{
+  PTHREAD_PRIO_NONE,
+  PTHREAD_PRIO_INHERIT,
+  PTHREAD_PRIO_PROTECT
+};
+
+
+
+#define PTHREAD_MUTEX_INITIALIZER { { __PTHREAD_MUTEX_INITIALIZER (PTHREAD_MUTEX_TIMED_NP) } }
+
+
+#define PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP { { __PTHREAD_MUTEX_INITIALIZER (PTHREAD_MUTEX_RECURSIVE_NP) } }
+
+#define PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP { { __PTHREAD_MUTEX_INITIALIZER (PTHREAD_MUTEX_ERRORCHECK_NP) } }
+
+#define PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP { { __PTHREAD_MUTEX_INITIALIZER (PTHREAD_MUTEX_ADAPTIVE_NP) } }
+
+
+
+
+
+
+enum
+{
+  PTHREAD_RWLOCK_PREFER_READER_NP,
+  PTHREAD_RWLOCK_PREFER_WRITER_NP,
+  PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP,
+  PTHREAD_RWLOCK_DEFAULT_NP = PTHREAD_RWLOCK_PREFER_READER_NP
+};
+
+
+
+#define PTHREAD_RWLOCK_INITIALIZER { { __PTHREAD_RWLOCK_INITIALIZER (PTHREAD_RWLOCK_DEFAULT_NP) } }
+
+
+#define PTHREAD_RWLOCK_WRITER_NONRECURSIVE_INITIALIZER_NP { { __PTHREAD_RWLOCK_INITIALIZER (PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP) } }
+
+
+
+
+
+
+enum
+{
+  PTHREAD_INHERIT_SCHED,
+#define PTHREAD_INHERIT_SCHED PTHREAD_INHERIT_SCHED
+  PTHREAD_EXPLICIT_SCHED
+#define PTHREAD_EXPLICIT_SCHED PTHREAD_EXPLICIT_SCHED
+};
+
+
+
+enum
+{
+  PTHREAD_SCOPE_SYSTEM,
+#define PTHREAD_SCOPE_SYSTEM PTHREAD_SCOPE_SYSTEM
+  PTHREAD_SCOPE_PROCESS
+#define PTHREAD_SCOPE_PROCESS PTHREAD_SCOPE_PROCESS
+};
+
+
+
+enum
+{
+  PTHREAD_PROCESS_PRIVATE,
+#define PTHREAD_PROCESS_PRIVATE PTHREAD_PROCESS_PRIVATE
+  PTHREAD_PROCESS_SHARED
+#define PTHREAD_PROCESS_SHARED PTHREAD_PROCESS_SHARED
+};
+
+
+
+
+#define PTHREAD_COND_INITIALIZER { { {0}, {0}, {0, 0}, {0, 0}, 0, 0, {0, 0} } }
+
+
+
+struct _pthread_cleanup_buffer
+{
+  void (*__routine) (void *);
+  void *__arg;
+  int __canceltype;
+  struct _pthread_cleanup_buffer *__prev;
+};
+
+
+enum
+{
+  PTHREAD_CANCEL_ENABLE,
+#define PTHREAD_CANCEL_ENABLE PTHREAD_CANCEL_ENABLE
+  PTHREAD_CANCEL_DISABLE
+#define PTHREAD_CANCEL_DISABLE PTHREAD_CANCEL_DISABLE
+};
+enum
+{
+  PTHREAD_CANCEL_DEFERRED,
+#define PTHREAD_CANCEL_DEFERRED PTHREAD_CANCEL_DEFERRED
+  PTHREAD_CANCEL_ASYNCHRONOUS
+#define PTHREAD_CANCEL_ASYNCHRONOUS PTHREAD_CANCEL_ASYNCHRONOUS
+};
+#define PTHREAD_CANCELED ((void *) -1)
+
+
+
+#define PTHREAD_ONCE_INIT 0
+
+
+
+
+
+
+#define PTHREAD_BARRIER_SERIAL_THREAD -1
+
+
+
+extern "C" {
+
+
+
+
+extern int pthread_create (pthread_t *__restrict __newthread,
+      const pthread_attr_t *__restrict __attr,
+      void *(*__start_routine) (void *),
+      void *__restrict __arg) throw () __attribute__ ((__nonnull__ (1, 3)));
+
+
+
+
+
+extern void pthread_exit (void *__retval) __attribute__ ((__noreturn__));
+
+
+
+
+
+
+
+extern int pthread_join (pthread_t __th, void **__thread_return);
+
+
+
+
+extern int pthread_tryjoin_np (pthread_t __th, void **__thread_return) throw ();
+
+
+
+
+
+
+
+extern int pthread_timedjoin_np (pthread_t __th, void **__thread_return,
+     const struct timespec *__abstime);
+# 239 "/usr/include/pthread.h" 3 4
+extern int pthread_clockjoin_np (pthread_t __th, void **__thread_return,
+                                 clockid_t __clockid,
+     const struct timespec *__abstime);
+
+
+
+
+
+
+extern int pthread_detach (pthread_t __th) throw ();
+
+
+
+extern pthread_t pthread_self (void) throw () __attribute__ ((__const__));
+
+
+extern int pthread_equal (pthread_t __thread1, pthread_t __thread2)
+  throw () __attribute__ ((__const__));
+
+
+
+
+
+
+
+extern int pthread_attr_init (pthread_attr_t *__attr) throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_attr_destroy (pthread_attr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_attr_getdetachstate (const pthread_attr_t *__attr,
+     int *__detachstate)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_attr_setdetachstate (pthread_attr_t *__attr,
+     int __detachstate)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int pthread_attr_getguardsize (const pthread_attr_t *__attr,
+          size_t *__guardsize)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_attr_setguardsize (pthread_attr_t *__attr,
+          size_t __guardsize)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int pthread_attr_getschedparam (const pthread_attr_t *__restrict __attr,
+           struct sched_param *__restrict __param)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_attr_setschedparam (pthread_attr_t *__restrict __attr,
+           const struct sched_param *__restrict
+           __param) throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_attr_getschedpolicy (const pthread_attr_t *__restrict
+     __attr, int *__restrict __policy)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_attr_setschedpolicy (pthread_attr_t *__attr, int __policy)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_attr_getinheritsched (const pthread_attr_t *__restrict
+      __attr, int *__restrict __inherit)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_attr_setinheritsched (pthread_attr_t *__attr,
+      int __inherit)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int pthread_attr_getscope (const pthread_attr_t *__restrict __attr,
+      int *__restrict __scope)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_attr_setscope (pthread_attr_t *__attr, int __scope)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_attr_getstackaddr (const pthread_attr_t *__restrict
+          __attr, void **__restrict __stackaddr)
+     throw () __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__deprecated__));
+
+
+
+
+
+extern int pthread_attr_setstackaddr (pthread_attr_t *__attr,
+          void *__stackaddr)
+     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__));
+
+
+extern int pthread_attr_getstacksize (const pthread_attr_t *__restrict
+          __attr, size_t *__restrict __stacksize)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+extern int pthread_attr_setstacksize (pthread_attr_t *__attr,
+          size_t __stacksize)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int pthread_attr_getstack (const pthread_attr_t *__restrict __attr,
+      void **__restrict __stackaddr,
+      size_t *__restrict __stacksize)
+     throw () __attribute__ ((__nonnull__ (1, 2, 3)));
+
+
+
+
+extern int pthread_attr_setstack (pthread_attr_t *__attr, void *__stackaddr,
+      size_t __stacksize) throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+extern int pthread_attr_setaffinity_np (pthread_attr_t *__attr,
+     size_t __cpusetsize,
+     const cpu_set_t *__cpuset)
+     throw () __attribute__ ((__nonnull__ (1, 3)));
+
+
+
+extern int pthread_attr_getaffinity_np (const pthread_attr_t *__attr,
+     size_t __cpusetsize,
+     cpu_set_t *__cpuset)
+     throw () __attribute__ ((__nonnull__ (1, 3)));
+
+
+extern int pthread_getattr_default_np (pthread_attr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_attr_setsigmask_np (pthread_attr_t *__attr,
+           const __sigset_t *sigmask);
+
+
+
+
+extern int pthread_attr_getsigmask_np (const pthread_attr_t *__attr,
+           __sigset_t *sigmask);
+
+
+
+#define PTHREAD_ATTR_NO_SIGMASK_NP (-1)
+
+
+
+extern int pthread_setattr_default_np (const pthread_attr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+extern int pthread_getattr_np (pthread_t __th, pthread_attr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (2)));
+
+
+
+
+
+
+
+extern int pthread_setschedparam (pthread_t __target_thread, int __policy,
+      const struct sched_param *__param)
+     throw () __attribute__ ((__nonnull__ (3)));
+
+
+extern int pthread_getschedparam (pthread_t __target_thread,
+      int *__restrict __policy,
+      struct sched_param *__restrict __param)
+     throw () __attribute__ ((__nonnull__ (2, 3)));
+
+
+extern int pthread_setschedprio (pthread_t __target_thread, int __prio)
+     throw ();
+
+
+
+
+extern int pthread_getname_np (pthread_t __target_thread, char *__buf,
+          size_t __buflen)
+     throw () __attribute__ ((__nonnull__ (2)));
+
+
+extern int pthread_setname_np (pthread_t __target_thread, const char *__name)
+     throw () __attribute__ ((__nonnull__ (2)));
+
+
+
+
+
+extern int pthread_getconcurrency (void) throw ();
+
+
+extern int pthread_setconcurrency (int __level) throw ();
+
+
+
+
+
+
+
+extern int pthread_yield (void) throw ();
+
+
+
+
+extern int pthread_setaffinity_np (pthread_t __th, size_t __cpusetsize,
+       const cpu_set_t *__cpuset)
+     throw () __attribute__ ((__nonnull__ (3)));
+
+
+extern int pthread_getaffinity_np (pthread_t __th, size_t __cpusetsize,
+       cpu_set_t *__cpuset)
+     throw () __attribute__ ((__nonnull__ (3)));
+# 485 "/usr/include/pthread.h" 3 4
+extern int pthread_once (pthread_once_t *__once_control,
+    void (*__init_routine) (void)) __attribute__ ((__nonnull__ (1, 2)));
+# 497 "/usr/include/pthread.h" 3 4
+extern int pthread_setcancelstate (int __state, int *__oldstate);
+
+
+
+extern int pthread_setcanceltype (int __type, int *__oldtype);
+
+
+extern int pthread_cancel (pthread_t __th);
+
+
+
+
+extern void pthread_testcancel (void);
+
+
+
+
+typedef struct
+{
+  struct
+  {
+    __jmp_buf __cancel_jmp_buf;
+    int __mask_was_saved;
+  } __cancel_jmp_buf[1];
+  void *__pad[4];
+} __pthread_unwind_buf_t __attribute__ ((__aligned__));
+
+
+
+#define __cleanup_fct_attribute 
+
+
+
+
+struct __pthread_cleanup_frame
+{
+  void (*__cancel_routine) (void *);
+  void *__cancel_arg;
+  int __do_it;
+  int __cancel_type;
+};
+
+
+
+
+class __pthread_cleanup_class
+{
+  void (*__cancel_routine) (void *);
+  void *__cancel_arg;
+  int __do_it;
+  int __cancel_type;
+
+ public:
+  __pthread_cleanup_class (void (*__fct) (void *), void *__arg)
+    : __cancel_routine (__fct), __cancel_arg (__arg), __do_it (1) { }
+  ~__pthread_cleanup_class () { if (__do_it) __cancel_routine (__cancel_arg); }
+  void __setdoit (int __newval) { __do_it = __newval; }
+  void __defer () { pthread_setcanceltype (PTHREAD_CANCEL_DEFERRED,
+        &__cancel_type); }
+  void __restore () const { pthread_setcanceltype (__cancel_type, 0); }
+};
+# 566 "/usr/include/pthread.h" 3 4
+#define pthread_cleanup_push(routine,arg) do { __pthread_cleanup_class __clframe (routine, arg)
+
+
+
+
+
+#define pthread_cleanup_pop(execute) __clframe.__setdoit (execute); } while (0)
+
+
+
+
+
+
+
+#define pthread_cleanup_push_defer_np(routine,arg) do { __pthread_cleanup_class __clframe (routine, arg); __clframe.__defer ()
+
+
+
+
+
+
+
+#define pthread_cleanup_pop_restore_np(execute) __clframe.__restore (); __clframe.__setdoit (execute); } while (0)
+# 733 "/usr/include/pthread.h" 3 4
+struct __jmp_buf_tag;
+extern int __sigsetjmp (struct __jmp_buf_tag *__env, int __savemask) throw ();
+
+
+
+
+
+extern int pthread_mutex_init (pthread_mutex_t *__mutex,
+          const pthread_mutexattr_t *__mutexattr)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_mutex_destroy (pthread_mutex_t *__mutex)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_mutex_trylock (pthread_mutex_t *__mutex)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_mutex_lock (pthread_mutex_t *__mutex)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int pthread_mutex_timedlock (pthread_mutex_t *__restrict __mutex,
+        const struct timespec *__restrict
+        __abstime) throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+extern int pthread_mutex_clocklock (pthread_mutex_t *__restrict __mutex,
+        clockid_t __clockid,
+        const struct timespec *__restrict
+        __abstime) throw () __attribute__ ((__nonnull__ (1, 3)));
+
+
+
+extern int pthread_mutex_unlock (pthread_mutex_t *__mutex)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int pthread_mutex_getprioceiling (const pthread_mutex_t *
+      __restrict __mutex,
+      int *__restrict __prioceiling)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+extern int pthread_mutex_setprioceiling (pthread_mutex_t *__restrict __mutex,
+      int __prioceiling,
+      int *__restrict __old_ceiling)
+     throw () __attribute__ ((__nonnull__ (1, 3)));
+
+
+
+
+extern int pthread_mutex_consistent (pthread_mutex_t *__mutex)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+extern int pthread_mutex_consistent_np (pthread_mutex_t *__mutex)
+     throw () __attribute__ ((__nonnull__ (1)));
+# 804 "/usr/include/pthread.h" 3 4
+extern int pthread_mutexattr_init (pthread_mutexattr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_mutexattr_destroy (pthread_mutexattr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_mutexattr_getpshared (const pthread_mutexattr_t *
+      __restrict __attr,
+      int *__restrict __pshared)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_mutexattr_setpshared (pthread_mutexattr_t *__attr,
+      int __pshared)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int pthread_mutexattr_gettype (const pthread_mutexattr_t *__restrict
+          __attr, int *__restrict __kind)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+extern int pthread_mutexattr_settype (pthread_mutexattr_t *__attr, int __kind)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int pthread_mutexattr_getprotocol (const pthread_mutexattr_t *
+       __restrict __attr,
+       int *__restrict __protocol)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+extern int pthread_mutexattr_setprotocol (pthread_mutexattr_t *__attr,
+       int __protocol)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_mutexattr_getprioceiling (const pthread_mutexattr_t *
+          __restrict __attr,
+          int *__restrict __prioceiling)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_mutexattr_setprioceiling (pthread_mutexattr_t *__attr,
+          int __prioceiling)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int pthread_mutexattr_getrobust (const pthread_mutexattr_t *__attr,
+     int *__robustness)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+extern int pthread_mutexattr_getrobust_np (const pthread_mutexattr_t *__attr,
+        int *__robustness)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+extern int pthread_mutexattr_setrobust (pthread_mutexattr_t *__attr,
+     int __robustness)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+extern int pthread_mutexattr_setrobust_np (pthread_mutexattr_t *__attr,
+        int __robustness)
+     throw () __attribute__ ((__nonnull__ (1)));
+# 886 "/usr/include/pthread.h" 3 4
+extern int pthread_rwlock_init (pthread_rwlock_t *__restrict __rwlock,
+    const pthread_rwlockattr_t *__restrict
+    __attr) throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_rwlock_destroy (pthread_rwlock_t *__rwlock)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock)
+  throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int pthread_rwlock_timedrdlock (pthread_rwlock_t *__restrict __rwlock,
+           const struct timespec *__restrict
+           __abstime) throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+extern int pthread_rwlock_clockrdlock (pthread_rwlock_t *__restrict __rwlock,
+           clockid_t __clockid,
+           const struct timespec *__restrict
+           __abstime) throw () __attribute__ ((__nonnull__ (1, 3)));
+
+
+
+extern int pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_rwlock_trywrlock (pthread_rwlock_t *__rwlock)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int pthread_rwlock_timedwrlock (pthread_rwlock_t *__restrict __rwlock,
+           const struct timespec *__restrict
+           __abstime) throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+extern int pthread_rwlock_clockwrlock (pthread_rwlock_t *__restrict __rwlock,
+           clockid_t __clockid,
+           const struct timespec *__restrict
+           __abstime) throw () __attribute__ ((__nonnull__ (1, 3)));
+
+
+
+extern int pthread_rwlock_unlock (pthread_rwlock_t *__rwlock)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+extern int pthread_rwlockattr_init (pthread_rwlockattr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_rwlockattr_destroy (pthread_rwlockattr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_rwlockattr_getpshared (const pthread_rwlockattr_t *
+       __restrict __attr,
+       int *__restrict __pshared)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_rwlockattr_setpshared (pthread_rwlockattr_t *__attr,
+       int __pshared)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_rwlockattr_getkind_np (const pthread_rwlockattr_t *
+       __restrict __attr,
+       int *__restrict __pref)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_rwlockattr_setkind_np (pthread_rwlockattr_t *__attr,
+       int __pref) throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+
+extern int pthread_cond_init (pthread_cond_t *__restrict __cond,
+         const pthread_condattr_t *__restrict __cond_attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_cond_destroy (pthread_cond_t *__cond)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_cond_signal (pthread_cond_t *__cond)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_cond_broadcast (pthread_cond_t *__cond)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+extern int pthread_cond_wait (pthread_cond_t *__restrict __cond,
+         pthread_mutex_t *__restrict __mutex)
+     __attribute__ ((__nonnull__ (1, 2)));
+# 1012 "/usr/include/pthread.h" 3 4
+extern int pthread_cond_timedwait (pthread_cond_t *__restrict __cond,
+       pthread_mutex_t *__restrict __mutex,
+       const struct timespec *__restrict __abstime)
+     __attribute__ ((__nonnull__ (1, 2, 3)));
+# 1025 "/usr/include/pthread.h" 3 4
+extern int pthread_cond_clockwait (pthread_cond_t *__restrict __cond,
+       pthread_mutex_t *__restrict __mutex,
+       __clockid_t __clock_id,
+       const struct timespec *__restrict __abstime)
+     __attribute__ ((__nonnull__ (1, 2, 4)));
+
+
+
+
+
+extern int pthread_condattr_init (pthread_condattr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_condattr_destroy (pthread_condattr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_condattr_getpshared (const pthread_condattr_t *
+     __restrict __attr,
+     int *__restrict __pshared)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_condattr_setpshared (pthread_condattr_t *__attr,
+     int __pshared) throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int pthread_condattr_getclock (const pthread_condattr_t *
+          __restrict __attr,
+          __clockid_t *__restrict __clock_id)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_condattr_setclock (pthread_condattr_t *__attr,
+          __clockid_t __clock_id)
+     throw () __attribute__ ((__nonnull__ (1)));
+# 1071 "/usr/include/pthread.h" 3 4
+extern int pthread_spin_init (pthread_spinlock_t *__lock, int __pshared)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_spin_destroy (pthread_spinlock_t *__lock)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_spin_lock (pthread_spinlock_t *__lock)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_spin_trylock (pthread_spinlock_t *__lock)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_spin_unlock (pthread_spinlock_t *__lock)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+extern int pthread_barrier_init (pthread_barrier_t *__restrict __barrier,
+     const pthread_barrierattr_t *__restrict
+     __attr, unsigned int __count)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_barrier_destroy (pthread_barrier_t *__barrier)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_barrier_wait (pthread_barrier_t *__barrier)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int pthread_barrierattr_init (pthread_barrierattr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_barrierattr_destroy (pthread_barrierattr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_barrierattr_getpshared (const pthread_barrierattr_t *
+        __restrict __attr,
+        int *__restrict __pshared)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_barrierattr_setpshared (pthread_barrierattr_t *__attr,
+        int __pshared)
+     throw () __attribute__ ((__nonnull__ (1)));
+# 1138 "/usr/include/pthread.h" 3 4
+extern int pthread_key_create (pthread_key_t *__key,
+          void (*__destr_function) (void *))
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_key_delete (pthread_key_t __key) throw ();
+
+
+extern void *pthread_getspecific (pthread_key_t __key) throw ();
+
+
+extern int pthread_setspecific (pthread_key_t __key,
+    const void *__pointer) throw () ;
+
+
+
+
+extern int pthread_getcpuclockid (pthread_t __thread_id,
+      __clockid_t *__clock_id)
+     throw () __attribute__ ((__nonnull__ (2)));
+# 1172 "/usr/include/pthread.h" 3 4
+extern int pthread_atfork (void (*__prepare) (void),
+      void (*__parent) (void),
+      void (*__child) (void)) throw ();
+# 1186 "/usr/include/pthread.h" 3 4
+}
+# 36 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/gthr-default.h" 2 3
+# 47 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/gthr-default.h" 3
+typedef pthread_t __gthread_t;
+typedef pthread_key_t __gthread_key_t;
+typedef pthread_once_t __gthread_once_t;
+typedef pthread_mutex_t __gthread_mutex_t;
+typedef pthread_mutex_t __gthread_recursive_mutex_t;
+typedef pthread_cond_t __gthread_cond_t;
+typedef struct timespec __gthread_time_t;
+
+
+
+#define __GTHREAD_HAS_COND 1
+
+#define __GTHREAD_MUTEX_INIT PTHREAD_MUTEX_INITIALIZER
+#define __GTHREAD_MUTEX_INIT_FUNCTION __gthread_mutex_init_function
+#define __GTHREAD_ONCE_INIT PTHREAD_ONCE_INIT
+
+
+
+#define __GTHREAD_RECURSIVE_MUTEX_INIT PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP
+
+
+
+#define __GTHREAD_COND_INIT PTHREAD_COND_INITIALIZER
+#define __GTHREAD_TIME_INIT {0,0}
+# 87 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/gthr-default.h" 3
+#define __gthrw_pragma(pragma) 
+
+#define __gthrw2(name,name2,type) static __typeof(type) name __attribute__ ((__weakref__(#name2), __copy__ (type))); __gthrw_pragma(weak type)
+
+
+
+#define __gthrw_(name) __gthrw_ ## name
+
+
+
+
+
+
+#define __gthrw(name) __gthrw2(__gthrw_ ## name,name,name)
+
+static __typeof(pthread_once) __gthrw_pthread_once __attribute__ ((__weakref__("pthread_once"), __copy__ (pthread_once)));
+static __typeof(pthread_getspecific) __gthrw_pthread_getspecific __attribute__ ((__weakref__("pthread_getspecific"), __copy__ (pthread_getspecific)));
+static __typeof(pthread_setspecific) __gthrw_pthread_setspecific __attribute__ ((__weakref__("pthread_setspecific"), __copy__ (pthread_setspecific)));
+
+static __typeof(pthread_create) __gthrw_pthread_create __attribute__ ((__weakref__("pthread_create"), __copy__ (pthread_create)));
+static __typeof(pthread_join) __gthrw_pthread_join __attribute__ ((__weakref__("pthread_join"), __copy__ (pthread_join)));
+static __typeof(pthread_equal) __gthrw_pthread_equal __attribute__ ((__weakref__("pthread_equal"), __copy__ (pthread_equal)));
+static __typeof(pthread_self) __gthrw_pthread_self __attribute__ ((__weakref__("pthread_self"), __copy__ (pthread_self)));
+static __typeof(pthread_detach) __gthrw_pthread_detach __attribute__ ((__weakref__("pthread_detach"), __copy__ (pthread_detach)));
+
+static __typeof(pthread_cancel) __gthrw_pthread_cancel __attribute__ ((__weakref__("pthread_cancel"), __copy__ (pthread_cancel)));
+
+static __typeof(sched_yield) __gthrw_sched_yield __attribute__ ((__weakref__("sched_yield"), __copy__ (sched_yield)));
+
+static __typeof(pthread_mutex_lock) __gthrw_pthread_mutex_lock __attribute__ ((__weakref__("pthread_mutex_lock"), __copy__ (pthread_mutex_lock)));
+static __typeof(pthread_mutex_trylock) __gthrw_pthread_mutex_trylock __attribute__ ((__weakref__("pthread_mutex_trylock"), __copy__ (pthread_mutex_trylock)));
+
+static __typeof(pthread_mutex_timedlock) __gthrw_pthread_mutex_timedlock __attribute__ ((__weakref__("pthread_mutex_timedlock"), __copy__ (pthread_mutex_timedlock)));
+
+static __typeof(pthread_mutex_unlock) __gthrw_pthread_mutex_unlock __attribute__ ((__weakref__("pthread_mutex_unlock"), __copy__ (pthread_mutex_unlock)));
+static __typeof(pthread_mutex_init) __gthrw_pthread_mutex_init __attribute__ ((__weakref__("pthread_mutex_init"), __copy__ (pthread_mutex_init)));
+static __typeof(pthread_mutex_destroy) __gthrw_pthread_mutex_destroy __attribute__ ((__weakref__("pthread_mutex_destroy"), __copy__ (pthread_mutex_destroy)));
+
+static __typeof(pthread_cond_init) __gthrw_pthread_cond_init __attribute__ ((__weakref__("pthread_cond_init"), __copy__ (pthread_cond_init)));
+static __typeof(pthread_cond_broadcast) __gthrw_pthread_cond_broadcast __attribute__ ((__weakref__("pthread_cond_broadcast"), __copy__ (pthread_cond_broadcast)));
+static __typeof(pthread_cond_signal) __gthrw_pthread_cond_signal __attribute__ ((__weakref__("pthread_cond_signal"), __copy__ (pthread_cond_signal)));
+static __typeof(pthread_cond_wait) __gthrw_pthread_cond_wait __attribute__ ((__weakref__("pthread_cond_wait"), __copy__ (pthread_cond_wait)));
+static __typeof(pthread_cond_timedwait) __gthrw_pthread_cond_timedwait __attribute__ ((__weakref__("pthread_cond_timedwait"), __copy__ (pthread_cond_timedwait)));
+static __typeof(pthread_cond_destroy) __gthrw_pthread_cond_destroy __attribute__ ((__weakref__("pthread_cond_destroy"), __copy__ (pthread_cond_destroy)));
+
+static __typeof(pthread_key_create) __gthrw_pthread_key_create __attribute__ ((__weakref__("pthread_key_create"), __copy__ (pthread_key_create)));
+static __typeof(pthread_key_delete) __gthrw_pthread_key_delete __attribute__ ((__weakref__("pthread_key_delete"), __copy__ (pthread_key_delete)));
+static __typeof(pthread_mutexattr_init) __gthrw_pthread_mutexattr_init __attribute__ ((__weakref__("pthread_mutexattr_init"), __copy__ (pthread_mutexattr_init)));
+static __typeof(pthread_mutexattr_settype) __gthrw_pthread_mutexattr_settype __attribute__ ((__weakref__("pthread_mutexattr_settype"), __copy__ (pthread_mutexattr_settype)));
+static __typeof(pthread_mutexattr_destroy) __gthrw_pthread_mutexattr_destroy __attribute__ ((__weakref__("pthread_mutexattr_destroy"), __copy__ (pthread_mutexattr_destroy)));
+# 237 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/gthr-default.h" 3
+static __typeof(pthread_key_create) __gthrw___pthread_key_create __attribute__ ((__weakref__("__pthread_key_create"), __copy__ (pthread_key_create)));
+
+
+#define GTHR_ACTIVE_PROXY __gthrw_(__pthread_key_create)
+
+
+
+
+
+
+static inline int
+__gthread_active_p (void)
+{
+  static void *const __gthread_active_ptr
+    = __extension__ (void *) &__gthrw___pthread_key_create;
+  return __gthread_active_ptr != 0;
+}
+# 659 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/gthr-default.h" 3
+static inline int
+__gthread_create (__gthread_t *__threadid, void *(*__func) (void*),
+    void *__args)
+{
+  return __gthrw_pthread_create (__threadid, __null, __func, __args);
+}
+
+static inline int
+__gthread_join (__gthread_t __threadid, void **__value_ptr)
+{
+  return __gthrw_pthread_join (__threadid, __value_ptr);
+}
+
+static inline int
+__gthread_detach (__gthread_t __threadid)
+{
+  return __gthrw_pthread_detach (__threadid);
+}
+
+static inline int
+__gthread_equal (__gthread_t __t1, __gthread_t __t2)
+{
+  return __gthrw_pthread_equal (__t1, __t2);
+}
+
+static inline __gthread_t
+__gthread_self (void)
+{
+  return __gthrw_pthread_self ();
+}
+
+static inline int
+__gthread_yield (void)
+{
+  return __gthrw_sched_yield ();
+}
+
+static inline int
+__gthread_once (__gthread_once_t *__once, void (*__func) (void))
+{
+  if (__gthread_active_p ())
+    return __gthrw_pthread_once (__once, __func);
+  else
+    return -1;
+}
+
+static inline int
+__gthread_key_create (__gthread_key_t *__key, void (*__dtor) (void *))
+{
+  return __gthrw_pthread_key_create (__key, __dtor);
+}
+
+static inline int
+__gthread_key_delete (__gthread_key_t __key)
+{
+  return __gthrw_pthread_key_delete (__key);
+}
+
+static inline void *
+__gthread_getspecific (__gthread_key_t __key)
+{
+  return __gthrw_pthread_getspecific (__key);
+}
+
+static inline int
+__gthread_setspecific (__gthread_key_t __key, const void *__ptr)
+{
+  return __gthrw_pthread_setspecific (__key, __ptr);
+}
+
+static inline void
+__gthread_mutex_init_function (__gthread_mutex_t *__mutex)
+{
+  if (__gthread_active_p ())
+    __gthrw_pthread_mutex_init (__mutex, __null);
+}
+
+static inline int
+__gthread_mutex_destroy (__gthread_mutex_t *__mutex)
+{
+  if (__gthread_active_p ())
+    return __gthrw_pthread_mutex_destroy (__mutex);
+  else
+    return 0;
+}
+
+static inline int
+__gthread_mutex_lock (__gthread_mutex_t *__mutex)
+{
+  if (__gthread_active_p ())
+    return __gthrw_pthread_mutex_lock (__mutex);
+  else
+    return 0;
+}
+
+static inline int
+__gthread_mutex_trylock (__gthread_mutex_t *__mutex)
+{
+  if (__gthread_active_p ())
+    return __gthrw_pthread_mutex_trylock (__mutex);
+  else
+    return 0;
+}
+
+
+static inline int
+__gthread_mutex_timedlock (__gthread_mutex_t *__mutex,
+      const __gthread_time_t *__abs_timeout)
+{
+  if (__gthread_active_p ())
+    return __gthrw_pthread_mutex_timedlock (__mutex, __abs_timeout);
+  else
+    return 0;
+}
+
+
+static inline int
+__gthread_mutex_unlock (__gthread_mutex_t *__mutex)
+{
+  if (__gthread_active_p ())
+    return __gthrw_pthread_mutex_unlock (__mutex);
+  else
+    return 0;
+}
+# 808 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/gthr-default.h" 3
+static inline int
+__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *__mutex)
+{
+  return __gthread_mutex_lock (__mutex);
+}
+
+static inline int
+__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *__mutex)
+{
+  return __gthread_mutex_trylock (__mutex);
+}
+
+
+static inline int
+__gthread_recursive_mutex_timedlock (__gthread_recursive_mutex_t *__mutex,
+         const __gthread_time_t *__abs_timeout)
+{
+  return __gthread_mutex_timedlock (__mutex, __abs_timeout);
+}
+
+
+static inline int
+__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *__mutex)
+{
+  return __gthread_mutex_unlock (__mutex);
+}
+
+static inline int
+__gthread_recursive_mutex_destroy (__gthread_recursive_mutex_t *__mutex)
+{
+  return __gthread_mutex_destroy (__mutex);
+}
+# 850 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/gthr-default.h" 3
+static inline int
+__gthread_cond_broadcast (__gthread_cond_t *__cond)
+{
+  return __gthrw_pthread_cond_broadcast (__cond);
+}
+
+static inline int
+__gthread_cond_signal (__gthread_cond_t *__cond)
+{
+  return __gthrw_pthread_cond_signal (__cond);
+}
+
+static inline int
+__gthread_cond_wait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex)
+{
+  return __gthrw_pthread_cond_wait (__cond, __mutex);
+}
+
+static inline int
+__gthread_cond_timedwait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex,
+     const __gthread_time_t *__abs_timeout)
+{
+  return __gthrw_pthread_cond_timedwait (__cond, __mutex, __abs_timeout);
+}
+
+static inline int
+__gthread_cond_wait_recursive (__gthread_cond_t *__cond,
+          __gthread_recursive_mutex_t *__mutex)
+{
+  return __gthread_cond_wait (__cond, __mutex);
+}
+
+static inline int
+__gthread_cond_destroy (__gthread_cond_t* __cond)
+{
+  return __gthrw_pthread_cond_destroy (__cond);
+}
+# 149 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/gthr.h" 2 3
+
+
+#pragma GCC visibility pop
+# 36 "/usr/include/c++/10.2.0/ext/atomicity.h" 2 3
+# 1 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/atomic_word.h" 1 3
+# 30 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/atomic_word.h" 3
+#define _GLIBCXX_ATOMIC_WORD_H 1
+
+typedef int _Atomic_word;
+
+
+
+#define _GLIBCXX_READ_MEM_BARRIER __atomic_thread_fence (__ATOMIC_ACQUIRE)
+
+#define _GLIBCXX_WRITE_MEM_BARRIER __atomic_thread_fence (__ATOMIC_RELEASE)
+# 37 "/usr/include/c++/10.2.0/ext/atomicity.h" 2 3
+
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+
+
+  inline _Atomic_word
+  __attribute__((__always_inline__))
+  __exchange_and_add(volatile _Atomic_word* __mem, int __val)
+  { return __atomic_fetch_add(__mem, __val, 4); }
+
+  inline void
+  __attribute__((__always_inline__))
+  __atomic_add(volatile _Atomic_word* __mem, int __val)
+  { __atomic_fetch_add(__mem, __val, 4); }
+# 64 "/usr/include/c++/10.2.0/ext/atomicity.h" 3
+  inline _Atomic_word
+  __attribute__((__always_inline__))
+  __exchange_and_add_single(_Atomic_word* __mem, int __val)
+  {
+    _Atomic_word __result = *__mem;
+    *__mem += __val;
+    return __result;
+  }
+
+  inline void
+  __attribute__((__always_inline__))
+  __atomic_add_single(_Atomic_word* __mem, int __val)
+  { *__mem += __val; }
+
+  inline _Atomic_word
+  __attribute__ ((__always_inline__))
+  __exchange_and_add_dispatch(_Atomic_word* __mem, int __val)
+  {
+
+    if (__gthread_active_p())
+      return __exchange_and_add(__mem, __val);
+
+    return __exchange_and_add_single(__mem, __val);
+  }
+
+  inline void
+  __attribute__ ((__always_inline__))
+  __atomic_add_dispatch(_Atomic_word* __mem, int __val)
+  {
+
+    if (__gthread_active_p())
+      {
+ __atomic_add(__mem, __val);
+ return;
+      }
+
+    __atomic_add_single(__mem, __val);
+  }
+
+
+}
+# 40 "/usr/include/c++/10.2.0/bits/basic_string.h" 2 3
+# 1 "/usr/include/c++/10.2.0/ext/alloc_traits.h" 1 3
+# 30 "/usr/include/c++/10.2.0/ext/alloc_traits.h" 3
+#define _EXT_ALLOC_TRAITS_H 1
+
+       
+# 33 "/usr/include/c++/10.2.0/ext/alloc_traits.h" 3
+
+# 1 "/usr/include/c++/10.2.0/bits/alloc_traits.h" 1 3
+# 31 "/usr/include/c++/10.2.0/bits/alloc_traits.h" 3
+#define _ALLOC_TRAITS_H 1
+
+# 1 "/usr/include/c++/10.2.0/bits/stl_construct.h" 1 3
+# 57 "/usr/include/c++/10.2.0/bits/stl_construct.h" 3
+#define _STL_CONSTRUCT_H 1
+# 73 "/usr/include/c++/10.2.0/bits/stl_construct.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+  template <typename _Tp>
+    inline void
+    destroy_at(_Tp* __location)
+    {
+      if constexpr (201703L > 201703L && is_array_v<_Tp>)
+ {
+   for (auto& __x : *__location)
+     std::destroy_at(std::__addressof(__x));
+ }
+      else
+ __location->~_Tp();
+    }
+# 106 "/usr/include/c++/10.2.0/bits/stl_construct.h" 3
+  template<typename _Tp, typename... _Args>
+    inline void
+    _Construct(_Tp* __p, _Args&&... __args)
+    { ::new(static_cast<void*>(__p)) _Tp(std::forward<_Args>(__args)...); }
+# 121 "/usr/include/c++/10.2.0/bits/stl_construct.h" 3
+  template<typename _T1>
+    inline void
+    _Construct_novalue(_T1* __p)
+    { ::new(static_cast<void*>(__p)) _T1; }
+
+  template<typename _ForwardIterator>
+    void
+    _Destroy(_ForwardIterator __first, _ForwardIterator __last);
+
+
+
+
+  template<typename _Tp>
+    constexpr inline void
+    _Destroy(_Tp* __pointer)
+    {
+
+
+
+      __pointer->~_Tp();
+
+    }
+
+  template<bool>
+    struct _Destroy_aux
+    {
+      template<typename _ForwardIterator>
+ static void
+ __destroy(_ForwardIterator __first, _ForwardIterator __last)
+ {
+   for (; __first != __last; ++__first)
+     std::_Destroy(std::__addressof(*__first));
+ }
+    };
+
+  template<>
+    struct _Destroy_aux<true>
+    {
+      template<typename _ForwardIterator>
+        static void
+        __destroy(_ForwardIterator, _ForwardIterator) { }
+    };
+
+
+
+
+
+
+  template<typename _ForwardIterator>
+    inline void
+    _Destroy(_ForwardIterator __first, _ForwardIterator __last)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+                       _Value_type;
+
+
+      static_assert(is_destructible<_Value_type>::value,
+      "value type is destructible");
+
+
+
+
+
+      std::_Destroy_aux<__has_trivial_destructor(_Value_type)>::
+ __destroy(__first, __last);
+    }
+
+  template<bool>
+    struct _Destroy_n_aux
+    {
+      template<typename _ForwardIterator, typename _Size>
+ static _ForwardIterator
+ __destroy_n(_ForwardIterator __first, _Size __count)
+ {
+   for (; __count > 0; (void)++__first, --__count)
+     std::_Destroy(std::__addressof(*__first));
+   return __first;
+ }
+    };
+
+  template<>
+    struct _Destroy_n_aux<true>
+    {
+      template<typename _ForwardIterator, typename _Size>
+        static _ForwardIterator
+        __destroy_n(_ForwardIterator __first, _Size __count)
+ {
+   std::advance(__first, __count);
+   return __first;
+ }
+    };
+
+
+
+
+
+
+  template<typename _ForwardIterator, typename _Size>
+    inline _ForwardIterator
+    _Destroy_n(_ForwardIterator __first, _Size __count)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+                       _Value_type;
+
+
+      static_assert(is_destructible<_Value_type>::value,
+      "value type is destructible");
+
+
+
+
+
+      return std::_Destroy_n_aux<__has_trivial_destructor(_Value_type)>::
+ __destroy_n(__first, __count);
+    }
+
+
+  template <typename _ForwardIterator>
+    inline void
+    destroy(_ForwardIterator __first, _ForwardIterator __last)
+    {
+      std::_Destroy(__first, __last);
+    }
+
+  template <typename _ForwardIterator, typename _Size>
+    inline _ForwardIterator
+    destroy_n(_ForwardIterator __first, _Size __count)
+    {
+      return std::_Destroy_n(__first, __count);
+    }
+
+
+
+}
+# 34 "/usr/include/c++/10.2.0/bits/alloc_traits.h" 2 3
+
+
+
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+#define __cpp_lib_allocator_traits_is_always_equal 201411
+
+  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 constexpr 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 constexpr 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 constexpr _Require<__has_construct<_Tp, _Args...>>
+ _S_construct(_Alloc& __a, _Tp* __p, _Args&&... __args)
+ noexcept(noexcept(__a.construct(__p, std::forward<_Args>(__args)...)))
+ { __a.construct(__p, std::forward<_Args>(__args)...); }
+
+      template<typename _Tp, typename... _Args>
+ static constexpr
+ _Require<__and_<__not_<__has_construct<_Tp, _Args...>>,
+          is_constructible<_Tp, _Args...>>>
+ _S_construct(_Alloc&, _Tp* __p, _Args&&... __args)
+ noexcept(std::is_nothrow_constructible<_Tp, _Args...>::value)
+ {
+
+   ::new((void*)__p) _Tp(std::forward<_Args>(__args)...);
+
+
+
+ }
+
+      template<typename _Alloc2, typename _Tp>
+ static constexpr auto
+ _S_destroy(_Alloc2& __a, _Tp* __p, int)
+ noexcept(noexcept(__a.destroy(__p)))
+ -> decltype(__a.destroy(__p))
+ { __a.destroy(__p); }
+
+      template<typename _Alloc2, typename _Tp>
+ static constexpr void
+ _S_destroy(_Alloc2&, _Tp* __p, ...)
+ noexcept(std::is_nothrow_destructible<_Tp>::value)
+ { std::_Destroy(__p); }
+
+      template<typename _Alloc2>
+ static constexpr auto
+ _S_max_size(_Alloc2& __a, int)
+ -> decltype(__a.max_size())
+ { return __a.max_size(); }
+
+      template<typename _Alloc2>
+ static constexpr size_type
+ _S_max_size(_Alloc2&, ...)
+ {
+
+
+   return __gnu_cxx::__numeric_traits<size_type>::__max
+     / sizeof(value_type);
+ }
+
+      template<typename _Alloc2>
+ static constexpr auto
+ _S_select(_Alloc2& __a, int)
+ -> decltype(__a.select_on_container_copy_construction())
+ { return __a.select_on_container_copy_construction(); }
+
+      template<typename _Alloc2>
+ static constexpr _Alloc2
+ _S_select(_Alloc2& __a, ...)
+ { return __a; }
+
+    public:
+# 312 "/usr/include/c++/10.2.0/bits/alloc_traits.h" 3
+      [[__nodiscard__]] static pointer
+      allocate(_Alloc& __a, size_type __n)
+      { return __a.allocate(__n); }
+# 327 "/usr/include/c++/10.2.0/bits/alloc_traits.h" 3
+      [[__nodiscard__]] static pointer
+      allocate(_Alloc& __a, size_type __n, const_void_pointer __hint)
+      { return _S_allocate(__a, __n, __hint, 0); }
+# 339 "/usr/include/c++/10.2.0/bits/alloc_traits.h" 3
+      static void
+      deallocate(_Alloc& __a, pointer __p, size_type __n)
+      { __a.deallocate(__p, __n); }
+# 354 "/usr/include/c++/10.2.0/bits/alloc_traits.h" 3
+      template<typename _Tp, typename... _Args>
+ static auto
+ construct(_Alloc& __a, _Tp* __p, _Args&&... __args)
+ noexcept(noexcept(_S_construct(__a, __p,
+           std::forward<_Args>(__args)...)))
+ -> decltype(_S_construct(__a, __p, std::forward<_Args>(__args)...))
+ { _S_construct(__a, __p, std::forward<_Args>(__args)...); }
+# 370 "/usr/include/c++/10.2.0/bits/alloc_traits.h" 3
+      template<typename _Tp>
+ static void
+ destroy(_Alloc& __a, _Tp* __p)
+ noexcept(noexcept(_S_destroy(__a, __p, 0)))
+ { _S_destroy(__a, __p, 0); }
+# 384 "/usr/include/c++/10.2.0/bits/alloc_traits.h" 3
+      static size_type
+      max_size(const _Alloc& __a) noexcept
+      { return _S_max_size(__a, 0); }
+# 396 "/usr/include/c++/10.2.0/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>>;
+# 458 "/usr/include/c++/10.2.0/bits/alloc_traits.h" 3
+      [[__nodiscard__]] static pointer
+      allocate(allocator_type& __a, size_type __n)
+      { return __a.allocate(__n); }
+# 472 "/usr/include/c++/10.2.0/bits/alloc_traits.h" 3
+      [[__nodiscard__]] static pointer
+      allocate(allocator_type& __a, size_type __n, const_void_pointer __hint)
+      {
+
+ return __a.allocate(__n, __hint);
+
+
+
+      }
+# 490 "/usr/include/c++/10.2.0/bits/alloc_traits.h" 3
+      static void
+      deallocate(allocator_type& __a, pointer __p, size_type __n)
+      { __a.deallocate(__p, __n); }
+# 505 "/usr/include/c++/10.2.0/bits/alloc_traits.h" 3
+      template<typename _Up, typename... _Args>
+ static void
+ construct(allocator_type& __a __attribute__((__unused__)), _Up* __p,
+    _Args&&... __args)
+ noexcept(std::is_nothrow_constructible<_Up, _Args...>::value)
+ {
+
+   __a.construct(__p, std::forward<_Args>(__args)...);
+
+
+
+ }
+# 525 "/usr/include/c++/10.2.0/bits/alloc_traits.h" 3
+      template<typename _Up>
+ static void
+ destroy(allocator_type& __a __attribute__((__unused__)), _Up* __p)
+ noexcept(is_nothrow_destructible<_Up>::value)
+ {
+
+   __a.destroy(__p);
+
+
+
+ }
+
+
+
+
+
+
+      static size_type
+      max_size(const allocator_type& __a __attribute__((__unused__))) noexcept
+      {
+
+ return __a.max_size();
+
+
+
+      }
+
+
+
+
+
+
+      static allocator_type
+      select_on_container_copy_construction(const allocator_type& __rhs)
+      { return __rhs; }
+    };
+# 574 "/usr/include/c++/10.2.0/bits/alloc_traits.h" 3
+  template<typename _Alloc>
+    constexpr inline void
+    __alloc_on_copy(_Alloc& __one, const _Alloc& __two)
+    {
+      typedef allocator_traits<_Alloc> __traits;
+      typedef typename __traits::propagate_on_container_copy_assignment __pocca;
+
+      if constexpr (__pocca::value)
+ __one = __two;
+
+
+
+    }
+
+  template<typename _Alloc>
+    constexpr _Alloc
+    __alloc_on_copy(const _Alloc& __a)
+    {
+      typedef allocator_traits<_Alloc> __traits;
+      return __traits::select_on_container_copy_construction(__a);
+    }
+# 606 "/usr/include/c++/10.2.0/bits/alloc_traits.h" 3
+  template<typename _Alloc>
+    constexpr inline void
+    __alloc_on_move(_Alloc& __one, _Alloc& __two)
+    {
+      typedef allocator_traits<_Alloc> __traits;
+      typedef typename __traits::propagate_on_container_move_assignment __pocma;
+
+      if constexpr (__pocma::value)
+ __one = std::move(__two);
+
+
+
+    }
+# 633 "/usr/include/c++/10.2.0/bits/alloc_traits.h" 3
+  template<typename _Alloc>
+    constexpr inline void
+    __alloc_on_swap(_Alloc& __one, _Alloc& __two)
+    {
+      typedef allocator_traits<_Alloc> __traits;
+      typedef typename __traits::propagate_on_container_swap __pocs;
+
+      if constexpr (__pocs::value)
+ {
+   using std::swap;
+   swap(__one, __two);
+ }
+
+
+
+    }
+
+  template<typename _Alloc, typename _Tp,
+    typename _ValueT = __remove_cvref_t<typename _Alloc::value_type>,
+    typename = void>
+    struct __is_alloc_insertable_impl
+    : false_type
+    { };
+
+  template<typename _Alloc, typename _Tp, typename _ValueT>
+    struct __is_alloc_insertable_impl<_Alloc, _Tp, _ValueT,
+      __void_t<decltype(allocator_traits<_Alloc>::construct(
+     std::declval<_Alloc&>(), std::declval<_ValueT*>(),
+     std::declval<_Tp>()))>>
+    : true_type
+    { };
+
+
+
+
+  template<typename _Alloc>
+    struct __is_copy_insertable
+    : __is_alloc_insertable_impl<_Alloc,
+     typename _Alloc::value_type const&>::type
+    { };
+
+
+  template<typename _Tp>
+    struct __is_copy_insertable<allocator<_Tp>>
+    : is_copy_constructible<_Tp>
+    { };
+
+
+
+
+  template<typename _Alloc>
+    struct __is_move_insertable
+    : __is_alloc_insertable_impl<_Alloc, typename _Alloc::value_type>::type
+    { };
+
+
+  template<typename _Tp>
+    struct __is_move_insertable<allocator<_Tp>>
+    : is_move_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;
+
+  template<typename _Alloc>
+    using _RequireNotAllocator
+      = typename enable_if<!__is_allocator<_Alloc>::value, _Alloc>::type;
+# 719 "/usr/include/c++/10.2.0/bits/alloc_traits.h" 3
+  template<typename _ForwardIterator, typename _Allocator>
+    void
+    _Destroy(_ForwardIterator __first, _ForwardIterator __last,
+      _Allocator& __alloc)
+    {
+      for (; __first != __last; ++__first)
+
+
+
+ allocator_traits<_Allocator>::destroy(__alloc,
+           std::__addressof(*__first));
+
+    }
+
+  template<typename _ForwardIterator, typename _Tp>
+    inline void
+    _Destroy(_ForwardIterator __first, _ForwardIterator __last,
+      allocator<_Tp>&)
+    {
+      _Destroy(__first, __last);
+    }
+
+
+}
+# 35 "/usr/include/c++/10.2.0/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 constexpr
+      std::__enable_if_t<__is_custom_pointer<_Ptr>::value>
+      construct(_Alloc& __a, _Ptr __p, _Args&&... __args)
+      noexcept(noexcept(_Base_type::construct(__a, std::__to_address(__p),
+           std::forward<_Args>(__args)...)))
+      {
+ _Base_type::construct(__a, std::__to_address(__p),
+         std::forward<_Args>(__args)...);
+      }
+
+
+    template<typename _Ptr>
+      static constexpr
+      std::__enable_if_t<__is_custom_pointer<_Ptr>::value>
+      destroy(_Alloc& __a, _Ptr __p)
+      noexcept(noexcept(_Base_type::destroy(__a, std::__to_address(__p))))
+      { _Base_type::destroy(__a, std::__to_address(__p)); }
+
+    static constexpr _Alloc _S_select_on_copy(const _Alloc& __a)
+    { return _Base_type::select_on_container_copy_construction(__a); }
+
+    static constexpr 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; };
+# 166 "/usr/include/c++/10.2.0/ext/alloc_traits.h" 3
+  };
+
+
+}
+# 41 "/usr/include/c++/10.2.0/bits/basic_string.h" 2 3
+
+
+
+
+
+
+
+# 1 "/usr/include/c++/10.2.0/string_view" 1 3
+# 34 "/usr/include/c++/10.2.0/string_view" 3
+#define _GLIBCXX_STRING_VIEW 1
+
+       
+# 37 "/usr/include/c++/10.2.0/string_view" 3
+
+
+
+
+
+# 1 "/usr/include/c++/10.2.0/bits/functional_hash.h" 1 3
+# 31 "/usr/include/c++/10.2.0/bits/functional_hash.h" 3
+#define _FUNCTIONAL_HASH_H 1
+
+       
+# 34 "/usr/include/c++/10.2.0/bits/functional_hash.h" 3
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 49 "/usr/include/c++/10.2.0/bits/functional_hash.h" 3
+  template<typename _Result, typename _Arg>
+    struct __hash_base
+    {
+      typedef _Result result_type [[__deprecated__]];
+      typedef _Arg argument_type [[__deprecated__]];
+    };
+
+
+  template<typename _Tp>
+    struct hash;
+
+  template<typename _Tp, typename = void>
+    struct __poison_hash
+    {
+      static constexpr bool __enable_hash_call = false;
+    private:
+
+      __poison_hash(__poison_hash&&);
+      ~__poison_hash();
+    };
+
+  template<typename _Tp>
+    struct __poison_hash<_Tp, __void_t<decltype(hash<_Tp>()(declval<_Tp>()))>>
+    {
+      static constexpr bool __enable_hash_call = true;
+    };
+
+
+  template<typename _Tp, bool = is_enum<_Tp>::value>
+    struct __hash_enum
+    {
+    private:
+
+      __hash_enum(__hash_enum&&);
+      ~__hash_enum();
+    };
+
+
+  template<typename _Tp>
+    struct __hash_enum<_Tp, true> : public __hash_base<size_t, _Tp>
+    {
+      size_t
+      operator()(_Tp __val) const noexcept
+      {
+       using __type = typename underlying_type<_Tp>::type;
+       return hash<__type>{}(static_cast<__type>(__val));
+      }
+    };
+
+
+
+  template<typename _Tp>
+    struct hash : __hash_enum<_Tp>
+    { };
+
+
+  template<typename _Tp>
+    struct hash<_Tp*> : public __hash_base<size_t, _Tp*>
+    {
+      size_t
+      operator()(_Tp* __p) const noexcept
+      { return reinterpret_cast<size_t>(__p); }
+    };
+
+
+#define _Cxx_hashtable_define_trivial_hash(_Tp) template<> struct hash<_Tp> : public __hash_base<size_t, _Tp> { size_t operator()(_Tp __val) const noexcept { return static_cast<size_t>(__val); } };
+# 124 "/usr/include/c++/10.2.0/bits/functional_hash.h" 3
+  template<> struct hash<bool> : public __hash_base<size_t, bool> { size_t operator()(bool __val) const noexcept { return static_cast<size_t>(__val); } };
+
+
+  template<> struct hash<char> : public __hash_base<size_t, char> { size_t operator()(char __val) const noexcept { return static_cast<size_t>(__val); } };
+
+
+  template<> struct hash<signed char> : public __hash_base<size_t, signed char> { size_t operator()(signed char __val) const noexcept { return static_cast<size_t>(__val); } };
+
+
+  template<> struct hash<unsigned char> : public __hash_base<size_t, unsigned char> { size_t operator()(unsigned char __val) const noexcept { return static_cast<size_t>(__val); } };
+
+
+  template<> struct hash<wchar_t> : public __hash_base<size_t, wchar_t> { size_t operator()(wchar_t __val) const noexcept { return static_cast<size_t>(__val); } };
+
+
+
+
+
+
+
+  template<> struct hash<char16_t> : public __hash_base<size_t, char16_t> { size_t operator()(char16_t __val) const noexcept { return static_cast<size_t>(__val); } };
+
+
+  template<> struct hash<char32_t> : public __hash_base<size_t, char32_t> { size_t operator()(char32_t __val) const noexcept { return static_cast<size_t>(__val); } };
+
+
+  template<> struct hash<short> : public __hash_base<size_t, short> { size_t operator()(short __val) const noexcept { return static_cast<size_t>(__val); } };
+
+
+  template<> struct hash<int> : public __hash_base<size_t, int> { size_t operator()(int __val) const noexcept { return static_cast<size_t>(__val); } };
+
+
+  template<> struct hash<long> : public __hash_base<size_t, long> { size_t operator()(long __val) const noexcept { return static_cast<size_t>(__val); } };
+
+
+  template<> struct hash<long long> : public __hash_base<size_t, long long> { size_t operator()(long long __val) const noexcept { return static_cast<size_t>(__val); } };
+
+
+  template<> struct hash<unsigned short> : public __hash_base<size_t, unsigned short> { size_t operator()(unsigned short __val) const noexcept { return static_cast<size_t>(__val); } };
+
+
+  template<> struct hash<unsigned int> : public __hash_base<size_t, unsigned int> { size_t operator()(unsigned int __val) const noexcept { return static_cast<size_t>(__val); } };
+
+
+  template<> struct hash<unsigned long> : public __hash_base<size_t, unsigned long> { size_t operator()(unsigned long __val) const noexcept { return static_cast<size_t>(__val); } };
+
+
+  template<> struct hash<unsigned long long> : public __hash_base<size_t, unsigned long long> { size_t operator()(unsigned long long __val) const noexcept { return static_cast<size_t>(__val); } };
+# 190 "/usr/include/c++/10.2.0/bits/functional_hash.h" 3
+#undef _Cxx_hashtable_define_trivial_hash
+
+  struct _Hash_impl
+  {
+    static size_t
+    hash(const void* __ptr, size_t __clength,
+  size_t __seed = static_cast<size_t>(0xc70f6907UL))
+    { return _Hash_bytes(__ptr, __clength, __seed); }
+
+    template<typename _Tp>
+      static size_t
+      hash(const _Tp& __val)
+      { return hash(&__val, sizeof(__val)); }
+
+    template<typename _Tp>
+      static size_t
+      __hash_combine(const _Tp& __val, size_t __hash)
+      { return hash(&__val, sizeof(__val), __hash); }
+  };
+
+
+  struct _Fnv_hash_impl
+  {
+    static size_t
+    hash(const void* __ptr, size_t __clength,
+  size_t __seed = static_cast<size_t>(2166136261UL))
+    { return _Fnv_hash_bytes(__ptr, __clength, __seed); }
+
+    template<typename _Tp>
+      static size_t
+      hash(const _Tp& __val)
+      { return hash(&__val, sizeof(__val)); }
+
+    template<typename _Tp>
+      static size_t
+      __hash_combine(const _Tp& __val, size_t __hash)
+      { return hash(&__val, sizeof(__val), __hash); }
+  };
+
+
+  template<>
+    struct hash<float> : public __hash_base<size_t, float>
+    {
+      size_t
+      operator()(float __val) const noexcept
+      {
+
+ return __val != 0.0f ? std::_Hash_impl::hash(__val) : 0;
+      }
+    };
+
+
+  template<>
+    struct hash<double> : public __hash_base<size_t, double>
+    {
+      size_t
+      operator()(double __val) const noexcept
+      {
+
+ return __val != 0.0 ? std::_Hash_impl::hash(__val) : 0;
+      }
+    };
+
+
+  template<>
+    struct hash<long double>
+    : public __hash_base<size_t, long double>
+    {
+      __attribute__ ((__pure__)) size_t
+      operator()(long double __val) const noexcept;
+    };
+
+
+  template<>
+    struct hash<nullptr_t> : public __hash_base<size_t, nullptr_t>
+    {
+      size_t
+      operator()(nullptr_t) const noexcept
+      { return 0; }
+    };
+# 278 "/usr/include/c++/10.2.0/bits/functional_hash.h" 3
+  template<typename _Hash>
+    struct __is_fast_hash : public std::true_type
+    { };
+
+  template<>
+    struct __is_fast_hash<hash<long double>> : public std::false_type
+    { };
+
+
+}
+# 43 "/usr/include/c++/10.2.0/string_view" 2 3
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+#define __cpp_lib_string_view 201803L
+
+
+
+
+
+  constexpr size_t
+  __sv_check(size_t __size, size_t __pos, const char* __s)
+  {
+    if (__pos > __size)
+      __throw_out_of_range_fmt(("%s: __pos (which is %zu) > __size " "(which is %zu)")
+                        , __s, __pos, __size);
+    return __pos;
+  }
+
+
+
+  constexpr size_t
+  __sv_limit(size_t __size, size_t __pos, size_t __off) noexcept
+  {
+   const bool __testoff = __off < __size - __pos;
+   return __testoff ? __off : __size - __pos;
+  }
+# 93 "/usr/include/c++/10.2.0/string_view" 3
+  template<typename _CharT, typename _Traits = std::char_traits<_CharT>>
+    class basic_string_view
+    {
+      static_assert(!is_array_v<_CharT>);
+      static_assert(is_trivial_v<_CharT> && is_standard_layout_v<_CharT>);
+      static_assert(is_same_v<_CharT, typename _Traits::char_type>);
+
+    public:
+
+
+      using traits_type = _Traits;
+      using value_type = _CharT;
+      using pointer = value_type*;
+      using const_pointer = const value_type*;
+      using reference = value_type&;
+      using const_reference = const value_type&;
+      using const_iterator = const value_type*;
+      using iterator = const_iterator;
+      using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+      using reverse_iterator = const_reverse_iterator;
+      using size_type = size_t;
+      using difference_type = ptrdiff_t;
+      static constexpr size_type npos = size_type(-1);
+
+
+
+      constexpr
+      basic_string_view() noexcept
+      : _M_len{0}, _M_str{nullptr}
+      { }
+
+      constexpr basic_string_view(const basic_string_view&) noexcept = default;
+
+      __attribute__((__nonnull__)) constexpr
+      basic_string_view(const _CharT* __str) noexcept
+      : _M_len{traits_type::length(__str)},
+ _M_str{__str}
+      { }
+
+      constexpr
+      basic_string_view(const _CharT* __str, size_type __len) noexcept
+      : _M_len{__len}, _M_str{__str}
+      { }
+# 147 "/usr/include/c++/10.2.0/string_view" 3
+      constexpr basic_string_view&
+      operator=(const basic_string_view&) noexcept = default;
+
+
+
+      constexpr const_iterator
+      begin() const noexcept
+      { return this->_M_str; }
+
+      constexpr const_iterator
+      end() const noexcept
+      { return this->_M_str + this->_M_len; }
+
+      constexpr const_iterator
+      cbegin() const noexcept
+      { return this->_M_str; }
+
+      constexpr const_iterator
+      cend() const noexcept
+      { return this->_M_str + this->_M_len; }
+
+      constexpr const_reverse_iterator
+      rbegin() const noexcept
+      { return const_reverse_iterator(this->end()); }
+
+      constexpr const_reverse_iterator
+      rend() const noexcept
+      { return const_reverse_iterator(this->begin()); }
+
+      constexpr const_reverse_iterator
+      crbegin() const noexcept
+      { return const_reverse_iterator(this->end()); }
+
+      constexpr const_reverse_iterator
+      crend() const noexcept
+      { return const_reverse_iterator(this->begin()); }
+
+
+
+      constexpr size_type
+      size() const noexcept
+      { return this->_M_len; }
+
+      constexpr size_type
+      length() const noexcept
+      { return _M_len; }
+
+      constexpr size_type
+      max_size() const noexcept
+      {
+ return (npos - sizeof(size_type) - sizeof(void*))
+  / sizeof(value_type) / 4;
+      }
+
+      [[nodiscard]] constexpr bool
+      empty() const noexcept
+      { return this->_M_len == 0; }
+
+
+
+      constexpr const_reference
+      operator[](size_type __pos) const noexcept
+      {
+
+
+ return *(this->_M_str + __pos);
+      }
+
+      constexpr const_reference
+      at(size_type __pos) const
+      {
+ if (__pos >= _M_len)
+   __throw_out_of_range_fmt(("basic_string_view::at: __pos " "(which is %zu) >= this->size() " "(which is %zu)")
+
+                            , __pos, this->size());
+ return *(this->_M_str + __pos);
+      }
+
+      constexpr const_reference
+      front() const noexcept
+      {
+
+
+ return *this->_M_str;
+      }
+
+      constexpr const_reference
+      back() const noexcept
+      {
+
+
+ return *(this->_M_str + this->_M_len - 1);
+      }
+
+      constexpr const_pointer
+      data() const noexcept
+      { return this->_M_str; }
+
+
+
+      constexpr void
+      remove_prefix(size_type __n) noexcept
+      {
+ ;
+ this->_M_str += __n;
+ this->_M_len -= __n;
+      }
+
+      constexpr void
+      remove_suffix(size_type __n) noexcept
+      { this->_M_len -= __n; }
+
+      constexpr void
+      swap(basic_string_view& __sv) noexcept
+      {
+ auto __tmp = *this;
+ *this = __sv;
+ __sv = __tmp;
+      }
+
+
+
+     
+      size_type
+      copy(_CharT* __str, size_type __n, size_type __pos = 0) const
+      {
+ ;
+ __pos = std::__sv_check(size(), __pos, "basic_string_view::copy");
+ const size_type __rlen = std::min(__n, _M_len - __pos);
+
+
+ traits_type::copy(__str, data() + __pos, __rlen);
+ return __rlen;
+      }
+
+      constexpr basic_string_view
+      substr(size_type __pos = 0, size_type __n = npos) const noexcept(false)
+      {
+ __pos = std::__sv_check(size(), __pos, "basic_string_view::substr");
+ const size_type __rlen = std::min(__n, _M_len - __pos);
+ return basic_string_view{_M_str + __pos, __rlen};
+      }
+
+      constexpr int
+      compare(basic_string_view __str) const noexcept
+      {
+ const size_type __rlen = std::min(this->_M_len, __str._M_len);
+ int __ret = traits_type::compare(this->_M_str, __str._M_str, __rlen);
+ if (__ret == 0)
+   __ret = _S_compare(this->_M_len, __str._M_len);
+ return __ret;
+      }
+
+      constexpr int
+      compare(size_type __pos1, size_type __n1, basic_string_view __str) const
+      { return this->substr(__pos1, __n1).compare(__str); }
+
+      constexpr int
+      compare(size_type __pos1, size_type __n1,
+       basic_string_view __str, size_type __pos2, size_type __n2) const
+      {
+ return this->substr(__pos1, __n1).compare(__str.substr(__pos2, __n2));
+      }
+
+      __attribute__((__nonnull__)) constexpr int
+      compare(const _CharT* __str) const noexcept
+      { return this->compare(basic_string_view{__str}); }
+
+      __attribute__((__nonnull__)) constexpr int
+      compare(size_type __pos1, size_type __n1, const _CharT* __str) const
+      { return this->substr(__pos1, __n1).compare(basic_string_view{__str}); }
+
+      constexpr int
+      compare(size_type __pos1, size_type __n1,
+       const _CharT* __str, size_type __n2) const noexcept(false)
+      {
+ return this->substr(__pos1, __n1)
+     .compare(basic_string_view(__str, __n2));
+      }
+# 359 "/usr/include/c++/10.2.0/string_view" 3
+      constexpr size_type
+      find(basic_string_view __str, size_type __pos = 0) const noexcept
+      { return this->find(__str._M_str, __pos, __str._M_len); }
+
+      constexpr size_type
+      find(_CharT __c, size_type __pos = 0) const noexcept;
+
+      constexpr size_type
+      find(const _CharT* __str, size_type __pos, size_type __n) const noexcept;
+
+      __attribute__((__nonnull__)) constexpr size_type
+      find(const _CharT* __str, size_type __pos = 0) const noexcept
+      { return this->find(__str, __pos, traits_type::length(__str)); }
+
+      constexpr size_type
+      rfind(basic_string_view __str, size_type __pos = npos) const noexcept
+      { return this->rfind(__str._M_str, __pos, __str._M_len); }
+
+      constexpr size_type
+      rfind(_CharT __c, size_type __pos = npos) const noexcept;
+
+      constexpr size_type
+      rfind(const _CharT* __str, size_type __pos, size_type __n) const noexcept;
+
+      __attribute__((__nonnull__)) constexpr size_type
+      rfind(const _CharT* __str, size_type __pos = npos) const noexcept
+      { return this->rfind(__str, __pos, traits_type::length(__str)); }
+
+      constexpr size_type
+      find_first_of(basic_string_view __str, size_type __pos = 0) const noexcept
+      { return this->find_first_of(__str._M_str, __pos, __str._M_len); }
+
+      constexpr size_type
+      find_first_of(_CharT __c, size_type __pos = 0) const noexcept
+      { return this->find(__c, __pos); }
+
+      constexpr size_type
+      find_first_of(const _CharT* __str, size_type __pos,
+      size_type __n) const noexcept;
+
+      __attribute__((__nonnull__)) constexpr size_type
+      find_first_of(const _CharT* __str, size_type __pos = 0) const noexcept
+      { return this->find_first_of(__str, __pos, traits_type::length(__str)); }
+
+      constexpr size_type
+      find_last_of(basic_string_view __str,
+     size_type __pos = npos) const noexcept
+      { return this->find_last_of(__str._M_str, __pos, __str._M_len); }
+
+      constexpr size_type
+      find_last_of(_CharT __c, size_type __pos=npos) const noexcept
+      { return this->rfind(__c, __pos); }
+
+      constexpr size_type
+      find_last_of(const _CharT* __str, size_type __pos,
+     size_type __n) const noexcept;
+
+      __attribute__((__nonnull__)) constexpr size_type
+      find_last_of(const _CharT* __str, size_type __pos = npos) const noexcept
+      { return this->find_last_of(__str, __pos, traits_type::length(__str)); }
+
+      constexpr size_type
+      find_first_not_of(basic_string_view __str,
+   size_type __pos = 0) const noexcept
+      { return this->find_first_not_of(__str._M_str, __pos, __str._M_len); }
+
+      constexpr size_type
+      find_first_not_of(_CharT __c, size_type __pos = 0) const noexcept;
+
+      constexpr size_type
+      find_first_not_of(const _CharT* __str,
+   size_type __pos, size_type __n) const noexcept;
+
+      __attribute__((__nonnull__)) constexpr size_type
+      find_first_not_of(const _CharT* __str, size_type __pos = 0) const noexcept
+      {
+ return this->find_first_not_of(__str, __pos,
+           traits_type::length(__str));
+      }
+
+      constexpr size_type
+      find_last_not_of(basic_string_view __str,
+         size_type __pos = npos) const noexcept
+      { return this->find_last_not_of(__str._M_str, __pos, __str._M_len); }
+
+      constexpr size_type
+      find_last_not_of(_CharT __c, size_type __pos = npos) const noexcept;
+
+      constexpr size_type
+      find_last_not_of(const _CharT* __str,
+         size_type __pos, size_type __n) const noexcept;
+
+      __attribute__((__nonnull__)) constexpr size_type
+      find_last_not_of(const _CharT* __str,
+         size_type __pos = npos) const noexcept
+      {
+ return this->find_last_not_of(__str, __pos,
+          traits_type::length(__str));
+      }
+
+    private:
+
+      static constexpr int
+      _S_compare(size_type __n1, size_type __n2) noexcept
+      {
+ const difference_type __diff = __n1 - __n2;
+ if (__diff > __detail::__int_limits<int>::max())
+   return __detail::__int_limits<int>::max();
+ if (__diff < __detail::__int_limits<int>::min())
+   return __detail::__int_limits<int>::min();
+ return static_cast<int>(__diff);
+      }
+
+      size_t _M_len;
+      const _CharT* _M_str;
+    };
+# 488 "/usr/include/c++/10.2.0/string_view" 3
+  template<typename _CharT, typename _Traits>
+    constexpr bool
+    operator==(basic_string_view<_CharT, _Traits> __x,
+               basic_string_view<_CharT, _Traits> __y) noexcept
+    { return __x.size() == __y.size() && __x.compare(__y) == 0; }
+
+  template<typename _CharT, typename _Traits>
+    constexpr bool
+    operator==(basic_string_view<_CharT, _Traits> __x,
+               __type_identity_t<basic_string_view<_CharT, _Traits>> __y)
+    noexcept
+    { return __x.size() == __y.size() && __x.compare(__y) == 0; }
+# 517 "/usr/include/c++/10.2.0/string_view" 3
+  template<typename _CharT, typename _Traits>
+    constexpr bool
+    operator==(__type_identity_t<basic_string_view<_CharT, _Traits>> __x,
+               basic_string_view<_CharT, _Traits> __y) noexcept
+    { return __x.size() == __y.size() && __x.compare(__y) == 0; }
+
+  template<typename _CharT, typename _Traits>
+    constexpr bool
+    operator!=(basic_string_view<_CharT, _Traits> __x,
+               basic_string_view<_CharT, _Traits> __y) noexcept
+    { return !(__x == __y); }
+
+  template<typename _CharT, typename _Traits>
+    constexpr bool
+    operator!=(basic_string_view<_CharT, _Traits> __x,
+               __type_identity_t<basic_string_view<_CharT, _Traits>> __y)
+    noexcept
+    { return !(__x == __y); }
+
+  template<typename _CharT, typename _Traits>
+    constexpr bool
+    operator!=(__type_identity_t<basic_string_view<_CharT, _Traits>> __x,
+               basic_string_view<_CharT, _Traits> __y) noexcept
+    { return !(__x == __y); }
+
+  template<typename _CharT, typename _Traits>
+    constexpr bool
+    operator< (basic_string_view<_CharT, _Traits> __x,
+               basic_string_view<_CharT, _Traits> __y) noexcept
+    { return __x.compare(__y) < 0; }
+
+  template<typename _CharT, typename _Traits>
+    constexpr bool
+    operator< (basic_string_view<_CharT, _Traits> __x,
+               __type_identity_t<basic_string_view<_CharT, _Traits>> __y)
+    noexcept
+    { return __x.compare(__y) < 0; }
+
+  template<typename _CharT, typename _Traits>
+    constexpr bool
+    operator< (__type_identity_t<basic_string_view<_CharT, _Traits>> __x,
+               basic_string_view<_CharT, _Traits> __y) noexcept
+    { return __x.compare(__y) < 0; }
+
+  template<typename _CharT, typename _Traits>
+    constexpr bool
+    operator> (basic_string_view<_CharT, _Traits> __x,
+               basic_string_view<_CharT, _Traits> __y) noexcept
+    { return __x.compare(__y) > 0; }
+
+  template<typename _CharT, typename _Traits>
+    constexpr bool
+    operator> (basic_string_view<_CharT, _Traits> __x,
+               __type_identity_t<basic_string_view<_CharT, _Traits>> __y)
+    noexcept
+    { return __x.compare(__y) > 0; }
+
+  template<typename _CharT, typename _Traits>
+    constexpr bool
+    operator> (__type_identity_t<basic_string_view<_CharT, _Traits>> __x,
+               basic_string_view<_CharT, _Traits> __y) noexcept
+    { return __x.compare(__y) > 0; }
+
+  template<typename _CharT, typename _Traits>
+    constexpr bool
+    operator<=(basic_string_view<_CharT, _Traits> __x,
+               basic_string_view<_CharT, _Traits> __y) noexcept
+    { return __x.compare(__y) <= 0; }
+
+  template<typename _CharT, typename _Traits>
+    constexpr bool
+    operator<=(basic_string_view<_CharT, _Traits> __x,
+               __type_identity_t<basic_string_view<_CharT, _Traits>> __y)
+    noexcept
+    { return __x.compare(__y) <= 0; }
+
+  template<typename _CharT, typename _Traits>
+    constexpr bool
+    operator<=(__type_identity_t<basic_string_view<_CharT, _Traits>> __x,
+               basic_string_view<_CharT, _Traits> __y) noexcept
+    { return __x.compare(__y) <= 0; }
+
+  template<typename _CharT, typename _Traits>
+    constexpr bool
+    operator>=(basic_string_view<_CharT, _Traits> __x,
+               basic_string_view<_CharT, _Traits> __y) noexcept
+    { return __x.compare(__y) >= 0; }
+
+  template<typename _CharT, typename _Traits>
+    constexpr bool
+    operator>=(basic_string_view<_CharT, _Traits> __x,
+               __type_identity_t<basic_string_view<_CharT, _Traits>> __y)
+    noexcept
+    { return __x.compare(__y) >= 0; }
+
+  template<typename _CharT, typename _Traits>
+    constexpr bool
+    operator>=(__type_identity_t<basic_string_view<_CharT, _Traits>> __x,
+               basic_string_view<_CharT, _Traits> __y) noexcept
+    { return __x.compare(__y) >= 0; }
+
+
+
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __os,
+        basic_string_view<_CharT,_Traits> __str)
+    { return __ostream_insert(__os, __str.data(), __str.size()); }
+
+
+
+
+  using string_view = basic_string_view<char>;
+
+  using wstring_view = basic_string_view<wchar_t>;
+
+
+
+
+  using u16string_view = basic_string_view<char16_t>;
+  using u32string_view = basic_string_view<char32_t>;
+
+
+
+  template<typename _Tp>
+    struct hash;
+
+  template<>
+    struct hash<string_view>
+    : public __hash_base<size_t, string_view>
+    {
+      size_t
+      operator()(const string_view& __str) const noexcept
+      { return std::_Hash_impl::hash(__str.data(), __str.length()); }
+    };
+
+  template<>
+    struct __is_fast_hash<hash<string_view>> : std::false_type
+    { };
+
+
+  template<>
+    struct hash<wstring_view>
+    : public __hash_base<size_t, wstring_view>
+    {
+      size_t
+      operator()(const wstring_view& __s) const noexcept
+      { return std::_Hash_impl::hash(__s.data(),
+                                     __s.length() * sizeof(wchar_t)); }
+    };
+
+  template<>
+    struct __is_fast_hash<hash<wstring_view>> : std::false_type
+    { };
+# 688 "/usr/include/c++/10.2.0/string_view" 3
+  template<>
+    struct hash<u16string_view>
+    : public __hash_base<size_t, u16string_view>
+    {
+      size_t
+      operator()(const u16string_view& __s) const noexcept
+      { return std::_Hash_impl::hash(__s.data(),
+                                     __s.length() * sizeof(char16_t)); }
+    };
+
+  template<>
+    struct __is_fast_hash<hash<u16string_view>> : std::false_type
+    { };
+
+  template<>
+    struct hash<u32string_view>
+    : public __hash_base<size_t, u32string_view>
+    {
+      size_t
+      operator()(const u32string_view& __s) const noexcept
+      { return std::_Hash_impl::hash(__s.data(),
+                                     __s.length() * sizeof(char32_t)); }
+    };
+
+  template<>
+    struct __is_fast_hash<hash<u32string_view>> : std::false_type
+    { };
+
+  inline namespace literals
+  {
+  inline namespace string_view_literals
+  {
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wliteral-suffix"
+    inline constexpr basic_string_view<char>
+    operator""sv(const char* __str, size_t __len) noexcept
+    { return basic_string_view<char>{__str, __len}; }
+
+
+    inline constexpr basic_string_view<wchar_t>
+    operator""sv(const wchar_t* __str, size_t __len) noexcept
+    { return basic_string_view<wchar_t>{__str, __len}; }
+# 738 "/usr/include/c++/10.2.0/string_view" 3
+    inline constexpr basic_string_view<char16_t>
+    operator""sv(const char16_t* __str, size_t __len) noexcept
+    { return basic_string_view<char16_t>{__str, __len}; }
+
+    inline constexpr basic_string_view<char32_t>
+    operator""sv(const char32_t* __str, size_t __len) noexcept
+    { return basic_string_view<char32_t>{__str, __len}; }
+
+#pragma GCC diagnostic pop
+  }
+  }
+# 764 "/usr/include/c++/10.2.0/string_view" 3
+
+}
+
+# 1 "/usr/include/c++/10.2.0/bits/string_view.tcc" 1 3
+# 35 "/usr/include/c++/10.2.0/bits/string_view.tcc" 3
+#define _GLIBCXX_STRING_VIEW_TCC 1
+
+       
+# 38 "/usr/include/c++/10.2.0/bits/string_view.tcc" 3
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  template<typename _CharT, typename _Traits>
+    constexpr typename basic_string_view<_CharT, _Traits>::size_type
+    basic_string_view<_CharT, _Traits>::
+    find(const _CharT* __str, size_type __pos, size_type __n) const noexcept
+    {
+      ;
+
+      if (__n == 0)
+ return __pos <= this->_M_len ? __pos : npos;
+
+      if (__n <= this->_M_len)
+ {
+   for (; __pos <= this->_M_len - __n; ++__pos)
+     if (traits_type::eq(this->_M_str[__pos], __str[0])
+  && traits_type::compare(this->_M_str + __pos + 1,
+     __str + 1, __n - 1) == 0)
+       return __pos;
+ }
+      return npos;
+    }
+
+  template<typename _CharT, typename _Traits>
+    constexpr typename basic_string_view<_CharT, _Traits>::size_type
+    basic_string_view<_CharT, _Traits>::
+    find(_CharT __c, size_type __pos) const noexcept
+    {
+      size_type __ret = npos;
+      if (__pos < this->_M_len)
+ {
+   const size_type __n = this->_M_len - __pos;
+   const _CharT* __p = traits_type::find(this->_M_str + __pos, __n, __c);
+   if (__p)
+     __ret = __p - this->_M_str;
+ }
+      return __ret;
+    }
+
+  template<typename _CharT, typename _Traits>
+    constexpr typename basic_string_view<_CharT, _Traits>::size_type
+    basic_string_view<_CharT, _Traits>::
+    rfind(const _CharT* __str, size_type __pos, size_type __n) const noexcept
+    {
+      ;
+
+      if (__n <= this->_M_len)
+ {
+   __pos = std::min(size_type(this->_M_len - __n), __pos);
+   do
+     {
+       if (traits_type::compare(this->_M_str + __pos, __str, __n) == 0)
+  return __pos;
+     }
+   while (__pos-- > 0);
+ }
+      return npos;
+    }
+
+  template<typename _CharT, typename _Traits>
+    constexpr typename basic_string_view<_CharT, _Traits>::size_type
+    basic_string_view<_CharT, _Traits>::
+    rfind(_CharT __c, size_type __pos) const noexcept
+    {
+      size_type __size = this->_M_len;
+      if (__size > 0)
+ {
+   if (--__size > __pos)
+     __size = __pos;
+   for (++__size; __size-- > 0; )
+     if (traits_type::eq(this->_M_str[__size], __c))
+       return __size;
+ }
+      return npos;
+    }
+
+  template<typename _CharT, typename _Traits>
+    constexpr typename basic_string_view<_CharT, _Traits>::size_type
+    basic_string_view<_CharT, _Traits>::
+    find_first_of(const _CharT* __str, size_type __pos,
+    size_type __n) const noexcept
+    {
+      ;
+      for (; __n && __pos < this->_M_len; ++__pos)
+ {
+   const _CharT* __p = traits_type::find(__str, __n,
+      this->_M_str[__pos]);
+   if (__p)
+     return __pos;
+ }
+      return npos;
+    }
+
+  template<typename _CharT, typename _Traits>
+    constexpr typename basic_string_view<_CharT, _Traits>::size_type
+    basic_string_view<_CharT, _Traits>::
+    find_last_of(const _CharT* __str, size_type __pos,
+   size_type __n) const noexcept
+    {
+      ;
+      size_type __size = this->size();
+      if (__size && __n)
+ {
+   if (--__size > __pos)
+     __size = __pos;
+   do
+     {
+       if (traits_type::find(__str, __n, this->_M_str[__size]))
+  return __size;
+     }
+   while (__size-- != 0);
+ }
+      return npos;
+    }
+
+  template<typename _CharT, typename _Traits>
+    constexpr typename basic_string_view<_CharT, _Traits>::size_type
+    basic_string_view<_CharT, _Traits>::
+    find_first_not_of(const _CharT* __str, size_type __pos,
+        size_type __n) const noexcept
+    {
+      ;
+      for (; __pos < this->_M_len; ++__pos)
+ if (!traits_type::find(__str, __n, this->_M_str[__pos]))
+   return __pos;
+      return npos;
+    }
+
+  template<typename _CharT, typename _Traits>
+    constexpr typename basic_string_view<_CharT, _Traits>::size_type
+    basic_string_view<_CharT, _Traits>::
+    find_first_not_of(_CharT __c, size_type __pos) const noexcept
+    {
+      for (; __pos < this->_M_len; ++__pos)
+ if (!traits_type::eq(this->_M_str[__pos], __c))
+   return __pos;
+      return npos;
+    }
+
+  template<typename _CharT, typename _Traits>
+    constexpr typename basic_string_view<_CharT, _Traits>::size_type
+    basic_string_view<_CharT, _Traits>::
+    find_last_not_of(const _CharT* __str, size_type __pos,
+       size_type __n) const noexcept
+    {
+      ;
+      size_type __size = this->_M_len;
+      if (__size)
+ {
+   if (--__size > __pos)
+     __size = __pos;
+   do
+     {
+       if (!traits_type::find(__str, __n, this->_M_str[__size]))
+  return __size;
+     }
+   while (__size--);
+ }
+      return npos;
+    }
+
+  template<typename _CharT, typename _Traits>
+    constexpr typename basic_string_view<_CharT, _Traits>::size_type
+    basic_string_view<_CharT, _Traits>::
+    find_last_not_of(_CharT __c, size_type __pos) const noexcept
+    {
+      size_type __size = this->_M_len;
+      if (__size)
+ {
+   if (--__size > __pos)
+     __size = __pos;
+   do
+     {
+       if (!traits_type::eq(this->_M_str[__size], __c))
+  return __size;
+     }
+   while (__size--);
+ }
+      return npos;
+    }
+
+
+}
+# 768 "/usr/include/c++/10.2.0/string_view" 2 3
+# 49 "/usr/include/c++/10.2.0/bits/basic_string.h" 2 3
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+namespace __cxx11 {
+# 76 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    class basic_string
+    {
+      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
+ rebind<_CharT>::other _Char_alloc_type;
+      typedef __gnu_cxx::__alloc_traits<_Char_alloc_type> _Alloc_traits;
+
+
+    public:
+      typedef _Traits traits_type;
+      typedef typename _Traits::char_type value_type;
+      typedef _Char_alloc_type allocator_type;
+      typedef typename _Alloc_traits::size_type size_type;
+      typedef typename _Alloc_traits::difference_type difference_type;
+      typedef typename _Alloc_traits::reference reference;
+      typedef typename _Alloc_traits::const_reference const_reference;
+      typedef typename _Alloc_traits::pointer pointer;
+      typedef typename _Alloc_traits::const_pointer const_pointer;
+      typedef __gnu_cxx::__normal_iterator<pointer, basic_string> iterator;
+      typedef __gnu_cxx::__normal_iterator<const_pointer, basic_string>
+       const_iterator;
+      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+      typedef std::reverse_iterator<iterator> reverse_iterator;
+
+
+      static const size_type npos = static_cast<size_type>(-1);
+
+    protected:
+
+
+
+
+      typedef const_iterator __const_iterator;
+
+
+    private:
+
+
+      typedef basic_string_view<_CharT, _Traits> __sv_type;
+
+      template<typename _Tp, typename _Res>
+ using _If_sv = enable_if_t<
+   __and_<is_convertible<const _Tp&, __sv_type>,
+   __not_<is_convertible<const _Tp*, const basic_string*>>,
+   __not_<is_convertible<const _Tp&, const _CharT*>>>::value,
+   _Res>;
+
+
+      static __sv_type
+      _S_to_string_view(__sv_type __svt) noexcept
+      { return __svt; }
+
+
+
+
+
+      struct __sv_wrapper
+      {
+ explicit __sv_wrapper(__sv_type __sv) noexcept : _M_sv(__sv) { }
+ __sv_type _M_sv;
+      };
+
+
+
+
+
+
+
+      explicit
+      basic_string(__sv_wrapper __svw, const _Alloc& __a)
+      : basic_string(__svw._M_sv.data(), __svw._M_sv.size(), __a) { }
+
+
+
+      struct _Alloc_hider : allocator_type
+      {
+
+
+
+
+ _Alloc_hider(pointer __dat, const _Alloc& __a)
+ : allocator_type(__a), _M_p(__dat) { }
+
+ _Alloc_hider(pointer __dat, _Alloc&& __a = _Alloc())
+ : allocator_type(std::move(__a)), _M_p(__dat) { }
+
+
+ pointer _M_p;
+      };
+
+      _Alloc_hider _M_dataplus;
+      size_type _M_string_length;
+
+      enum { _S_local_capacity = 15 / sizeof(_CharT) };
+
+      union
+      {
+ _CharT _M_local_buf[_S_local_capacity + 1];
+ size_type _M_allocated_capacity;
+      };
+
+      void
+      _M_data(pointer __p)
+      { _M_dataplus._M_p = __p; }
+
+      void
+      _M_length(size_type __length)
+      { _M_string_length = __length; }
+
+      pointer
+      _M_data() const
+      { return _M_dataplus._M_p; }
+
+      pointer
+      _M_local_data()
+      {
+
+ return std::pointer_traits<pointer>::pointer_to(*_M_local_buf);
+
+
+
+      }
+
+      const_pointer
+      _M_local_data() const
+      {
+
+ return std::pointer_traits<const_pointer>::pointer_to(*_M_local_buf);
+
+
+
+      }
+
+      void
+      _M_capacity(size_type __capacity)
+      { _M_allocated_capacity = __capacity; }
+
+      void
+      _M_set_length(size_type __n)
+      {
+ _M_length(__n);
+ traits_type::assign(_M_data()[__n], _CharT());
+      }
+
+      bool
+      _M_is_local() const
+      { return _M_data() == _M_local_data(); }
+
+
+      pointer
+      _M_create(size_type&, size_type);
+
+      void
+      _M_dispose()
+      {
+ if (!_M_is_local())
+   _M_destroy(_M_allocated_capacity);
+      }
+
+      void
+      _M_destroy(size_type __size) throw()
+      { _Alloc_traits::deallocate(_M_get_allocator(), _M_data(), __size + 1); }
+
+
+
+      template<typename _InIterator>
+        void
+        _M_construct_aux(_InIterator __beg, _InIterator __end,
+    std::__false_type)
+ {
+          typedef typename iterator_traits<_InIterator>::iterator_category _Tag;
+          _M_construct(__beg, __end, _Tag());
+ }
+
+
+
+      template<typename _Integer>
+        void
+        _M_construct_aux(_Integer __beg, _Integer __end, std::__true_type)
+ { _M_construct_aux_2(static_cast<size_type>(__beg), __end); }
+
+      void
+      _M_construct_aux_2(size_type __req, _CharT __c)
+      { _M_construct(__req, __c); }
+
+      template<typename _InIterator>
+        void
+        _M_construct(_InIterator __beg, _InIterator __end)
+ {
+   typedef typename std::__is_integer<_InIterator>::__type _Integral;
+   _M_construct_aux(__beg, __end, _Integral());
+        }
+
+
+      template<typename _InIterator>
+        void
+        _M_construct(_InIterator __beg, _InIterator __end,
+       std::input_iterator_tag);
+
+
+
+      template<typename _FwdIterator>
+        void
+        _M_construct(_FwdIterator __beg, _FwdIterator __end,
+       std::forward_iterator_tag);
+
+      void
+      _M_construct(size_type __req, _CharT __c);
+
+      allocator_type&
+      _M_get_allocator()
+      { return _M_dataplus; }
+
+      const allocator_type&
+      _M_get_allocator() const
+      { return _M_dataplus; }
+
+    private:
+# 309 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      size_type
+      _M_check(size_type __pos, const char* __s) const
+      {
+ if (__pos > this->size())
+   __throw_out_of_range_fmt(("%s: __pos (which is %zu) > " "this->size() (which is %zu)")
+                                         ,
+       __s, __pos, this->size());
+ return __pos;
+      }
+
+      void
+      _M_check_length(size_type __n1, size_type __n2, const char* __s) const
+      {
+ if (this->max_size() - (this->size() - __n1) < __n2)
+   __throw_length_error((__s));
+      }
+
+
+
+      size_type
+      _M_limit(size_type __pos, size_type __off) const noexcept
+      {
+ const bool __testoff = __off < this->size() - __pos;
+ return __testoff ? __off : this->size() - __pos;
+      }
+
+
+      bool
+      _M_disjunct(const _CharT* __s) const noexcept
+      {
+ return (less<const _CharT*>()(__s, _M_data())
+  || less<const _CharT*>()(_M_data() + this->size(), __s));
+      }
+
+
+
+      static void
+      _S_copy(_CharT* __d, const _CharT* __s, size_type __n)
+      {
+ if (__n == 1)
+   traits_type::assign(*__d, *__s);
+ else
+   traits_type::copy(__d, __s, __n);
+      }
+
+      static void
+      _S_move(_CharT* __d, const _CharT* __s, size_type __n)
+      {
+ if (__n == 1)
+   traits_type::assign(*__d, *__s);
+ else
+   traits_type::move(__d, __s, __n);
+      }
+
+      static void
+      _S_assign(_CharT* __d, size_type __n, _CharT __c)
+      {
+ if (__n == 1)
+   traits_type::assign(*__d, __c);
+ else
+   traits_type::assign(__d, __n, __c);
+      }
+
+
+
+      template<class _Iterator>
+        static void
+        _S_copy_chars(_CharT* __p, _Iterator __k1, _Iterator __k2)
+        {
+   for (; __k1 != __k2; ++__k1, (void)++__p)
+     traits_type::assign(*__p, *__k1);
+ }
+
+      static void
+      _S_copy_chars(_CharT* __p, iterator __k1, iterator __k2) noexcept
+      { _S_copy_chars(__p, __k1.base(), __k2.base()); }
+
+      static void
+      _S_copy_chars(_CharT* __p, const_iterator __k1, const_iterator __k2)
+      noexcept
+      { _S_copy_chars(__p, __k1.base(), __k2.base()); }
+
+      static void
+      _S_copy_chars(_CharT* __p, _CharT* __k1, _CharT* __k2) noexcept
+      { _S_copy(__p, __k1, __k2 - __k1); }
+
+      static void
+      _S_copy_chars(_CharT* __p, const _CharT* __k1, const _CharT* __k2)
+      noexcept
+      { _S_copy(__p, __k1, __k2 - __k1); }
+
+      static int
+      _S_compare(size_type __n1, size_type __n2) noexcept
+      {
+ const difference_type __d = difference_type(__n1 - __n2);
+
+ if (__d > __gnu_cxx::__numeric_traits<int>::__max)
+   return __gnu_cxx::__numeric_traits<int>::__max;
+ else if (__d < __gnu_cxx::__numeric_traits<int>::__min)
+   return __gnu_cxx::__numeric_traits<int>::__min;
+ else
+   return int(__d);
+      }
+
+      void
+      _M_assign(const basic_string&);
+
+      void
+      _M_mutate(size_type __pos, size_type __len1, const _CharT* __s,
+  size_type __len2);
+
+      void
+      _M_erase(size_type __pos, size_type __n);
+
+    public:
+
+
+
+
+
+
+
+      basic_string()
+      noexcept(is_nothrow_default_constructible<_Alloc>::value)
+      : _M_dataplus(_M_local_data())
+      { _M_set_length(0); }
+
+
+
+
+      explicit
+      basic_string(const _Alloc& __a) noexcept
+      : _M_dataplus(_M_local_data(), __a)
+      { _M_set_length(0); }
+
+
+
+
+
+      basic_string(const basic_string& __str)
+      : _M_dataplus(_M_local_data(),
+      _Alloc_traits::_S_select_on_copy(__str._M_get_allocator()))
+      { _M_construct(__str._M_data(), __str._M_data() + __str.length()); }
+# 461 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      basic_string(const basic_string& __str, size_type __pos,
+     const _Alloc& __a = _Alloc())
+      : _M_dataplus(_M_local_data(), __a)
+      {
+ const _CharT* __start = __str._M_data()
+   + __str._M_check(__pos, "basic_string::basic_string");
+ _M_construct(__start, __start + __str._M_limit(__pos, npos));
+      }
+
+
+
+
+
+
+
+      basic_string(const basic_string& __str, size_type __pos,
+     size_type __n)
+      : _M_dataplus(_M_local_data())
+      {
+ const _CharT* __start = __str._M_data()
+   + __str._M_check(__pos, "basic_string::basic_string");
+ _M_construct(__start, __start + __str._M_limit(__pos, __n));
+      }
+# 492 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      basic_string(const basic_string& __str, size_type __pos,
+     size_type __n, const _Alloc& __a)
+      : _M_dataplus(_M_local_data(), __a)
+      {
+ const _CharT* __start
+   = __str._M_data() + __str._M_check(__pos, "string::string");
+ _M_construct(__start, __start + __str._M_limit(__pos, __n));
+      }
+# 510 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      basic_string(const _CharT* __s, size_type __n,
+     const _Alloc& __a = _Alloc())
+      : _M_dataplus(_M_local_data(), __a)
+      { _M_construct(__s, __s + __n); }
+# 523 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      template<typename = _RequireAllocator<_Alloc>>
+
+      basic_string(const _CharT* __s, const _Alloc& __a = _Alloc())
+      : _M_dataplus(_M_local_data(), __a)
+      { _M_construct(__s, __s ? __s + traits_type::length(__s) : __s+npos); }
+# 538 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      template<typename = _RequireAllocator<_Alloc>>
+
+      basic_string(size_type __n, _CharT __c, const _Alloc& __a = _Alloc())
+      : _M_dataplus(_M_local_data(), __a)
+      { _M_construct(__n, __c); }
+# 552 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      basic_string(basic_string&& __str) noexcept
+      : _M_dataplus(_M_local_data(), std::move(__str._M_get_allocator()))
+      {
+ if (__str._M_is_local())
+   {
+     traits_type::copy(_M_local_buf, __str._M_local_buf,
+         _S_local_capacity + 1);
+   }
+ else
+   {
+     _M_data(__str._M_data());
+     _M_capacity(__str._M_allocated_capacity);
+   }
+
+
+
+
+ _M_length(__str.length());
+ __str._M_data(__str._M_local_data());
+ __str._M_set_length(0);
+      }
+
+
+
+
+
+
+      basic_string(initializer_list<_CharT> __l, const _Alloc& __a = _Alloc())
+      : _M_dataplus(_M_local_data(), __a)
+      { _M_construct(__l.begin(), __l.end()); }
+
+      basic_string(const basic_string& __str, const _Alloc& __a)
+      : _M_dataplus(_M_local_data(), __a)
+      { _M_construct(__str.begin(), __str.end()); }
+
+      basic_string(basic_string&& __str, const _Alloc& __a)
+      noexcept(_Alloc_traits::_S_always_equal())
+      : _M_dataplus(_M_local_data(), __a)
+      {
+ if (__str._M_is_local())
+   {
+     traits_type::copy(_M_local_buf, __str._M_local_buf,
+         _S_local_capacity + 1);
+     _M_length(__str.length());
+     __str._M_set_length(0);
+   }
+ else if (_Alloc_traits::_S_always_equal()
+     || __str.get_allocator() == __a)
+   {
+     _M_data(__str._M_data());
+     _M_length(__str.length());
+     _M_capacity(__str._M_allocated_capacity);
+     __str._M_data(__str._M_local_buf);
+     __str._M_set_length(0);
+   }
+ else
+   _M_construct(__str.begin(), __str.end());
+      }
+# 620 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      template<typename _InputIterator,
+        typename = std::_RequireInputIter<_InputIterator>>
+
+
+
+        basic_string(_InputIterator __beg, _InputIterator __end,
+       const _Alloc& __a = _Alloc())
+ : _M_dataplus(_M_local_data(), __a)
+ { _M_construct(__beg, __end); }
+# 638 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      template<typename _Tp, typename = _If_sv<_Tp, void>>
+ basic_string(const _Tp& __t, size_type __pos, size_type __n,
+       const _Alloc& __a = _Alloc())
+ : basic_string(_S_to_string_view(__t).substr(__pos, __n), __a) { }
+
+
+
+
+
+
+      template<typename _Tp, typename = _If_sv<_Tp, void>>
+ explicit
+ basic_string(const _Tp& __t, const _Alloc& __a = _Alloc())
+ : basic_string(__sv_wrapper(_S_to_string_view(__t)), __a) { }
+
+
+
+
+
+      ~basic_string()
+      { _M_dispose(); }
+
+
+
+
+
+      basic_string&
+      operator=(const basic_string& __str)
+      {
+ return this->assign(__str);
+      }
+
+
+
+
+
+      basic_string&
+      operator=(const _CharT* __s)
+      { return this->assign(__s); }
+# 685 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      basic_string&
+      operator=(_CharT __c)
+      {
+ this->assign(1, __c);
+ return *this;
+      }
+# 702 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      basic_string&
+      operator=(basic_string&& __str)
+      noexcept(_Alloc_traits::_S_nothrow_move())
+      {
+ if (!_M_is_local() && _Alloc_traits::_S_propagate_on_move_assign()
+     && !_Alloc_traits::_S_always_equal()
+     && _M_get_allocator() != __str._M_get_allocator())
+   {
+
+     _M_destroy(_M_allocated_capacity);
+     _M_data(_M_local_data());
+     _M_set_length(0);
+   }
+
+ std::__alloc_on_move(_M_get_allocator(), __str._M_get_allocator());
+
+ if (__str._M_is_local())
+   {
+
+     if (__str.size())
+       this->_S_copy(_M_data(), __str._M_data(), __str.size());
+     _M_set_length(__str.size());
+   }
+ else if (_Alloc_traits::_S_propagate_on_move_assign()
+     || _Alloc_traits::_S_always_equal()
+     || _M_get_allocator() == __str._M_get_allocator())
+   {
+
+     pointer __data = nullptr;
+     size_type __capacity;
+     if (!_M_is_local())
+       {
+  if (_Alloc_traits::_S_always_equal())
+    {
+
+      __data = _M_data();
+      __capacity = _M_allocated_capacity;
+    }
+  else
+    _M_destroy(_M_allocated_capacity);
+       }
+
+     _M_data(__str._M_data());
+     _M_length(__str.length());
+     _M_capacity(__str._M_allocated_capacity);
+     if (__data)
+       {
+  __str._M_data(__data);
+  __str._M_capacity(__capacity);
+       }
+     else
+       __str._M_data(__str._M_local_buf);
+   }
+ else
+   assign(__str);
+ __str.clear();
+ return *this;
+      }
+
+
+
+
+
+      basic_string&
+      operator=(initializer_list<_CharT> __l)
+      {
+ this->assign(__l.begin(), __l.size());
+ return *this;
+      }
+
+
+
+
+
+
+
+     template<typename _Tp>
+       _If_sv<_Tp, basic_string&>
+       operator=(const _Tp& __svt)
+       { return this->assign(__svt); }
+
+
+
+
+
+      operator __sv_type() const noexcept
+      { return __sv_type(data(), size()); }
+
+
+
+
+
+
+
+      iterator
+      begin() noexcept
+      { return iterator(_M_data()); }
+
+
+
+
+
+      const_iterator
+      begin() const noexcept
+      { return const_iterator(_M_data()); }
+
+
+
+
+
+      iterator
+      end() noexcept
+      { return iterator(_M_data() + this->size()); }
+
+
+
+
+
+      const_iterator
+      end() const noexcept
+      { return const_iterator(_M_data() + this->size()); }
+
+
+
+
+
+
+      reverse_iterator
+      rbegin() noexcept
+      { return reverse_iterator(this->end()); }
+
+
+
+
+
+
+      const_reverse_iterator
+      rbegin() const noexcept
+      { return const_reverse_iterator(this->end()); }
+
+
+
+
+
+
+      reverse_iterator
+      rend() noexcept
+      { return reverse_iterator(this->begin()); }
+
+
+
+
+
+
+      const_reverse_iterator
+      rend() const noexcept
+      { return const_reverse_iterator(this->begin()); }
+
+
+
+
+
+
+      const_iterator
+      cbegin() const noexcept
+      { return const_iterator(this->_M_data()); }
+
+
+
+
+
+      const_iterator
+      cend() const noexcept
+      { return const_iterator(this->_M_data() + this->size()); }
+
+
+
+
+
+
+      const_reverse_iterator
+      crbegin() const noexcept
+      { return const_reverse_iterator(this->end()); }
+
+
+
+
+
+
+      const_reverse_iterator
+      crend() const noexcept
+      { return const_reverse_iterator(this->begin()); }
+
+
+    public:
+
+
+
+      size_type
+      size() const noexcept
+      { return _M_string_length; }
+
+
+
+      size_type
+      length() const noexcept
+      { return _M_string_length; }
+
+
+      size_type
+      max_size() const noexcept
+      { return (_Alloc_traits::max_size(_M_get_allocator()) - 1) / 2; }
+# 925 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      void
+      resize(size_type __n, _CharT __c);
+# 938 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      void
+      resize(size_type __n)
+      { this->resize(__n, _CharT()); }
+
+
+
+      void
+      shrink_to_fit() noexcept
+      {
+
+ if (capacity() > size())
+   {
+     try
+       { reserve(0); }
+     catch(...)
+       { }
+   }
+
+      }
+
+
+
+
+
+
+      size_type
+      capacity() const noexcept
+      {
+ return _M_is_local() ? size_type(_S_local_capacity)
+                      : _M_allocated_capacity;
+      }
+# 987 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      void
+      reserve(size_type __res_arg = 0);
+
+
+
+
+      void
+      clear() noexcept
+      { _M_set_length(0); }
+
+
+
+
+
+      [[__nodiscard__]] bool
+      empty() const noexcept
+      { return this->size() == 0; }
+# 1016 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      const_reference
+      operator[] (size_type __pos) const noexcept
+      {
+ ;
+ return _M_data()[__pos];
+      }
+# 1033 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      reference
+      operator[](size_type __pos)
+      {
+
+
+ ;
+
+ ;
+ return _M_data()[__pos];
+      }
+# 1054 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      const_reference
+      at(size_type __n) const
+      {
+ if (__n >= this->size())
+   __throw_out_of_range_fmt(("basic_string::at: __n " "(which is %zu) >= this->size() " "(which is %zu)")
+
+                            ,
+       __n, this->size());
+ return _M_data()[__n];
+      }
+# 1075 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      reference
+      at(size_type __n)
+      {
+ if (__n >= size())
+   __throw_out_of_range_fmt(("basic_string::at: __n " "(which is %zu) >= this->size() " "(which is %zu)")
+
+                            ,
+       __n, this->size());
+ return _M_data()[__n];
+      }
+
+
+
+
+
+
+      reference
+      front() noexcept
+      {
+ ;
+ return operator[](0);
+      }
+
+
+
+
+
+      const_reference
+      front() const noexcept
+      {
+ ;
+ return operator[](0);
+      }
+
+
+
+
+
+      reference
+      back() noexcept
+      {
+ ;
+ return operator[](this->size() - 1);
+      }
+
+
+
+
+
+      const_reference
+      back() const noexcept
+      {
+ ;
+ return operator[](this->size() - 1);
+      }
+# 1138 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      basic_string&
+      operator+=(const basic_string& __str)
+      { return this->append(__str); }
+
+
+
+
+
+
+      basic_string&
+      operator+=(const _CharT* __s)
+      { return this->append(__s); }
+
+
+
+
+
+
+      basic_string&
+      operator+=(_CharT __c)
+      {
+ this->push_back(__c);
+ return *this;
+      }
+
+
+
+
+
+
+
+      basic_string&
+      operator+=(initializer_list<_CharT> __l)
+      { return this->append(__l.begin(), __l.size()); }
+# 1180 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      template<typename _Tp>
+ _If_sv<_Tp, basic_string&>
+ operator+=(const _Tp& __svt)
+ { return this->append(__svt); }
+
+
+
+
+
+
+
+      basic_string&
+      append(const basic_string& __str)
+      { return _M_append(__str._M_data(), __str.size()); }
+# 1208 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      basic_string&
+      append(const basic_string& __str, size_type __pos, size_type __n = npos)
+      { return _M_append(__str._M_data()
+    + __str._M_check(__pos, "basic_string::append"),
+    __str._M_limit(__pos, __n)); }
+
+
+
+
+
+
+
+      basic_string&
+      append(const _CharT* __s, size_type __n)
+      {
+ ;
+ _M_check_length(size_type(0), __n, "basic_string::append");
+ return _M_append(__s, __n);
+      }
+
+
+
+
+
+
+      basic_string&
+      append(const _CharT* __s)
+      {
+ ;
+ const size_type __n = traits_type::length(__s);
+ _M_check_length(size_type(0), __n, "basic_string::append");
+ return _M_append(__s, __n);
+      }
+# 1250 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      basic_string&
+      append(size_type __n, _CharT __c)
+      { return _M_replace_aux(this->size(), size_type(0), __n, __c); }
+
+
+
+
+
+
+
+      basic_string&
+      append(initializer_list<_CharT> __l)
+      { return this->append(__l.begin(), __l.size()); }
+# 1274 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      template<class _InputIterator,
+        typename = std::_RequireInputIter<_InputIterator>>
+
+
+
+        basic_string&
+        append(_InputIterator __first, _InputIterator __last)
+        { return this->replace(end(), end(), __first, __last); }
+
+
+
+
+
+
+
+      template<typename _Tp>
+        _If_sv<_Tp, basic_string&>
+        append(const _Tp& __svt)
+        {
+          __sv_type __sv = __svt;
+          return this->append(__sv.data(), __sv.size());
+        }
+# 1304 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      template<typename _Tp>
+        _If_sv<_Tp, basic_string&>
+ append(const _Tp& __svt, size_type __pos, size_type __n = npos)
+ {
+   __sv_type __sv = __svt;
+   return _M_append(__sv.data()
+       + std::__sv_check(__sv.size(), __pos, "basic_string::append"),
+       std::__sv_limit(__sv.size(), __pos, __n));
+ }
+
+
+
+
+
+
+      void
+      push_back(_CharT __c)
+      {
+ const size_type __size = this->size();
+ if (__size + 1 > this->capacity())
+   this->_M_mutate(__size, size_type(0), 0, size_type(1));
+ traits_type::assign(this->_M_data()[__size], __c);
+ this->_M_set_length(__size + 1);
+      }
+
+
+
+
+
+
+      basic_string&
+      assign(const basic_string& __str)
+      {
+
+ if (_Alloc_traits::_S_propagate_on_copy_assign())
+   {
+     if (!_Alloc_traits::_S_always_equal() && !_M_is_local()
+  && _M_get_allocator() != __str._M_get_allocator())
+       {
+
+
+  if (__str.size() <= _S_local_capacity)
+    {
+      _M_destroy(_M_allocated_capacity);
+      _M_data(_M_local_data());
+      _M_set_length(0);
+    }
+  else
+    {
+      const auto __len = __str.size();
+      auto __alloc = __str._M_get_allocator();
+
+      auto __ptr = _Alloc_traits::allocate(__alloc, __len + 1);
+      _M_destroy(_M_allocated_capacity);
+      _M_data(__ptr);
+      _M_capacity(__len);
+      _M_set_length(__len);
+    }
+       }
+     std::__alloc_on_copy(_M_get_allocator(), __str._M_get_allocator());
+   }
+
+ this->_M_assign(__str);
+ return *this;
+      }
+# 1379 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      basic_string&
+      assign(basic_string&& __str)
+      noexcept(_Alloc_traits::_S_nothrow_move())
+      {
+
+
+ return *this = std::move(__str);
+      }
+# 1402 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      basic_string&
+      assign(const basic_string& __str, size_type __pos, size_type __n = npos)
+      { return _M_replace(size_type(0), this->size(), __str._M_data()
+     + __str._M_check(__pos, "basic_string::assign"),
+     __str._M_limit(__pos, __n)); }
+# 1418 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      basic_string&
+      assign(const _CharT* __s, size_type __n)
+      {
+ ;
+ return _M_replace(size_type(0), this->size(), __s, __n);
+      }
+# 1434 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      basic_string&
+      assign(const _CharT* __s)
+      {
+ ;
+ return _M_replace(size_type(0), this->size(), __s,
+     traits_type::length(__s));
+      }
+# 1451 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      basic_string&
+      assign(size_type __n, _CharT __c)
+      { return _M_replace_aux(size_type(0), this->size(), __n, __c); }
+# 1464 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      template<class _InputIterator,
+        typename = std::_RequireInputIter<_InputIterator>>
+
+
+
+        basic_string&
+        assign(_InputIterator __first, _InputIterator __last)
+        { return this->replace(begin(), end(), __first, __last); }
+
+
+
+
+
+
+
+      basic_string&
+      assign(initializer_list<_CharT> __l)
+      { return this->assign(__l.begin(), __l.size()); }
+# 1490 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      template<typename _Tp>
+ _If_sv<_Tp, basic_string&>
+ assign(const _Tp& __svt)
+ {
+   __sv_type __sv = __svt;
+   return this->assign(__sv.data(), __sv.size());
+ }
+# 1505 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      template<typename _Tp>
+ _If_sv<_Tp, basic_string&>
+ assign(const _Tp& __svt, size_type __pos, size_type __n = npos)
+ {
+   __sv_type __sv = __svt;
+   return _M_replace(size_type(0), this->size(),
+       __sv.data()
+       + std::__sv_check(__sv.size(), __pos, "basic_string::assign"),
+       std::__sv_limit(__sv.size(), __pos, __n));
+ }
+# 1533 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      iterator
+      insert(const_iterator __p, size_type __n, _CharT __c)
+      {
+ ;
+ const size_type __pos = __p - begin();
+ this->replace(__p, __p, __n, __c);
+ return iterator(this->_M_data() + __pos);
+      }
+# 1575 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      template<class _InputIterator,
+        typename = std::_RequireInputIter<_InputIterator>>
+ iterator
+        insert(const_iterator __p, _InputIterator __beg, _InputIterator __end)
+        {
+   ;
+   const size_type __pos = __p - begin();
+   this->replace(__p, __p, __beg, __end);
+   return iterator(this->_M_data() + __pos);
+ }
+# 1611 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      iterator
+      insert(const_iterator __p, initializer_list<_CharT> __l)
+      { return this->insert(__p, __l.begin(), __l.end()); }
+# 1638 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      basic_string&
+      insert(size_type __pos1, const basic_string& __str)
+      { return this->replace(__pos1, size_type(0),
+        __str._M_data(), __str.size()); }
+# 1661 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      basic_string&
+      insert(size_type __pos1, const basic_string& __str,
+      size_type __pos2, size_type __n = npos)
+      { return this->replace(__pos1, size_type(0), __str._M_data()
+        + __str._M_check(__pos2, "basic_string::insert"),
+        __str._M_limit(__pos2, __n)); }
+# 1684 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      basic_string&
+      insert(size_type __pos, const _CharT* __s, size_type __n)
+      { return this->replace(__pos, size_type(0), __s, __n); }
+# 1703 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      basic_string&
+      insert(size_type __pos, const _CharT* __s)
+      {
+ ;
+ return this->replace(__pos, size_type(0), __s,
+        traits_type::length(__s));
+      }
+# 1727 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      basic_string&
+      insert(size_type __pos, size_type __n, _CharT __c)
+      { return _M_replace_aux(_M_check(__pos, "basic_string::insert"),
+         size_type(0), __n, __c); }
+# 1745 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      iterator
+      insert(__const_iterator __p, _CharT __c)
+      {
+ ;
+ const size_type __pos = __p - begin();
+ _M_replace_aux(__pos, size_type(0), size_type(1), __c);
+ return iterator(_M_data() + __pos);
+      }
+# 1761 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      template<typename _Tp>
+ _If_sv<_Tp, basic_string&>
+ insert(size_type __pos, const _Tp& __svt)
+ {
+   __sv_type __sv = __svt;
+   return this->insert(__pos, __sv.data(), __sv.size());
+ }
+# 1777 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      template<typename _Tp>
+ _If_sv<_Tp, basic_string&>
+ insert(size_type __pos1, const _Tp& __svt,
+        size_type __pos2, size_type __n = npos)
+ {
+   __sv_type __sv = __svt;
+   return this->replace(__pos1, size_type(0),
+       __sv.data()
+       + std::__sv_check(__sv.size(), __pos2, "basic_string::insert"),
+       std::__sv_limit(__sv.size(), __pos2, __n));
+ }
+# 1805 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      basic_string&
+      erase(size_type __pos = 0, size_type __n = npos)
+      {
+ _M_check(__pos, "basic_string::erase");
+ if (__n == npos)
+   this->_M_set_length(__pos);
+ else if (__n != 0)
+   this->_M_erase(__pos, _M_limit(__pos, __n));
+ return *this;
+      }
+# 1824 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      iterator
+      erase(__const_iterator __position)
+      {
+
+                           ;
+ const size_type __pos = __position - begin();
+ this->_M_erase(__pos, size_type(1));
+ return iterator(_M_data() + __pos);
+      }
+# 1843 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      iterator
+      erase(__const_iterator __first, __const_iterator __last)
+      {
+
+                        ;
+        const size_type __pos = __first - begin();
+ if (__last == end())
+   this->_M_set_length(__pos);
+ else
+   this->_M_erase(__pos, __last - __first);
+ return iterator(this->_M_data() + __pos);
+      }
+
+
+
+
+
+
+
+      void
+      pop_back() noexcept
+      {
+ ;
+ _M_erase(size() - 1, 1);
+      }
+# 1887 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      basic_string&
+      replace(size_type __pos, size_type __n, const basic_string& __str)
+      { return this->replace(__pos, __n, __str._M_data(), __str.size()); }
+# 1909 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      basic_string&
+      replace(size_type __pos1, size_type __n1, const basic_string& __str,
+       size_type __pos2, size_type __n2 = npos)
+      { return this->replace(__pos1, __n1, __str._M_data()
+        + __str._M_check(__pos2, "basic_string::replace"),
+        __str._M_limit(__pos2, __n2)); }
+# 1934 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      basic_string&
+      replace(size_type __pos, size_type __n1, const _CharT* __s,
+       size_type __n2)
+      {
+ ;
+ return _M_replace(_M_check(__pos, "basic_string::replace"),
+     _M_limit(__pos, __n1), __s, __n2);
+      }
+# 1959 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      basic_string&
+      replace(size_type __pos, size_type __n1, const _CharT* __s)
+      {
+ ;
+ return this->replace(__pos, __n1, __s, traits_type::length(__s));
+      }
+# 1983 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      basic_string&
+      replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c)
+      { return _M_replace_aux(_M_check(__pos, "basic_string::replace"),
+         _M_limit(__pos, __n1), __n2, __c); }
+# 2001 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      basic_string&
+      replace(__const_iterator __i1, __const_iterator __i2,
+       const basic_string& __str)
+      { return this->replace(__i1, __i2, __str._M_data(), __str.size()); }
+# 2021 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      basic_string&
+      replace(__const_iterator __i1, __const_iterator __i2,
+       const _CharT* __s, size_type __n)
+      {
+
+                      ;
+ return this->replace(__i1 - begin(), __i2 - __i1, __s, __n);
+      }
+# 2043 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      basic_string&
+      replace(__const_iterator __i1, __const_iterator __i2, const _CharT* __s)
+      {
+ ;
+ return this->replace(__i1, __i2, __s, traits_type::length(__s));
+      }
+# 2064 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      basic_string&
+      replace(__const_iterator __i1, __const_iterator __i2, size_type __n,
+       _CharT __c)
+      {
+
+                      ;
+ return _M_replace_aux(__i1 - begin(), __i2 - __i1, __n, __c);
+      }
+# 2089 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      template<class _InputIterator,
+        typename = std::_RequireInputIter<_InputIterator>>
+        basic_string&
+        replace(const_iterator __i1, const_iterator __i2,
+  _InputIterator __k1, _InputIterator __k2)
+        {
+  
+                        ;
+   ;
+   return this->_M_replace_dispatch(__i1, __i2, __k1, __k2,
+        std::__false_type());
+ }
+# 2121 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      basic_string&
+      replace(__const_iterator __i1, __const_iterator __i2,
+       _CharT* __k1, _CharT* __k2)
+      {
+
+                      ;
+ ;
+ return this->replace(__i1 - begin(), __i2 - __i1,
+        __k1, __k2 - __k1);
+      }
+
+      basic_string&
+      replace(__const_iterator __i1, __const_iterator __i2,
+       const _CharT* __k1, const _CharT* __k2)
+      {
+
+                      ;
+ ;
+ return this->replace(__i1 - begin(), __i2 - __i1,
+        __k1, __k2 - __k1);
+      }
+
+      basic_string&
+      replace(__const_iterator __i1, __const_iterator __i2,
+       iterator __k1, iterator __k2)
+      {
+
+                      ;
+ ;
+ return this->replace(__i1 - begin(), __i2 - __i1,
+        __k1.base(), __k2 - __k1);
+      }
+
+      basic_string&
+      replace(__const_iterator __i1, __const_iterator __i2,
+       const_iterator __k1, const_iterator __k2)
+      {
+
+                      ;
+ ;
+ return this->replace(__i1 - begin(), __i2 - __i1,
+        __k1.base(), __k2 - __k1);
+      }
+# 2180 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      basic_string& replace(const_iterator __i1, const_iterator __i2,
+       initializer_list<_CharT> __l)
+      { return this->replace(__i1, __i2, __l.begin(), __l.size()); }
+# 2193 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      template<typename _Tp>
+ _If_sv<_Tp, basic_string&>
+ replace(size_type __pos, size_type __n, const _Tp& __svt)
+ {
+   __sv_type __sv = __svt;
+   return this->replace(__pos, __n, __sv.data(), __sv.size());
+ }
+# 2210 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      template<typename _Tp>
+ _If_sv<_Tp, basic_string&>
+ replace(size_type __pos1, size_type __n1, const _Tp& __svt,
+  size_type __pos2, size_type __n2 = npos)
+ {
+   __sv_type __sv = __svt;
+   return this->replace(__pos1, __n1,
+       __sv.data()
+       + std::__sv_check(__sv.size(), __pos2, "basic_string::replace"),
+       std::__sv_limit(__sv.size(), __pos2, __n2));
+ }
+# 2231 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      template<typename _Tp>
+ _If_sv<_Tp, basic_string&>
+ replace(const_iterator __i1, const_iterator __i2, const _Tp& __svt)
+ {
+   __sv_type __sv = __svt;
+   return this->replace(__i1 - begin(), __i2 - __i1, __sv);
+ }
+
+
+    private:
+      template<class _Integer>
+ basic_string&
+ _M_replace_dispatch(const_iterator __i1, const_iterator __i2,
+       _Integer __n, _Integer __val, __true_type)
+        { return _M_replace_aux(__i1 - begin(), __i2 - __i1, __n, __val); }
+
+      template<class _InputIterator>
+ basic_string&
+ _M_replace_dispatch(const_iterator __i1, const_iterator __i2,
+       _InputIterator __k1, _InputIterator __k2,
+       __false_type);
+
+      basic_string&
+      _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
+       _CharT __c);
+
+      basic_string&
+      _M_replace(size_type __pos, size_type __len1, const _CharT* __s,
+   const size_type __len2);
+
+      basic_string&
+      _M_append(const _CharT* __s, size_type __n);
+
+    public:
+# 2278 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      size_type
+      copy(_CharT* __s, size_type __n, size_type __pos = 0) const;
+# 2288 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      void
+      swap(basic_string& __s) noexcept;
+# 2298 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      const _CharT*
+      c_str() const noexcept
+      { return _M_data(); }
+# 2310 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      const _CharT*
+      data() const noexcept
+      { return _M_data(); }
+# 2321 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      _CharT*
+      data() noexcept
+      { return _M_data(); }
+
+
+
+
+
+      allocator_type
+      get_allocator() const noexcept
+      { return _M_get_allocator(); }
+# 2345 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      size_type
+      find(const _CharT* __s, size_type __pos, size_type __n) const
+      noexcept;
+# 2359 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      size_type
+      find(const basic_string& __str, size_type __pos = 0) const
+      noexcept
+      { return this->find(__str.data(), __pos, __str.size()); }
+# 2371 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      template<typename _Tp>
+ _If_sv<_Tp, size_type>
+ find(const _Tp& __svt, size_type __pos = 0) const
+ noexcept(is_same<_Tp, __sv_type>::value)
+ {
+   __sv_type __sv = __svt;
+   return this->find(__sv.data(), __pos, __sv.size());
+ }
+# 2391 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      size_type
+      find(const _CharT* __s, size_type __pos = 0) const noexcept
+      {
+ ;
+ return this->find(__s, __pos, traits_type::length(__s));
+      }
+# 2408 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      size_type
+      find(_CharT __c, size_type __pos = 0) const noexcept;
+# 2421 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      size_type
+      rfind(const basic_string& __str, size_type __pos = npos) const
+      noexcept
+      { return this->rfind(__str.data(), __pos, __str.size()); }
+# 2433 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      template<typename _Tp>
+ _If_sv<_Tp, size_type>
+ rfind(const _Tp& __svt, size_type __pos = npos) const
+ noexcept(is_same<_Tp, __sv_type>::value)
+ {
+   __sv_type __sv = __svt;
+   return this->rfind(__sv.data(), __pos, __sv.size());
+ }
+# 2455 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      size_type
+      rfind(const _CharT* __s, size_type __pos, size_type __n) const
+      noexcept;
+# 2469 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      size_type
+      rfind(const _CharT* __s, size_type __pos = npos) const
+      {
+ ;
+ return this->rfind(__s, __pos, traits_type::length(__s));
+      }
+# 2486 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      size_type
+      rfind(_CharT __c, size_type __pos = npos) const noexcept;
+# 2500 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      size_type
+      find_first_of(const basic_string& __str, size_type __pos = 0) const
+      noexcept
+      { return this->find_first_of(__str.data(), __pos, __str.size()); }
+# 2513 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      template<typename _Tp>
+ _If_sv<_Tp, size_type>
+ find_first_of(const _Tp& __svt, size_type __pos = 0) const
+ noexcept(is_same<_Tp, __sv_type>::value)
+ {
+   __sv_type __sv = __svt;
+   return this->find_first_of(__sv.data(), __pos, __sv.size());
+ }
+# 2535 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      size_type
+      find_first_of(const _CharT* __s, size_type __pos, size_type __n) const
+      noexcept;
+# 2549 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      size_type
+      find_first_of(const _CharT* __s, size_type __pos = 0) const
+      noexcept
+      {
+ ;
+ return this->find_first_of(__s, __pos, traits_type::length(__s));
+      }
+# 2569 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      size_type
+      find_first_of(_CharT __c, size_type __pos = 0) const noexcept
+      { return this->find(__c, __pos); }
+# 2584 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      size_type
+      find_last_of(const basic_string& __str, size_type __pos = npos) const
+      noexcept
+      { return this->find_last_of(__str.data(), __pos, __str.size()); }
+# 2597 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      template<typename _Tp>
+ _If_sv<_Tp, size_type>
+ find_last_of(const _Tp& __svt, size_type __pos = npos) const
+ noexcept(is_same<_Tp, __sv_type>::value)
+ {
+   __sv_type __sv = __svt;
+   return this->find_last_of(__sv.data(), __pos, __sv.size());
+ }
+# 2619 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      size_type
+      find_last_of(const _CharT* __s, size_type __pos, size_type __n) const
+      noexcept;
+# 2633 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      size_type
+      find_last_of(const _CharT* __s, size_type __pos = npos) const
+      noexcept
+      {
+ ;
+ return this->find_last_of(__s, __pos, traits_type::length(__s));
+      }
+# 2653 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      size_type
+      find_last_of(_CharT __c, size_type __pos = npos) const noexcept
+      { return this->rfind(__c, __pos); }
+# 2667 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      size_type
+      find_first_not_of(const basic_string& __str, size_type __pos = 0) const
+      noexcept
+      { return this->find_first_not_of(__str.data(), __pos, __str.size()); }
+# 2680 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      template<typename _Tp>
+ _If_sv<_Tp, size_type>
+ find_first_not_of(const _Tp& __svt, size_type __pos = 0) const
+ noexcept(is_same<_Tp, __sv_type>::value)
+ {
+   __sv_type __sv = __svt;
+   return this->find_first_not_of(__sv.data(), __pos, __sv.size());
+ }
+# 2702 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      size_type
+      find_first_not_of(const _CharT* __s, size_type __pos,
+   size_type __n) const noexcept;
+# 2716 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      size_type
+      find_first_not_of(const _CharT* __s, size_type __pos = 0) const
+      noexcept
+      {
+ ;
+ return this->find_first_not_of(__s, __pos, traits_type::length(__s));
+      }
+# 2734 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      size_type
+      find_first_not_of(_CharT __c, size_type __pos = 0) const
+      noexcept;
+# 2749 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      size_type
+      find_last_not_of(const basic_string& __str, size_type __pos = npos) const
+      noexcept
+      { return this->find_last_not_of(__str.data(), __pos, __str.size()); }
+# 2762 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      template<typename _Tp>
+ _If_sv<_Tp, size_type>
+ find_last_not_of(const _Tp& __svt, size_type __pos = npos) const
+ noexcept(is_same<_Tp, __sv_type>::value)
+ {
+   __sv_type __sv = __svt;
+   return this->find_last_not_of(__sv.data(), __pos, __sv.size());
+ }
+# 2784 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      size_type
+      find_last_not_of(const _CharT* __s, size_type __pos,
+         size_type __n) const noexcept;
+# 2798 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      size_type
+      find_last_not_of(const _CharT* __s, size_type __pos = npos) const
+      noexcept
+      {
+ ;
+ return this->find_last_not_of(__s, __pos, traits_type::length(__s));
+      }
+# 2816 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      size_type
+      find_last_not_of(_CharT __c, size_type __pos = npos) const
+      noexcept;
+# 2832 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      basic_string
+      substr(size_type __pos = 0, size_type __n = npos) const
+      { return basic_string(*this,
+       _M_check(__pos, "basic_string::substr"), __n); }
+# 2851 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      int
+      compare(const basic_string& __str) const
+      {
+ const size_type __size = this->size();
+ const size_type __osize = __str.size();
+ const size_type __len = std::min(__size, __osize);
+
+ int __r = traits_type::compare(_M_data(), __str.data(), __len);
+ if (!__r)
+   __r = _S_compare(__size, __osize);
+ return __r;
+      }
+
+
+
+
+
+
+
+      template<typename _Tp>
+ _If_sv<_Tp, int>
+ compare(const _Tp& __svt) const
+ noexcept(is_same<_Tp, __sv_type>::value)
+ {
+   __sv_type __sv = __svt;
+   const size_type __size = this->size();
+   const size_type __osize = __sv.size();
+   const size_type __len = std::min(__size, __osize);
+
+   int __r = traits_type::compare(_M_data(), __sv.data(), __len);
+   if (!__r)
+     __r = _S_compare(__size, __osize);
+   return __r;
+ }
+# 2894 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      template<typename _Tp>
+ _If_sv<_Tp, int>
+ compare(size_type __pos, size_type __n, const _Tp& __svt) const
+ noexcept(is_same<_Tp, __sv_type>::value)
+ {
+   __sv_type __sv = __svt;
+   return __sv_type(*this).substr(__pos, __n).compare(__sv);
+ }
+# 2913 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      template<typename _Tp>
+ _If_sv<_Tp, int>
+ compare(size_type __pos1, size_type __n1, const _Tp& __svt,
+  size_type __pos2, size_type __n2 = npos) const
+ noexcept(is_same<_Tp, __sv_type>::value)
+ {
+   __sv_type __sv = __svt;
+   return __sv_type(*this)
+     .substr(__pos1, __n1).compare(__sv.substr(__pos2, __n2));
+ }
+# 2944 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      int
+      compare(size_type __pos, size_type __n, const basic_string& __str) const;
+# 2970 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      int
+      compare(size_type __pos1, size_type __n1, const basic_string& __str,
+       size_type __pos2, size_type __n2 = npos) const;
+# 2988 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      int
+      compare(const _CharT* __s) const noexcept;
+# 3012 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      int
+      compare(size_type __pos, size_type __n1, const _CharT* __s) const;
+# 3039 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      int
+      compare(size_type __pos, size_type __n1, const _CharT* __s,
+       size_type __n2) const;
+# 3070 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      template<typename, typename, typename> friend class basic_stringbuf;
+    };
+}
+# 5985 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+namespace __cxx11 {
+  template<typename _InputIterator, typename _CharT
+      = typename iterator_traits<_InputIterator>::value_type,
+    typename _Allocator = allocator<_CharT>,
+    typename = _RequireInputIter<_InputIterator>,
+    typename = _RequireAllocator<_Allocator>>
+    basic_string(_InputIterator, _InputIterator, _Allocator = _Allocator())
+      -> basic_string<_CharT, char_traits<_CharT>, _Allocator>;
+
+
+
+  template<typename _CharT, typename _Traits,
+    typename _Allocator = allocator<_CharT>,
+    typename = _RequireAllocator<_Allocator>>
+    basic_string(basic_string_view<_CharT, _Traits>, const _Allocator& = _Allocator())
+      -> basic_string<_CharT, _Traits, _Allocator>;
+
+  template<typename _CharT, typename _Traits,
+    typename _Allocator = allocator<_CharT>,
+    typename = _RequireAllocator<_Allocator>>
+    basic_string(basic_string_view<_CharT, _Traits>,
+   typename basic_string<_CharT, _Traits, _Allocator>::size_type,
+   typename basic_string<_CharT, _Traits, _Allocator>::size_type,
+   const _Allocator& = _Allocator())
+      -> basic_string<_CharT, _Traits, _Allocator>;
+}
+# 6020 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>
+    operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    {
+      basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
+      __str.append(__rhs);
+      return __str;
+    }
+
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT,_Traits,_Alloc>
+    operator+(const _CharT* __lhs,
+       const basic_string<_CharT,_Traits,_Alloc>& __rhs);
+
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT,_Traits,_Alloc>
+    operator+(_CharT __lhs, const basic_string<_CharT,_Traits,_Alloc>& __rhs);
+
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_string<_CharT, _Traits, _Alloc>
+    operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+       const _CharT* __rhs)
+    {
+      basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
+      __str.append(__rhs);
+      return __str;
+    }
+
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_string<_CharT, _Traits, _Alloc>
+    operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, _CharT __rhs)
+    {
+      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
+      typedef typename __string_type::size_type __size_type;
+      __string_type __str(__lhs);
+      __str.append(__size_type(1), __rhs);
+      return __str;
+    }
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_string<_CharT, _Traits, _Alloc>
+    operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
+       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return std::move(__lhs.append(__rhs)); }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_string<_CharT, _Traits, _Alloc>
+    operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+       basic_string<_CharT, _Traits, _Alloc>&& __rhs)
+    { return std::move(__rhs.insert(0, __lhs)); }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_string<_CharT, _Traits, _Alloc>
+    operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
+       basic_string<_CharT, _Traits, _Alloc>&& __rhs)
+    {
+
+      using _Alloc_traits = allocator_traits<_Alloc>;
+      bool __use_rhs = false;
+      if constexpr (typename _Alloc_traits::is_always_equal{})
+ __use_rhs = true;
+      else if (__lhs.get_allocator() == __rhs.get_allocator())
+ __use_rhs = true;
+      if (__use_rhs)
+
+ {
+   const auto __size = __lhs.size() + __rhs.size();
+   if (__size > __lhs.capacity() && __size <= __rhs.capacity())
+     return std::move(__rhs.insert(0, __lhs));
+ }
+      return std::move(__lhs.append(__rhs));
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_string<_CharT, _Traits, _Alloc>
+    operator+(const _CharT* __lhs,
+       basic_string<_CharT, _Traits, _Alloc>&& __rhs)
+    { return std::move(__rhs.insert(0, __lhs)); }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_string<_CharT, _Traits, _Alloc>
+    operator+(_CharT __lhs,
+       basic_string<_CharT, _Traits, _Alloc>&& __rhs)
+    { return std::move(__rhs.insert(0, 1, __lhs)); }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_string<_CharT, _Traits, _Alloc>
+    operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
+       const _CharT* __rhs)
+    { return std::move(__lhs.append(__rhs)); }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_string<_CharT, _Traits, _Alloc>
+    operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
+       _CharT __rhs)
+    { return std::move(__lhs.append(1, __rhs)); }
+# 6151 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    noexcept
+    { return __lhs.compare(__rhs) == 0; }
+
+  template<typename _CharT>
+    inline
+    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, bool>::__type
+    operator==(const basic_string<_CharT>& __lhs,
+        const basic_string<_CharT>& __rhs) noexcept
+    { return (__lhs.size() == __rhs.size()
+       && !std::char_traits<_CharT>::compare(__lhs.data(), __rhs.data(),
+          __lhs.size())); }
+
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+        const _CharT* __rhs)
+    { return __lhs.compare(__rhs) == 0; }
+# 6214 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator==(const _CharT* __lhs,
+        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return __rhs.compare(__lhs) == 0; }
+# 6227 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    noexcept
+    { return !(__lhs == __rhs); }
+
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator!=(const _CharT* __lhs,
+        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return !(__lhs == __rhs); }
+
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+        const _CharT* __rhs)
+    { return !(__lhs == __rhs); }
+# 6265 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    noexcept
+    { return __lhs.compare(__rhs) < 0; }
+
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+       const _CharT* __rhs)
+    { return __lhs.compare(__rhs) < 0; }
+
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator<(const _CharT* __lhs,
+       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return __rhs.compare(__lhs) > 0; }
+# 6303 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    noexcept
+    { return __lhs.compare(__rhs) > 0; }
+
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+       const _CharT* __rhs)
+    { return __lhs.compare(__rhs) > 0; }
+
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator>(const _CharT* __lhs,
+       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return __rhs.compare(__lhs) < 0; }
+# 6341 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    noexcept
+    { return __lhs.compare(__rhs) <= 0; }
+
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+        const _CharT* __rhs)
+    { return __lhs.compare(__rhs) <= 0; }
+
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator<=(const _CharT* __lhs,
+        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return __rhs.compare(__lhs) >= 0; }
+# 6379 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    noexcept
+    { return __lhs.compare(__rhs) >= 0; }
+
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+        const _CharT* __rhs)
+    { return __lhs.compare(__rhs) >= 0; }
+
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator>=(const _CharT* __lhs,
+      const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return __rhs.compare(__lhs) <= 0; }
+# 6418 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline void
+    swap(basic_string<_CharT, _Traits, _Alloc>& __lhs,
+  basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    noexcept(noexcept(__lhs.swap(__rhs)))
+    { __lhs.swap(__rhs); }
+# 6438 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __is,
+        basic_string<_CharT, _Traits, _Alloc>& __str);
+
+  template<>
+    basic_istream<char>&
+    operator>>(basic_istream<char>& __is, basic_string<char>& __str);
+# 6456 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __os,
+        const basic_string<_CharT, _Traits, _Alloc>& __str)
+    {
+
+
+      return __ostream_insert(__os, __str.data(), __str.size());
+    }
+# 6479 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_istream<_CharT, _Traits>&
+    getline(basic_istream<_CharT, _Traits>& __is,
+     basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim);
+# 6496 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_istream<_CharT, _Traits>&
+    getline(basic_istream<_CharT, _Traits>& __is,
+     basic_string<_CharT, _Traits, _Alloc>& __str)
+    { return std::getline(__is, __str, __is.widen('\n')); }
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_istream<_CharT, _Traits>&
+    getline(basic_istream<_CharT, _Traits>&& __is,
+     basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim)
+    { return std::getline(__is, __str, __delim); }
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_istream<_CharT, _Traits>&
+    getline(basic_istream<_CharT, _Traits>&& __is,
+     basic_string<_CharT, _Traits, _Alloc>& __str)
+    { return std::getline(__is, __str); }
+
+
+  template<>
+    basic_istream<char>&
+    getline(basic_istream<char>& __in, basic_string<char>& __str,
+     char __delim);
+
+
+  template<>
+    basic_istream<wchar_t>&
+    getline(basic_istream<wchar_t>& __in, basic_string<wchar_t>& __str,
+     wchar_t __delim);
+
+
+
+}
+
+
+
+# 1 "/usr/include/c++/10.2.0/ext/string_conversions.h" 1 3
+# 30 "/usr/include/c++/10.2.0/ext/string_conversions.h" 3
+#define _STRING_CONVERSIONS_H 1
+
+       
+# 33 "/usr/include/c++/10.2.0/ext/string_conversions.h" 3
+# 41 "/usr/include/c++/10.2.0/ext/string_conversions.h" 3
+# 1 "/usr/include/c++/10.2.0/cstdlib" 1 3
+# 39 "/usr/include/c++/10.2.0/cstdlib" 3
+       
+# 40 "/usr/include/c++/10.2.0/cstdlib" 3
+# 42 "/usr/include/c++/10.2.0/ext/string_conversions.h" 2 3
+# 1 "/usr/include/c++/10.2.0/cwchar" 1 3
+# 39 "/usr/include/c++/10.2.0/cwchar" 3
+       
+# 40 "/usr/include/c++/10.2.0/cwchar" 3
+# 43 "/usr/include/c++/10.2.0/ext/string_conversions.h" 2 3
+# 1 "/usr/include/c++/10.2.0/cstdio" 1 3
+# 39 "/usr/include/c++/10.2.0/cstdio" 3
+       
+# 40 "/usr/include/c++/10.2.0/cstdio" 3
+
+
+# 1 "/usr/include/stdio.h" 1 3 4
+# 24 "/usr/include/stdio.h" 3 4
+#define _STDIO_H 1
+
+#define __GLIBC_INTERNAL_STARTING_HEADER_IMPLEMENTATION 
+# 1 "/usr/include/bits/libc-header-start.h" 1 3 4
+# 31 "/usr/include/bits/libc-header-start.h" 3 4
+#undef __GLIBC_INTERNAL_STARTING_HEADER_IMPLEMENTATION
+
+
+
+
+
+#undef __GLIBC_USE_LIB_EXT2
+
+
+#define __GLIBC_USE_LIB_EXT2 1
+# 49 "/usr/include/bits/libc-header-start.h" 3 4
+#undef __GLIBC_USE_IEC_60559_BFP_EXT
+
+#define __GLIBC_USE_IEC_60559_BFP_EXT 1
+
+
+
+#undef __GLIBC_USE_IEC_60559_BFP_EXT_C2X
+
+#define __GLIBC_USE_IEC_60559_BFP_EXT_C2X 1
+# 66 "/usr/include/bits/libc-header-start.h" 3 4
+#undef __GLIBC_USE_IEC_60559_FUNCS_EXT
+
+#define __GLIBC_USE_IEC_60559_FUNCS_EXT 1
+
+
+
+#undef __GLIBC_USE_IEC_60559_FUNCS_EXT_C2X
+
+#define __GLIBC_USE_IEC_60559_FUNCS_EXT_C2X 1
+
+
+
+
+
+
+#undef __GLIBC_USE_IEC_60559_TYPES_EXT
+
+#define __GLIBC_USE_IEC_60559_TYPES_EXT 1
+# 28 "/usr/include/stdio.h" 2 3 4
+
+extern "C" {
+
+#define __need_size_t 
+#define __need_NULL 
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 1 3 4
+# 155 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef __need_ptrdiff_t
+# 231 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef __need_size_t
+# 340 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef __need_wchar_t
+# 390 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef NULL
+
+#define NULL __null
+# 401 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef __need_NULL
+
+
+
+
+#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
+# 34 "/usr/include/stdio.h" 2 3 4
+
+#define __need___va_list 
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stdarg.h" 1 3 4
+# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stdarg.h" 3 4
+#undef __need___va_list
+# 37 "/usr/include/stdio.h" 2 3 4
+
+
+# 1 "/usr/include/bits/types/__fpos_t.h" 1 3 4
+
+#define _____fpos_t_defined 1
+
+
+
+
+
+
+
+typedef struct _G_fpos_t
+{
+  __off_t __pos;
+  __mbstate_t __state;
+} __fpos_t;
+# 40 "/usr/include/stdio.h" 2 3 4
+# 1 "/usr/include/bits/types/__fpos64_t.h" 1 3 4
+
+#define _____fpos64_t_defined 1
+
+
+
+
+
+
+
+typedef struct _G_fpos64_t
+{
+  __off64_t __pos;
+  __mbstate_t __state;
+} __fpos64_t;
+# 41 "/usr/include/stdio.h" 2 3 4
+
+
+# 1 "/usr/include/bits/types/struct_FILE.h" 1 3 4
+# 19 "/usr/include/bits/types/struct_FILE.h" 3 4
+#define __struct_FILE_defined 1
+# 35 "/usr/include/bits/types/struct_FILE.h" 3 4
+struct _IO_FILE;
+struct _IO_marker;
+struct _IO_codecvt;
+struct _IO_wide_data;
+
+
+
+
+typedef void _IO_lock_t;
+
+
+
+
+
+struct _IO_FILE
+{
+  int _flags;
+
+
+  char *_IO_read_ptr;
+  char *_IO_read_end;
+  char *_IO_read_base;
+  char *_IO_write_base;
+  char *_IO_write_ptr;
+  char *_IO_write_end;
+  char *_IO_buf_base;
+  char *_IO_buf_end;
+
+
+  char *_IO_save_base;
+  char *_IO_backup_base;
+  char *_IO_save_end;
+
+  struct _IO_marker *_markers;
+
+  struct _IO_FILE *_chain;
+
+  int _fileno;
+  int _flags2;
+  __off_t _old_offset;
+
+
+  unsigned short _cur_column;
+  signed char _vtable_offset;
+  char _shortbuf[1];
+
+  _IO_lock_t *_lock;
+
+
+
+
+
+
+
+  __off64_t _offset;
+
+  struct _IO_codecvt *_codecvt;
+  struct _IO_wide_data *_wide_data;
+  struct _IO_FILE *_freeres_list;
+  void *_freeres_buf;
+  size_t __pad5;
+  int _mode;
+
+  char _unused2[15 * sizeof (int) - 4 * sizeof (void *) - sizeof (size_t)];
+};
+
+
+#define __getc_unlocked_body(_fp) (__glibc_unlikely ((_fp)->_IO_read_ptr >= (_fp)->_IO_read_end) ? __uflow (_fp) : *(unsigned char *) (_fp)->_IO_read_ptr++)
+
+
+
+#define __putc_unlocked_body(_ch,_fp) (__glibc_unlikely ((_fp)->_IO_write_ptr >= (_fp)->_IO_write_end) ? __overflow (_fp, (unsigned char) (_ch)) : (unsigned char) (*(_fp)->_IO_write_ptr++ = (_ch)))
+
+
+
+
+#define _IO_EOF_SEEN 0x0010
+#define __feof_unlocked_body(_fp) (((_fp)->_flags & _IO_EOF_SEEN) != 0)
+
+#define _IO_ERR_SEEN 0x0020
+#define __ferror_unlocked_body(_fp) (((_fp)->_flags & _IO_ERR_SEEN) != 0)
+
+#define _IO_USER_LOCK 0x8000
+# 44 "/usr/include/stdio.h" 2 3 4
+
+
+# 1 "/usr/include/bits/types/cookie_io_functions_t.h" 1 3 4
+# 19 "/usr/include/bits/types/cookie_io_functions_t.h" 3 4
+#define __cookie_io_functions_t_defined 1
+
+
+
+
+
+
+
+typedef __ssize_t cookie_read_function_t (void *__cookie, char *__buf,
+                                          size_t __nbytes);
+
+
+
+
+
+
+
+typedef __ssize_t cookie_write_function_t (void *__cookie, const char *__buf,
+                                           size_t __nbytes);
+
+
+
+
+
+
+
+typedef int cookie_seek_function_t (void *__cookie, __off64_t *__pos, int __w);
+
+
+typedef int cookie_close_function_t (void *__cookie);
+
+
+
+
+
+
+typedef struct _IO_cookie_io_functions_t
+{
+  cookie_read_function_t *read;
+  cookie_write_function_t *write;
+  cookie_seek_function_t *seek;
+  cookie_close_function_t *close;
+} cookie_io_functions_t;
+# 47 "/usr/include/stdio.h" 2 3 4
+
+
+
+
+
+typedef __gnuc_va_list va_list;
+#define _VA_LIST_DEFINED 
+# 84 "/usr/include/stdio.h" 3 4
+typedef __fpos_t fpos_t;
+
+
+
+
+typedef __fpos64_t fpos64_t;
+
+
+
+#define _IOFBF 0
+#define _IOLBF 1
+#define _IONBF 2
+
+
+
+#define BUFSIZ 8192
+
+
+
+
+#define EOF (-1)
+
+
+
+
+#define SEEK_SET 0
+#define SEEK_CUR 1
+#define SEEK_END 2
+
+#define SEEK_DATA 3
+#define SEEK_HOLE 4
+
+
+
+
+
+#define P_tmpdir "/tmp"
+# 133 "/usr/include/stdio.h" 3 4
+# 1 "/usr/include/bits/stdio_lim.h" 1 3 4
+# 19 "/usr/include/bits/stdio_lim.h" 3 4
+#define _BITS_STDIO_LIM_H 1
+
+
+
+
+
+#define L_tmpnam 20
+#define TMP_MAX 238328
+#define FILENAME_MAX 4096
+
+
+#define L_ctermid 9
+
+#define L_cuserid 9
+
+
+
+#undef FOPEN_MAX
+#define FOPEN_MAX 16
+# 134 "/usr/include/stdio.h" 2 3 4
+
+
+
+extern FILE *stdin;
+extern FILE *stdout;
+extern FILE *stderr;
+
+#define stdin stdin
+#define stdout stdout
+#define stderr stderr
+
+
+extern int remove (const char *__filename) throw ();
+
+extern int rename (const char *__old, const char *__new) throw ();
+
+
+
+extern int renameat (int __oldfd, const char *__old, int __newfd,
+       const char *__new) throw ();
+
+
+
+
+#define RENAME_NOREPLACE (1 << 0)
+#define RENAME_EXCHANGE (1 << 1)
+#define RENAME_WHITEOUT (1 << 2)
+
+
+
+extern int renameat2 (int __oldfd, const char *__old, int __newfd,
+        const char *__new, unsigned int __flags) throw ();
+
+
+
+
+
+
+
+extern FILE *tmpfile (void) ;
+# 183 "/usr/include/stdio.h" 3 4
+extern FILE *tmpfile64 (void) ;
+
+
+
+extern char *tmpnam (char *__s) throw () ;
+
+
+
+
+extern char *tmpnam_r (char *__s) throw () ;
+# 204 "/usr/include/stdio.h" 3 4
+extern char *tempnam (const char *__dir, const char *__pfx)
+     throw () __attribute__ ((__malloc__)) ;
+
+
+
+
+
+
+
+extern int fclose (FILE *__stream);
+
+
+
+
+extern int fflush (FILE *__stream);
+# 227 "/usr/include/stdio.h" 3 4
+extern int fflush_unlocked (FILE *__stream);
+# 237 "/usr/include/stdio.h" 3 4
+extern int fcloseall (void);
+# 246 "/usr/include/stdio.h" 3 4
+extern FILE *fopen (const char *__restrict __filename,
+      const char *__restrict __modes) ;
+
+
+
+
+extern FILE *freopen (const char *__restrict __filename,
+        const char *__restrict __modes,
+        FILE *__restrict __stream) ;
+# 270 "/usr/include/stdio.h" 3 4
+extern FILE *fopen64 (const char *__restrict __filename,
+        const char *__restrict __modes) ;
+extern FILE *freopen64 (const char *__restrict __filename,
+   const char *__restrict __modes,
+   FILE *__restrict __stream) ;
+
+
+
+
+extern FILE *fdopen (int __fd, const char *__modes) throw () ;
+
+
+
+
+
+extern FILE *fopencookie (void *__restrict __magic_cookie,
+     const char *__restrict __modes,
+     cookie_io_functions_t __io_funcs) throw () ;
+
+
+
+
+extern FILE *fmemopen (void *__s, size_t __len, const char *__modes)
+  throw () ;
+
+
+
+
+extern FILE *open_memstream (char **__bufloc, size_t *__sizeloc) throw () ;
+
+
+
+
+
+extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) throw ();
+
+
+
+extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf,
+      int __modes, size_t __n) throw ();
+
+
+
+
+extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf,
+         size_t __size) throw ();
+
+
+extern void setlinebuf (FILE *__stream) throw ();
+
+
+
+
+
+
+
+extern int fprintf (FILE *__restrict __stream,
+      const char *__restrict __format, ...);
+
+
+
+
+extern int printf (const char *__restrict __format, ...);
+
+extern int sprintf (char *__restrict __s,
+      const char *__restrict __format, ...) throw ();
+
+
+
+
+
+extern int vfprintf (FILE *__restrict __s, const char *__restrict __format,
+       __gnuc_va_list __arg);
+
+
+
+
+extern int vprintf (const char *__restrict __format, __gnuc_va_list __arg);
+
+extern int vsprintf (char *__restrict __s, const char *__restrict __format,
+       __gnuc_va_list __arg) throw ();
+
+
+
+extern int snprintf (char *__restrict __s, size_t __maxlen,
+       const char *__restrict __format, ...)
+     throw () __attribute__ ((__format__ (__printf__, 3, 4)));
+
+extern int vsnprintf (char *__restrict __s, size_t __maxlen,
+        const char *__restrict __format, __gnuc_va_list __arg)
+     throw () __attribute__ ((__format__ (__printf__, 3, 0)));
+
+
+
+
+
+extern int vasprintf (char **__restrict __ptr, const char *__restrict __f,
+        __gnuc_va_list __arg)
+     throw () __attribute__ ((__format__ (__printf__, 2, 0))) ;
+extern int __asprintf (char **__restrict __ptr,
+         const char *__restrict __fmt, ...)
+     throw () __attribute__ ((__format__ (__printf__, 2, 3))) ;
+extern int asprintf (char **__restrict __ptr,
+       const char *__restrict __fmt, ...)
+     throw () __attribute__ ((__format__ (__printf__, 2, 3))) ;
+
+
+
+
+extern int vdprintf (int __fd, const char *__restrict __fmt,
+       __gnuc_va_list __arg)
+     __attribute__ ((__format__ (__printf__, 2, 0)));
+extern int dprintf (int __fd, const char *__restrict __fmt, ...)
+     __attribute__ ((__format__ (__printf__, 2, 3)));
+
+
+
+
+
+
+
+extern int fscanf (FILE *__restrict __stream,
+     const char *__restrict __format, ...) ;
+
+
+
+
+extern int scanf (const char *__restrict __format, ...) ;
+
+extern int sscanf (const char *__restrict __s,
+     const char *__restrict __format, ...) throw ();
+# 410 "/usr/include/stdio.h" 3 4
+extern int fscanf (FILE *__restrict __stream, const char *__restrict __format, ...) __asm__ ("" "__isoc99_fscanf")
+
+                               ;
+extern int scanf (const char *__restrict __format, ...) __asm__ ("" "__isoc99_scanf")
+                              ;
+extern int sscanf (const char *__restrict __s, const char *__restrict __format, ...) throw () __asm__ ("" "__isoc99_sscanf")
+
+                      ;
+# 435 "/usr/include/stdio.h" 3 4
+extern int vfscanf (FILE *__restrict __s, const char *__restrict __format,
+      __gnuc_va_list __arg)
+     __attribute__ ((__format__ (__scanf__, 2, 0))) ;
+
+
+
+
+
+extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg)
+     __attribute__ ((__format__ (__scanf__, 1, 0))) ;
+
+
+extern int vsscanf (const char *__restrict __s,
+      const char *__restrict __format, __gnuc_va_list __arg)
+     throw () __attribute__ ((__format__ (__scanf__, 2, 0)));
+
+
+
+
+
+extern int vfscanf (FILE *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc99_vfscanf")
+
+
+
+     __attribute__ ((__format__ (__scanf__, 2, 0))) ;
+extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc99_vscanf")
+
+     __attribute__ ((__format__ (__scanf__, 1, 0))) ;
+extern int vsscanf (const char *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) throw () __asm__ ("" "__isoc99_vsscanf")
+
+
+
+     __attribute__ ((__format__ (__scanf__, 2, 0)));
+# 489 "/usr/include/stdio.h" 3 4
+extern int fgetc (FILE *__stream);
+extern int getc (FILE *__stream);
+
+
+
+
+
+extern int getchar (void);
+
+
+
+
+
+
+extern int getc_unlocked (FILE *__stream);
+extern int getchar_unlocked (void);
+# 514 "/usr/include/stdio.h" 3 4
+extern int fgetc_unlocked (FILE *__stream);
+# 525 "/usr/include/stdio.h" 3 4
+extern int fputc (int __c, FILE *__stream);
+extern int putc (int __c, FILE *__stream);
+
+
+
+
+
+extern int putchar (int __c);
+# 541 "/usr/include/stdio.h" 3 4
+extern int fputc_unlocked (int __c, FILE *__stream);
+
+
+
+
+
+
+
+extern int putc_unlocked (int __c, FILE *__stream);
+extern int putchar_unlocked (int __c);
+
+
+
+
+
+
+extern int getw (FILE *__stream);
+
+
+extern int putw (int __w, FILE *__stream);
+
+
+
+
+
+
+
+extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream)
+     __attribute__ ((__access__ (__write_only__, 1, 2)));
+# 591 "/usr/include/stdio.h" 3 4
+extern char *fgets_unlocked (char *__restrict __s, int __n,
+        FILE *__restrict __stream)
+    __attribute__ ((__access__ (__write_only__, 1, 2)));
+# 608 "/usr/include/stdio.h" 3 4
+extern __ssize_t __getdelim (char **__restrict __lineptr,
+                             size_t *__restrict __n, int __delimiter,
+                             FILE *__restrict __stream) ;
+extern __ssize_t getdelim (char **__restrict __lineptr,
+                           size_t *__restrict __n, int __delimiter,
+                           FILE *__restrict __stream) ;
+
+
+
+
+
+
+
+extern __ssize_t getline (char **__restrict __lineptr,
+                          size_t *__restrict __n,
+                          FILE *__restrict __stream) ;
+
+
+
+
+
+
+
+extern int fputs (const char *__restrict __s, FILE *__restrict __stream);
+
+
+
+
+
+extern int puts (const char *__s);
+
+
+
+
+
+
+extern int ungetc (int __c, FILE *__stream);
+
+
+
+
+
+
+extern size_t fread (void *__restrict __ptr, size_t __size,
+       size_t __n, FILE *__restrict __stream) ;
+
+
+
+
+extern size_t fwrite (const void *__restrict __ptr, size_t __size,
+        size_t __n, FILE *__restrict __s);
+# 667 "/usr/include/stdio.h" 3 4
+extern int fputs_unlocked (const char *__restrict __s,
+      FILE *__restrict __stream);
+# 678 "/usr/include/stdio.h" 3 4
+extern size_t fread_unlocked (void *__restrict __ptr, size_t __size,
+         size_t __n, FILE *__restrict __stream) ;
+extern size_t fwrite_unlocked (const void *__restrict __ptr, size_t __size,
+          size_t __n, FILE *__restrict __stream);
+
+
+
+
+
+
+
+extern int fseek (FILE *__stream, long int __off, int __whence);
+
+
+
+
+extern long int ftell (FILE *__stream) ;
+
+
+
+
+extern void rewind (FILE *__stream);
+# 712 "/usr/include/stdio.h" 3 4
+extern int fseeko (FILE *__stream, __off_t __off, int __whence);
+
+
+
+
+extern __off_t ftello (FILE *__stream) ;
+# 736 "/usr/include/stdio.h" 3 4
+extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos);
+
+
+
+
+extern int fsetpos (FILE *__stream, const fpos_t *__pos);
+# 755 "/usr/include/stdio.h" 3 4
+extern int fseeko64 (FILE *__stream, __off64_t __off, int __whence);
+extern __off64_t ftello64 (FILE *__stream) ;
+extern int fgetpos64 (FILE *__restrict __stream, fpos64_t *__restrict __pos);
+extern int fsetpos64 (FILE *__stream, const fpos64_t *__pos);
+
+
+
+extern void clearerr (FILE *__stream) throw ();
+
+extern int feof (FILE *__stream) throw () ;
+
+extern int ferror (FILE *__stream) throw () ;
+
+
+
+extern void clearerr_unlocked (FILE *__stream) throw ();
+extern int feof_unlocked (FILE *__stream) throw () ;
+extern int ferror_unlocked (FILE *__stream) throw () ;
+
+
+
+
+
+
+
+extern void perror (const char *__s);
+
+
+
+
+extern int fileno (FILE *__stream) throw () ;
+
+
+
+
+extern int fileno_unlocked (FILE *__stream) throw () ;
+# 799 "/usr/include/stdio.h" 3 4
+extern FILE *popen (const char *__command, const char *__modes) ;
+
+
+
+
+
+extern int pclose (FILE *__stream);
+
+
+
+
+
+extern char *ctermid (char *__s) throw ();
+
+
+
+
+
+extern char *cuserid (char *__s);
+
+
+
+
+struct obstack;
+
+
+extern int obstack_printf (struct obstack *__restrict __obstack,
+      const char *__restrict __format, ...)
+     throw () __attribute__ ((__format__ (__printf__, 2, 3)));
+extern int obstack_vprintf (struct obstack *__restrict __obstack,
+       const char *__restrict __format,
+       __gnuc_va_list __args)
+     throw () __attribute__ ((__format__ (__printf__, 2, 0)));
+
+
+
+
+
+
+
+extern void flockfile (FILE *__stream) throw ();
+
+
+
+extern int ftrylockfile (FILE *__stream) throw () ;
+
+
+extern void funlockfile (FILE *__stream) throw ();
+# 857 "/usr/include/stdio.h" 3 4
+extern int __uflow (FILE *);
+extern int __overflow (FILE *, int);
+# 874 "/usr/include/stdio.h" 3 4
+}
+# 43 "/usr/include/c++/10.2.0/cstdio" 2 3
+
+
+#define _GLIBCXX_CSTDIO 1
+
+
+
+
+
+
+#undef clearerr
+#undef fclose
+#undef feof
+#undef ferror
+#undef fflush
+#undef fgetc
+#undef fgetpos
+#undef fgets
+#undef fopen
+#undef fprintf
+#undef fputc
+#undef fputs
+#undef fread
+#undef freopen
+#undef fscanf
+#undef fseek
+#undef fsetpos
+#undef ftell
+#undef fwrite
+#undef getc
+#undef getchar
+
+
+
+#undef perror
+#undef printf
+#undef putc
+#undef putchar
+#undef puts
+#undef remove
+#undef rename
+#undef rewind
+#undef scanf
+#undef setbuf
+#undef setvbuf
+#undef sprintf
+#undef sscanf
+#undef tmpfile
+#undef tmpnam
+#undef ungetc
+#undef vfprintf
+#undef vprintf
+#undef vsprintf
+
+namespace std
+{
+  using ::FILE;
+  using ::fpos_t;
+
+  using ::clearerr;
+  using ::fclose;
+  using ::feof;
+  using ::ferror;
+  using ::fflush;
+  using ::fgetc;
+  using ::fgetpos;
+  using ::fgets;
+  using ::fopen;
+  using ::fprintf;
+  using ::fputc;
+  using ::fputs;
+  using ::fread;
+  using ::freopen;
+  using ::fscanf;
+  using ::fseek;
+  using ::fsetpos;
+  using ::ftell;
+  using ::fwrite;
+  using ::getc;
+  using ::getchar;
+
+
+
+
+  using ::perror;
+  using ::printf;
+  using ::putc;
+  using ::putchar;
+  using ::puts;
+  using ::remove;
+  using ::rename;
+  using ::rewind;
+  using ::scanf;
+  using ::setbuf;
+  using ::setvbuf;
+  using ::sprintf;
+  using ::sscanf;
+  using ::tmpfile;
+
+  using ::tmpnam;
+
+  using ::ungetc;
+  using ::vfprintf;
+  using ::vprintf;
+  using ::vsprintf;
+}
+
+
+
+#undef snprintf
+#undef vfscanf
+#undef vscanf
+#undef vsnprintf
+#undef vsscanf
+
+namespace __gnu_cxx
+{
+# 175 "/usr/include/c++/10.2.0/cstdio" 3
+  using ::snprintf;
+  using ::vfscanf;
+  using ::vscanf;
+  using ::vsnprintf;
+  using ::vsscanf;
+
+}
+
+namespace std
+{
+  using ::__gnu_cxx::snprintf;
+  using ::__gnu_cxx::vfscanf;
+  using ::__gnu_cxx::vscanf;
+  using ::__gnu_cxx::vsnprintf;
+  using ::__gnu_cxx::vsscanf;
+}
+# 44 "/usr/include/c++/10.2.0/ext/string_conversions.h" 2 3
+# 1 "/usr/include/c++/10.2.0/cerrno" 1 3
+# 39 "/usr/include/c++/10.2.0/cerrno" 3
+       
+# 40 "/usr/include/c++/10.2.0/cerrno" 3
+
+
+# 1 "/usr/include/errno.h" 1 3 4
+# 23 "/usr/include/errno.h" 3 4
+#define _ERRNO_H 1
+
+
+
+
+# 1 "/usr/include/bits/errno.h" 1 3 4
+# 20 "/usr/include/bits/errno.h" 3 4
+#define _BITS_ERRNO_H 1
+
+
+
+
+
+# 1 "/usr/include/linux/errno.h" 1 3 4
+# 1 "/usr/include/asm/errno.h" 1 3 4
+# 1 "/usr/include/asm-generic/errno.h" 1 3 4
+
+
+#define _ASM_GENERIC_ERRNO_H 
+
+# 1 "/usr/include/asm-generic/errno-base.h" 1 3 4
+
+
+#define _ASM_GENERIC_ERRNO_BASE_H 
+
+#define EPERM 1
+#define ENOENT 2
+#define ESRCH 3
+#define EINTR 4
+#define EIO 5
+#define ENXIO 6
+#define E2BIG 7
+#define ENOEXEC 8
+#define EBADF 9
+#define ECHILD 10
+#define EAGAIN 11
+#define ENOMEM 12
+#define EACCES 13
+#define EFAULT 14
+#define ENOTBLK 15
+#define EBUSY 16
+#define EEXIST 17
+#define EXDEV 18
+#define ENODEV 19
+#define ENOTDIR 20
+#define EISDIR 21
+#define EINVAL 22
+#define ENFILE 23
+#define EMFILE 24
+#define ENOTTY 25
+#define ETXTBSY 26
+#define EFBIG 27
+#define ENOSPC 28
+#define ESPIPE 29
+#define EROFS 30
+#define EMLINK 31
+#define EPIPE 32
+#define EDOM 33
+#define ERANGE 34
+# 6 "/usr/include/asm-generic/errno.h" 2 3 4
+
+#define EDEADLK 35
+#define ENAMETOOLONG 36
+#define ENOLCK 37
+# 18 "/usr/include/asm-generic/errno.h" 3 4
+#define ENOSYS 38
+
+#define ENOTEMPTY 39
+#define ELOOP 40
+#define EWOULDBLOCK EAGAIN
+#define ENOMSG 42
+#define EIDRM 43
+#define ECHRNG 44
+#define EL2NSYNC 45
+#define EL3HLT 46
+#define EL3RST 47
+#define ELNRNG 48
+#define EUNATCH 49
+#define ENOCSI 50
+#define EL2HLT 51
+#define EBADE 52
+#define EBADR 53
+#define EXFULL 54
+#define ENOANO 55
+#define EBADRQC 56
+#define EBADSLT 57
+
+#define EDEADLOCK EDEADLK
+
+#define EBFONT 59
+#define ENOSTR 60
+#define ENODATA 61
+#define ETIME 62
+#define ENOSR 63
+#define ENONET 64
+#define ENOPKG 65
+#define EREMOTE 66
+#define ENOLINK 67
+#define EADV 68
+#define ESRMNT 69
+#define ECOMM 70
+#define EPROTO 71
+#define EMULTIHOP 72
+#define EDOTDOT 73
+#define EBADMSG 74
+#define EOVERFLOW 75
+#define ENOTUNIQ 76
+#define EBADFD 77
+#define EREMCHG 78
+#define ELIBACC 79
+#define ELIBBAD 80
+#define ELIBSCN 81
+#define ELIBMAX 82
+#define ELIBEXEC 83
+#define EILSEQ 84
+#define ERESTART 85
+#define ESTRPIPE 86
+#define EUSERS 87
+#define ENOTSOCK 88
+#define EDESTADDRREQ 89
+#define EMSGSIZE 90
+#define EPROTOTYPE 91
+#define ENOPROTOOPT 92
+#define EPROTONOSUPPORT 93
+#define ESOCKTNOSUPPORT 94
+#define EOPNOTSUPP 95
+#define EPFNOSUPPORT 96
+#define EAFNOSUPPORT 97
+#define EADDRINUSE 98
+#define EADDRNOTAVAIL 99
+#define ENETDOWN 100
+#define ENETUNREACH 101
+#define ENETRESET 102
+#define ECONNABORTED 103
+#define ECONNRESET 104
+#define ENOBUFS 105
+#define EISCONN 106
+#define ENOTCONN 107
+#define ESHUTDOWN 108
+#define ETOOMANYREFS 109
+#define ETIMEDOUT 110
+#define ECONNREFUSED 111
+#define EHOSTDOWN 112
+#define EHOSTUNREACH 113
+#define EALREADY 114
+#define EINPROGRESS 115
+#define ESTALE 116
+#define EUCLEAN 117
+#define ENOTNAM 118
+#define ENAVAIL 119
+#define EISNAM 120
+#define EREMOTEIO 121
+#define EDQUOT 122
+
+#define ENOMEDIUM 123
+#define EMEDIUMTYPE 124
+#define ECANCELED 125
+#define ENOKEY 126
+#define EKEYEXPIRED 127
+#define EKEYREVOKED 128
+#define EKEYREJECTED 129
+
+
+#define EOWNERDEAD 130
+#define ENOTRECOVERABLE 131
+
+#define ERFKILL 132
+
+#define EHWPOISON 133
+# 2 "/usr/include/asm/errno.h" 2 3 4
+# 2 "/usr/include/linux/errno.h" 2 3 4
+# 27 "/usr/include/bits/errno.h" 2 3 4
+
+
+
+#define ENOTSUP EOPNOTSUPP
+# 29 "/usr/include/errno.h" 2 3 4
+
+
+
+
+
+extern "C" {
+
+
+extern int *__errno_location (void) throw () __attribute__ ((__const__));
+#define errno (*__errno_location ())
+
+
+
+
+
+
+extern char *program_invocation_name;
+extern char *program_invocation_short_name;
+
+# 1 "/usr/include/bits/types/error_t.h" 1 3 4
+# 20 "/usr/include/bits/types/error_t.h" 3 4
+#define __error_t_defined 1
+
+typedef int error_t;
+# 49 "/usr/include/errno.h" 2 3 4
+
+
+
+}
+# 43 "/usr/include/c++/10.2.0/cerrno" 2 3
+
+
+#define _GLIBCXX_CERRNO 1
+# 45 "/usr/include/c++/10.2.0/ext/string_conversions.h" 2 3
+
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+  template<typename _TRet, typename _Ret = _TRet, typename _CharT,
+    typename... _Base>
+    _Ret
+    __stoa(_TRet (*__convf) (const _CharT*, _CharT**, _Base...),
+    const char* __name, const _CharT* __str, std::size_t* __idx,
+    _Base... __base)
+    {
+      _Ret __ret;
+
+      _CharT* __endptr;
+
+      struct _Save_errno {
+ _Save_errno() : _M_errno((*__errno_location ())) { (*__errno_location ()) = 0; }
+ ~_Save_errno() { if ((*__errno_location ()) == 0) (*__errno_location ()) = _M_errno; }
+ int _M_errno;
+      } const __save_errno;
+
+      struct _Range_chk {
+   static bool
+   _S_chk(_TRet, std::false_type) { return false; }
+
+   static bool
+   _S_chk(_TRet __val, std::true_type)
+   {
+     return __val < _TRet(__numeric_traits<int>::__min)
+       || __val > _TRet(__numeric_traits<int>::__max);
+   }
+      };
+
+      const _TRet __tmp = __convf(__str, &__endptr, __base...);
+
+      if (__endptr == __str)
+ std::__throw_invalid_argument(__name);
+      else if ((*__errno_location ()) == 34
+   || _Range_chk::_S_chk(__tmp, std::is_same<_Ret, int>{}))
+ std::__throw_out_of_range(__name);
+      else
+ __ret = __tmp;
+
+      if (__idx)
+ *__idx = __endptr - __str;
+
+      return __ret;
+    }
+
+
+  template<typename _String, typename _CharT = typename _String::value_type>
+    _String
+    __to_xstring(int (*__convf) (_CharT*, std::size_t, const _CharT*,
+     __builtin_va_list), std::size_t __n,
+   const _CharT* __fmt, ...)
+    {
+
+
+      _CharT* __s = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
+         * __n));
+
+      __builtin_va_list __args;
+      __builtin_va_start(__args, __fmt);
+
+      const int __len = __convf(__s, __n, __fmt, __args);
+
+      __builtin_va_end(__args);
+
+      return _String(__s, __s + __len);
+    }
+
+
+}
+# 6536 "/usr/include/c++/10.2.0/bits/basic_string.h" 2 3
+# 1 "/usr/include/c++/10.2.0/bits/charconv.h" 1 3
+# 31 "/usr/include/c++/10.2.0/bits/charconv.h" 3
+#define _GLIBCXX_CHARCONV_H 1
+
+       
+# 34 "/usr/include/c++/10.2.0/bits/charconv.h" 3
+
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+namespace __detail
+{
+
+  template<typename _Tp>
+    constexpr unsigned
+    __to_chars_len(_Tp __value, int __base = 10) noexcept
+    {
+      static_assert(is_integral<_Tp>::value, "implementation bug");
+      static_assert(is_unsigned<_Tp>::value, "implementation bug");
+
+      unsigned __n = 1;
+      const unsigned __b2 = __base * __base;
+      const unsigned __b3 = __b2 * __base;
+      const unsigned long __b4 = __b3 * __base;
+      for (;;)
+ {
+   if (__value < (unsigned)__base) return __n;
+   if (__value < __b2) return __n + 1;
+   if (__value < __b3) return __n + 2;
+   if (__value < __b4) return __n + 3;
+   __value /= __b4;
+   __n += 4;
+ }
+    }
+
+
+
+
+  template<typename _Tp>
+    void
+    __to_chars_10_impl(char* __first, unsigned __len, _Tp __val) noexcept
+    {
+      static_assert(is_integral<_Tp>::value, "implementation bug");
+      static_assert(is_unsigned<_Tp>::value, "implementation bug");
+
+      static constexpr char __digits[201] =
+ "0001020304050607080910111213141516171819"
+ "2021222324252627282930313233343536373839"
+ "4041424344454647484950515253545556575859"
+ "6061626364656667686970717273747576777879"
+ "8081828384858687888990919293949596979899";
+      unsigned __pos = __len - 1;
+      while (__val >= 100)
+ {
+   auto const __num = (__val % 100) * 2;
+   __val /= 100;
+   __first[__pos] = __digits[__num + 1];
+   __first[__pos - 1] = __digits[__num];
+   __pos -= 2;
+ }
+      if (__val >= 10)
+ {
+   auto const __num = __val * 2;
+   __first[1] = __digits[__num + 1];
+   __first[0] = __digits[__num];
+ }
+      else
+ __first[0] = '0' + __val;
+    }
+
+}
+
+}
+# 6537 "/usr/include/c++/10.2.0/bits/basic_string.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+namespace __cxx11 {
+
+
+
+  inline int
+  stoi(const string& __str, size_t* __idx = 0, int __base = 10)
+  { return __gnu_cxx::__stoa<long, int>(&std::strtol, "stoi", __str.c_str(),
+     __idx, __base); }
+
+  inline long
+  stol(const string& __str, size_t* __idx = 0, int __base = 10)
+  { return __gnu_cxx::__stoa(&std::strtol, "stol", __str.c_str(),
+        __idx, __base); }
+
+  inline unsigned long
+  stoul(const string& __str, size_t* __idx = 0, int __base = 10)
+  { return __gnu_cxx::__stoa(&std::strtoul, "stoul", __str.c_str(),
+        __idx, __base); }
+
+  inline long long
+  stoll(const string& __str, size_t* __idx = 0, int __base = 10)
+  { return __gnu_cxx::__stoa(&std::strtoll, "stoll", __str.c_str(),
+        __idx, __base); }
+
+  inline unsigned long long
+  stoull(const string& __str, size_t* __idx = 0, int __base = 10)
+  { return __gnu_cxx::__stoa(&std::strtoull, "stoull", __str.c_str(),
+        __idx, __base); }
+
+
+  inline float
+  stof(const string& __str, size_t* __idx = 0)
+  { return __gnu_cxx::__stoa(&std::strtof, "stof", __str.c_str(), __idx); }
+
+  inline double
+  stod(const string& __str, size_t* __idx = 0)
+  { return __gnu_cxx::__stoa(&std::strtod, "stod", __str.c_str(), __idx); }
+
+  inline long double
+  stold(const string& __str, size_t* __idx = 0)
+  { return __gnu_cxx::__stoa(&std::strtold, "stold", __str.c_str(), __idx); }
+
+
+
+
+  inline string
+  to_string(int __val)
+  {
+    const bool __neg = __val < 0;
+    const unsigned __uval = __neg ? (unsigned)~__val + 1u : __val;
+    const auto __len = __detail::__to_chars_len(__uval);
+    string __str(__neg + __len, '-');
+    __detail::__to_chars_10_impl(&__str[__neg], __len, __uval);
+    return __str;
+  }
+
+  inline string
+  to_string(unsigned __val)
+  {
+    string __str(__detail::__to_chars_len(__val), '\0');
+    __detail::__to_chars_10_impl(&__str[0], __str.size(), __val);
+    return __str;
+  }
+
+  inline string
+  to_string(long __val)
+  {
+    const bool __neg = __val < 0;
+    const unsigned long __uval = __neg ? (unsigned long)~__val + 1ul : __val;
+    const auto __len = __detail::__to_chars_len(__uval);
+    string __str(__neg + __len, '-');
+    __detail::__to_chars_10_impl(&__str[__neg], __len, __uval);
+    return __str;
+  }
+
+  inline string
+  to_string(unsigned long __val)
+  {
+    string __str(__detail::__to_chars_len(__val), '\0');
+    __detail::__to_chars_10_impl(&__str[0], __str.size(), __val);
+    return __str;
+  }
+
+  inline string
+  to_string(long long __val)
+  {
+    const bool __neg = __val < 0;
+    const unsigned long long __uval
+      = __neg ? (unsigned long long)~__val + 1ull : __val;
+    const auto __len = __detail::__to_chars_len(__uval);
+    string __str(__neg + __len, '-');
+    __detail::__to_chars_10_impl(&__str[__neg], __len, __uval);
+    return __str;
+  }
+
+  inline string
+  to_string(unsigned long long __val)
+  {
+    string __str(__detail::__to_chars_len(__val), '\0');
+    __detail::__to_chars_10_impl(&__str[0], __str.size(), __val);
+    return __str;
+  }
+
+
+
+
+  inline string
+  to_string(float __val)
+  {
+    const int __n =
+      __gnu_cxx::__numeric_traits<float>::__max_exponent10 + 20;
+    return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, __n,
+        "%f", __val);
+  }
+
+  inline string
+  to_string(double __val)
+  {
+    const int __n =
+      __gnu_cxx::__numeric_traits<double>::__max_exponent10 + 20;
+    return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, __n,
+        "%f", __val);
+  }
+
+  inline string
+  to_string(long double __val)
+  {
+    const int __n =
+      __gnu_cxx::__numeric_traits<long double>::__max_exponent10 + 20;
+    return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, __n,
+        "%Lf", __val);
+  }
+
+
+
+  inline int
+  stoi(const wstring& __str, size_t* __idx = 0, int __base = 10)
+  { return __gnu_cxx::__stoa<long, int>(&std::wcstol, "stoi", __str.c_str(),
+     __idx, __base); }
+
+  inline long
+  stol(const wstring& __str, size_t* __idx = 0, int __base = 10)
+  { return __gnu_cxx::__stoa(&std::wcstol, "stol", __str.c_str(),
+        __idx, __base); }
+
+  inline unsigned long
+  stoul(const wstring& __str, size_t* __idx = 0, int __base = 10)
+  { return __gnu_cxx::__stoa(&std::wcstoul, "stoul", __str.c_str(),
+        __idx, __base); }
+
+  inline long long
+  stoll(const wstring& __str, size_t* __idx = 0, int __base = 10)
+  { return __gnu_cxx::__stoa(&std::wcstoll, "stoll", __str.c_str(),
+        __idx, __base); }
+
+  inline unsigned long long
+  stoull(const wstring& __str, size_t* __idx = 0, int __base = 10)
+  { return __gnu_cxx::__stoa(&std::wcstoull, "stoull", __str.c_str(),
+        __idx, __base); }
+
+
+  inline float
+  stof(const wstring& __str, size_t* __idx = 0)
+  { return __gnu_cxx::__stoa(&std::wcstof, "stof", __str.c_str(), __idx); }
+
+  inline double
+  stod(const wstring& __str, size_t* __idx = 0)
+  { return __gnu_cxx::__stoa(&std::wcstod, "stod", __str.c_str(), __idx); }
+
+  inline long double
+  stold(const wstring& __str, size_t* __idx = 0)
+  { return __gnu_cxx::__stoa(&std::wcstold, "stold", __str.c_str(), __idx); }
+
+
+
+  inline wstring
+  to_wstring(int __val)
+  { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, 4 * sizeof(int),
+         L"%d", __val); }
+
+  inline wstring
+  to_wstring(unsigned __val)
+  { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
+         4 * sizeof(unsigned),
+         L"%u", __val); }
+
+  inline wstring
+  to_wstring(long __val)
+  { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, 4 * sizeof(long),
+         L"%ld", __val); }
+
+  inline wstring
+  to_wstring(unsigned long __val)
+  { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
+         4 * sizeof(unsigned long),
+         L"%lu", __val); }
+
+  inline wstring
+  to_wstring(long long __val)
+  { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
+         4 * sizeof(long long),
+         L"%lld", __val); }
+
+  inline wstring
+  to_wstring(unsigned long long __val)
+  { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
+         4 * sizeof(unsigned long long),
+         L"%llu", __val); }
+
+  inline wstring
+  to_wstring(float __val)
+  {
+    const int __n =
+      __gnu_cxx::__numeric_traits<float>::__max_exponent10 + 20;
+    return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, __n,
+         L"%f", __val);
+  }
+
+  inline wstring
+  to_wstring(double __val)
+  {
+    const int __n =
+      __gnu_cxx::__numeric_traits<double>::__max_exponent10 + 20;
+    return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, __n,
+         L"%f", __val);
+  }
+
+  inline wstring
+  to_wstring(long double __val)
+  {
+    const int __n =
+      __gnu_cxx::__numeric_traits<long double>::__max_exponent10 + 20;
+    return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, __n,
+         L"%Lf", __val);
+  }
+
+
+
+}
+
+}
+
+
+
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+
+  template<>
+    struct hash<string>
+    : public __hash_base<size_t, string>
+    {
+      size_t
+      operator()(const string& __s) const noexcept
+      { return std::_Hash_impl::hash(__s.data(), __s.length()); }
+    };
+
+  template<>
+    struct __is_fast_hash<hash<string>> : std::false_type
+    { };
+
+
+
+  template<>
+    struct hash<wstring>
+    : public __hash_base<size_t, wstring>
+    {
+      size_t
+      operator()(const wstring& __s) const noexcept
+      { return std::_Hash_impl::hash(__s.data(),
+                                     __s.length() * sizeof(wchar_t)); }
+    };
+
+  template<>
+    struct __is_fast_hash<hash<wstring>> : std::false_type
+    { };
+# 6846 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+  template<>
+    struct hash<u16string>
+    : public __hash_base<size_t, u16string>
+    {
+      size_t
+      operator()(const u16string& __s) const noexcept
+      { return std::_Hash_impl::hash(__s.data(),
+                                     __s.length() * sizeof(char16_t)); }
+    };
+
+  template<>
+    struct __is_fast_hash<hash<u16string>> : std::false_type
+    { };
+
+
+  template<>
+    struct hash<u32string>
+    : public __hash_base<size_t, u32string>
+    {
+      size_t
+      operator()(const u32string& __s) const noexcept
+      { return std::_Hash_impl::hash(__s.data(),
+                                     __s.length() * sizeof(char32_t)); }
+    };
+
+  template<>
+    struct __is_fast_hash<hash<u32string>> : std::false_type
+    { };
+
+
+
+#define __cpp_lib_string_udls 201304
+
+  inline namespace literals
+  {
+  inline namespace string_literals
+  {
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wliteral-suffix"
+    __attribute ((__abi_tag__ ("cxx11")))
+    inline basic_string<char>
+    operator""s(const char* __str, size_t __len)
+    { return basic_string<char>{__str, __len}; }
+
+
+    __attribute ((__abi_tag__ ("cxx11")))
+    inline basic_string<wchar_t>
+    operator""s(const wchar_t* __str, size_t __len)
+    { return basic_string<wchar_t>{__str, __len}; }
+# 6904 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+    __attribute ((__abi_tag__ ("cxx11")))
+    inline basic_string<char16_t>
+    operator""s(const char16_t* __str, size_t __len)
+    { return basic_string<char16_t>{__str, __len}; }
+
+    __attribute ((__abi_tag__ ("cxx11")))
+    inline basic_string<char32_t>
+    operator""s(const char32_t* __str, size_t __len)
+    { return basic_string<char32_t>{__str, __len}; }
+
+#pragma GCC diagnostic pop
+  }
+  }
+
+
+  namespace __detail::__variant
+  {
+    template<typename> struct _Never_valueless_alt;
+
+
+
+    template<typename _Tp, typename _Traits, typename _Alloc>
+      struct _Never_valueless_alt<std::basic_string<_Tp, _Traits, _Alloc>>
+      : __and_<
+ is_nothrow_move_constructible<std::basic_string<_Tp, _Traits, _Alloc>>,
+ is_nothrow_move_assignable<std::basic_string<_Tp, _Traits, _Alloc>>
+ >::type
+      { };
+  }
+
+
+
+
+}
+# 56 "/usr/include/c++/10.2.0/string" 2 3
+# 1 "/usr/include/c++/10.2.0/bits/basic_string.tcc" 1 3
+# 40 "/usr/include/c++/10.2.0/bits/basic_string.tcc" 3
+#define _BASIC_STRING_TCC 1
+
+       
+# 43 "/usr/include/c++/10.2.0/bits/basic_string.tcc" 3
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    const typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::npos;
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    void
+    basic_string<_CharT, _Traits, _Alloc>::
+    swap(basic_string& __s) noexcept
+    {
+      if (this == &__s)
+ return;
+
+      _Alloc_traits::_S_on_swap(_M_get_allocator(), __s._M_get_allocator());
+
+      if (_M_is_local())
+ if (__s._M_is_local())
+   {
+     if (length() && __s.length())
+       {
+  _CharT __tmp_data[_S_local_capacity + 1];
+  traits_type::copy(__tmp_data, __s._M_local_buf,
+      _S_local_capacity + 1);
+  traits_type::copy(__s._M_local_buf, _M_local_buf,
+      _S_local_capacity + 1);
+  traits_type::copy(_M_local_buf, __tmp_data,
+      _S_local_capacity + 1);
+       }
+     else if (__s.length())
+       {
+  traits_type::copy(_M_local_buf, __s._M_local_buf,
+      _S_local_capacity + 1);
+  _M_length(__s.length());
+  __s._M_set_length(0);
+  return;
+       }
+     else if (length())
+       {
+  traits_type::copy(__s._M_local_buf, _M_local_buf,
+      _S_local_capacity + 1);
+  __s._M_length(length());
+  _M_set_length(0);
+  return;
+       }
+   }
+ else
+   {
+     const size_type __tmp_capacity = __s._M_allocated_capacity;
+     traits_type::copy(__s._M_local_buf, _M_local_buf,
+         _S_local_capacity + 1);
+     _M_data(__s._M_data());
+     __s._M_data(__s._M_local_buf);
+     _M_capacity(__tmp_capacity);
+   }
+      else
+ {
+   const size_type __tmp_capacity = _M_allocated_capacity;
+   if (__s._M_is_local())
+     {
+       traits_type::copy(_M_local_buf, __s._M_local_buf,
+    _S_local_capacity + 1);
+       __s._M_data(_M_data());
+       _M_data(_M_local_buf);
+     }
+   else
+     {
+       pointer __tmp_ptr = _M_data();
+       _M_data(__s._M_data());
+       __s._M_data(__tmp_ptr);
+       _M_capacity(__s._M_allocated_capacity);
+     }
+   __s._M_capacity(__tmp_capacity);
+ }
+
+      const size_type __tmp_length = length();
+      _M_length(__s.length());
+      __s._M_length(__tmp_length);
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::pointer
+    basic_string<_CharT, _Traits, _Alloc>::
+    _M_create(size_type& __capacity, size_type __old_capacity)
+    {
+
+
+      if (__capacity > max_size())
+ std::__throw_length_error(("basic_string::_M_create"));
+
+
+
+
+      if (__capacity > __old_capacity && __capacity < 2 * __old_capacity)
+ {
+   __capacity = 2 * __old_capacity;
+
+   if (__capacity > max_size())
+     __capacity = max_size();
+ }
+
+
+
+      return _Alloc_traits::allocate(_M_get_allocator(), __capacity + 1);
+    }
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    template<typename _InIterator>
+      void
+      basic_string<_CharT, _Traits, _Alloc>::
+      _M_construct(_InIterator __beg, _InIterator __end,
+     std::input_iterator_tag)
+      {
+ size_type __len = 0;
+ size_type __capacity = size_type(_S_local_capacity);
+
+ while (__beg != __end && __len < __capacity)
+   {
+     _M_data()[__len++] = *__beg;
+     ++__beg;
+   }
+
+ try
+   {
+     while (__beg != __end)
+       {
+  if (__len == __capacity)
+    {
+
+      __capacity = __len + 1;
+      pointer __another = _M_create(__capacity, __len);
+      this->_S_copy(__another, _M_data(), __len);
+      _M_dispose();
+      _M_data(__another);
+      _M_capacity(__capacity);
+    }
+  _M_data()[__len++] = *__beg;
+  ++__beg;
+       }
+   }
+ catch(...)
+   {
+     _M_dispose();
+     throw;
+   }
+
+ _M_set_length(__len);
+      }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    template<typename _InIterator>
+      void
+      basic_string<_CharT, _Traits, _Alloc>::
+      _M_construct(_InIterator __beg, _InIterator __end,
+     std::forward_iterator_tag)
+      {
+
+ if (__gnu_cxx::__is_null_pointer(__beg) && __beg != __end)
+   std::__throw_logic_error(("basic_string::" "_M_construct null not valid")
+                                         );
+
+ size_type __dnew = static_cast<size_type>(std::distance(__beg, __end));
+
+ if (__dnew > size_type(_S_local_capacity))
+   {
+     _M_data(_M_create(__dnew, size_type(0)));
+     _M_capacity(__dnew);
+   }
+
+
+ try
+   { this->_S_copy_chars(_M_data(), __beg, __end); }
+ catch(...)
+   {
+     _M_dispose();
+     throw;
+   }
+
+ _M_set_length(__dnew);
+      }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    void
+    basic_string<_CharT, _Traits, _Alloc>::
+    _M_construct(size_type __n, _CharT __c)
+    {
+      if (__n > size_type(_S_local_capacity))
+ {
+   _M_data(_M_create(__n, size_type(0)));
+   _M_capacity(__n);
+ }
+
+      if (__n)
+ this->_S_assign(_M_data(), __n, __c);
+
+      _M_set_length(__n);
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    void
+    basic_string<_CharT, _Traits, _Alloc>::
+    _M_assign(const basic_string& __str)
+    {
+      if (this != &__str)
+ {
+   const size_type __rsize = __str.length();
+   const size_type __capacity = capacity();
+
+   if (__rsize > __capacity)
+     {
+       size_type __new_capacity = __rsize;
+       pointer __tmp = _M_create(__new_capacity, __capacity);
+       _M_dispose();
+       _M_data(__tmp);
+       _M_capacity(__new_capacity);
+     }
+
+   if (__rsize)
+     this->_S_copy(_M_data(), __str._M_data(), __rsize);
+
+   _M_set_length(__rsize);
+ }
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    void
+    basic_string<_CharT, _Traits, _Alloc>::
+    reserve(size_type __res)
+    {
+
+      if (__res < length())
+ __res = length();
+
+      const size_type __capacity = capacity();
+      if (__res != __capacity)
+ {
+   if (__res > __capacity
+       || __res > size_type(_S_local_capacity))
+     {
+       pointer __tmp = _M_create(__res, __capacity);
+       this->_S_copy(__tmp, _M_data(), length() + 1);
+       _M_dispose();
+       _M_data(__tmp);
+       _M_capacity(__res);
+     }
+   else if (!_M_is_local())
+     {
+       this->_S_copy(_M_local_data(), _M_data(), length() + 1);
+       _M_destroy(__capacity);
+       _M_data(_M_local_data());
+     }
+ }
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    void
+    basic_string<_CharT, _Traits, _Alloc>::
+    _M_mutate(size_type __pos, size_type __len1, const _CharT* __s,
+       size_type __len2)
+    {
+      const size_type __how_much = length() - __pos - __len1;
+
+      size_type __new_capacity = length() + __len2 - __len1;
+      pointer __r = _M_create(__new_capacity, capacity());
+
+      if (__pos)
+ this->_S_copy(__r, _M_data(), __pos);
+      if (__s && __len2)
+ this->_S_copy(__r + __pos, __s, __len2);
+      if (__how_much)
+ this->_S_copy(__r + __pos + __len2,
+        _M_data() + __pos + __len1, __how_much);
+
+      _M_dispose();
+      _M_data(__r);
+      _M_capacity(__new_capacity);
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    void
+    basic_string<_CharT, _Traits, _Alloc>::
+    _M_erase(size_type __pos, size_type __n)
+    {
+      const size_type __how_much = length() - __pos - __n;
+
+      if (__how_much && __n)
+ this->_S_move(_M_data() + __pos, _M_data() + __pos + __n, __how_much);
+
+      _M_set_length(length() - __n);
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    void
+    basic_string<_CharT, _Traits, _Alloc>::
+    resize(size_type __n, _CharT __c)
+    {
+      const size_type __size = this->size();
+      if (__size < __n)
+ this->append(__n - __size, __c);
+      else if (__n < __size)
+ this->_M_set_length(__n);
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>&
+    basic_string<_CharT, _Traits, _Alloc>::
+    _M_append(const _CharT* __s, size_type __n)
+    {
+      const size_type __len = __n + this->size();
+
+      if (__len <= this->capacity())
+ {
+   if (__n)
+     this->_S_copy(this->_M_data() + this->size(), __s, __n);
+ }
+      else
+ this->_M_mutate(this->size(), size_type(0), __s, __n);
+
+      this->_M_set_length(__len);
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    template<typename _InputIterator>
+      basic_string<_CharT, _Traits, _Alloc>&
+      basic_string<_CharT, _Traits, _Alloc>::
+      _M_replace_dispatch(const_iterator __i1, const_iterator __i2,
+     _InputIterator __k1, _InputIterator __k2,
+     std::__false_type)
+      {
+
+
+ const basic_string __s(__k1, __k2, this->get_allocator());
+ const size_type __n1 = __i2 - __i1;
+ return _M_replace(__i1 - begin(), __n1, __s._M_data(),
+     __s.size());
+      }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>&
+    basic_string<_CharT, _Traits, _Alloc>::
+    _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
+     _CharT __c)
+    {
+      _M_check_length(__n1, __n2, "basic_string::_M_replace_aux");
+
+      const size_type __old_size = this->size();
+      const size_type __new_size = __old_size + __n2 - __n1;
+
+      if (__new_size <= this->capacity())
+ {
+   pointer __p = this->_M_data() + __pos1;
+
+   const size_type __how_much = __old_size - __pos1 - __n1;
+   if (__how_much && __n1 != __n2)
+     this->_S_move(__p + __n2, __p + __n1, __how_much);
+ }
+      else
+ this->_M_mutate(__pos1, __n1, 0, __n2);
+
+      if (__n2)
+ this->_S_assign(this->_M_data() + __pos1, __n2, __c);
+
+      this->_M_set_length(__new_size);
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>&
+    basic_string<_CharT, _Traits, _Alloc>::
+    _M_replace(size_type __pos, size_type __len1, const _CharT* __s,
+        const size_type __len2)
+    {
+      _M_check_length(__len1, __len2, "basic_string::_M_replace");
+
+      const size_type __old_size = this->size();
+      const size_type __new_size = __old_size + __len2 - __len1;
+
+      if (__new_size <= this->capacity())
+ {
+   pointer __p = this->_M_data() + __pos;
+
+   const size_type __how_much = __old_size - __pos - __len1;
+   if (_M_disjunct(__s))
+     {
+       if (__how_much && __len1 != __len2)
+  this->_S_move(__p + __len2, __p + __len1, __how_much);
+       if (__len2)
+  this->_S_copy(__p, __s, __len2);
+     }
+   else
+     {
+
+       if (__len2 && __len2 <= __len1)
+  this->_S_move(__p, __s, __len2);
+       if (__how_much && __len1 != __len2)
+  this->_S_move(__p + __len2, __p + __len1, __how_much);
+       if (__len2 > __len1)
+  {
+    if (__s + __len2 <= __p + __len1)
+      this->_S_move(__p, __s, __len2);
+    else if (__s >= __p + __len1)
+      this->_S_copy(__p, __s + __len2 - __len1, __len2);
+    else
+      {
+        const size_type __nleft = (__p + __len1) - __s;
+        this->_S_move(__p, __s, __nleft);
+        this->_S_copy(__p + __nleft, __p + __len2,
+        __len2 - __nleft);
+      }
+  }
+     }
+ }
+      else
+ this->_M_mutate(__pos, __len1, __s, __len2);
+
+      this->_M_set_length(__new_size);
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    copy(_CharT* __s, size_type __n, size_type __pos) const
+    {
+      _M_check(__pos, "basic_string::copy");
+      __n = _M_limit(__pos, __n);
+      ;
+      if (__n)
+ _S_copy(__s, _M_data() + __pos, __n);
+
+      return __n;
+    }
+# 1158 "/usr/include/c++/10.2.0/bits/basic_string.tcc" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>
+    operator+(const _CharT* __lhs,
+       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    {
+      ;
+      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
+      typedef typename __string_type::size_type __size_type;
+      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
+ rebind<_CharT>::other _Char_alloc_type;
+      typedef __gnu_cxx::__alloc_traits<_Char_alloc_type> _Alloc_traits;
+      const __size_type __len = _Traits::length(__lhs);
+      __string_type __str(_Alloc_traits::_S_select_on_copy(
+          __rhs.get_allocator()));
+      __str.reserve(__len + __rhs.size());
+      __str.append(__lhs, __len);
+      __str.append(__rhs);
+      return __str;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>
+    operator+(_CharT __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    {
+      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
+      typedef typename __string_type::size_type __size_type;
+      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
+ rebind<_CharT>::other _Char_alloc_type;
+      typedef __gnu_cxx::__alloc_traits<_Char_alloc_type> _Alloc_traits;
+      __string_type __str(_Alloc_traits::_S_select_on_copy(
+          __rhs.get_allocator()));
+      const __size_type __len = __rhs.size();
+      __str.reserve(__len + 1);
+      __str.append(__size_type(1), __lhs);
+      __str.append(__rhs);
+      return __str;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    find(const _CharT* __s, size_type __pos, size_type __n) const
+    noexcept
+    {
+      ;
+      const size_type __size = this->size();
+
+      if (__n == 0)
+ return __pos <= __size ? __pos : npos;
+      if (__pos >= __size)
+ return npos;
+
+      const _CharT __elem0 = __s[0];
+      const _CharT* const __data = data();
+      const _CharT* __first = __data + __pos;
+      const _CharT* const __last = __data + __size;
+      size_type __len = __size - __pos;
+
+      while (__len >= __n)
+ {
+
+   __first = traits_type::find(__first, __len - __n + 1, __elem0);
+   if (!__first)
+     return npos;
+
+
+
+   if (traits_type::compare(__first, __s, __n) == 0)
+     return __first - __data;
+   __len = __last - ++__first;
+ }
+      return npos;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    find(_CharT __c, size_type __pos) const noexcept
+    {
+      size_type __ret = npos;
+      const size_type __size = this->size();
+      if (__pos < __size)
+ {
+   const _CharT* __data = _M_data();
+   const size_type __n = __size - __pos;
+   const _CharT* __p = traits_type::find(__data + __pos, __n, __c);
+   if (__p)
+     __ret = __p - __data;
+ }
+      return __ret;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    rfind(const _CharT* __s, size_type __pos, size_type __n) const
+    noexcept
+    {
+      ;
+      const size_type __size = this->size();
+      if (__n <= __size)
+ {
+   __pos = std::min(size_type(__size - __n), __pos);
+   const _CharT* __data = _M_data();
+   do
+     {
+       if (traits_type::compare(__data + __pos, __s, __n) == 0)
+  return __pos;
+     }
+   while (__pos-- > 0);
+ }
+      return npos;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    rfind(_CharT __c, size_type __pos) const noexcept
+    {
+      size_type __size = this->size();
+      if (__size)
+ {
+   if (--__size > __pos)
+     __size = __pos;
+   for (++__size; __size-- > 0; )
+     if (traits_type::eq(_M_data()[__size], __c))
+       return __size;
+ }
+      return npos;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    find_first_of(const _CharT* __s, size_type __pos, size_type __n) const
+    noexcept
+    {
+      ;
+      for (; __n && __pos < this->size(); ++__pos)
+ {
+   const _CharT* __p = traits_type::find(__s, __n, _M_data()[__pos]);
+   if (__p)
+     return __pos;
+ }
+      return npos;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    find_last_of(const _CharT* __s, size_type __pos, size_type __n) const
+    noexcept
+    {
+      ;
+      size_type __size = this->size();
+      if (__size && __n)
+ {
+   if (--__size > __pos)
+     __size = __pos;
+   do
+     {
+       if (traits_type::find(__s, __n, _M_data()[__size]))
+  return __size;
+     }
+   while (__size-- != 0);
+ }
+      return npos;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const
+    noexcept
+    {
+      ;
+      for (; __pos < this->size(); ++__pos)
+ if (!traits_type::find(__s, __n, _M_data()[__pos]))
+   return __pos;
+      return npos;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    find_first_not_of(_CharT __c, size_type __pos) const noexcept
+    {
+      for (; __pos < this->size(); ++__pos)
+ if (!traits_type::eq(_M_data()[__pos], __c))
+   return __pos;
+      return npos;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const
+    noexcept
+    {
+      ;
+      size_type __size = this->size();
+      if (__size)
+ {
+   if (--__size > __pos)
+     __size = __pos;
+   do
+     {
+       if (!traits_type::find(__s, __n, _M_data()[__size]))
+  return __size;
+     }
+   while (__size--);
+ }
+      return npos;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    find_last_not_of(_CharT __c, size_type __pos) const noexcept
+    {
+      size_type __size = this->size();
+      if (__size)
+ {
+   if (--__size > __pos)
+     __size = __pos;
+   do
+     {
+       if (!traits_type::eq(_M_data()[__size], __c))
+  return __size;
+     }
+   while (__size--);
+ }
+      return npos;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    int
+    basic_string<_CharT, _Traits, _Alloc>::
+    compare(size_type __pos, size_type __n, const basic_string& __str) const
+    {
+      _M_check(__pos, "basic_string::compare");
+      __n = _M_limit(__pos, __n);
+      const size_type __osize = __str.size();
+      const size_type __len = std::min(__n, __osize);
+      int __r = traits_type::compare(_M_data() + __pos, __str.data(), __len);
+      if (!__r)
+ __r = _S_compare(__n, __osize);
+      return __r;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    int
+    basic_string<_CharT, _Traits, _Alloc>::
+    compare(size_type __pos1, size_type __n1, const basic_string& __str,
+     size_type __pos2, size_type __n2) const
+    {
+      _M_check(__pos1, "basic_string::compare");
+      __str._M_check(__pos2, "basic_string::compare");
+      __n1 = _M_limit(__pos1, __n1);
+      __n2 = __str._M_limit(__pos2, __n2);
+      const size_type __len = std::min(__n1, __n2);
+      int __r = traits_type::compare(_M_data() + __pos1,
+         __str.data() + __pos2, __len);
+      if (!__r)
+ __r = _S_compare(__n1, __n2);
+      return __r;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    int
+    basic_string<_CharT, _Traits, _Alloc>::
+    compare(const _CharT* __s) const noexcept
+    {
+      ;
+      const size_type __size = this->size();
+      const size_type __osize = traits_type::length(__s);
+      const size_type __len = std::min(__size, __osize);
+      int __r = traits_type::compare(_M_data(), __s, __len);
+      if (!__r)
+ __r = _S_compare(__size, __osize);
+      return __r;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    int
+    basic_string <_CharT, _Traits, _Alloc>::
+    compare(size_type __pos, size_type __n1, const _CharT* __s) const
+    {
+      ;
+      _M_check(__pos, "basic_string::compare");
+      __n1 = _M_limit(__pos, __n1);
+      const size_type __osize = traits_type::length(__s);
+      const size_type __len = std::min(__n1, __osize);
+      int __r = traits_type::compare(_M_data() + __pos, __s, __len);
+      if (!__r)
+ __r = _S_compare(__n1, __osize);
+      return __r;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    int
+    basic_string <_CharT, _Traits, _Alloc>::
+    compare(size_type __pos, size_type __n1, const _CharT* __s,
+     size_type __n2) const
+    {
+      ;
+      _M_check(__pos, "basic_string::compare");
+      __n1 = _M_limit(__pos, __n1);
+      const size_type __len = std::min(__n1, __n2);
+      int __r = traits_type::compare(_M_data() + __pos, __s, __len);
+      if (!__r)
+ __r = _S_compare(__n1, __n2);
+      return __r;
+    }
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __in,
+        basic_string<_CharT, _Traits, _Alloc>& __str)
+    {
+      typedef basic_istream<_CharT, _Traits> __istream_type;
+      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
+      typedef typename __istream_type::ios_base __ios_base;
+      typedef typename __istream_type::int_type __int_type;
+      typedef typename __string_type::size_type __size_type;
+      typedef ctype<_CharT> __ctype_type;
+      typedef typename __ctype_type::ctype_base __ctype_base;
+
+      __size_type __extracted = 0;
+      typename __ios_base::iostate __err = __ios_base::goodbit;
+      typename __istream_type::sentry __cerb(__in, false);
+      if (__cerb)
+ {
+   try
+     {
+
+       __str.erase();
+       _CharT __buf[128];
+       __size_type __len = 0;
+       const streamsize __w = __in.width();
+       const __size_type __n = __w > 0 ? static_cast<__size_type>(__w)
+                                : __str.max_size();
+       const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
+       const __int_type __eof = _Traits::eof();
+       __int_type __c = __in.rdbuf()->sgetc();
+
+       while (__extracted < __n
+       && !_Traits::eq_int_type(__c, __eof)
+       && !__ct.is(__ctype_base::space,
+     _Traits::to_char_type(__c)))
+  {
+    if (__len == sizeof(__buf) / sizeof(_CharT))
+      {
+        __str.append(__buf, sizeof(__buf) / sizeof(_CharT));
+        __len = 0;
+      }
+    __buf[__len++] = _Traits::to_char_type(__c);
+    ++__extracted;
+    __c = __in.rdbuf()->snextc();
+  }
+       __str.append(__buf, __len);
+
+       if (_Traits::eq_int_type(__c, __eof))
+  __err |= __ios_base::eofbit;
+       __in.width(0);
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       __in._M_setstate(__ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     {
+
+
+
+       __in._M_setstate(__ios_base::badbit);
+     }
+ }
+
+      if (!__extracted)
+ __err |= __ios_base::failbit;
+      if (__err)
+ __in.setstate(__err);
+      return __in;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_istream<_CharT, _Traits>&
+    getline(basic_istream<_CharT, _Traits>& __in,
+     basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim)
+    {
+      typedef basic_istream<_CharT, _Traits> __istream_type;
+      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
+      typedef typename __istream_type::ios_base __ios_base;
+      typedef typename __istream_type::int_type __int_type;
+      typedef typename __string_type::size_type __size_type;
+
+      __size_type __extracted = 0;
+      const __size_type __n = __str.max_size();
+      typename __ios_base::iostate __err = __ios_base::goodbit;
+      typename __istream_type::sentry __cerb(__in, true);
+      if (__cerb)
+ {
+   try
+     {
+       __str.erase();
+       const __int_type __idelim = _Traits::to_int_type(__delim);
+       const __int_type __eof = _Traits::eof();
+       __int_type __c = __in.rdbuf()->sgetc();
+
+       while (__extracted < __n
+       && !_Traits::eq_int_type(__c, __eof)
+       && !_Traits::eq_int_type(__c, __idelim))
+  {
+    __str += _Traits::to_char_type(__c);
+    ++__extracted;
+    __c = __in.rdbuf()->snextc();
+  }
+
+       if (_Traits::eq_int_type(__c, __eof))
+  __err |= __ios_base::eofbit;
+       else if (_Traits::eq_int_type(__c, __idelim))
+  {
+    ++__extracted;
+    __in.rdbuf()->sbumpc();
+  }
+       else
+  __err |= __ios_base::failbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       __in._M_setstate(__ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     {
+
+
+
+       __in._M_setstate(__ios_base::badbit);
+     }
+ }
+      if (!__extracted)
+ __err |= __ios_base::failbit;
+      if (__err)
+ __in.setstate(__err);
+      return __in;
+    }
+# 1618 "/usr/include/c++/10.2.0/bits/basic_string.tcc" 3
+  extern template class basic_string<char>;
+
+
+
+
+
+
+
+  extern template
+    basic_istream<char>&
+    operator>>(basic_istream<char>&, string&);
+  extern template
+    basic_ostream<char>&
+    operator<<(basic_ostream<char>&, const string&);
+  extern template
+    basic_istream<char>&
+    getline(basic_istream<char>&, string&, char);
+  extern template
+    basic_istream<char>&
+    getline(basic_istream<char>&, string&);
+
+
+
+  extern template class basic_string<wchar_t>;
+
+
+
+
+
+  extern template
+    basic_istream<wchar_t>&
+    operator>>(basic_istream<wchar_t>&, wstring&);
+  extern template
+    basic_ostream<wchar_t>&
+    operator<<(basic_ostream<wchar_t>&, const wstring&);
+  extern template
+    basic_istream<wchar_t>&
+    getline(basic_istream<wchar_t>&, wstring&, wchar_t);
+  extern template
+    basic_istream<wchar_t>&
+    getline(basic_istream<wchar_t>&, wstring&);
+
+
+
+
+}
+# 57 "/usr/include/c++/10.2.0/string" 2 3
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  namespace pmr {
+    template<typename _Tp> class polymorphic_allocator;
+    template<typename _CharT, typename _Traits = char_traits<_CharT>>
+      using basic_string = std::basic_string<_CharT, _Traits,
+          polymorphic_allocator<_CharT>>;
+    using string = basic_string<char>;
+
+
+
+    using u16string = basic_string<char16_t>;
+    using u32string = basic_string<char32_t>;
+
+    using wstring = basic_string<wchar_t>;
+
+  }
+
+  template<typename _Str>
+    struct __hash_string_base
+    : public __hash_base<size_t, _Str>
+    {
+      size_t
+      operator()(const _Str& __s) const noexcept
+      { return hash<basic_string_view<typename _Str::value_type>>{}(__s); }
+    };
+
+  template<>
+    struct hash<pmr::string>
+    : public __hash_string_base<pmr::string>
+    { };
+
+
+
+
+
+
+  template<>
+    struct hash<pmr::u16string>
+    : public __hash_string_base<pmr::u16string>
+    { };
+  template<>
+    struct hash<pmr::u32string>
+    : public __hash_string_base<pmr::u32string>
+    { };
+
+  template<>
+    struct hash<pmr::wstring>
+    : public __hash_string_base<pmr::wstring>
+    { };
+
+
+
+}
+# 26 "/usr/include/boost/test/utils/basic_cstring/bcs_char_traits.hpp" 2 3 4
+
+
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 29 "/usr/include/boost/test/utils/basic_cstring/bcs_char_traits.hpp" 2 3 4
+
+
+
+namespace boost {
+
+namespace unit_test {
+
+namespace ut_detail {
+
+template<typename CharT> struct bcs_base_char { typedef CharT type; };
+
+template<> struct bcs_base_char<char const> { typedef char type; };
+template<> struct bcs_base_char<unsigned char> { typedef char type; };
+
+template<> struct bcs_base_char<unsigned char const> { typedef char type; };
+
+
+template<> struct bcs_base_char<wchar_t const> { typedef wchar_t type; };
+
+
+
+
+
+template<typename CharT>
+struct bcs_char_traits_impl
+{
+
+
+
+    typedef typename boost::add_const<CharT>::type const_char;
+
+    static bool eq( CharT c1, CharT c2 )
+    {
+        return c1 == c2;
+    }
+    static bool lt( CharT c1, CharT c2 )
+    {
+        return c1 < c2;
+    }
+
+    static int compare( const_char* cstr1, const_char* cstr2, std::size_t n )
+    {
+        while( n > 0 ) {
+            if( !eq( *cstr1, *cstr2 ) )
+                return lt( *cstr1, *cstr2 ) ? -1 : 1;
+            ++cstr1;
+            ++cstr2;
+            --n;
+        }
+
+        return 0;
+    }
+
+    static std::size_t length( const_char* cstr )
+    {
+        const_char null_char = CharT();
+
+        const_char* ptr = cstr;
+        while( !eq( *ptr, null_char ) )
+            ++ptr;
+
+        return ptr - cstr;
+    }
+
+    static const_char* find( const_char* s, std::size_t n, CharT c )
+    {
+        while( n > 0 ) {
+            if( eq( *s, c ) )
+                return s;
+
+            ++s;
+            --n;
+        }
+        return 0;
+    }
+};
+# 125 "/usr/include/boost/test/utils/basic_cstring/bcs_char_traits.hpp" 3 4
+template<> struct bcs_char_traits_impl<char> : public std::char_traits<char> {};
+template<> struct bcs_char_traits_impl<wchar_t> : public std::char_traits<wchar_t> {};
+
+
+template<typename CharT>
+class bcs_char_traits : public bcs_char_traits_impl<CharT> {
+    typedef typename ut_detail::bcs_base_char<CharT>::type the_base_char;
+public:
+
+
+
+    typedef std::basic_string<the_base_char, std::char_traits<the_base_char> > std_string;
+
+};
+
+}
+
+}
+
+}
+
+
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 149 "/usr/include/boost/test/utils/basic_cstring/bcs_char_traits.hpp" 2 3 4
+# 22 "/usr/include/boost/test/utils/basic_cstring/basic_cstring.hpp" 2 3 4
+
+
+# 1 "/usr/include/boost/type_traits/remove_cv.hpp" 1 3 4
+# 12 "/usr/include/boost/type_traits/remove_cv.hpp" 3 4
+#define BOOST_TT_REMOVE_CV_HPP_INCLUDED 
+
+
+
+
+
+namespace boost {
+
+
+template <class T> struct remove_cv{ typedef T type; };
+template <class T> struct remove_cv<T const>{ typedef T type; };
+template <class T> struct remove_cv<T volatile>{ typedef T type; };
+template <class T> struct remove_cv<T const volatile>{ typedef T type; };
+
+
+template <class T, std::size_t N> struct remove_cv<T const[N]>{ typedef T type[N]; };
+template <class T, std::size_t N> struct remove_cv<T const volatile[N]>{ typedef T type[N]; };
+template <class T, std::size_t N> struct remove_cv<T volatile[N]>{ typedef T type[N]; };
+
+template <class T> struct remove_cv<T const[]>{ typedef T type[]; };
+template <class T> struct remove_cv<T const volatile[]>{ typedef T type[]; };
+template <class T> struct remove_cv<T volatile[]>{ typedef T type[]; };
+
+
+
+
+
+   template <class T> using remove_cv_t = typename remove_cv<T>::type;
+
+
+
+}
+# 25 "/usr/include/boost/test/utils/basic_cstring/basic_cstring.hpp" 2 3 4
+# 33 "/usr/include/boost/test/utils/basic_cstring/basic_cstring.hpp" 3 4
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 34 "/usr/include/boost/test/utils/basic_cstring/basic_cstring.hpp" 2 3 4
+
+
+
+namespace boost {
+
+namespace unit_test {
+
+
+
+
+
+template<typename CharT>
+class __attribute__((__visibility__("default"))) basic_cstring {
+    typedef basic_cstring<CharT> self_type;
+public:
+
+    typedef ut_detail::bcs_char_traits<CharT> traits_type;
+    typedef typename traits_type::std_string std_string;
+
+    typedef CharT value_type;
+    typedef typename remove_cv<value_type>::type value_ret_type;
+    typedef value_type* pointer;
+    typedef value_type const* const_pointer;
+    typedef value_type& reference;
+    typedef const value_type& const_reference;
+    typedef std::size_t size_type;
+    typedef std::ptrdiff_t difference_type;
+
+    typedef value_type const* const_iterator;
+    typedef value_type* iterator;
+
+
+
+
+    static const size_type npos = static_cast<size_type>(-1);
+
+
+
+
+
+
+    static pointer null_str();
+
+
+    basic_cstring();
+    basic_cstring( basic_cstring const & );
+    basic_cstring( std_string const& s );
+    basic_cstring( pointer s );
+    template<typename LenType>
+    basic_cstring( pointer s, LenType len ) : m_begin( s ), m_end( m_begin + len ) {}
+    basic_cstring( pointer first, pointer last );
+
+
+    value_ret_type operator[]( size_type index ) const;
+    value_ret_type at( size_type index ) const;
+
+
+    size_type size() const;
+    bool is_empty() const;
+    void clear();
+    void resize( size_type new_len );
+
+
+    bool empty() const;
+
+
+    self_type& trim_right( size_type trim_size );
+    self_type& trim_left( size_type trim_size );
+    self_type& trim_right( iterator it );
+    self_type& trim_left( iterator it );
+
+    self_type& trim_left( self_type exclusions = self_type() ) ;
+    self_type& trim_right( self_type exclusions = self_type() ) ;
+    self_type& trim( self_type exclusions = self_type() ) ;
+# 119 "/usr/include/boost/test/utils/basic_cstring/basic_cstring.hpp" 3 4
+    basic_cstring& operator=( self_type const& s );
+    basic_cstring& operator=( std_string const& s );
+    basic_cstring& operator=( pointer s );
+
+    template<typename CharT2>
+    basic_cstring& assign( basic_cstring<CharT2> const& s )
+    {
+        return *this = basic_cstring<CharT>( s.begin(), s.end() );
+    }
+    template<typename PosType, typename LenType>
+    basic_cstring& assign( self_type const& s, PosType pos, LenType len )
+    {
+        return *this = self_type( s.m_begin + pos, len );
+    }
+
+    basic_cstring& assign( std_string const& s );
+    template<typename PosType, typename LenType>
+    basic_cstring& assign( std_string const& s, PosType pos, LenType len )
+    {
+        return *this = self_type( s.c_str() + pos, len );
+    }
+    basic_cstring& assign( pointer s );
+    template<typename LenType>
+    basic_cstring& assign( pointer s, LenType len )
+    {
+        return *this = self_type( s, len );
+    }
+    basic_cstring& assign( pointer f, pointer l );
+
+
+    void swap( self_type& s );
+
+
+    iterator begin();
+    const_iterator begin() const;
+    iterator end();
+    const_iterator end() const;
+
+
+
+
+    size_type find( basic_cstring ) const;
+    size_type rfind( basic_cstring ) const;
+    self_type substr( size_type beg_index, size_type end_index = npos ) const;
+
+private:
+    static self_type default_trim_ex();
+
+
+    iterator m_begin;
+    iterator m_end;
+    static CharT null;
+};
+# 183 "/usr/include/boost/test/utils/basic_cstring/basic_cstring.hpp" 3 4
+template <class CharT, class string_view_t = std::basic_string_view<CharT>>
+class __attribute__((__visibility__("default"))) stringview_cstring_helper : public basic_cstring<CharT> {
+public:
+  stringview_cstring_helper(string_view_t const& sv)
+  : basic_cstring<CharT>(const_cast<CharT*>(sv.data()), sv.size())
+  {}
+};
+# 199 "/usr/include/boost/test/utils/basic_cstring/basic_cstring.hpp" 3 4
+template<typename CharT>
+CharT basic_cstring<CharT>::null = 0;
+
+
+
+template<typename CharT>
+inline typename basic_cstring<CharT>::pointer
+basic_cstring<CharT>::null_str()
+{
+    return &null;
+}
+
+
+
+template<typename CharT>
+inline
+basic_cstring<CharT>::basic_cstring()
+: m_begin( null_str() )
+, m_end( m_begin )
+{
+}
+
+
+
+template<typename CharT>
+inline
+basic_cstring<CharT>::basic_cstring(basic_cstring const & s)
+: m_begin( s.m_begin )
+, m_end( s.m_end )
+{
+}
+
+
+
+template<typename CharT>
+inline
+basic_cstring<CharT>::basic_cstring( std_string const& s )
+: m_begin( s.c_str() )
+, m_end( m_begin + s.size() )
+{
+}
+
+
+
+template<typename CharT>
+inline
+basic_cstring<CharT>::basic_cstring( pointer s )
+: m_begin( s ? s : null_str() )
+, m_end ( m_begin + (s ? traits_type::length( s ) : 0 ) )
+{
+}
+
+
+
+template<typename CharT>
+inline
+basic_cstring<CharT>::basic_cstring( pointer first, pointer last )
+: m_begin( first )
+, m_end( last )
+{
+}
+
+
+
+template<typename CharT>
+inline typename basic_cstring<CharT>::value_ret_type
+basic_cstring<CharT>::operator[]( size_type index ) const
+{
+    return m_begin[index];
+}
+
+
+
+template<typename CharT>
+inline typename basic_cstring<CharT>::value_ret_type
+basic_cstring<CharT>::at( size_type index ) const
+{
+    if( m_begin + index >= m_end )
+        return static_cast<value_type>(0);
+
+    return m_begin[index];
+}
+
+
+
+template<typename CharT>
+inline typename basic_cstring<CharT>::size_type
+basic_cstring<CharT>::size() const
+{
+    return static_cast<size_type>(m_end - m_begin);
+}
+
+
+
+template<typename CharT>
+inline bool
+basic_cstring<CharT>::is_empty() const
+{
+    return m_end == m_begin;
+}
+
+
+
+template<typename CharT>
+inline bool
+basic_cstring<CharT>::empty() const
+{
+    return is_empty();
+}
+
+
+
+template<typename CharT>
+inline void
+basic_cstring<CharT>::clear()
+{
+    m_begin = m_end;
+}
+
+
+
+template<typename CharT>
+inline void
+basic_cstring<CharT>::resize( size_type new_len )
+{
+    if( m_begin + new_len < m_end )
+        m_end = m_begin + new_len;
+}
+
+
+
+template<typename CharT>
+inline basic_cstring<CharT>&
+basic_cstring<CharT>::trim_left( size_type trim_size )
+{
+    m_begin += trim_size;
+    if( m_end <= m_begin )
+        clear();
+
+    return *this;
+}
+
+
+
+template<typename CharT>
+inline basic_cstring<CharT>&
+basic_cstring<CharT>::trim_left( iterator it )
+{
+    m_begin = it;
+    if( m_end <= m_begin )
+        clear();
+
+    return *this;
+}
+
+
+
+template<typename CharT>
+inline basic_cstring<CharT>&
+basic_cstring<CharT>::trim_left( basic_cstring exclusions )
+{
+    if( exclusions.is_empty() )
+        exclusions = default_trim_ex();
+
+    iterator it;
+    for( it = begin(); it != end(); ++it ) {
+        if( traits_type::find( exclusions.begin(), exclusions.size(), *it ) == reinterpret_cast<pointer>(0) )
+            break;
+    }
+
+    return trim_left( it );
+}
+
+
+
+template<typename CharT>
+inline basic_cstring<CharT>&
+basic_cstring<CharT>::trim_right( size_type trim_size )
+{
+    m_end -= trim_size;
+    if( m_end <= m_begin )
+        clear();
+
+    return *this;
+}
+
+
+
+template<typename CharT>
+inline basic_cstring<CharT>&
+basic_cstring<CharT>::trim_right( iterator it )
+{
+    m_end = it;
+    if( m_end <= m_begin )
+        clear();
+
+    return *this;
+}
+
+
+
+template<typename CharT>
+inline basic_cstring<CharT>&
+basic_cstring<CharT>::trim_right( basic_cstring exclusions )
+{
+    if( exclusions.is_empty() )
+        exclusions = default_trim_ex();
+
+    iterator it;
+
+    for( it = end()-1; it != begin()-1; --it ) {
+        if( self_type::traits_type::find( exclusions.begin(), exclusions.size(), *it ) == reinterpret_cast<pointer>(0) )
+            break;
+    }
+
+    return trim_right( it+1 );
+}
+
+
+
+template<typename CharT>
+inline basic_cstring<CharT>&
+basic_cstring<CharT>::trim( basic_cstring exclusions )
+{
+    trim_left( exclusions );
+    trim_right( exclusions );
+
+    return *this;
+}
+
+
+
+template<typename CharT>
+inline basic_cstring<CharT>&
+basic_cstring<CharT>::operator=( basic_cstring<CharT> const& s )
+{
+    m_begin = s.m_begin;
+    m_end = s.m_end;
+
+    return *this;
+}
+
+
+
+template<typename CharT>
+inline basic_cstring<CharT>&
+basic_cstring<CharT>::operator=( std_string const& s )
+{
+    return *this = self_type( s );
+}
+
+
+
+template<typename CharT>
+inline basic_cstring<CharT>&
+basic_cstring<CharT>::operator=( pointer s )
+{
+    return *this = self_type( s );
+}
+
+
+
+template<typename CharT>
+inline basic_cstring<CharT>&
+basic_cstring<CharT>::assign( std_string const& s )
+{
+    return *this = self_type( s );
+}
+
+
+
+template<typename CharT>
+inline basic_cstring<CharT>&
+basic_cstring<CharT>::assign( pointer s )
+{
+    return *this = self_type( s );
+}
+
+
+
+template<typename CharT>
+inline basic_cstring<CharT>&
+basic_cstring<CharT>::assign( pointer f, pointer l )
+{
+    return *this = self_type( f, l );
+}
+
+
+
+template<typename CharT>
+inline void
+basic_cstring<CharT>::swap( basic_cstring<CharT>& s )
+{
+
+    pointer tmp1 = m_begin;
+    pointer tmp2 = m_end;
+
+    m_begin = s.m_begin;
+    m_end = s.m_end;
+
+    s.m_begin = tmp1;
+    s.m_end = tmp2;
+}
+
+
+
+template<typename CharT>
+inline typename basic_cstring<CharT>::iterator
+basic_cstring<CharT>::begin()
+{
+    return m_begin;
+}
+
+
+
+template<typename CharT>
+inline typename basic_cstring<CharT>::const_iterator
+basic_cstring<CharT>::begin() const
+{
+    return m_begin;
+}
+
+
+
+template<typename CharT>
+inline typename basic_cstring<CharT>::iterator
+basic_cstring<CharT>::end()
+{
+    return m_end;
+}
+
+
+
+template<typename CharT>
+inline typename basic_cstring<CharT>::const_iterator
+basic_cstring<CharT>::end() const
+{
+    return m_end;
+}
+
+
+
+template<typename CharT>
+inline typename basic_cstring<CharT>::size_type
+basic_cstring<CharT>::find( basic_cstring<CharT> str ) const
+{
+    if( str.is_empty() || str.size() > size() )
+        return static_cast<size_type>(npos);
+
+    const_iterator it = begin();
+    const_iterator last = end() - str.size() + 1;
+
+    while( it != last ) {
+        if( traits_type::compare( it, str.begin(), str.size() ) == 0 )
+            break;
+
+        ++it;
+    }
+
+    return it == last ? npos : static_cast<size_type>(it - begin());
+}
+
+
+
+template<typename CharT>
+inline typename basic_cstring<CharT>::size_type
+basic_cstring<CharT>::rfind( basic_cstring<CharT> str ) const
+{
+    if( str.is_empty() || str.size() > size() )
+        return static_cast<size_type>(npos);
+
+    const_iterator it = end() - str.size();
+    const_iterator last = begin()-1;
+
+    while( it != last ) {
+        if( traits_type::compare( it, str.begin(), str.size() ) == 0 )
+            break;
+
+        --it;
+    }
+
+    return it == last ? static_cast<size_type>(npos) : static_cast<size_type>(it - begin());
+}
+
+
+
+template<typename CharT>
+inline basic_cstring<CharT>
+basic_cstring<CharT>::substr( size_type beg_index, size_type end_index ) const
+{
+    return beg_index > size()
+            ? self_type()
+            : end_index > size()
+                ? self_type( m_begin + beg_index, m_end )
+                : self_type( m_begin + beg_index, m_begin + end_index );
+}
+
+
+
+template<typename CharT>
+inline basic_cstring<CharT>
+basic_cstring<CharT>::default_trim_ex()
+{
+    static CharT ws[3] = { CharT(' '), CharT('\t'), CharT('\n') };
+
+    return self_type( ws, 3 );
+}
+
+
+
+
+
+
+
+template<typename CharT1,typename CharT2>
+inline bool
+operator==( basic_cstring<CharT1> const& s1, basic_cstring<CharT2> const& s2 )
+{
+    typedef typename basic_cstring<CharT1>::traits_type traits_type;
+    return s1.size() == s2.size() &&
+               traits_type::compare( s1.begin(), s2.begin(), s1.size() ) == 0;
+}
+
+
+
+template<typename CharT1,typename CharT2>
+inline bool
+operator==( basic_cstring<CharT1> const& s1, CharT2* s2 )
+{
+
+    return s1 == basic_cstring<CharT2>( s2 );
+
+
+
+}
+
+
+
+template<typename CharT>
+inline bool
+operator==( basic_cstring<CharT> const& s1, typename basic_cstring<CharT>::std_string const& s2 )
+{
+    return s1 == basic_cstring<CharT>( s2 );
+}
+
+
+
+template<typename CharT1,typename CharT2>
+inline bool
+operator==( CharT1* s2, basic_cstring<CharT2> const& s1 )
+{
+    return s1 == s2;
+}
+
+
+
+template<typename CharT>
+inline bool
+operator==( typename basic_cstring<CharT>::std_string const& s2, basic_cstring<CharT> const& s1 )
+{
+    return s1 == s2;
+}
+
+
+
+template<typename CharT>
+inline bool
+operator!=( basic_cstring<CharT> const& s1, CharT* s2 )
+{
+    return !(s1 == s2);
+}
+
+
+
+template<typename CharT>
+inline bool
+operator!=( CharT* s2, basic_cstring<CharT> const& s1 )
+{
+    return !(s1 == s2);
+}
+
+
+
+template<typename CharT>
+inline bool
+operator!=( basic_cstring<CharT> const& s1, basic_cstring<CharT> const& s2 )
+{
+    return !(s1 == s2);
+}
+
+
+
+template<typename CharT>
+inline bool
+operator!=( basic_cstring<CharT> const& s1, typename basic_cstring<CharT>::std_string const& s2 )
+{
+    return !(s1 == s2);
+}
+
+
+
+template<typename CharT>
+inline bool
+operator!=( typename basic_cstring<CharT>::std_string const& s2, basic_cstring<CharT> const& s1 )
+{
+    return !(s1 == s2);
+}
+
+
+
+
+
+
+
+template<typename CharT>
+inline typename basic_cstring<CharT>::value_ret_type
+first_char( basic_cstring<CharT> source )
+{
+    typedef typename basic_cstring<CharT>::value_ret_type res_type;
+
+    return source.is_empty() ? static_cast<res_type>(0) : *source.begin();
+}
+
+
+
+
+
+
+
+template<typename CharT>
+inline typename basic_cstring<CharT>::value_ret_type
+last_char( basic_cstring<CharT> source )
+{
+    typedef typename basic_cstring<CharT>::value_ret_type res_type;
+
+    return source.is_empty() ? static_cast<res_type>(0) : *(source.end()-1);
+}
+
+
+
+
+
+
+
+template<typename CharT1, typename CharT2>
+inline void
+assign_op( std::basic_string<CharT1>& target, basic_cstring<CharT2> src, int )
+{
+    target.assign( src.begin(), src.size() );
+}
+
+
+
+template<typename CharT1, typename CharT2>
+inline std::basic_string<CharT1>&
+operator+=( std::basic_string<CharT1>& target, basic_cstring<CharT2> const& str )
+{
+    target.append( str.begin(), str.end() );
+    return target;
+}
+
+
+
+template<typename CharT1, typename CharT2>
+inline std::basic_string<CharT1>
+operator+( std::basic_string<CharT1> const& lhs, basic_cstring<CharT2> const& rhs )
+{
+    std::basic_string<CharT1> res( lhs );
+
+    res.append( rhs.begin(), rhs.end() );
+    return res;
+}
+
+
+
+}
+
+}
+
+
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 781 "/usr/include/boost/test/utils/basic_cstring/basic_cstring.hpp" 2 3 4
+# 16 "/usr/include/boost/test/detail/global_typedef.hpp" 2 3 4
+
+#define BOOST_TEST_L(s) ::boost::unit_test::const_string( s, sizeof( s ) - 1 )
+#define BOOST_TEST_STRINGIZE(s) BOOST_TEST_L( BOOST_STRINGIZE( s ) )
+#define BOOST_TEST_EMPTY_STRING BOOST_TEST_L( "" )
+
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 22 "/usr/include/boost/test/detail/global_typedef.hpp" 2 3 4
+
+
+
+namespace boost {
+namespace unit_test {
+
+typedef unsigned long counter_t;
+
+
+
+enum report_level { INV_REPORT_LEVEL, CONFIRMATION_REPORT, SHORT_REPORT, DETAILED_REPORT, NO_REPORT };
+
+
+
+
+enum output_format { OF_INVALID,
+                     OF_CLF,
+                     OF_XML,
+                     OF_JUNIT,
+                     OF_CUSTOM_LOGGER,
+                     OF_DOT
+};
+
+
+
+enum test_unit_type { TUT_CASE = 0x01, TUT_SUITE = 0x10, TUT_ANY = 0x11 };
+
+
+
+enum assertion_result { AR_FAILED, AR_PASSED, AR_TRIGGERED };
+
+
+
+typedef unsigned long test_unit_id;
+
+const test_unit_id INV_TEST_UNIT_ID = 0xFFFFFFFF;
+const test_unit_id MAX_TEST_CASE_ID = 0xFFFFFFFE;
+const test_unit_id MIN_TEST_CASE_ID = 0x00010000;
+const test_unit_id MAX_TEST_SUITE_ID = 0x0000FF00;
+const test_unit_id MIN_TEST_SUITE_ID = 0x00000001;
+
+
+
+namespace ut_detail {
+
+inline test_unit_type
+test_id_2_unit_type( test_unit_id id )
+{
+    return (id & 0xFFFF0000) != 0 ? TUT_CASE : TUT_SUITE;
+}
+
+
+struct test_unit_id_restore {
+    test_unit_id_restore(test_unit_id& to_restore_, test_unit_id new_value)
+    : to_restore(to_restore_)
+    , bkup(to_restore_) {
+        to_restore = new_value;
+    }
+    ~test_unit_id_restore() {
+        to_restore = bkup;
+    }
+private:
+    test_unit_id& to_restore;
+    test_unit_id bkup;
+};
+
+
+
+}
+
+
+template<class T>
+struct static_constant {
+    static T value;
+};
+
+template<class T>
+T static_constant<T>::value;
+# 108 "/usr/include/boost/test/detail/global_typedef.hpp" 3 4
+#define BOOST_TEST_SINGLETON_CONS_NO_CTOR(type) public: static type& instance(); private: BOOST_DELETED_FUNCTION(type(type const&)) BOOST_DELETED_FUNCTION(type& operator=(type const&)) BOOST_DEFAULTED_FUNCTION(~type(), {})
+# 117 "/usr/include/boost/test/detail/global_typedef.hpp" 3 4
+#define BOOST_TEST_SINGLETON_CONS(type) BOOST_TEST_SINGLETON_CONS_NO_CTOR(type) private: BOOST_DEFAULTED_FUNCTION(type(), {})
+
+
+
+
+
+#define BOOST_TEST_SINGLETON_CONS_IMPL(type) type& type::instance() { static type the_inst; return the_inst; }
+# 137 "/usr/include/boost/test/detail/global_typedef.hpp" 3 4
+#define BOOST_TEST_SINGLETON_INST(inst) namespace { BOOST_JOIN( inst, _t)& inst BOOST_ATTRIBUTE_UNUSED = BOOST_JOIN( inst, _t)::instance(); }
+
+
+
+
+}
+}
+
+
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 148 "/usr/include/boost/test/detail/global_typedef.hpp" 2 3 4
+# 17 "/usr/include/boost/test/output/compiler_log_formatter.hpp" 2 3 4
+# 1 "/usr/include/boost/test/unit_test_log_formatter.hpp" 1 3 4
+# 16 "/usr/include/boost/test/unit_test_log_formatter.hpp" 3 4
+#define BOOST_TEST_UNIT_TEST_LOG_FORMATTER_HPP_071894GER 
+
+
+
+# 1 "/usr/include/boost/test/detail/log_level.hpp" 1 3 4
+# 13 "/usr/include/boost/test/detail/log_level.hpp" 3 4
+#define BOOST_TEST_LOG_LEVEL_HPP_011605GER 
+
+
+
+namespace boost {
+namespace unit_test {
+
+
+
+
+
+
+enum __attribute__((__visibility__("default"))) log_level {
+    invalid_log_level = -1,
+    log_successful_tests = 0,
+    log_test_units = 1,
+    log_messages = 2,
+    log_warnings = 3,
+    log_all_errors = 4,
+    log_cpp_exception_errors = 5,
+    log_system_errors = 6,
+    log_fatal_errors = 7,
+
+    log_nothing = 8
+};
+
+}
+}
+# 21 "/usr/include/boost/test/unit_test_log_formatter.hpp" 2 3 4
+# 1 "/usr/include/boost/test/detail/fwd_decl.hpp" 1 3 4
+# 13 "/usr/include/boost/test/detail/fwd_decl.hpp" 3 4
+#define BOOST_TEST_FWD_DECL_HPP_011605GER 
+
+namespace boost {
+
+class execution_monitor;
+class execution_exception;
+
+namespace unit_test {
+
+class test_unit;
+class test_case;
+class test_suite;
+class master_test_suite_t;
+
+class test_tree_visitor;
+class test_observer;
+class test_unit_fixture;
+class global_fixture;
+
+
+class unit_test_monitor_t;
+class unit_test_log_t;
+
+class unit_test_log_formatter;
+struct log_entry_data;
+struct log_checkpoint_data;
+
+class lazy_ostream;
+
+}
+
+}
+# 22 "/usr/include/boost/test/unit_test_log_formatter.hpp" 2 3 4
+
+
+
+
+# 1 "/usr/include/c++/10.2.0/iostream" 1 3 4
+# 34 "/usr/include/c++/10.2.0/iostream" 3 4
+#define _GLIBCXX_IOSTREAM 1
+
+       
+# 37 "/usr/include/c++/10.2.0/iostream" 3
+
+
+# 1 "/usr/include/c++/10.2.0/ostream" 1 3
+# 34 "/usr/include/c++/10.2.0/ostream" 3
+#define _GLIBCXX_OSTREAM 1
+
+       
+# 37 "/usr/include/c++/10.2.0/ostream" 3
+
+# 1 "/usr/include/c++/10.2.0/ios" 1 3
+# 34 "/usr/include/c++/10.2.0/ios" 3
+#define _GLIBCXX_IOS 1
+
+       
+# 37 "/usr/include/c++/10.2.0/ios" 3
+
+
+
+
+
+# 1 "/usr/include/c++/10.2.0/bits/ios_base.h" 1 3
+# 35 "/usr/include/c++/10.2.0/bits/ios_base.h" 3
+#define _IOS_BASE_H 1
+
+       
+# 38 "/usr/include/c++/10.2.0/bits/ios_base.h" 3
+
+
+
+# 1 "/usr/include/c++/10.2.0/bits/locale_classes.h" 1 3
+# 35 "/usr/include/c++/10.2.0/bits/locale_classes.h" 3
+#define _LOCALE_CLASSES_H 1
+
+       
+# 38 "/usr/include/c++/10.2.0/bits/locale_classes.h" 3
+
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 62 "/usr/include/c++/10.2.0/bits/locale_classes.h" 3
+  class locale
+  {
+  public:
+
+
+    typedef int category;
+
+
+    class facet;
+    class id;
+    class _Impl;
+
+    friend class facet;
+    friend class _Impl;
+
+    template<typename _Facet>
+      friend bool
+      has_facet(const locale&) throw();
+
+    template<typename _Facet>
+      friend const _Facet&
+      use_facet(const locale&);
+
+    template<typename _Cache>
+      friend struct __use_cache;
+# 98 "/usr/include/c++/10.2.0/bits/locale_classes.h" 3
+    static const category none = 0;
+    static const category ctype = 1L << 0;
+    static const category numeric = 1L << 1;
+    static const category collate = 1L << 2;
+    static const category time = 1L << 3;
+    static const category monetary = 1L << 4;
+    static const category messages = 1L << 5;
+    static const category all = (ctype | numeric | collate |
+        time | monetary | messages);
+# 117 "/usr/include/c++/10.2.0/bits/locale_classes.h" 3
+    locale() throw();
+# 126 "/usr/include/c++/10.2.0/bits/locale_classes.h" 3
+    locale(const locale& __other) throw();
+# 136 "/usr/include/c++/10.2.0/bits/locale_classes.h" 3
+    explicit
+    locale(const char* __s);
+# 151 "/usr/include/c++/10.2.0/bits/locale_classes.h" 3
+    locale(const locale& __base, const char* __s, category __cat);
+# 162 "/usr/include/c++/10.2.0/bits/locale_classes.h" 3
+    explicit
+    locale(const std::string& __s) : locale(__s.c_str()) { }
+# 177 "/usr/include/c++/10.2.0/bits/locale_classes.h" 3
+    locale(const locale& __base, const std::string& __s, category __cat)
+    : locale(__base, __s.c_str(), __cat) { }
+# 192 "/usr/include/c++/10.2.0/bits/locale_classes.h" 3
+    locale(const locale& __base, const locale& __add, category __cat);
+# 205 "/usr/include/c++/10.2.0/bits/locale_classes.h" 3
+    template<typename _Facet>
+      locale(const locale& __other, _Facet* __f);
+
+
+    ~locale() throw();
+# 219 "/usr/include/c++/10.2.0/bits/locale_classes.h" 3
+    const locale&
+    operator=(const locale& __other) throw();
+# 234 "/usr/include/c++/10.2.0/bits/locale_classes.h" 3
+    template<typename _Facet>
+      locale
+      combine(const locale& __other) const;
+
+
+
+
+
+
+    __attribute ((__abi_tag__ ("cxx11")))
+    string
+    name() const;
+# 254 "/usr/include/c++/10.2.0/bits/locale_classes.h" 3
+    bool
+    operator==(const locale& __other) const throw();
+# 264 "/usr/include/c++/10.2.0/bits/locale_classes.h" 3
+    bool
+    operator!=(const locale& __other) const throw()
+    { return !(this->operator==(__other)); }
+# 284 "/usr/include/c++/10.2.0/bits/locale_classes.h" 3
+    template<typename _Char, typename _Traits, typename _Alloc>
+      bool
+      operator()(const basic_string<_Char, _Traits, _Alloc>& __s1,
+   const basic_string<_Char, _Traits, _Alloc>& __s2) const;
+# 300 "/usr/include/c++/10.2.0/bits/locale_classes.h" 3
+    static locale
+    global(const locale& __loc);
+
+
+
+
+    static const locale&
+    classic();
+
+  private:
+
+    _Impl* _M_impl;
+
+
+    static _Impl* _S_classic;
+
+
+    static _Impl* _S_global;
+
+
+
+
+
+    static const char* const* const _S_categories;
+# 335 "/usr/include/c++/10.2.0/bits/locale_classes.h" 3
+    enum { _S_categories_size = 6 + 6 };
+
+
+    static __gthread_once_t _S_once;
+
+
+    explicit
+    locale(_Impl*) throw();
+
+    static void
+    _S_initialize();
+
+    static void
+    _S_initialize_once() throw();
+
+    static category
+    _S_normalize_category(category);
+
+    void
+    _M_coalesce(const locale& __base, const locale& __add, category __cat);
+
+
+    static const id* const _S_twinned_facets[];
+
+  };
+# 373 "/usr/include/c++/10.2.0/bits/locale_classes.h" 3
+  class locale::facet
+  {
+  private:
+    friend class locale;
+    friend class locale::_Impl;
+
+    mutable _Atomic_word _M_refcount;
+
+
+    static __c_locale _S_c_locale;
+
+
+    static const char _S_c_name[2];
+
+
+    static __gthread_once_t _S_once;
+
+
+    static void
+    _S_initialize_once();
+
+  protected:
+# 404 "/usr/include/c++/10.2.0/bits/locale_classes.h" 3
+    explicit
+    facet(size_t __refs = 0) throw() : _M_refcount(__refs ? 1 : 0)
+    { }
+
+
+    virtual
+    ~facet();
+
+    static void
+    _S_create_c_locale(__c_locale& __cloc, const char* __s,
+         __c_locale __old = 0);
+
+    static __c_locale
+    _S_clone_c_locale(__c_locale& __cloc) throw();
+
+    static void
+    _S_destroy_c_locale(__c_locale& __cloc);
+
+    static __c_locale
+    _S_lc_ctype_c_locale(__c_locale __cloc, const char* __s);
+
+
+
+    static __c_locale
+    _S_get_c_locale();
+
+    __attribute__ ((__const__)) static const char*
+    _S_get_c_name() throw();
+# 440 "/usr/include/c++/10.2.0/bits/locale_classes.h" 3
+    facet(const facet&) = delete;
+
+    facet&
+    operator=(const facet&) = delete;
+
+
+  private:
+    void
+    _M_add_reference() const throw()
+    { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }
+
+    void
+    _M_remove_reference() const throw()
+    {
+
+      ;
+      if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1)
+ {
+          ;
+   try
+     { delete this; }
+   catch(...)
+     { }
+ }
+    }
+
+    const facet* _M_sso_shim(const id*) const;
+    const facet* _M_cow_shim(const id*) const;
+
+  protected:
+    class __shim;
+  };
+# 485 "/usr/include/c++/10.2.0/bits/locale_classes.h" 3
+  class locale::id
+  {
+  private:
+    friend class locale;
+    friend class locale::_Impl;
+
+    template<typename _Facet>
+      friend const _Facet&
+      use_facet(const locale&);
+
+    template<typename _Facet>
+      friend bool
+      has_facet(const locale&) throw();
+
+
+
+
+    mutable size_t _M_index;
+
+
+    static _Atomic_word _S_refcount;
+
+    void
+    operator=(const id&);
+
+    id(const id&);
+
+  public:
+
+
+
+    id() { }
+
+    size_t
+    _M_id() const throw();
+  };
+
+
+
+  class locale::_Impl
+  {
+  public:
+
+    friend class locale;
+    friend class locale::facet;
+
+    template<typename _Facet>
+      friend bool
+      has_facet(const locale&) throw();
+
+    template<typename _Facet>
+      friend const _Facet&
+      use_facet(const locale&);
+
+    template<typename _Cache>
+      friend struct __use_cache;
+
+  private:
+
+    _Atomic_word _M_refcount;
+    const facet** _M_facets;
+    size_t _M_facets_size;
+    const facet** _M_caches;
+    char** _M_names;
+    static const locale::id* const _S_id_ctype[];
+    static const locale::id* const _S_id_numeric[];
+    static const locale::id* const _S_id_collate[];
+    static const locale::id* const _S_id_time[];
+    static const locale::id* const _S_id_monetary[];
+    static const locale::id* const _S_id_messages[];
+    static const locale::id* const* const _S_facet_categories[];
+
+    void
+    _M_add_reference() throw()
+    { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }
+
+    void
+    _M_remove_reference() throw()
+    {
+
+      ;
+      if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1)
+ {
+          ;
+   try
+     { delete this; }
+   catch(...)
+     { }
+ }
+    }
+
+    _Impl(const _Impl&, size_t);
+    _Impl(const char*, size_t);
+    _Impl(size_t) throw();
+
+   ~_Impl() throw();
+
+    _Impl(const _Impl&);
+
+    void
+    operator=(const _Impl&);
+
+    bool
+    _M_check_same_name()
+    {
+      bool __ret = true;
+      if (_M_names[1])
+
+ for (size_t __i = 0; __ret && __i < _S_categories_size - 1; ++__i)
+   __ret = __builtin_strcmp(_M_names[__i], _M_names[__i + 1]) == 0;
+      return __ret;
+    }
+
+    void
+    _M_replace_categories(const _Impl*, category);
+
+    void
+    _M_replace_category(const _Impl*, const locale::id* const*);
+
+    void
+    _M_replace_facet(const _Impl*, const locale::id*);
+
+    void
+    _M_install_facet(const locale::id*, const facet*);
+
+    template<typename _Facet>
+      void
+      _M_init_facet(_Facet* __facet)
+      { _M_install_facet(&_Facet::id, __facet); }
+
+    template<typename _Facet>
+      void
+      _M_init_facet_unchecked(_Facet* __facet)
+      {
+ __facet->_M_add_reference();
+ _M_facets[_Facet::id._M_id()] = __facet;
+      }
+
+    void
+    _M_install_cache(const facet*, size_t);
+
+    void _M_init_extra(facet**);
+    void _M_init_extra(void*, void*, const char*, const char*);
+  };
+# 643 "/usr/include/c++/10.2.0/bits/locale_classes.h" 3
+  template<typename _CharT>
+    class __cxx11:: collate : public locale::facet
+    {
+    public:
+
+
+
+      typedef _CharT char_type;
+      typedef basic_string<_CharT> string_type;
+
+
+    protected:
+
+
+      __c_locale _M_c_locale_collate;
+
+    public:
+
+      static locale::id id;
+# 670 "/usr/include/c++/10.2.0/bits/locale_classes.h" 3
+      explicit
+      collate(size_t __refs = 0)
+      : facet(__refs), _M_c_locale_collate(_S_get_c_locale())
+      { }
+# 684 "/usr/include/c++/10.2.0/bits/locale_classes.h" 3
+      explicit
+      collate(__c_locale __cloc, size_t __refs = 0)
+      : facet(__refs), _M_c_locale_collate(_S_clone_c_locale(__cloc))
+      { }
+# 701 "/usr/include/c++/10.2.0/bits/locale_classes.h" 3
+      int
+      compare(const _CharT* __lo1, const _CharT* __hi1,
+       const _CharT* __lo2, const _CharT* __hi2) const
+      { return this->do_compare(__lo1, __hi1, __lo2, __hi2); }
+# 720 "/usr/include/c++/10.2.0/bits/locale_classes.h" 3
+      string_type
+      transform(const _CharT* __lo, const _CharT* __hi) const
+      { return this->do_transform(__lo, __hi); }
+# 734 "/usr/include/c++/10.2.0/bits/locale_classes.h" 3
+      long
+      hash(const _CharT* __lo, const _CharT* __hi) const
+      { return this->do_hash(__lo, __hi); }
+
+
+      int
+      _M_compare(const _CharT*, const _CharT*) const throw();
+
+      size_t
+      _M_transform(_CharT*, const _CharT*, size_t) const throw();
+
+  protected:
+
+      virtual
+      ~collate()
+      { _S_destroy_c_locale(_M_c_locale_collate); }
+# 763 "/usr/include/c++/10.2.0/bits/locale_classes.h" 3
+      virtual int
+      do_compare(const _CharT* __lo1, const _CharT* __hi1,
+   const _CharT* __lo2, const _CharT* __hi2) const;
+# 777 "/usr/include/c++/10.2.0/bits/locale_classes.h" 3
+      virtual string_type
+      do_transform(const _CharT* __lo, const _CharT* __hi) const;
+# 790 "/usr/include/c++/10.2.0/bits/locale_classes.h" 3
+      virtual long
+      do_hash(const _CharT* __lo, const _CharT* __hi) const;
+    };
+
+  template<typename _CharT>
+    locale::id collate<_CharT>::id;
+
+
+  template<>
+    int
+    collate<char>::_M_compare(const char*, const char*) const throw();
+
+  template<>
+    size_t
+    collate<char>::_M_transform(char*, const char*, size_t) const throw();
+
+
+  template<>
+    int
+    collate<wchar_t>::_M_compare(const wchar_t*, const wchar_t*) const throw();
+
+  template<>
+    size_t
+    collate<wchar_t>::_M_transform(wchar_t*, const wchar_t*, size_t) const throw();
+
+
+
+  template<typename _CharT>
+    class __cxx11:: collate_byname : public collate<_CharT>
+    {
+    public:
+
+
+      typedef _CharT char_type;
+      typedef basic_string<_CharT> string_type;
+
+
+      explicit
+      collate_byname(const char* __s, size_t __refs = 0)
+      : collate<_CharT>(__refs)
+      {
+ if (__builtin_strcmp(__s, "C") != 0
+     && __builtin_strcmp(__s, "POSIX") != 0)
+   {
+     this->_S_destroy_c_locale(this->_M_c_locale_collate);
+     this->_S_create_c_locale(this->_M_c_locale_collate, __s);
+   }
+      }
+
+
+      explicit
+      collate_byname(const string& __s, size_t __refs = 0)
+      : collate_byname(__s.c_str(), __refs) { }
+
+
+    protected:
+      virtual
+      ~collate_byname() { }
+    };
+
+
+}
+
+# 1 "/usr/include/c++/10.2.0/bits/locale_classes.tcc" 1 3
+# 35 "/usr/include/c++/10.2.0/bits/locale_classes.tcc" 3
+#define _LOCALE_CLASSES_TCC 1
+
+       
+# 38 "/usr/include/c++/10.2.0/bits/locale_classes.tcc" 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  template<typename _Facet>
+    locale::
+    locale(const locale& __other, _Facet* __f)
+    {
+      _M_impl = new _Impl(*__other._M_impl, 1);
+
+      try
+ { _M_impl->_M_install_facet(&_Facet::id, __f); }
+      catch(...)
+ {
+   _M_impl->_M_remove_reference();
+   throw;
+ }
+      delete [] _M_impl->_M_names[0];
+      _M_impl->_M_names[0] = 0;
+    }
+
+  template<typename _Facet>
+    locale
+    locale::
+    combine(const locale& __other) const
+    {
+      _Impl* __tmp = new _Impl(*_M_impl, 1);
+      try
+ {
+   __tmp->_M_replace_facet(__other._M_impl, &_Facet::id);
+ }
+      catch(...)
+ {
+   __tmp->_M_remove_reference();
+   throw;
+ }
+      return locale(__tmp);
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    bool
+    locale::
+    operator()(const basic_string<_CharT, _Traits, _Alloc>& __s1,
+        const basic_string<_CharT, _Traits, _Alloc>& __s2) const
+    {
+      typedef std::collate<_CharT> __collate_type;
+      const __collate_type& __collate = use_facet<__collate_type>(*this);
+      return (__collate.compare(__s1.data(), __s1.data() + __s1.length(),
+    __s2.data(), __s2.data() + __s2.length()) < 0);
+    }
+# 102 "/usr/include/c++/10.2.0/bits/locale_classes.tcc" 3
+  template<typename _Facet>
+    bool
+    has_facet(const locale& __loc) throw()
+    {
+      const size_t __i = _Facet::id._M_id();
+      const locale::facet** __facets = __loc._M_impl->_M_facets;
+      return (__i < __loc._M_impl->_M_facets_size
+
+       && dynamic_cast<const _Facet*>(__facets[__i]));
+
+
+
+    }
+# 130 "/usr/include/c++/10.2.0/bits/locale_classes.tcc" 3
+  template<typename _Facet>
+    const _Facet&
+    use_facet(const locale& __loc)
+    {
+      const size_t __i = _Facet::id._M_id();
+      const locale::facet** __facets = __loc._M_impl->_M_facets;
+      if (__i >= __loc._M_impl->_M_facets_size || !__facets[__i])
+        __throw_bad_cast();
+
+      return dynamic_cast<const _Facet&>(*__facets[__i]);
+
+
+
+    }
+
+
+
+  template<typename _CharT>
+    int
+    collate<_CharT>::_M_compare(const _CharT*, const _CharT*) const throw ()
+    { return 0; }
+
+
+  template<typename _CharT>
+    size_t
+    collate<_CharT>::_M_transform(_CharT*, const _CharT*, size_t) const throw ()
+    { return 0; }
+
+  template<typename _CharT>
+    int
+    collate<_CharT>::
+    do_compare(const _CharT* __lo1, const _CharT* __hi1,
+        const _CharT* __lo2, const _CharT* __hi2) const
+    {
+
+
+      const string_type __one(__lo1, __hi1);
+      const string_type __two(__lo2, __hi2);
+
+      const _CharT* __p = __one.c_str();
+      const _CharT* __pend = __one.data() + __one.length();
+      const _CharT* __q = __two.c_str();
+      const _CharT* __qend = __two.data() + __two.length();
+
+
+
+
+      for (;;)
+ {
+   const int __res = _M_compare(__p, __q);
+   if (__res)
+     return __res;
+
+   __p += char_traits<_CharT>::length(__p);
+   __q += char_traits<_CharT>::length(__q);
+   if (__p == __pend && __q == __qend)
+     return 0;
+   else if (__p == __pend)
+     return -1;
+   else if (__q == __qend)
+     return 1;
+
+   __p++;
+   __q++;
+ }
+    }
+
+  template<typename _CharT>
+    typename collate<_CharT>::string_type
+    collate<_CharT>::
+    do_transform(const _CharT* __lo, const _CharT* __hi) const
+    {
+      string_type __ret;
+
+
+      const string_type __str(__lo, __hi);
+
+      const _CharT* __p = __str.c_str();
+      const _CharT* __pend = __str.data() + __str.length();
+
+      size_t __len = (__hi - __lo) * 2;
+
+      _CharT* __c = new _CharT[__len];
+
+      try
+ {
+
+
+
+   for (;;)
+     {
+
+       size_t __res = _M_transform(__c, __p, __len);
+
+
+       if (__res >= __len)
+  {
+    __len = __res + 1;
+    delete [] __c, __c = 0;
+    __c = new _CharT[__len];
+    __res = _M_transform(__c, __p, __len);
+  }
+
+       __ret.append(__c, __res);
+       __p += char_traits<_CharT>::length(__p);
+       if (__p == __pend)
+  break;
+
+       __p++;
+       __ret.push_back(_CharT());
+     }
+ }
+      catch(...)
+ {
+   delete [] __c;
+   throw;
+ }
+
+      delete [] __c;
+
+      return __ret;
+    }
+
+  template<typename _CharT>
+    long
+    collate<_CharT>::
+    do_hash(const _CharT* __lo, const _CharT* __hi) const
+    {
+      unsigned long __val = 0;
+      for (; __lo < __hi; ++__lo)
+ __val =
+   *__lo + ((__val << 7)
+     | (__val >> (__gnu_cxx::__numeric_traits<unsigned long>::
+    __digits - 7)));
+      return static_cast<long>(__val);
+    }
+
+
+
+
+  extern template class collate<char>;
+  extern template class collate_byname<char>;
+
+  extern template
+    const collate<char>&
+    use_facet<collate<char> >(const locale&);
+
+  extern template
+    bool
+    has_facet<collate<char> >(const locale&);
+
+
+  extern template class collate<wchar_t>;
+  extern template class collate_byname<wchar_t>;
+
+  extern template
+    const collate<wchar_t>&
+    use_facet<collate<wchar_t> >(const locale&);
+
+  extern template
+    bool
+    has_facet<collate<wchar_t> >(const locale&);
+
+
+
+
+}
+# 854 "/usr/include/c++/10.2.0/bits/locale_classes.h" 2 3
+# 42 "/usr/include/c++/10.2.0/bits/ios_base.h" 2 3
+
+
+
+
+# 1 "/usr/include/c++/10.2.0/system_error" 1 3
+# 30 "/usr/include/c++/10.2.0/system_error" 3
+#define _GLIBCXX_SYSTEM_ERROR 1
+
+       
+# 33 "/usr/include/c++/10.2.0/system_error" 3
+
+
+
+
+
+
+# 1 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/error_constants.h" 1 3
+# 31 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/error_constants.h" 3
+#define _GLIBCXX_ERROR_CONSTANTS 1
+
+
+# 1 "/usr/include/c++/10.2.0/cerrno" 1 3
+# 39 "/usr/include/c++/10.2.0/cerrno" 3
+       
+# 40 "/usr/include/c++/10.2.0/cerrno" 3
+# 35 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/error_constants.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  enum class errc
+    {
+      address_family_not_supported = 97,
+      address_in_use = 98,
+      address_not_available = 99,
+      already_connected = 106,
+      argument_list_too_long = 7,
+      argument_out_of_domain = 33,
+      bad_address = 14,
+      bad_file_descriptor = 9,
+
+
+      bad_message = 74,
+
+
+      broken_pipe = 32,
+      connection_aborted = 103,
+      connection_already_in_progress = 114,
+      connection_refused = 111,
+      connection_reset = 104,
+      cross_device_link = 18,
+      destination_address_required = 89,
+      device_or_resource_busy = 16,
+      directory_not_empty = 39,
+      executable_format_error = 8,
+      file_exists = 17,
+      file_too_large = 27,
+      filename_too_long = 36,
+      function_not_supported = 38,
+      host_unreachable = 113,
+
+
+      identifier_removed = 43,
+
+
+      illegal_byte_sequence = 84,
+      inappropriate_io_control_operation = 25,
+      interrupted = 4,
+      invalid_argument = 22,
+      invalid_seek = 29,
+      io_error = 5,
+      is_a_directory = 21,
+      message_size = 90,
+      network_down = 100,
+      network_reset = 102,
+      network_unreachable = 101,
+      no_buffer_space = 105,
+      no_child_process = 10,
+
+
+      no_link = 67,
+
+
+      no_lock_available = 37,
+
+
+      no_message_available = 61,
+
+
+      no_message = 42,
+      no_protocol_option = 92,
+      no_space_on_device = 28,
+
+
+      no_stream_resources = 63,
+
+
+      no_such_device_or_address = 6,
+      no_such_device = 19,
+      no_such_file_or_directory = 2,
+      no_such_process = 3,
+      not_a_directory = 20,
+      not_a_socket = 88,
+
+
+      not_a_stream = 60,
+
+
+      not_connected = 107,
+      not_enough_memory = 12,
+
+
+      not_supported = 95,
+
+
+
+      operation_canceled = 125,
+
+
+      operation_in_progress = 115,
+      operation_not_permitted = 1,
+      operation_not_supported = 95,
+      operation_would_block = 11,
+
+
+      owner_dead = 130,
+
+
+      permission_denied = 13,
+
+
+      protocol_error = 71,
+
+
+      protocol_not_supported = 93,
+      read_only_file_system = 30,
+      resource_deadlock_would_occur = 35,
+      resource_unavailable_try_again = 11,
+      result_out_of_range = 34,
+
+
+      state_not_recoverable = 131,
+
+
+
+      stream_timeout = 62,
+
+
+
+      text_file_busy = 26,
+
+
+      timed_out = 110,
+      too_many_files_open_in_system = 23,
+      too_many_files_open = 24,
+      too_many_links = 31,
+      too_many_symbolic_link_levels = 40,
+
+
+      value_too_large = 75,
+
+
+      wrong_protocol_type = 91
+    };
+
+
+}
+# 40 "/usr/include/c++/10.2.0/system_error" 2 3
+
+# 1 "/usr/include/c++/10.2.0/stdexcept" 1 3
+# 34 "/usr/include/c++/10.2.0/stdexcept" 3
+#define _GLIBCXX_STDEXCEPT 1
+
+       
+# 37 "/usr/include/c++/10.2.0/stdexcept" 3
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+  struct __cow_string
+  {
+    union {
+      const char* _M_p;
+      char _M_bytes[sizeof(const char*)];
+    };
+
+    __cow_string();
+    __cow_string(const std::string&);
+    __cow_string(const char*, size_t);
+    __cow_string(const __cow_string&) noexcept;
+    __cow_string& operator=(const __cow_string&) noexcept;
+    ~__cow_string();
+
+    __cow_string(__cow_string&&) noexcept;
+    __cow_string& operator=(__cow_string&&) noexcept;
+
+  };
+
+  typedef basic_string<char> __sso_string;
+# 113 "/usr/include/c++/10.2.0/stdexcept" 3
+  class logic_error : public exception
+  {
+    __cow_string _M_msg;
+
+  public:
+
+    explicit
+    logic_error(const string& __arg) ;
+
+
+    explicit
+    logic_error(const char*) ;
+
+    logic_error(logic_error&&) noexcept;
+    logic_error& operator=(logic_error&&) noexcept;
+
+
+
+    logic_error(const logic_error&) noexcept;
+    logic_error& operator=(const logic_error&) noexcept;
+
+
+
+
+
+    virtual ~logic_error() noexcept;
+
+
+
+    virtual const char*
+    what() const noexcept;
+
+
+
+
+
+  };
+
+
+
+  class domain_error : public logic_error
+  {
+  public:
+    explicit domain_error(const string& __arg) ;
+
+    explicit domain_error(const char*) ;
+    domain_error(const domain_error&) = default;
+    domain_error& operator=(const domain_error&) = default;
+    domain_error(domain_error&&) = default;
+    domain_error& operator=(domain_error&&) = default;
+
+    virtual ~domain_error() noexcept;
+  };
+
+
+  class invalid_argument : public logic_error
+  {
+  public:
+    explicit invalid_argument(const string& __arg) ;
+
+    explicit invalid_argument(const char*) ;
+    invalid_argument(const invalid_argument&) = default;
+    invalid_argument& operator=(const invalid_argument&) = default;
+    invalid_argument(invalid_argument&&) = default;
+    invalid_argument& operator=(invalid_argument&&) = default;
+
+    virtual ~invalid_argument() noexcept;
+  };
+
+
+
+  class length_error : public logic_error
+  {
+  public:
+    explicit length_error(const string& __arg) ;
+
+    explicit length_error(const char*) ;
+    length_error(const length_error&) = default;
+    length_error& operator=(const length_error&) = default;
+    length_error(length_error&&) = default;
+    length_error& operator=(length_error&&) = default;
+
+    virtual ~length_error() noexcept;
+  };
+
+
+
+  class out_of_range : public logic_error
+  {
+  public:
+    explicit out_of_range(const string& __arg) ;
+
+    explicit out_of_range(const char*) ;
+    out_of_range(const out_of_range&) = default;
+    out_of_range& operator=(const out_of_range&) = default;
+    out_of_range(out_of_range&&) = default;
+    out_of_range& operator=(out_of_range&&) = default;
+
+    virtual ~out_of_range() noexcept;
+  };
+
+
+
+
+
+
+  class runtime_error : public exception
+  {
+    __cow_string _M_msg;
+
+  public:
+
+    explicit
+    runtime_error(const string& __arg) ;
+
+
+    explicit
+    runtime_error(const char*) ;
+
+    runtime_error(runtime_error&&) noexcept;
+    runtime_error& operator=(runtime_error&&) noexcept;
+
+
+
+    runtime_error(const runtime_error&) noexcept;
+    runtime_error& operator=(const runtime_error&) noexcept;
+
+
+
+
+
+    virtual ~runtime_error() noexcept;
+
+
+
+    virtual const char*
+    what() const noexcept;
+
+
+
+
+
+  };
+
+
+  class range_error : public runtime_error
+  {
+  public:
+    explicit range_error(const string& __arg) ;
+
+    explicit range_error(const char*) ;
+    range_error(const range_error&) = default;
+    range_error& operator=(const range_error&) = default;
+    range_error(range_error&&) = default;
+    range_error& operator=(range_error&&) = default;
+
+    virtual ~range_error() noexcept;
+  };
+
+
+  class overflow_error : public runtime_error
+  {
+  public:
+    explicit overflow_error(const string& __arg) ;
+
+    explicit overflow_error(const char*) ;
+    overflow_error(const overflow_error&) = default;
+    overflow_error& operator=(const overflow_error&) = default;
+    overflow_error(overflow_error&&) = default;
+    overflow_error& operator=(overflow_error&&) = default;
+
+    virtual ~overflow_error() noexcept;
+  };
+
+
+  class underflow_error : public runtime_error
+  {
+  public:
+    explicit underflow_error(const string& __arg) ;
+
+    explicit underflow_error(const char*) ;
+    underflow_error(const underflow_error&) = default;
+    underflow_error& operator=(const underflow_error&) = default;
+    underflow_error(underflow_error&&) = default;
+    underflow_error& operator=(underflow_error&&) = default;
+
+    virtual ~underflow_error() noexcept;
+  };
+
+
+
+
+}
+# 42 "/usr/include/c++/10.2.0/system_error" 2 3
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+
+  class error_code;
+  class error_condition;
+  class system_error;
+
+
+  template<typename _Tp>
+    struct is_error_code_enum : public false_type { };
+
+
+  template<typename _Tp>
+    struct is_error_condition_enum : public false_type { };
+
+  template<>
+    struct is_error_condition_enum<errc>
+    : public true_type { };
+
+
+  template <typename _Tp>
+    inline constexpr bool is_error_code_enum_v =
+      is_error_code_enum<_Tp>::value;
+  template <typename _Tp>
+    inline constexpr bool is_error_condition_enum_v =
+      is_error_condition_enum<_Tp>::value;
+
+  inline namespace _V2 {
+# 89 "/usr/include/c++/10.2.0/system_error" 3
+  class error_category
+  {
+  public:
+    constexpr error_category() noexcept = default;
+
+    virtual ~error_category();
+
+    error_category(const error_category&) = delete;
+    error_category& operator=(const error_category&) = delete;
+
+    virtual const char*
+    name() const noexcept = 0;
+
+
+
+
+
+
+  private:
+    __attribute ((__abi_tag__ ("cxx11")))
+    virtual __cow_string
+    _M_message(int) const;
+
+  public:
+    __attribute ((__abi_tag__ ("cxx11")))
+    virtual string
+    message(int) const = 0;
+# 125 "/usr/include/c++/10.2.0/system_error" 3
+  public:
+    virtual error_condition
+    default_error_condition(int __i) const noexcept;
+
+    virtual bool
+    equivalent(int __i, const error_condition& __cond) const noexcept;
+
+    virtual bool
+    equivalent(const error_code& __code, int __i) const noexcept;
+
+    bool
+    operator==(const error_category& __other) const noexcept
+    { return this == &__other; }
+
+
+
+
+
+
+    bool
+    operator!=(const error_category& __other) const noexcept
+    { return this != &__other; }
+
+    bool
+    operator<(const error_category& __other) const noexcept
+    { return less<const error_category*>()(this, &__other); }
+
+  };
+
+
+
+
+  __attribute__ ((__const__)) const error_category& generic_category() noexcept;
+
+
+  __attribute__ ((__const__)) const error_category& system_category() noexcept;
+
+  }
+
+  error_code make_error_code(errc) noexcept;
+# 180 "/usr/include/c++/10.2.0/system_error" 3
+  struct error_code
+  {
+    error_code() noexcept
+    : _M_value(0), _M_cat(&system_category()) { }
+
+    error_code(int __v, const error_category& __cat) noexcept
+    : _M_value(__v), _M_cat(&__cat) { }
+
+    template<typename _ErrorCodeEnum, typename = typename
+      enable_if<is_error_code_enum<_ErrorCodeEnum>::value>::type>
+      error_code(_ErrorCodeEnum __e) noexcept
+      { *this = make_error_code(__e); }
+
+    void
+    assign(int __v, const error_category& __cat) noexcept
+    {
+      _M_value = __v;
+      _M_cat = &__cat;
+    }
+
+    void
+    clear() noexcept
+    { assign(0, system_category()); }
+
+
+    template<typename _ErrorCodeEnum>
+      typename enable_if<is_error_code_enum<_ErrorCodeEnum>::value,
+    error_code&>::type
+      operator=(_ErrorCodeEnum __e) noexcept
+      { return *this = make_error_code(__e); }
+
+    int
+    value() const noexcept { return _M_value; }
+
+    const error_category&
+    category() const noexcept { return *_M_cat; }
+
+    error_condition
+    default_error_condition() const noexcept;
+
+    __attribute ((__abi_tag__ ("cxx11")))
+    string
+    message() const
+    { return category().message(value()); }
+
+    explicit operator bool() const noexcept
+    { return _M_value != 0; }
+
+
+  private:
+    int _M_value;
+    const error_category* _M_cat;
+  };
+
+
+
+
+
+  inline error_code
+  make_error_code(errc __e) noexcept
+  { return error_code(static_cast<int>(__e), generic_category()); }
+# 251 "/usr/include/c++/10.2.0/system_error" 3
+  inline bool
+  operator<(const error_code& __lhs, const error_code& __rhs) noexcept
+  {
+    return (__lhs.category() < __rhs.category()
+     || (__lhs.category() == __rhs.category()
+  && __lhs.value() < __rhs.value()));
+  }
+
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __os, const error_code& __e)
+    { return (__os << __e.category().name() << ':' << __e.value()); }
+
+
+
+  error_condition make_error_condition(errc) noexcept;
+# 278 "/usr/include/c++/10.2.0/system_error" 3
+  struct error_condition
+  {
+    error_condition() noexcept
+    : _M_value(0), _M_cat(&generic_category()) { }
+
+    error_condition(int __v, const error_category& __cat) noexcept
+    : _M_value(__v), _M_cat(&__cat) { }
+
+    template<typename _ErrorConditionEnum, typename = typename
+  enable_if<is_error_condition_enum<_ErrorConditionEnum>::value>::type>
+      error_condition(_ErrorConditionEnum __e) noexcept
+      { *this = make_error_condition(__e); }
+
+    void
+    assign(int __v, const error_category& __cat) noexcept
+    {
+      _M_value = __v;
+      _M_cat = &__cat;
+    }
+
+
+    template<typename _ErrorConditionEnum>
+      typename enable_if<is_error_condition_enum
+    <_ErrorConditionEnum>::value, error_condition&>::type
+      operator=(_ErrorConditionEnum __e) noexcept
+      { return *this = make_error_condition(__e); }
+
+    void
+    clear() noexcept
+    { assign(0, generic_category()); }
+
+
+    int
+    value() const noexcept { return _M_value; }
+
+    const error_category&
+    category() const noexcept { return *_M_cat; }
+
+    __attribute ((__abi_tag__ ("cxx11")))
+    string
+    message() const
+    { return category().message(value()); }
+
+    explicit operator bool() const noexcept
+    { return _M_value != 0; }
+
+
+  private:
+    int _M_value;
+    const error_category* _M_cat;
+  };
+
+
+
+
+
+  inline error_condition
+  make_error_condition(errc __e) noexcept
+  { return error_condition(static_cast<int>(__e), generic_category()); }
+
+
+
+
+  inline bool
+  operator==(const error_code& __lhs, const error_code& __rhs) noexcept
+  { return (__lhs.category() == __rhs.category()
+     && __lhs.value() == __rhs.value()); }
+
+
+
+  inline bool
+  operator==(const error_code& __lhs, const error_condition& __rhs) noexcept
+  {
+    return (__lhs.category().equivalent(__lhs.value(), __rhs)
+     || __rhs.category().equivalent(__lhs, __rhs.value()));
+  }
+
+
+  inline bool
+  operator==(const error_condition& __lhs,
+      const error_condition& __rhs) noexcept
+  {
+    return (__lhs.category() == __rhs.category()
+     && __lhs.value() == __rhs.value());
+  }
+# 378 "/usr/include/c++/10.2.0/system_error" 3
+  inline bool
+  operator<(const error_condition& __lhs,
+     const error_condition& __rhs) noexcept
+  {
+    return (__lhs.category() < __rhs.category()
+     || (__lhs.category() == __rhs.category()
+  && __lhs.value() < __rhs.value()));
+  }
+
+
+
+  inline bool
+  operator==(const error_condition& __lhs, const error_code& __rhs) noexcept
+  {
+    return (__rhs.category().equivalent(__rhs.value(), __lhs)
+     || __lhs.category().equivalent(__rhs, __lhs.value()));
+  }
+
+
+  inline bool
+  operator!=(const error_code& __lhs, const error_code& __rhs) noexcept
+  { return !(__lhs == __rhs); }
+
+
+
+  inline bool
+  operator!=(const error_code& __lhs, const error_condition& __rhs) noexcept
+  { return !(__lhs == __rhs); }
+
+
+
+  inline bool
+  operator!=(const error_condition& __lhs, const error_code& __rhs) noexcept
+  { return !(__lhs == __rhs); }
+
+
+  inline bool
+  operator!=(const error_condition& __lhs,
+      const error_condition& __rhs) noexcept
+  { return !(__lhs == __rhs); }
+# 428 "/usr/include/c++/10.2.0/system_error" 3
+  class system_error : public std::runtime_error
+  {
+  private:
+    error_code _M_code;
+
+  public:
+    system_error(error_code __ec = error_code())
+    : runtime_error(__ec.message()), _M_code(__ec) { }
+
+    system_error(error_code __ec, const string& __what)
+    : runtime_error(__what + ": " + __ec.message()), _M_code(__ec) { }
+
+    system_error(error_code __ec, const char* __what)
+    : runtime_error(__what + (": " + __ec.message())), _M_code(__ec) { }
+
+    system_error(int __v, const error_category& __ecat, const char* __what)
+    : system_error(error_code(__v, __ecat), __what) { }
+
+    system_error(int __v, const error_category& __ecat)
+    : runtime_error(error_code(__v, __ecat).message()),
+      _M_code(__v, __ecat) { }
+
+    system_error(int __v, const error_category& __ecat, const string& __what)
+    : runtime_error(__what + ": " + error_code(__v, __ecat).message()),
+      _M_code(__v, __ecat) { }
+
+
+    system_error (const system_error &) = default;
+    system_error &operator= (const system_error &) = default;
+
+
+    virtual ~system_error() noexcept;
+
+    const error_code&
+    code() const noexcept { return _M_code; }
+  };
+
+
+}
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+
+  template<>
+    struct hash<error_code>
+    : public __hash_base<size_t, error_code>
+    {
+      size_t
+      operator()(const error_code& __e) const noexcept
+      {
+ const size_t __tmp = std::_Hash_impl::hash(__e.value());
+ return std::_Hash_impl::__hash_combine(&__e.category(), __tmp);
+      }
+    };
+
+
+
+
+
+
+  template<>
+    struct hash<error_condition>
+    : public __hash_base<size_t, error_condition>
+    {
+      size_t
+      operator()(const error_condition& __e) const noexcept
+      {
+ const size_t __tmp = std::_Hash_impl::hash(__e.value());
+ return std::_Hash_impl::__hash_combine(&__e.category(), __tmp);
+      }
+    };
+
+
+
+}
+# 47 "/usr/include/c++/10.2.0/bits/ios_base.h" 2 3
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+
+  enum _Ios_Fmtflags
+    {
+      _S_boolalpha = 1L << 0,
+      _S_dec = 1L << 1,
+      _S_fixed = 1L << 2,
+      _S_hex = 1L << 3,
+      _S_internal = 1L << 4,
+      _S_left = 1L << 5,
+      _S_oct = 1L << 6,
+      _S_right = 1L << 7,
+      _S_scientific = 1L << 8,
+      _S_showbase = 1L << 9,
+      _S_showpoint = 1L << 10,
+      _S_showpos = 1L << 11,
+      _S_skipws = 1L << 12,
+      _S_unitbuf = 1L << 13,
+      _S_uppercase = 1L << 14,
+      _S_adjustfield = _S_left | _S_right | _S_internal,
+      _S_basefield = _S_dec | _S_oct | _S_hex,
+      _S_floatfield = _S_scientific | _S_fixed,
+      _S_ios_fmtflags_end = 1L << 16,
+      _S_ios_fmtflags_max = 0x7fffffff,
+      _S_ios_fmtflags_min = ~0x7fffffff
+    };
+
+  inline constexpr _Ios_Fmtflags
+  operator&(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
+  { return _Ios_Fmtflags(static_cast<int>(__a) & static_cast<int>(__b)); }
+
+  inline constexpr _Ios_Fmtflags
+  operator|(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
+  { return _Ios_Fmtflags(static_cast<int>(__a) | static_cast<int>(__b)); }
+
+  inline constexpr _Ios_Fmtflags
+  operator^(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
+  { return _Ios_Fmtflags(static_cast<int>(__a) ^ static_cast<int>(__b)); }
+
+  inline constexpr _Ios_Fmtflags
+  operator~(_Ios_Fmtflags __a)
+  { return _Ios_Fmtflags(~static_cast<int>(__a)); }
+
+  inline const _Ios_Fmtflags&
+  operator|=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
+  { return __a = __a | __b; }
+
+  inline const _Ios_Fmtflags&
+  operator&=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
+  { return __a = __a & __b; }
+
+  inline const _Ios_Fmtflags&
+  operator^=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
+  { return __a = __a ^ __b; }
+
+
+  enum _Ios_Openmode
+    {
+      _S_app = 1L << 0,
+      _S_ate = 1L << 1,
+      _S_bin = 1L << 2,
+      _S_in = 1L << 3,
+      _S_out = 1L << 4,
+      _S_trunc = 1L << 5,
+      _S_ios_openmode_end = 1L << 16,
+      _S_ios_openmode_max = 0x7fffffff,
+      _S_ios_openmode_min = ~0x7fffffff
+    };
+
+  inline constexpr _Ios_Openmode
+  operator&(_Ios_Openmode __a, _Ios_Openmode __b)
+  { return _Ios_Openmode(static_cast<int>(__a) & static_cast<int>(__b)); }
+
+  inline constexpr _Ios_Openmode
+  operator|(_Ios_Openmode __a, _Ios_Openmode __b)
+  { return _Ios_Openmode(static_cast<int>(__a) | static_cast<int>(__b)); }
+
+  inline constexpr _Ios_Openmode
+  operator^(_Ios_Openmode __a, _Ios_Openmode __b)
+  { return _Ios_Openmode(static_cast<int>(__a) ^ static_cast<int>(__b)); }
+
+  inline constexpr _Ios_Openmode
+  operator~(_Ios_Openmode __a)
+  { return _Ios_Openmode(~static_cast<int>(__a)); }
+
+  inline const _Ios_Openmode&
+  operator|=(_Ios_Openmode& __a, _Ios_Openmode __b)
+  { return __a = __a | __b; }
+
+  inline const _Ios_Openmode&
+  operator&=(_Ios_Openmode& __a, _Ios_Openmode __b)
+  { return __a = __a & __b; }
+
+  inline const _Ios_Openmode&
+  operator^=(_Ios_Openmode& __a, _Ios_Openmode __b)
+  { return __a = __a ^ __b; }
+
+
+  enum _Ios_Iostate
+    {
+      _S_goodbit = 0,
+      _S_badbit = 1L << 0,
+      _S_eofbit = 1L << 1,
+      _S_failbit = 1L << 2,
+      _S_ios_iostate_end = 1L << 16,
+      _S_ios_iostate_max = 0x7fffffff,
+      _S_ios_iostate_min = ~0x7fffffff
+    };
+
+  inline constexpr _Ios_Iostate
+  operator&(_Ios_Iostate __a, _Ios_Iostate __b)
+  { return _Ios_Iostate(static_cast<int>(__a) & static_cast<int>(__b)); }
+
+  inline constexpr _Ios_Iostate
+  operator|(_Ios_Iostate __a, _Ios_Iostate __b)
+  { return _Ios_Iostate(static_cast<int>(__a) | static_cast<int>(__b)); }
+
+  inline constexpr _Ios_Iostate
+  operator^(_Ios_Iostate __a, _Ios_Iostate __b)
+  { return _Ios_Iostate(static_cast<int>(__a) ^ static_cast<int>(__b)); }
+
+  inline constexpr _Ios_Iostate
+  operator~(_Ios_Iostate __a)
+  { return _Ios_Iostate(~static_cast<int>(__a)); }
+
+  inline const _Ios_Iostate&
+  operator|=(_Ios_Iostate& __a, _Ios_Iostate __b)
+  { return __a = __a | __b; }
+
+  inline const _Ios_Iostate&
+  operator&=(_Ios_Iostate& __a, _Ios_Iostate __b)
+  { return __a = __a & __b; }
+
+  inline const _Ios_Iostate&
+  operator^=(_Ios_Iostate& __a, _Ios_Iostate __b)
+  { return __a = __a ^ __b; }
+
+
+  enum _Ios_Seekdir
+    {
+      _S_beg = 0,
+      _S_cur = 1,
+      _S_end = 2,
+      _S_ios_seekdir_end = 1L << 16
+    };
+
+
+
+  enum class io_errc { stream = 1 };
+
+  template <> struct is_error_code_enum<io_errc> : public true_type { };
+
+  const error_category& iostream_category() noexcept;
+
+  inline error_code
+  make_error_code(io_errc __e) noexcept
+  { return error_code(static_cast<int>(__e), iostream_category()); }
+
+  inline error_condition
+  make_error_condition(io_errc __e) noexcept
+  { return error_condition(static_cast<int>(__e), iostream_category()); }
+# 228 "/usr/include/c++/10.2.0/bits/ios_base.h" 3
+  class ios_base
+  {
+# 246 "/usr/include/c++/10.2.0/bits/ios_base.h" 3
+  public:
+# 255 "/usr/include/c++/10.2.0/bits/ios_base.h" 3
+    class __attribute ((__abi_tag__ ("cxx11"))) failure : public system_error
+    {
+    public:
+      explicit
+      failure(const string& __str);
+
+
+      explicit
+      failure(const string&, const error_code&);
+
+      explicit
+      failure(const char*, const error_code& = io_errc::stream);
+
+
+      virtual
+      ~failure() throw();
+
+      virtual const char*
+      what() const throw();
+    };
+# 323 "/usr/include/c++/10.2.0/bits/ios_base.h" 3
+    typedef _Ios_Fmtflags fmtflags;
+
+
+    static const fmtflags boolalpha = _S_boolalpha;
+
+
+    static const fmtflags dec = _S_dec;
+
+
+    static const fmtflags fixed = _S_fixed;
+
+
+    static const fmtflags hex = _S_hex;
+
+
+
+
+    static const fmtflags internal = _S_internal;
+
+
+
+    static const fmtflags left = _S_left;
+
+
+    static const fmtflags oct = _S_oct;
+
+
+
+    static const fmtflags right = _S_right;
+
+
+    static const fmtflags scientific = _S_scientific;
+
+
+
+    static const fmtflags showbase = _S_showbase;
+
+
+
+    static const fmtflags showpoint = _S_showpoint;
+
+
+    static const fmtflags showpos = _S_showpos;
+
+
+    static const fmtflags skipws = _S_skipws;
+
+
+    static const fmtflags unitbuf = _S_unitbuf;
+
+
+
+    static const fmtflags uppercase = _S_uppercase;
+
+
+    static const fmtflags adjustfield = _S_adjustfield;
+
+
+    static const fmtflags basefield = _S_basefield;
+
+
+    static const fmtflags floatfield = _S_floatfield;
+# 398 "/usr/include/c++/10.2.0/bits/ios_base.h" 3
+    typedef _Ios_Iostate iostate;
+
+
+
+    static const iostate badbit = _S_badbit;
+
+
+    static const iostate eofbit = _S_eofbit;
+
+
+
+
+    static const iostate failbit = _S_failbit;
+
+
+    static const iostate goodbit = _S_goodbit;
+# 429 "/usr/include/c++/10.2.0/bits/ios_base.h" 3
+    typedef _Ios_Openmode openmode;
+
+
+    static const openmode app = _S_app;
+
+
+    static const openmode ate = _S_ate;
+
+
+
+
+    static const openmode binary = _S_bin;
+
+
+    static const openmode in = _S_in;
+
+
+    static const openmode out = _S_out;
+
+
+    static const openmode trunc = _S_trunc;
+# 461 "/usr/include/c++/10.2.0/bits/ios_base.h" 3
+    typedef _Ios_Seekdir seekdir;
+
+
+    static const seekdir beg = _S_beg;
+
+
+    static const seekdir cur = _S_cur;
+
+
+    static const seekdir end = _S_end;
+# 489 "/usr/include/c++/10.2.0/bits/ios_base.h" 3
+    enum event
+    {
+      erase_event,
+      imbue_event,
+      copyfmt_event
+    };
+# 506 "/usr/include/c++/10.2.0/bits/ios_base.h" 3
+    typedef void (*event_callback) (event __e, ios_base& __b, int __i);
+# 518 "/usr/include/c++/10.2.0/bits/ios_base.h" 3
+    void
+    register_callback(event_callback __fn, int __index);
+
+  protected:
+    streamsize _M_precision;
+    streamsize _M_width;
+    fmtflags _M_flags;
+    iostate _M_exception;
+    iostate _M_streambuf_state;
+
+
+
+    struct _Callback_list
+    {
+
+      _Callback_list* _M_next;
+      ios_base::event_callback _M_fn;
+      int _M_index;
+      _Atomic_word _M_refcount;
+
+      _Callback_list(ios_base::event_callback __fn, int __index,
+       _Callback_list* __cb)
+      : _M_next(__cb), _M_fn(__fn), _M_index(__index), _M_refcount(0) { }
+
+      void
+      _M_add_reference() { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }
+
+
+      int
+      _M_remove_reference()
+      {
+
+        ;
+        int __res = __gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1);
+        if (__res == 0)
+          {
+            ;
+          }
+        return __res;
+      }
+    };
+
+     _Callback_list* _M_callbacks;
+
+    void
+    _M_call_callbacks(event __ev) throw();
+
+    void
+    _M_dispose_callbacks(void) throw();
+
+
+    struct _Words
+    {
+      void* _M_pword;
+      long _M_iword;
+      _Words() : _M_pword(0), _M_iword(0) { }
+    };
+
+
+    _Words _M_word_zero;
+
+
+
+    enum { _S_local_word_size = 8 };
+    _Words _M_local_word[_S_local_word_size];
+
+
+    int _M_word_size;
+    _Words* _M_word;
+
+    _Words&
+    _M_grow_words(int __index, bool __iword);
+
+
+    locale _M_ios_locale;
+
+    void
+    _M_init() throw();
+
+  public:
+
+
+
+
+
+    class Init
+    {
+      friend class ios_base;
+    public:
+      Init();
+      ~Init();
+
+
+      Init(const Init&) = default;
+      Init& operator=(const Init&) = default;
+
+
+    private:
+      static _Atomic_word _S_refcount;
+      static bool _S_synced_with_stdio;
+    };
+
+
+
+
+
+
+    fmtflags
+    flags() const
+    { return _M_flags; }
+# 636 "/usr/include/c++/10.2.0/bits/ios_base.h" 3
+    fmtflags
+    flags(fmtflags __fmtfl)
+    {
+      fmtflags __old = _M_flags;
+      _M_flags = __fmtfl;
+      return __old;
+    }
+# 652 "/usr/include/c++/10.2.0/bits/ios_base.h" 3
+    fmtflags
+    setf(fmtflags __fmtfl)
+    {
+      fmtflags __old = _M_flags;
+      _M_flags |= __fmtfl;
+      return __old;
+    }
+# 669 "/usr/include/c++/10.2.0/bits/ios_base.h" 3
+    fmtflags
+    setf(fmtflags __fmtfl, fmtflags __mask)
+    {
+      fmtflags __old = _M_flags;
+      _M_flags &= ~__mask;
+      _M_flags |= (__fmtfl & __mask);
+      return __old;
+    }
+
+
+
+
+
+
+
+    void
+    unsetf(fmtflags __mask)
+    { _M_flags &= ~__mask; }
+# 695 "/usr/include/c++/10.2.0/bits/ios_base.h" 3
+    streamsize
+    precision() const
+    { return _M_precision; }
+
+
+
+
+
+
+    streamsize
+    precision(streamsize __prec)
+    {
+      streamsize __old = _M_precision;
+      _M_precision = __prec;
+      return __old;
+    }
+
+
+
+
+
+
+
+    streamsize
+    width() const
+    { return _M_width; }
+
+
+
+
+
+
+    streamsize
+    width(streamsize __wide)
+    {
+      streamsize __old = _M_width;
+      _M_width = __wide;
+      return __old;
+    }
+# 746 "/usr/include/c++/10.2.0/bits/ios_base.h" 3
+    static bool
+    sync_with_stdio(bool __sync = true);
+# 758 "/usr/include/c++/10.2.0/bits/ios_base.h" 3
+    locale
+    imbue(const locale& __loc) throw();
+# 769 "/usr/include/c++/10.2.0/bits/ios_base.h" 3
+    locale
+    getloc() const
+    { return _M_ios_locale; }
+# 780 "/usr/include/c++/10.2.0/bits/ios_base.h" 3
+    const locale&
+    _M_getloc() const
+    { return _M_ios_locale; }
+# 799 "/usr/include/c++/10.2.0/bits/ios_base.h" 3
+    static int
+    xalloc() throw();
+# 815 "/usr/include/c++/10.2.0/bits/ios_base.h" 3
+    long&
+    iword(int __ix)
+    {
+      _Words& __word = ((unsigned)__ix < (unsigned)_M_word_size)
+   ? _M_word[__ix] : _M_grow_words(__ix, true);
+      return __word._M_iword;
+    }
+# 836 "/usr/include/c++/10.2.0/bits/ios_base.h" 3
+    void*&
+    pword(int __ix)
+    {
+      _Words& __word = ((unsigned)__ix < (unsigned)_M_word_size)
+   ? _M_word[__ix] : _M_grow_words(__ix, false);
+      return __word._M_pword;
+    }
+# 853 "/usr/include/c++/10.2.0/bits/ios_base.h" 3
+    virtual ~ios_base();
+
+  protected:
+    ios_base() throw ();
+# 867 "/usr/include/c++/10.2.0/bits/ios_base.h" 3
+  public:
+    ios_base(const ios_base&) = delete;
+
+    ios_base&
+    operator=(const ios_base&) = delete;
+
+  protected:
+    void
+    _M_move(ios_base&) noexcept;
+
+    void
+    _M_swap(ios_base& __rhs) noexcept;
+
+  };
+
+
+
+  inline ios_base&
+  boolalpha(ios_base& __base)
+  {
+    __base.setf(ios_base::boolalpha);
+    return __base;
+  }
+
+
+  inline ios_base&
+  noboolalpha(ios_base& __base)
+  {
+    __base.unsetf(ios_base::boolalpha);
+    return __base;
+  }
+
+
+  inline ios_base&
+  showbase(ios_base& __base)
+  {
+    __base.setf(ios_base::showbase);
+    return __base;
+  }
+
+
+  inline ios_base&
+  noshowbase(ios_base& __base)
+  {
+    __base.unsetf(ios_base::showbase);
+    return __base;
+  }
+
+
+  inline ios_base&
+  showpoint(ios_base& __base)
+  {
+    __base.setf(ios_base::showpoint);
+    return __base;
+  }
+
+
+  inline ios_base&
+  noshowpoint(ios_base& __base)
+  {
+    __base.unsetf(ios_base::showpoint);
+    return __base;
+  }
+
+
+  inline ios_base&
+  showpos(ios_base& __base)
+  {
+    __base.setf(ios_base::showpos);
+    return __base;
+  }
+
+
+  inline ios_base&
+  noshowpos(ios_base& __base)
+  {
+    __base.unsetf(ios_base::showpos);
+    return __base;
+  }
+
+
+  inline ios_base&
+  skipws(ios_base& __base)
+  {
+    __base.setf(ios_base::skipws);
+    return __base;
+  }
+
+
+  inline ios_base&
+  noskipws(ios_base& __base)
+  {
+    __base.unsetf(ios_base::skipws);
+    return __base;
+  }
+
+
+  inline ios_base&
+  uppercase(ios_base& __base)
+  {
+    __base.setf(ios_base::uppercase);
+    return __base;
+  }
+
+
+  inline ios_base&
+  nouppercase(ios_base& __base)
+  {
+    __base.unsetf(ios_base::uppercase);
+    return __base;
+  }
+
+
+  inline ios_base&
+  unitbuf(ios_base& __base)
+  {
+     __base.setf(ios_base::unitbuf);
+     return __base;
+  }
+
+
+  inline ios_base&
+  nounitbuf(ios_base& __base)
+  {
+     __base.unsetf(ios_base::unitbuf);
+     return __base;
+  }
+
+
+
+  inline ios_base&
+  internal(ios_base& __base)
+  {
+     __base.setf(ios_base::internal, ios_base::adjustfield);
+     return __base;
+  }
+
+
+  inline ios_base&
+  left(ios_base& __base)
+  {
+    __base.setf(ios_base::left, ios_base::adjustfield);
+    return __base;
+  }
+
+
+  inline ios_base&
+  right(ios_base& __base)
+  {
+    __base.setf(ios_base::right, ios_base::adjustfield);
+    return __base;
+  }
+
+
+
+  inline ios_base&
+  dec(ios_base& __base)
+  {
+    __base.setf(ios_base::dec, ios_base::basefield);
+    return __base;
+  }
+
+
+  inline ios_base&
+  hex(ios_base& __base)
+  {
+    __base.setf(ios_base::hex, ios_base::basefield);
+    return __base;
+  }
+
+
+  inline ios_base&
+  oct(ios_base& __base)
+  {
+    __base.setf(ios_base::oct, ios_base::basefield);
+    return __base;
+  }
+
+
+
+  inline ios_base&
+  fixed(ios_base& __base)
+  {
+    __base.setf(ios_base::fixed, ios_base::floatfield);
+    return __base;
+  }
+
+
+  inline ios_base&
+  scientific(ios_base& __base)
+  {
+    __base.setf(ios_base::scientific, ios_base::floatfield);
+    return __base;
+  }
+
+
+
+
+
+
+  inline ios_base&
+  hexfloat(ios_base& __base)
+  {
+    __base.setf(ios_base::fixed | ios_base::scientific, ios_base::floatfield);
+    return __base;
+  }
+
+
+  inline ios_base&
+  defaultfloat(ios_base& __base)
+  {
+    __base.unsetf(ios_base::floatfield);
+    return __base;
+  }
+
+
+
+}
+# 43 "/usr/include/c++/10.2.0/ios" 2 3
+# 1 "/usr/include/c++/10.2.0/streambuf" 1 3
+# 34 "/usr/include/c++/10.2.0/streambuf" 3
+#define _GLIBXX_STREAMBUF 1
+
+       
+# 37 "/usr/include/c++/10.2.0/streambuf" 3
+# 45 "/usr/include/c++/10.2.0/streambuf" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+#define _IsUnused __attribute__ ((__unused__))
+
+  template<typename _CharT, typename _Traits>
+    streamsize
+    __copy_streambufs_eof(basic_streambuf<_CharT, _Traits>*,
+     basic_streambuf<_CharT, _Traits>*, bool&);
+# 121 "/usr/include/c++/10.2.0/streambuf" 3
+  template<typename _CharT, typename _Traits>
+    class basic_streambuf
+    {
+    public:
+
+
+
+
+
+
+      typedef _CharT char_type;
+      typedef _Traits traits_type;
+      typedef typename traits_type::int_type int_type;
+      typedef typename traits_type::pos_type pos_type;
+      typedef typename traits_type::off_type off_type;
+
+
+
+
+      typedef basic_streambuf<char_type, traits_type> __streambuf_type;
+
+
+      friend class basic_ios<char_type, traits_type>;
+      friend class basic_istream<char_type, traits_type>;
+      friend class basic_ostream<char_type, traits_type>;
+      friend class istreambuf_iterator<char_type, traits_type>;
+      friend class ostreambuf_iterator<char_type, traits_type>;
+
+      friend streamsize
+      __copy_streambufs_eof<>(basic_streambuf*, basic_streambuf*, bool&);
+
+      template<bool _IsMove, typename _CharT2>
+        friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
+            _CharT2*>::__type
+        __copy_move_a2(istreambuf_iterator<_CharT2>,
+         istreambuf_iterator<_CharT2>, _CharT2*);
+
+      template<typename _CharT2>
+        friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
+      istreambuf_iterator<_CharT2> >::__type
+        find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
+      const _CharT2&);
+
+      template<typename _CharT2, typename _Distance>
+        friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
+            void>::__type
+        advance(istreambuf_iterator<_CharT2>&, _Distance);
+
+      template<typename _CharT2, typename _Traits2>
+        friend basic_istream<_CharT2, _Traits2>&
+        operator>>(basic_istream<_CharT2, _Traits2>&, _CharT2*);
+
+      template<typename _CharT2, typename _Traits2, typename _Alloc>
+        friend basic_istream<_CharT2, _Traits2>&
+        operator>>(basic_istream<_CharT2, _Traits2>&,
+     basic_string<_CharT2, _Traits2, _Alloc>&);
+
+      template<typename _CharT2, typename _Traits2, typename _Alloc>
+        friend basic_istream<_CharT2, _Traits2>&
+        getline(basic_istream<_CharT2, _Traits2>&,
+  basic_string<_CharT2, _Traits2, _Alloc>&, _CharT2);
+
+    protected:
+
+
+
+
+
+
+
+      char_type* _M_in_beg;
+      char_type* _M_in_cur;
+      char_type* _M_in_end;
+      char_type* _M_out_beg;
+      char_type* _M_out_cur;
+      char_type* _M_out_end;
+
+
+      locale _M_buf_locale;
+
+  public:
+
+      virtual
+      ~basic_streambuf()
+      { }
+# 215 "/usr/include/c++/10.2.0/streambuf" 3
+      locale
+      pubimbue(const locale& __loc)
+      {
+ locale __tmp(this->getloc());
+ this->imbue(__loc);
+ _M_buf_locale = __loc;
+ return __tmp;
+      }
+# 232 "/usr/include/c++/10.2.0/streambuf" 3
+      locale
+      getloc() const
+      { return _M_buf_locale; }
+# 245 "/usr/include/c++/10.2.0/streambuf" 3
+      basic_streambuf*
+      pubsetbuf(char_type* __s, streamsize __n)
+      { return this->setbuf(__s, __n); }
+# 257 "/usr/include/c++/10.2.0/streambuf" 3
+      pos_type
+      pubseekoff(off_type __off, ios_base::seekdir __way,
+   ios_base::openmode __mode = ios_base::in | ios_base::out)
+      { return this->seekoff(__off, __way, __mode); }
+# 269 "/usr/include/c++/10.2.0/streambuf" 3
+      pos_type
+      pubseekpos(pos_type __sp,
+   ios_base::openmode __mode = ios_base::in | ios_base::out)
+      { return this->seekpos(__sp, __mode); }
+
+
+
+
+      int
+      pubsync() { return this->sync(); }
+# 290 "/usr/include/c++/10.2.0/streambuf" 3
+      streamsize
+      in_avail()
+      {
+ const streamsize __ret = this->egptr() - this->gptr();
+ return __ret ? __ret : this->showmanyc();
+      }
+# 304 "/usr/include/c++/10.2.0/streambuf" 3
+      int_type
+      snextc()
+      {
+ int_type __ret = traits_type::eof();
+ if (__builtin_expect(!traits_type::eq_int_type(this->sbumpc(),
+             __ret), true))
+   __ret = this->sgetc();
+ return __ret;
+      }
+# 322 "/usr/include/c++/10.2.0/streambuf" 3
+      int_type
+      sbumpc()
+      {
+ int_type __ret;
+ if (__builtin_expect(this->gptr() < this->egptr(), true))
+   {
+     __ret = traits_type::to_int_type(*this->gptr());
+     this->gbump(1);
+   }
+ else
+   __ret = this->uflow();
+ return __ret;
+      }
+# 344 "/usr/include/c++/10.2.0/streambuf" 3
+      int_type
+      sgetc()
+      {
+ int_type __ret;
+ if (__builtin_expect(this->gptr() < this->egptr(), true))
+   __ret = traits_type::to_int_type(*this->gptr());
+ else
+   __ret = this->underflow();
+ return __ret;
+      }
+# 363 "/usr/include/c++/10.2.0/streambuf" 3
+      streamsize
+      sgetn(char_type* __s, streamsize __n)
+      { return this->xsgetn(__s, __n); }
+# 378 "/usr/include/c++/10.2.0/streambuf" 3
+      int_type
+      sputbackc(char_type __c)
+      {
+ int_type __ret;
+ const bool __testpos = this->eback() < this->gptr();
+ if (__builtin_expect(!__testpos ||
+        !traits_type::eq(__c, this->gptr()[-1]), false))
+   __ret = this->pbackfail(traits_type::to_int_type(__c));
+ else
+   {
+     this->gbump(-1);
+     __ret = traits_type::to_int_type(*this->gptr());
+   }
+ return __ret;
+      }
+# 403 "/usr/include/c++/10.2.0/streambuf" 3
+      int_type
+      sungetc()
+      {
+ int_type __ret;
+ if (__builtin_expect(this->eback() < this->gptr(), true))
+   {
+     this->gbump(-1);
+     __ret = traits_type::to_int_type(*this->gptr());
+   }
+ else
+   __ret = this->pbackfail();
+ return __ret;
+      }
+# 430 "/usr/include/c++/10.2.0/streambuf" 3
+      int_type
+      sputc(char_type __c)
+      {
+ int_type __ret;
+ if (__builtin_expect(this->pptr() < this->epptr(), true))
+   {
+     *this->pptr() = __c;
+     this->pbump(1);
+     __ret = traits_type::to_int_type(__c);
+   }
+ else
+   __ret = this->overflow(traits_type::to_int_type(__c));
+ return __ret;
+      }
+# 456 "/usr/include/c++/10.2.0/streambuf" 3
+      streamsize
+      sputn(const char_type* __s, streamsize __n)
+      { return this->xsputn(__s, __n); }
+
+    protected:
+# 470 "/usr/include/c++/10.2.0/streambuf" 3
+      basic_streambuf()
+      : _M_in_beg(0), _M_in_cur(0), _M_in_end(0),
+      _M_out_beg(0), _M_out_cur(0), _M_out_end(0),
+      _M_buf_locale(locale())
+      { }
+# 488 "/usr/include/c++/10.2.0/streambuf" 3
+      char_type*
+      eback() const { return _M_in_beg; }
+
+      char_type*
+      gptr() const { return _M_in_cur; }
+
+      char_type*
+      egptr() const { return _M_in_end; }
+# 504 "/usr/include/c++/10.2.0/streambuf" 3
+      void
+      gbump(int __n) { _M_in_cur += __n; }
+# 515 "/usr/include/c++/10.2.0/streambuf" 3
+      void
+      setg(char_type* __gbeg, char_type* __gnext, char_type* __gend)
+      {
+ _M_in_beg = __gbeg;
+ _M_in_cur = __gnext;
+ _M_in_end = __gend;
+      }
+# 535 "/usr/include/c++/10.2.0/streambuf" 3
+      char_type*
+      pbase() const { return _M_out_beg; }
+
+      char_type*
+      pptr() const { return _M_out_cur; }
+
+      char_type*
+      epptr() const { return _M_out_end; }
+# 551 "/usr/include/c++/10.2.0/streambuf" 3
+      void
+      pbump(int __n) { _M_out_cur += __n; }
+# 561 "/usr/include/c++/10.2.0/streambuf" 3
+      void
+      setp(char_type* __pbeg, char_type* __pend)
+      {
+ _M_out_beg = _M_out_cur = __pbeg;
+ _M_out_end = __pend;
+      }
+# 582 "/usr/include/c++/10.2.0/streambuf" 3
+      virtual void
+      imbue(const locale& __loc __attribute__ ((__unused__)))
+      { }
+# 597 "/usr/include/c++/10.2.0/streambuf" 3
+      virtual basic_streambuf<char_type,_Traits>*
+      setbuf(char_type*, streamsize)
+      { return this; }
+# 608 "/usr/include/c++/10.2.0/streambuf" 3
+      virtual pos_type
+      seekoff(off_type, ios_base::seekdir,
+       ios_base::openmode = ios_base::in | ios_base::out)
+      { return pos_type(off_type(-1)); }
+# 620 "/usr/include/c++/10.2.0/streambuf" 3
+      virtual pos_type
+      seekpos(pos_type,
+       ios_base::openmode = ios_base::in | ios_base::out)
+      { return pos_type(off_type(-1)); }
+# 633 "/usr/include/c++/10.2.0/streambuf" 3
+      virtual int
+      sync() { return 0; }
+# 655 "/usr/include/c++/10.2.0/streambuf" 3
+      virtual streamsize
+      showmanyc() { return 0; }
+# 671 "/usr/include/c++/10.2.0/streambuf" 3
+      virtual streamsize
+      xsgetn(char_type* __s, streamsize __n);
+# 693 "/usr/include/c++/10.2.0/streambuf" 3
+      virtual int_type
+      underflow()
+      { return traits_type::eof(); }
+# 706 "/usr/include/c++/10.2.0/streambuf" 3
+      virtual int_type
+      uflow()
+      {
+ int_type __ret = traits_type::eof();
+ const bool __testeof = traits_type::eq_int_type(this->underflow(),
+       __ret);
+ if (!__testeof)
+   {
+     __ret = traits_type::to_int_type(*this->gptr());
+     this->gbump(1);
+   }
+ return __ret;
+      }
+# 730 "/usr/include/c++/10.2.0/streambuf" 3
+      virtual int_type
+      pbackfail(int_type __c __attribute__ ((__unused__)) = traits_type::eof())
+      { return traits_type::eof(); }
+# 748 "/usr/include/c++/10.2.0/streambuf" 3
+      virtual streamsize
+      xsputn(const char_type* __s, streamsize __n);
+# 774 "/usr/include/c++/10.2.0/streambuf" 3
+      virtual int_type
+      overflow(int_type __c __attribute__ ((__unused__)) = traits_type::eof())
+      { return traits_type::eof(); }
+# 803 "/usr/include/c++/10.2.0/streambuf" 3
+      void
+      __safe_gbump(streamsize __n) { _M_in_cur += __n; }
+
+      void
+      __safe_pbump(streamsize __n) { _M_out_cur += __n; }
+
+
+
+
+    protected:
+
+      basic_streambuf(const basic_streambuf&);
+
+      basic_streambuf&
+      operator=(const basic_streambuf&);
+
+
+      void
+      swap(basic_streambuf& __sb)
+      {
+ std::swap(_M_in_beg, __sb._M_in_beg);
+ std::swap(_M_in_cur, __sb._M_in_cur);
+ std::swap(_M_in_end, __sb._M_in_end);
+ std::swap(_M_out_beg, __sb._M_out_beg);
+ std::swap(_M_out_cur, __sb._M_out_cur);
+ std::swap(_M_out_end, __sb._M_out_end);
+ std::swap(_M_buf_locale, __sb._M_buf_locale);
+      }
+
+    };
+
+
+  template<typename _CharT, typename _Traits>
+    std::basic_streambuf<_CharT, _Traits>::
+    basic_streambuf(const basic_streambuf&) = default;
+
+  template<typename _CharT, typename _Traits>
+    std::basic_streambuf<_CharT, _Traits>&
+    std::basic_streambuf<_CharT, _Traits>::
+    operator=(const basic_streambuf&) = default;
+
+
+
+  template<>
+    streamsize
+    __copy_streambufs_eof(basic_streambuf<char>* __sbin,
+     basic_streambuf<char>* __sbout, bool& __ineof);
+
+  template<>
+    streamsize
+    __copy_streambufs_eof(basic_streambuf<wchar_t>* __sbin,
+     basic_streambuf<wchar_t>* __sbout, bool& __ineof);
+
+
+#undef _IsUnused
+
+
+}
+
+# 1 "/usr/include/c++/10.2.0/bits/streambuf.tcc" 1 3
+# 35 "/usr/include/c++/10.2.0/bits/streambuf.tcc" 3
+#define _STREAMBUF_TCC 1
+
+       
+# 38 "/usr/include/c++/10.2.0/bits/streambuf.tcc" 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  template<typename _CharT, typename _Traits>
+    streamsize
+    basic_streambuf<_CharT, _Traits>::
+    xsgetn(char_type* __s, streamsize __n)
+    {
+      streamsize __ret = 0;
+      while (__ret < __n)
+ {
+   const streamsize __buf_len = this->egptr() - this->gptr();
+   if (__buf_len)
+     {
+       const streamsize __remaining = __n - __ret;
+       const streamsize __len = std::min(__buf_len, __remaining);
+       traits_type::copy(__s, this->gptr(), __len);
+       __ret += __len;
+       __s += __len;
+       this->__safe_gbump(__len);
+     }
+
+   if (__ret < __n)
+     {
+       const int_type __c = this->uflow();
+       if (!traits_type::eq_int_type(__c, traits_type::eof()))
+  {
+    traits_type::assign(*__s++, traits_type::to_char_type(__c));
+    ++__ret;
+  }
+       else
+  break;
+     }
+ }
+      return __ret;
+    }
+
+  template<typename _CharT, typename _Traits>
+    streamsize
+    basic_streambuf<_CharT, _Traits>::
+    xsputn(const char_type* __s, streamsize __n)
+    {
+      streamsize __ret = 0;
+      while (__ret < __n)
+ {
+   const streamsize __buf_len = this->epptr() - this->pptr();
+   if (__buf_len)
+     {
+       const streamsize __remaining = __n - __ret;
+       const streamsize __len = std::min(__buf_len, __remaining);
+       traits_type::copy(this->pptr(), __s, __len);
+       __ret += __len;
+       __s += __len;
+       this->__safe_pbump(__len);
+     }
+
+   if (__ret < __n)
+     {
+       int_type __c = this->overflow(traits_type::to_int_type(*__s));
+       if (!traits_type::eq_int_type(__c, traits_type::eof()))
+  {
+    ++__ret;
+    ++__s;
+  }
+       else
+  break;
+     }
+ }
+      return __ret;
+    }
+
+
+
+
+  template<typename _CharT, typename _Traits>
+    streamsize
+    __copy_streambufs_eof(basic_streambuf<_CharT, _Traits>* __sbin,
+     basic_streambuf<_CharT, _Traits>* __sbout,
+     bool& __ineof)
+    {
+      streamsize __ret = 0;
+      __ineof = true;
+      typename _Traits::int_type __c = __sbin->sgetc();
+      while (!_Traits::eq_int_type(__c, _Traits::eof()))
+ {
+   __c = __sbout->sputc(_Traits::to_char_type(__c));
+   if (_Traits::eq_int_type(__c, _Traits::eof()))
+     {
+       __ineof = false;
+       break;
+     }
+   ++__ret;
+   __c = __sbin->snextc();
+ }
+      return __ret;
+    }
+
+  template<typename _CharT, typename _Traits>
+    inline streamsize
+    __copy_streambufs(basic_streambuf<_CharT, _Traits>* __sbin,
+        basic_streambuf<_CharT, _Traits>* __sbout)
+    {
+      bool __ineof;
+      return __copy_streambufs_eof(__sbin, __sbout, __ineof);
+    }
+
+
+
+
+  extern template class basic_streambuf<char>;
+  extern template
+    streamsize
+    __copy_streambufs(basic_streambuf<char>*,
+        basic_streambuf<char>*);
+  extern template
+    streamsize
+    __copy_streambufs_eof(basic_streambuf<char>*,
+     basic_streambuf<char>*, bool&);
+
+
+  extern template class basic_streambuf<wchar_t>;
+  extern template
+    streamsize
+    __copy_streambufs(basic_streambuf<wchar_t>*,
+        basic_streambuf<wchar_t>*);
+  extern template
+    streamsize
+    __copy_streambufs_eof(basic_streambuf<wchar_t>*,
+     basic_streambuf<wchar_t>*, bool&);
+
+
+
+
+}
+# 863 "/usr/include/c++/10.2.0/streambuf" 2 3
+# 44 "/usr/include/c++/10.2.0/ios" 2 3
+# 1 "/usr/include/c++/10.2.0/bits/basic_ios.h" 1 3
+# 31 "/usr/include/c++/10.2.0/bits/basic_ios.h" 3
+#define _BASIC_IOS_H 1
+
+       
+# 34 "/usr/include/c++/10.2.0/bits/basic_ios.h" 3
+
+
+
+# 1 "/usr/include/c++/10.2.0/bits/locale_facets.h" 1 3
+# 35 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+#define _LOCALE_FACETS_H 1
+
+       
+# 38 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+
+# 1 "/usr/include/c++/10.2.0/cwctype" 1 3
+# 39 "/usr/include/c++/10.2.0/cwctype" 3
+       
+# 40 "/usr/include/c++/10.2.0/cwctype" 3
+# 50 "/usr/include/c++/10.2.0/cwctype" 3
+# 1 "/usr/include/wctype.h" 1 3 4
+# 24 "/usr/include/wctype.h" 3 4
+#define _WCTYPE_H 1
+# 38 "/usr/include/wctype.h" 3 4
+# 1 "/usr/include/bits/wctype-wchar.h" 1 3 4
+# 24 "/usr/include/bits/wctype-wchar.h" 3 4
+#define _BITS_WCTYPE_WCHAR_H 1
+# 38 "/usr/include/bits/wctype-wchar.h" 3 4
+typedef unsigned long int wctype_t;
+# 49 "/usr/include/bits/wctype-wchar.h" 3 4
+#define _ISwbit(bit) ((bit) < 8 ? (int) ((1UL << (bit)) << 24) : ((bit) < 16 ? (int) ((1UL << (bit)) << 8) : ((bit) < 24 ? (int) ((1UL << (bit)) >> 8) : (int) ((1UL << (bit)) >> 24))))
+
+
+
+
+
+
+enum
+{
+  __ISwupper = 0,
+  __ISwlower = 1,
+  __ISwalpha = 2,
+  __ISwdigit = 3,
+  __ISwxdigit = 4,
+  __ISwspace = 5,
+  __ISwprint = 6,
+  __ISwgraph = 7,
+  __ISwblank = 8,
+  __ISwcntrl = 9,
+  __ISwpunct = 10,
+  __ISwalnum = 11,
+
+  _ISwupper = ((__ISwupper) < 8 ? (int) ((1UL << (__ISwupper)) << 24) : ((__ISwupper) < 16 ? (int) ((1UL << (__ISwupper)) << 8) : ((__ISwupper) < 24 ? (int) ((1UL << (__ISwupper)) >> 8) : (int) ((1UL << (__ISwupper)) >> 24)))),
+  _ISwlower = ((__ISwlower) < 8 ? (int) ((1UL << (__ISwlower)) << 24) : ((__ISwlower) < 16 ? (int) ((1UL << (__ISwlower)) << 8) : ((__ISwlower) < 24 ? (int) ((1UL << (__ISwlower)) >> 8) : (int) ((1UL << (__ISwlower)) >> 24)))),
+  _ISwalpha = ((__ISwalpha) < 8 ? (int) ((1UL << (__ISwalpha)) << 24) : ((__ISwalpha) < 16 ? (int) ((1UL << (__ISwalpha)) << 8) : ((__ISwalpha) < 24 ? (int) ((1UL << (__ISwalpha)) >> 8) : (int) ((1UL << (__ISwalpha)) >> 24)))),
+  _ISwdigit = ((__ISwdigit) < 8 ? (int) ((1UL << (__ISwdigit)) << 24) : ((__ISwdigit) < 16 ? (int) ((1UL << (__ISwdigit)) << 8) : ((__ISwdigit) < 24 ? (int) ((1UL << (__ISwdigit)) >> 8) : (int) ((1UL << (__ISwdigit)) >> 24)))),
+  _ISwxdigit = ((__ISwxdigit) < 8 ? (int) ((1UL << (__ISwxdigit)) << 24) : ((__ISwxdigit) < 16 ? (int) ((1UL << (__ISwxdigit)) << 8) : ((__ISwxdigit) < 24 ? (int) ((1UL << (__ISwxdigit)) >> 8) : (int) ((1UL << (__ISwxdigit)) >> 24)))),
+  _ISwspace = ((__ISwspace) < 8 ? (int) ((1UL << (__ISwspace)) << 24) : ((__ISwspace) < 16 ? (int) ((1UL << (__ISwspace)) << 8) : ((__ISwspace) < 24 ? (int) ((1UL << (__ISwspace)) >> 8) : (int) ((1UL << (__ISwspace)) >> 24)))),
+  _ISwprint = ((__ISwprint) < 8 ? (int) ((1UL << (__ISwprint)) << 24) : ((__ISwprint) < 16 ? (int) ((1UL << (__ISwprint)) << 8) : ((__ISwprint) < 24 ? (int) ((1UL << (__ISwprint)) >> 8) : (int) ((1UL << (__ISwprint)) >> 24)))),
+  _ISwgraph = ((__ISwgraph) < 8 ? (int) ((1UL << (__ISwgraph)) << 24) : ((__ISwgraph) < 16 ? (int) ((1UL << (__ISwgraph)) << 8) : ((__ISwgraph) < 24 ? (int) ((1UL << (__ISwgraph)) >> 8) : (int) ((1UL << (__ISwgraph)) >> 24)))),
+  _ISwblank = ((__ISwblank) < 8 ? (int) ((1UL << (__ISwblank)) << 24) : ((__ISwblank) < 16 ? (int) ((1UL << (__ISwblank)) << 8) : ((__ISwblank) < 24 ? (int) ((1UL << (__ISwblank)) >> 8) : (int) ((1UL << (__ISwblank)) >> 24)))),
+  _ISwcntrl = ((__ISwcntrl) < 8 ? (int) ((1UL << (__ISwcntrl)) << 24) : ((__ISwcntrl) < 16 ? (int) ((1UL << (__ISwcntrl)) << 8) : ((__ISwcntrl) < 24 ? (int) ((1UL << (__ISwcntrl)) >> 8) : (int) ((1UL << (__ISwcntrl)) >> 24)))),
+  _ISwpunct = ((__ISwpunct) < 8 ? (int) ((1UL << (__ISwpunct)) << 24) : ((__ISwpunct) < 16 ? (int) ((1UL << (__ISwpunct)) << 8) : ((__ISwpunct) < 24 ? (int) ((1UL << (__ISwpunct)) >> 8) : (int) ((1UL << (__ISwpunct)) >> 24)))),
+  _ISwalnum = ((__ISwalnum) < 8 ? (int) ((1UL << (__ISwalnum)) << 24) : ((__ISwalnum) < 16 ? (int) ((1UL << (__ISwalnum)) << 8) : ((__ISwalnum) < 24 ? (int) ((1UL << (__ISwalnum)) >> 8) : (int) ((1UL << (__ISwalnum)) >> 24))))
+};
+
+
+
+extern "C" {
+
+
+
+
+
+
+
+extern int iswalnum (wint_t __wc) throw ();
+
+
+
+
+
+extern int iswalpha (wint_t __wc) throw ();
+
+
+extern int iswcntrl (wint_t __wc) throw ();
+
+
+
+extern int iswdigit (wint_t __wc) throw ();
+
+
+
+extern int iswgraph (wint_t __wc) throw ();
+
+
+
+
+extern int iswlower (wint_t __wc) throw ();
+
+
+extern int iswprint (wint_t __wc) throw ();
+
+
+
+
+extern int iswpunct (wint_t __wc) throw ();
+
+
+
+
+extern int iswspace (wint_t __wc) throw ();
+
+
+
+
+extern int iswupper (wint_t __wc) throw ();
+
+
+
+
+extern int iswxdigit (wint_t __wc) throw ();
+
+
+
+
+
+extern int iswblank (wint_t __wc) throw ();
+# 155 "/usr/include/bits/wctype-wchar.h" 3 4
+extern wctype_t wctype (const char *__property) throw ();
+
+
+
+extern int iswctype (wint_t __wc, wctype_t __desc) throw ();
+
+
+
+
+
+
+extern wint_t towlower (wint_t __wc) throw ();
+
+
+extern wint_t towupper (wint_t __wc) throw ();
+
+}
+# 39 "/usr/include/wctype.h" 2 3 4
+
+
+
+
+
+extern "C" {
+
+
+
+typedef const __int32_t *wctrans_t;
+
+
+
+extern wctrans_t wctrans (const char *__property) throw ();
+
+
+extern wint_t towctrans (wint_t __wc, wctrans_t __desc) throw ();
+
+
+
+
+
+
+
+extern int iswalnum_l (wint_t __wc, locale_t __locale) throw ();
+
+
+
+
+
+extern int iswalpha_l (wint_t __wc, locale_t __locale) throw ();
+
+
+extern int iswcntrl_l (wint_t __wc, locale_t __locale) throw ();
+
+
+
+extern int iswdigit_l (wint_t __wc, locale_t __locale) throw ();
+
+
+
+extern int iswgraph_l (wint_t __wc, locale_t __locale) throw ();
+
+
+
+
+extern int iswlower_l (wint_t __wc, locale_t __locale) throw ();
+
+
+extern int iswprint_l (wint_t __wc, locale_t __locale) throw ();
+
+
+
+
+extern int iswpunct_l (wint_t __wc, locale_t __locale) throw ();
+
+
+
+
+extern int iswspace_l (wint_t __wc, locale_t __locale) throw ();
+
+
+
+
+extern int iswupper_l (wint_t __wc, locale_t __locale) throw ();
+
+
+
+
+extern int iswxdigit_l (wint_t __wc, locale_t __locale) throw ();
+
+
+
+
+extern int iswblank_l (wint_t __wc, locale_t __locale) throw ();
+
+
+
+extern wctype_t wctype_l (const char *__property, locale_t __locale)
+     throw ();
+
+
+
+extern int iswctype_l (wint_t __wc, wctype_t __desc, locale_t __locale)
+     throw ();
+
+
+
+
+
+
+extern wint_t towlower_l (wint_t __wc, locale_t __locale) throw ();
+
+
+extern wint_t towupper_l (wint_t __wc, locale_t __locale) throw ();
+
+
+
+extern wctrans_t wctrans_l (const char *__property, locale_t __locale)
+     throw ();
+
+
+extern wint_t towctrans_l (wint_t __wc, wctrans_t __desc,
+      locale_t __locale) throw ();
+
+
+
+}
+# 51 "/usr/include/c++/10.2.0/cwctype" 2 3
+
+
+
+#define _GLIBCXX_CWCTYPE 1
+
+
+#undef iswalnum
+#undef iswalpha
+
+#undef iswblank
+
+#undef iswcntrl
+#undef iswctype
+#undef iswdigit
+#undef iswgraph
+#undef iswlower
+#undef iswprint
+#undef iswpunct
+#undef iswspace
+#undef iswupper
+#undef iswxdigit
+#undef towctrans
+#undef towlower
+#undef towupper
+#undef wctrans
+#undef wctype
+
+
+
+namespace std
+{
+  using ::wctrans_t;
+  using ::wctype_t;
+  using ::wint_t;
+
+  using ::iswalnum;
+  using ::iswalpha;
+
+  using ::iswblank;
+
+  using ::iswcntrl;
+  using ::iswctype;
+  using ::iswdigit;
+  using ::iswgraph;
+  using ::iswlower;
+  using ::iswprint;
+  using ::iswpunct;
+  using ::iswspace;
+  using ::iswupper;
+  using ::iswxdigit;
+  using ::towctrans;
+  using ::towlower;
+  using ::towupper;
+  using ::wctrans;
+  using ::wctype;
+}
+# 40 "/usr/include/c++/10.2.0/bits/locale_facets.h" 2 3
+# 1 "/usr/include/c++/10.2.0/cctype" 1 3
+# 39 "/usr/include/c++/10.2.0/cctype" 3
+       
+# 40 "/usr/include/c++/10.2.0/cctype" 3
+# 41 "/usr/include/c++/10.2.0/bits/locale_facets.h" 2 3
+# 1 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/ctype_base.h" 1 3
+# 36 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/ctype_base.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+  struct ctype_base
+  {
+
+    typedef const int* __to_type;
+
+
+
+    typedef unsigned short mask;
+    static const mask upper = _ISupper;
+    static const mask lower = _ISlower;
+    static const mask alpha = _ISalpha;
+    static const mask digit = _ISdigit;
+    static const mask xdigit = _ISxdigit;
+    static const mask space = _ISspace;
+    static const mask print = _ISprint;
+    static const mask graph = _ISalpha | _ISdigit | _ISpunct;
+    static const mask cntrl = _IScntrl;
+    static const mask punct = _ISpunct;
+    static const mask alnum = _ISalpha | _ISdigit;
+
+    static const mask blank = _ISblank;
+
+  };
+
+
+}
+# 42 "/usr/include/c++/10.2.0/bits/locale_facets.h" 2 3
+
+
+
+
+
+
+# 1 "/usr/include/c++/10.2.0/bits/streambuf_iterator.h" 1 3
+# 31 "/usr/include/c++/10.2.0/bits/streambuf_iterator.h" 3
+#define _STREAMBUF_ITERATOR_H 1
+
+       
+# 34 "/usr/include/c++/10.2.0/bits/streambuf_iterator.h" 3
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 49 "/usr/include/c++/10.2.0/bits/streambuf_iterator.h" 3
+  template<typename _CharT, typename _Traits>
+    class istreambuf_iterator
+    : public iterator<input_iterator_tag, _CharT, typename _Traits::off_type,
+        _CharT*, _CharT>
+    {
+    public:
+# 66 "/usr/include/c++/10.2.0/bits/streambuf_iterator.h" 3
+      typedef _CharT char_type;
+      typedef _Traits traits_type;
+      typedef typename _Traits::int_type int_type;
+      typedef basic_streambuf<_CharT, _Traits> streambuf_type;
+      typedef basic_istream<_CharT, _Traits> istream_type;
+
+
+      template<typename _CharT2>
+ friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
+        ostreambuf_iterator<_CharT2> >::__type
+ copy(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
+      ostreambuf_iterator<_CharT2>);
+
+      template<bool _IsMove, typename _CharT2>
+ friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
+            _CharT2*>::__type
+ __copy_move_a2(istreambuf_iterator<_CharT2>,
+         istreambuf_iterator<_CharT2>, _CharT2*);
+
+
+      template<typename _CharT2, typename _Size>
+ friend __enable_if_t<__is_char<_CharT2>::__value, _CharT2*>
+ __copy_n_a(istreambuf_iterator<_CharT2>, _Size, _CharT2*);
+
+
+      template<typename _CharT2>
+ friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
+        istreambuf_iterator<_CharT2> >::__type
+ find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
+      const _CharT2&);
+
+      template<typename _CharT2, typename _Distance>
+ friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
+            void>::__type
+ advance(istreambuf_iterator<_CharT2>&, _Distance);
+
+    private:
+
+
+
+
+
+
+
+      mutable streambuf_type* _M_sbuf;
+      int_type _M_c;
+
+    public:
+
+      constexpr istreambuf_iterator() noexcept
+      : _M_sbuf(0), _M_c(traits_type::eof()) { }
+
+
+
+
+
+
+
+      istreambuf_iterator(const istreambuf_iterator&) noexcept = default;
+
+      ~istreambuf_iterator() = default;
+
+
+
+      istreambuf_iterator(istream_type& __s) noexcept
+      : _M_sbuf(__s.rdbuf()), _M_c(traits_type::eof()) { }
+
+
+      istreambuf_iterator(streambuf_type* __s) noexcept
+      : _M_sbuf(__s), _M_c(traits_type::eof()) { }
+
+
+      istreambuf_iterator&
+      operator=(const istreambuf_iterator&) noexcept = default;
+
+
+
+
+
+      char_type
+      operator*() const
+      {
+ int_type __c = _M_get();
+# 157 "/usr/include/c++/10.2.0/bits/streambuf_iterator.h" 3
+ return traits_type::to_char_type(__c);
+      }
+
+
+      istreambuf_iterator&
+      operator++()
+      {
+
+
+
+                        ;
+
+ _M_sbuf->sbumpc();
+ _M_c = traits_type::eof();
+ return *this;
+      }
+
+
+      istreambuf_iterator
+      operator++(int)
+      {
+
+
+
+                        ;
+
+ istreambuf_iterator __old = *this;
+ __old._M_c = _M_sbuf->sbumpc();
+ _M_c = traits_type::eof();
+ return __old;
+      }
+
+
+
+
+
+      bool
+      equal(const istreambuf_iterator& __b) const
+      { return _M_at_eof() == __b._M_at_eof(); }
+
+    private:
+      int_type
+      _M_get() const
+      {
+ int_type __ret = _M_c;
+ if (_M_sbuf && _S_is_eof(__ret) && _S_is_eof(__ret = _M_sbuf->sgetc()))
+   _M_sbuf = 0;
+ return __ret;
+      }
+
+      bool
+      _M_at_eof() const
+      { return _S_is_eof(_M_get()); }
+
+      static bool
+      _S_is_eof(int_type __c)
+      {
+ const int_type __eof = traits_type::eof();
+ return traits_type::eq_int_type(__c, __eof);
+      }
+
+
+
+
+
+
+    };
+
+  template<typename _CharT, typename _Traits>
+    inline bool
+    operator==(const istreambuf_iterator<_CharT, _Traits>& __a,
+        const istreambuf_iterator<_CharT, _Traits>& __b)
+    { return __a.equal(__b); }
+
+  template<typename _CharT, typename _Traits>
+    inline bool
+    operator!=(const istreambuf_iterator<_CharT, _Traits>& __a,
+        const istreambuf_iterator<_CharT, _Traits>& __b)
+    { return !__a.equal(__b); }
+
+
+  template<typename _CharT, typename _Traits>
+    class ostreambuf_iterator
+    : public iterator<output_iterator_tag, void, void, void, void>
+    {
+    public:
+
+
+
+
+
+
+      typedef _CharT char_type;
+      typedef _Traits traits_type;
+      typedef basic_streambuf<_CharT, _Traits> streambuf_type;
+      typedef basic_ostream<_CharT, _Traits> ostream_type;
+
+
+      template<typename _CharT2>
+ friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
+        ostreambuf_iterator<_CharT2> >::__type
+ copy(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
+      ostreambuf_iterator<_CharT2>);
+
+    private:
+      streambuf_type* _M_sbuf;
+      bool _M_failed;
+
+    public:
+# 274 "/usr/include/c++/10.2.0/bits/streambuf_iterator.h" 3
+      ostreambuf_iterator(ostream_type& __s) noexcept
+      : _M_sbuf(__s.rdbuf()), _M_failed(!_M_sbuf) { }
+
+
+      ostreambuf_iterator(streambuf_type* __s) noexcept
+      : _M_sbuf(__s), _M_failed(!_M_sbuf) { }
+
+
+      ostreambuf_iterator&
+      operator=(_CharT __c)
+      {
+ if (!_M_failed &&
+     _Traits::eq_int_type(_M_sbuf->sputc(__c), _Traits::eof()))
+   _M_failed = true;
+ return *this;
+      }
+
+
+      ostreambuf_iterator&
+      operator*()
+      { return *this; }
+
+
+      ostreambuf_iterator&
+      operator++(int)
+      { return *this; }
+
+
+      ostreambuf_iterator&
+      operator++()
+      { return *this; }
+
+
+      bool
+      failed() const noexcept
+      { return _M_failed; }
+
+      ostreambuf_iterator&
+      _M_put(const _CharT* __ws, streamsize __len)
+      {
+ if (__builtin_expect(!_M_failed, true)
+     && __builtin_expect(this->_M_sbuf->sputn(__ws, __len) != __len,
+    false))
+   _M_failed = true;
+ return *this;
+      }
+    };
+
+
+  template<typename _CharT>
+    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
+        ostreambuf_iterator<_CharT> >::__type
+    copy(istreambuf_iterator<_CharT> __first,
+  istreambuf_iterator<_CharT> __last,
+  ostreambuf_iterator<_CharT> __result)
+    {
+      if (__first._M_sbuf && !__last._M_sbuf && !__result._M_failed)
+ {
+   bool __ineof;
+   __copy_streambufs_eof(__first._M_sbuf, __result._M_sbuf, __ineof);
+   if (!__ineof)
+     __result._M_failed = true;
+ }
+      return __result;
+    }
+
+  template<bool _IsMove, typename _CharT>
+    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
+        ostreambuf_iterator<_CharT> >::__type
+    __copy_move_a2(_CharT* __first, _CharT* __last,
+     ostreambuf_iterator<_CharT> __result)
+    {
+      const streamsize __num = __last - __first;
+      if (__num > 0)
+ __result._M_put(__first, __num);
+      return __result;
+    }
+
+  template<bool _IsMove, typename _CharT>
+    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
+        ostreambuf_iterator<_CharT> >::__type
+    __copy_move_a2(const _CharT* __first, const _CharT* __last,
+     ostreambuf_iterator<_CharT> __result)
+    {
+      const streamsize __num = __last - __first;
+      if (__num > 0)
+ __result._M_put(__first, __num);
+      return __result;
+    }
+
+  template<bool _IsMove, typename _CharT>
+    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
+        _CharT*>::__type
+    __copy_move_a2(istreambuf_iterator<_CharT> __first,
+     istreambuf_iterator<_CharT> __last, _CharT* __result)
+    {
+      typedef istreambuf_iterator<_CharT> __is_iterator_type;
+      typedef typename __is_iterator_type::traits_type traits_type;
+      typedef typename __is_iterator_type::streambuf_type streambuf_type;
+      typedef typename traits_type::int_type int_type;
+
+      if (__first._M_sbuf && !__last._M_sbuf)
+ {
+   streambuf_type* __sb = __first._M_sbuf;
+   int_type __c = __sb->sgetc();
+   while (!traits_type::eq_int_type(__c, traits_type::eof()))
+     {
+       const streamsize __n = __sb->egptr() - __sb->gptr();
+       if (__n > 1)
+  {
+    traits_type::copy(__result, __sb->gptr(), __n);
+    __sb->__safe_gbump(__n);
+    __result += __n;
+    __c = __sb->underflow();
+  }
+       else
+  {
+    *__result++ = traits_type::to_char_type(__c);
+    __c = __sb->snextc();
+  }
+     }
+ }
+      return __result;
+    }
+
+
+  template<typename _CharT, typename _Size>
+    __enable_if_t<__is_char<_CharT>::__value, _CharT*>
+    __copy_n_a(istreambuf_iterator<_CharT> __it, _Size __n, _CharT* __result)
+    {
+      if (__n == 0)
+ return __result;
+
+     
+
+                            ;
+      _CharT* __beg = __result;
+      __result += __it._M_sbuf->sgetn(__beg, __n);
+     
+
+                            ;
+      return __result;
+    }
+
+
+  template<typename _CharT>
+    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
+          istreambuf_iterator<_CharT> >::__type
+    find(istreambuf_iterator<_CharT> __first,
+  istreambuf_iterator<_CharT> __last, const _CharT& __val)
+    {
+      typedef istreambuf_iterator<_CharT> __is_iterator_type;
+      typedef typename __is_iterator_type::traits_type traits_type;
+      typedef typename __is_iterator_type::streambuf_type streambuf_type;
+      typedef typename traits_type::int_type int_type;
+      const int_type __eof = traits_type::eof();
+
+      if (__first._M_sbuf && !__last._M_sbuf)
+ {
+   const int_type __ival = traits_type::to_int_type(__val);
+   streambuf_type* __sb = __first._M_sbuf;
+   int_type __c = __sb->sgetc();
+   while (!traits_type::eq_int_type(__c, __eof)
+   && !traits_type::eq_int_type(__c, __ival))
+     {
+       streamsize __n = __sb->egptr() - __sb->gptr();
+       if (__n > 1)
+  {
+    const _CharT* __p = traits_type::find(__sb->gptr(),
+       __n, __val);
+    if (__p)
+      __n = __p - __sb->gptr();
+    __sb->__safe_gbump(__n);
+    __c = __sb->sgetc();
+  }
+       else
+  __c = __sb->snextc();
+     }
+
+   __first._M_c = __eof;
+ }
+
+      return __first;
+    }
+
+  template<typename _CharT, typename _Distance>
+    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
+        void>::__type
+    advance(istreambuf_iterator<_CharT>& __i, _Distance __n)
+    {
+      if (__n == 0)
+ return;
+
+      ;
+     
+
+                           ;
+
+      typedef istreambuf_iterator<_CharT> __is_iterator_type;
+      typedef typename __is_iterator_type::traits_type traits_type;
+      typedef typename __is_iterator_type::streambuf_type streambuf_type;
+      typedef typename traits_type::int_type int_type;
+      const int_type __eof = traits_type::eof();
+
+      streambuf_type* __sb = __i._M_sbuf;
+      while (__n > 0)
+ {
+   streamsize __size = __sb->egptr() - __sb->gptr();
+   if (__size > __n)
+     {
+       __sb->__safe_gbump(__n);
+       break;
+     }
+
+   __sb->__safe_gbump(__size);
+   __n -= __size;
+   if (traits_type::eq_int_type(__sb->underflow(), __eof))
+     {
+      
+
+                      ;
+       break;
+     }
+ }
+
+      __i._M_c = __eof;
+    }
+
+
+
+
+}
+# 49 "/usr/include/c++/10.2.0/bits/locale_facets.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+#define _GLIBCXX_NUM_FACETS 28
+#define _GLIBCXX_NUM_CXX11_FACETS 16
+
+
+
+
+
+
+
+#define _GLIBCXX_NUM_UNICODE_FACETS 2
+
+
+
+
+
+  template<typename _Tp>
+    void
+    __convert_to_v(const char*, _Tp&, ios_base::iostate&,
+     const __c_locale&) throw();
+
+
+  template<>
+    void
+    __convert_to_v(const char*, float&, ios_base::iostate&,
+     const __c_locale&) throw();
+
+  template<>
+    void
+    __convert_to_v(const char*, double&, ios_base::iostate&,
+     const __c_locale&) throw();
+
+  template<>
+    void
+    __convert_to_v(const char*, long double&, ios_base::iostate&,
+     const __c_locale&) throw();
+
+
+
+  template<typename _CharT, typename _Traits>
+    struct __pad
+    {
+      static void
+      _S_pad(ios_base& __io, _CharT __fill, _CharT* __news,
+      const _CharT* __olds, streamsize __newlen, streamsize __oldlen);
+    };
+
+
+
+
+
+
+  template<typename _CharT>
+    _CharT*
+    __add_grouping(_CharT* __s, _CharT __sep,
+     const char* __gbeg, size_t __gsize,
+     const _CharT* __first, const _CharT* __last);
+
+
+
+
+  template<typename _CharT>
+    inline
+    ostreambuf_iterator<_CharT>
+    __write(ostreambuf_iterator<_CharT> __s, const _CharT* __ws, int __len)
+    {
+      __s._M_put(__ws, __len);
+      return __s;
+    }
+
+
+  template<typename _CharT, typename _OutIter>
+    inline
+    _OutIter
+    __write(_OutIter __s, const _CharT* __ws, int __len)
+    {
+      for (int __j = 0; __j < __len; __j++, ++__s)
+ *__s = __ws[__j];
+      return __s;
+    }
+# 149 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+  template<typename _CharT>
+    class __ctype_abstract_base : public locale::facet, public ctype_base
+    {
+    public:
+
+
+      typedef _CharT char_type;
+# 168 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      bool
+      is(mask __m, char_type __c) const
+      { return this->do_is(__m, __c); }
+# 185 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      const char_type*
+      is(const char_type *__lo, const char_type *__hi, mask *__vec) const
+      { return this->do_is(__lo, __hi, __vec); }
+# 201 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      const char_type*
+      scan_is(mask __m, const char_type* __lo, const char_type* __hi) const
+      { return this->do_scan_is(__m, __lo, __hi); }
+# 217 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      const char_type*
+      scan_not(mask __m, const char_type* __lo, const char_type* __hi) const
+      { return this->do_scan_not(__m, __lo, __hi); }
+# 231 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      char_type
+      toupper(char_type __c) const
+      { return this->do_toupper(__c); }
+# 246 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      const char_type*
+      toupper(char_type *__lo, const char_type* __hi) const
+      { return this->do_toupper(__lo, __hi); }
+# 260 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      char_type
+      tolower(char_type __c) const
+      { return this->do_tolower(__c); }
+# 275 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      const char_type*
+      tolower(char_type* __lo, const char_type* __hi) const
+      { return this->do_tolower(__lo, __hi); }
+# 292 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      char_type
+      widen(char __c) const
+      { return this->do_widen(__c); }
+# 311 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      const char*
+      widen(const char* __lo, const char* __hi, char_type* __to) const
+      { return this->do_widen(__lo, __hi, __to); }
+# 330 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      char
+      narrow(char_type __c, char __dfault) const
+      { return this->do_narrow(__c, __dfault); }
+# 352 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      const char_type*
+      narrow(const char_type* __lo, const char_type* __hi,
+       char __dfault, char* __to) const
+      { return this->do_narrow(__lo, __hi, __dfault, __to); }
+
+    protected:
+      explicit
+      __ctype_abstract_base(size_t __refs = 0): facet(__refs) { }
+
+      virtual
+      ~__ctype_abstract_base() { }
+# 377 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual bool
+      do_is(mask __m, char_type __c) const = 0;
+# 396 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_is(const char_type* __lo, const char_type* __hi,
+     mask* __vec) const = 0;
+# 415 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_scan_is(mask __m, const char_type* __lo,
+   const char_type* __hi) const = 0;
+# 434 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_scan_not(mask __m, const char_type* __lo,
+    const char_type* __hi) const = 0;
+# 452 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual char_type
+      do_toupper(char_type __c) const = 0;
+# 469 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_toupper(char_type* __lo, const char_type* __hi) const = 0;
+# 485 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual char_type
+      do_tolower(char_type __c) const = 0;
+# 502 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_tolower(char_type* __lo, const char_type* __hi) const = 0;
+# 521 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual char_type
+      do_widen(char __c) const = 0;
+# 542 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual const char*
+      do_widen(const char* __lo, const char* __hi, char_type* __to) const = 0;
+# 563 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual char
+      do_narrow(char_type __c, char __dfault) const = 0;
+# 588 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_narrow(const char_type* __lo, const char_type* __hi,
+  char __dfault, char* __to) const = 0;
+    };
+# 611 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+  template<typename _CharT>
+    class ctype : public __ctype_abstract_base<_CharT>
+    {
+    public:
+
+      typedef _CharT char_type;
+      typedef typename __ctype_abstract_base<_CharT>::mask mask;
+
+
+      static locale::id id;
+
+      explicit
+      ctype(size_t __refs = 0) : __ctype_abstract_base<_CharT>(__refs) { }
+
+   protected:
+      virtual
+      ~ctype();
+
+      virtual bool
+      do_is(mask __m, char_type __c) const;
+
+      virtual const char_type*
+      do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;
+
+      virtual const char_type*
+      do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;
+
+      virtual const char_type*
+      do_scan_not(mask __m, const char_type* __lo,
+    const char_type* __hi) const;
+
+      virtual char_type
+      do_toupper(char_type __c) const;
+
+      virtual const char_type*
+      do_toupper(char_type* __lo, const char_type* __hi) const;
+
+      virtual char_type
+      do_tolower(char_type __c) const;
+
+      virtual const char_type*
+      do_tolower(char_type* __lo, const char_type* __hi) const;
+
+      virtual char_type
+      do_widen(char __c) const;
+
+      virtual const char*
+      do_widen(const char* __lo, const char* __hi, char_type* __dest) const;
+
+      virtual char
+      do_narrow(char_type, char __dfault) const;
+
+      virtual const char_type*
+      do_narrow(const char_type* __lo, const char_type* __hi,
+  char __dfault, char* __to) const;
+    };
+
+  template<typename _CharT>
+    locale::id ctype<_CharT>::id;
+# 680 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+  template<>
+    class ctype<char> : public locale::facet, public ctype_base
+    {
+    public:
+
+
+      typedef char char_type;
+
+    protected:
+
+      __c_locale _M_c_locale_ctype;
+      bool _M_del;
+      __to_type _M_toupper;
+      __to_type _M_tolower;
+      const mask* _M_table;
+      mutable char _M_widen_ok;
+      mutable char _M_widen[1 + static_cast<unsigned char>(-1)];
+      mutable char _M_narrow[1 + static_cast<unsigned char>(-1)];
+      mutable char _M_narrow_ok;
+
+
+    public:
+
+      static locale::id id;
+
+      static const size_t table_size = 1 + static_cast<unsigned char>(-1);
+# 717 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      explicit
+      ctype(const mask* __table = 0, bool __del = false, size_t __refs = 0);
+# 730 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      explicit
+      ctype(__c_locale __cloc, const mask* __table = 0, bool __del = false,
+     size_t __refs = 0);
+# 743 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      inline bool
+      is(mask __m, char __c) const;
+# 758 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      inline const char*
+      is(const char* __lo, const char* __hi, mask* __vec) const;
+# 772 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      inline const char*
+      scan_is(mask __m, const char* __lo, const char* __hi) const;
+# 786 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      inline const char*
+      scan_not(mask __m, const char* __lo, const char* __hi) const;
+# 801 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      char_type
+      toupper(char_type __c) const
+      { return this->do_toupper(__c); }
+# 818 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      const char_type*
+      toupper(char_type *__lo, const char_type* __hi) const
+      { return this->do_toupper(__lo, __hi); }
+# 834 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      char_type
+      tolower(char_type __c) const
+      { return this->do_tolower(__c); }
+# 851 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      const char_type*
+      tolower(char_type* __lo, const char_type* __hi) const
+      { return this->do_tolower(__lo, __hi); }
+# 871 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      char_type
+      widen(char __c) const
+      {
+ if (_M_widen_ok)
+   return _M_widen[static_cast<unsigned char>(__c)];
+ this->_M_widen_init();
+ return this->do_widen(__c);
+      }
+# 898 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      const char*
+      widen(const char* __lo, const char* __hi, char_type* __to) const
+      {
+ if (_M_widen_ok == 1)
+   {
+     if (__builtin_expect(__hi != __lo, true))
+       __builtin_memcpy(__to, __lo, __hi - __lo);
+     return __hi;
+   }
+ if (!_M_widen_ok)
+   _M_widen_init();
+ return this->do_widen(__lo, __hi, __to);
+      }
+# 930 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      char
+      narrow(char_type __c, char __dfault) const
+      {
+ if (_M_narrow[static_cast<unsigned char>(__c)])
+   return _M_narrow[static_cast<unsigned char>(__c)];
+ const char __t = do_narrow(__c, __dfault);
+ if (__t != __dfault)
+   _M_narrow[static_cast<unsigned char>(__c)] = __t;
+ return __t;
+      }
+# 963 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      const char_type*
+      narrow(const char_type* __lo, const char_type* __hi,
+      char __dfault, char* __to) const
+      {
+ if (__builtin_expect(_M_narrow_ok == 1, true))
+   {
+     if (__builtin_expect(__hi != __lo, true))
+       __builtin_memcpy(__to, __lo, __hi - __lo);
+     return __hi;
+   }
+ if (!_M_narrow_ok)
+   _M_narrow_init();
+ return this->do_narrow(__lo, __hi, __dfault, __to);
+      }
+
+
+
+
+
+      const mask*
+      table() const throw()
+      { return _M_table; }
+
+
+      static const mask*
+      classic_table() throw();
+    protected:
+
+
+
+
+
+
+
+      virtual
+      ~ctype();
+# 1013 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual char_type
+      do_toupper(char_type __c) const;
+# 1030 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_toupper(char_type* __lo, const char_type* __hi) const;
+# 1046 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual char_type
+      do_tolower(char_type __c) const;
+# 1063 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_tolower(char_type* __lo, const char_type* __hi) const;
+# 1083 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual char_type
+      do_widen(char __c) const
+      { return __c; }
+# 1106 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual const char*
+      do_widen(const char* __lo, const char* __hi, char_type* __to) const
+      {
+ if (__builtin_expect(__hi != __lo, true))
+   __builtin_memcpy(__to, __lo, __hi - __lo);
+ return __hi;
+      }
+# 1133 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual char
+      do_narrow(char_type __c, char __dfault __attribute__((__unused__))) const
+      { return __c; }
+# 1159 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_narrow(const char_type* __lo, const char_type* __hi,
+  char __dfault __attribute__((__unused__)), char* __to) const
+      {
+ if (__builtin_expect(__hi != __lo, true))
+   __builtin_memcpy(__to, __lo, __hi - __lo);
+ return __hi;
+      }
+
+    private:
+      void _M_narrow_init() const;
+      void _M_widen_init() const;
+    };
+# 1185 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+  template<>
+    class ctype<wchar_t> : public __ctype_abstract_base<wchar_t>
+    {
+    public:
+
+
+      typedef wchar_t char_type;
+      typedef wctype_t __wmask_type;
+
+    protected:
+      __c_locale _M_c_locale_ctype;
+
+
+      bool _M_narrow_ok;
+      char _M_narrow[128];
+      wint_t _M_widen[1 + static_cast<unsigned char>(-1)];
+
+
+      mask _M_bit[16];
+      __wmask_type _M_wmask[16];
+
+    public:
+
+
+      static locale::id id;
+# 1218 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      explicit
+      ctype(size_t __refs = 0);
+# 1229 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      explicit
+      ctype(__c_locale __cloc, size_t __refs = 0);
+
+    protected:
+      __wmask_type
+      _M_convert_to_wmask(const mask __m) const throw();
+
+
+      virtual
+      ~ctype();
+# 1253 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual bool
+      do_is(mask __m, char_type __c) const;
+# 1272 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;
+# 1290 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;
+# 1308 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_scan_not(mask __m, const char_type* __lo,
+    const char_type* __hi) const;
+# 1325 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual char_type
+      do_toupper(char_type __c) const;
+# 1342 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_toupper(char_type* __lo, const char_type* __hi) const;
+# 1358 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual char_type
+      do_tolower(char_type __c) const;
+# 1375 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_tolower(char_type* __lo, const char_type* __hi) const;
+# 1395 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual char_type
+      do_widen(char __c) const;
+# 1417 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual const char*
+      do_widen(const char* __lo, const char* __hi, char_type* __to) const;
+# 1440 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual char
+      do_narrow(char_type __c, char __dfault) const;
+# 1466 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_narrow(const char_type* __lo, const char_type* __hi,
+  char __dfault, char* __to) const;
+
+
+      void
+      _M_initialize_ctype() throw();
+    };
+
+
+
+  template<typename _CharT>
+    class ctype_byname : public ctype<_CharT>
+    {
+    public:
+      typedef typename ctype<_CharT>::mask mask;
+
+      explicit
+      ctype_byname(const char* __s, size_t __refs = 0);
+
+
+      explicit
+      ctype_byname(const string& __s, size_t __refs = 0)
+      : ctype_byname(__s.c_str(), __refs) { }
+
+
+    protected:
+      virtual
+      ~ctype_byname() { }
+    };
+
+
+  template<>
+    class ctype_byname<char> : public ctype<char>
+    {
+    public:
+      explicit
+      ctype_byname(const char* __s, size_t __refs = 0);
+
+
+      explicit
+      ctype_byname(const string& __s, size_t __refs = 0);
+
+
+    protected:
+      virtual
+      ~ctype_byname();
+    };
+
+
+  template<>
+    class ctype_byname<wchar_t> : public ctype<wchar_t>
+    {
+    public:
+      explicit
+      ctype_byname(const char* __s, size_t __refs = 0);
+
+
+      explicit
+      ctype_byname(const string& __s, size_t __refs = 0);
+
+
+    protected:
+      virtual
+      ~ctype_byname();
+    };
+
+
+
+}
+
+
+# 1 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/ctype_inline.h" 1 3
+# 37 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/ctype_inline.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  bool
+  ctype<char>::
+  is(mask __m, char __c) const
+  { return _M_table[static_cast<unsigned char>(__c)] & __m; }
+
+  const char*
+  ctype<char>::
+  is(const char* __low, const char* __high, mask* __vec) const
+  {
+    while (__low < __high)
+      *__vec++ = _M_table[static_cast<unsigned char>(*__low++)];
+    return __high;
+  }
+
+  const char*
+  ctype<char>::
+  scan_is(mask __m, const char* __low, const char* __high) const
+  {
+    while (__low < __high
+    && !(_M_table[static_cast<unsigned char>(*__low)] & __m))
+      ++__low;
+    return __low;
+  }
+
+  const char*
+  ctype<char>::
+  scan_not(mask __m, const char* __low, const char* __high) const
+  {
+    while (__low < __high
+    && (_M_table[static_cast<unsigned char>(*__low)] & __m) != 0)
+      ++__low;
+    return __low;
+  }
+
+
+}
+# 1539 "/usr/include/c++/10.2.0/bits/locale_facets.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+  class __num_base
+  {
+  public:
+
+
+    enum
+      {
+ _S_ominus,
+ _S_oplus,
+ _S_ox,
+ _S_oX,
+ _S_odigits,
+ _S_odigits_end = _S_odigits + 16,
+ _S_oudigits = _S_odigits_end,
+ _S_oudigits_end = _S_oudigits + 16,
+ _S_oe = _S_odigits + 14,
+ _S_oE = _S_oudigits + 14,
+ _S_oend = _S_oudigits_end
+      };
+
+
+
+
+
+
+    static const char* _S_atoms_out;
+
+
+
+    static const char* _S_atoms_in;
+
+    enum
+    {
+      _S_iminus,
+      _S_iplus,
+      _S_ix,
+      _S_iX,
+      _S_izero,
+      _S_ie = _S_izero + 14,
+      _S_iE = _S_izero + 20,
+      _S_iend = 26
+    };
+
+
+
+    static void
+    _S_format_float(const ios_base& __io, char* __fptr, char __mod) throw();
+  };
+
+  template<typename _CharT>
+    struct __numpunct_cache : public locale::facet
+    {
+      const char* _M_grouping;
+      size_t _M_grouping_size;
+      bool _M_use_grouping;
+      const _CharT* _M_truename;
+      size_t _M_truename_size;
+      const _CharT* _M_falsename;
+      size_t _M_falsename_size;
+      _CharT _M_decimal_point;
+      _CharT _M_thousands_sep;
+
+
+
+
+
+      _CharT _M_atoms_out[__num_base::_S_oend];
+
+
+
+
+
+      _CharT _M_atoms_in[__num_base::_S_iend];
+
+      bool _M_allocated;
+
+      __numpunct_cache(size_t __refs = 0)
+      : facet(__refs), _M_grouping(0), _M_grouping_size(0),
+ _M_use_grouping(false),
+ _M_truename(0), _M_truename_size(0), _M_falsename(0),
+ _M_falsename_size(0), _M_decimal_point(_CharT()),
+ _M_thousands_sep(_CharT()), _M_allocated(false)
+ { }
+
+      ~__numpunct_cache();
+
+      void
+      _M_cache(const locale& __loc);
+
+    private:
+      __numpunct_cache&
+      operator=(const __numpunct_cache&);
+
+      explicit
+      __numpunct_cache(const __numpunct_cache&);
+    };
+
+  template<typename _CharT>
+    __numpunct_cache<_CharT>::~__numpunct_cache()
+    {
+      if (_M_allocated)
+ {
+   delete [] _M_grouping;
+   delete [] _M_truename;
+   delete [] _M_falsename;
+ }
+    }
+
+namespace __cxx11 {
+# 1669 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+  template<typename _CharT>
+    class numpunct : public locale::facet
+    {
+    public:
+
+
+
+      typedef _CharT char_type;
+      typedef basic_string<_CharT> string_type;
+
+      typedef __numpunct_cache<_CharT> __cache_type;
+
+    protected:
+      __cache_type* _M_data;
+
+    public:
+
+      static locale::id id;
+
+
+
+
+
+
+      explicit
+      numpunct(size_t __refs = 0)
+      : facet(__refs), _M_data(0)
+      { _M_initialize_numpunct(); }
+# 1707 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      explicit
+      numpunct(__cache_type* __cache, size_t __refs = 0)
+      : facet(__refs), _M_data(__cache)
+      { _M_initialize_numpunct(); }
+# 1721 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      explicit
+      numpunct(__c_locale __cloc, size_t __refs = 0)
+      : facet(__refs), _M_data(0)
+      { _M_initialize_numpunct(__cloc); }
+# 1735 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      char_type
+      decimal_point() const
+      { return this->do_decimal_point(); }
+# 1748 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      char_type
+      thousands_sep() const
+      { return this->do_thousands_sep(); }
+# 1779 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      string
+      grouping() const
+      { return this->do_grouping(); }
+# 1792 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      string_type
+      truename() const
+      { return this->do_truename(); }
+# 1805 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      string_type
+      falsename() const
+      { return this->do_falsename(); }
+
+    protected:
+
+      virtual
+      ~numpunct();
+# 1822 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual char_type
+      do_decimal_point() const
+      { return _M_data->_M_decimal_point; }
+# 1834 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual char_type
+      do_thousands_sep() const
+      { return _M_data->_M_thousands_sep; }
+# 1847 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual string
+      do_grouping() const
+      { return _M_data->_M_grouping; }
+# 1860 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual string_type
+      do_truename() const
+      { return _M_data->_M_truename; }
+# 1873 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual string_type
+      do_falsename() const
+      { return _M_data->_M_falsename; }
+
+
+      void
+      _M_initialize_numpunct(__c_locale __cloc = 0);
+    };
+
+  template<typename _CharT>
+    locale::id numpunct<_CharT>::id;
+
+  template<>
+    numpunct<char>::~numpunct();
+
+  template<>
+    void
+    numpunct<char>::_M_initialize_numpunct(__c_locale __cloc);
+
+
+  template<>
+    numpunct<wchar_t>::~numpunct();
+
+  template<>
+    void
+    numpunct<wchar_t>::_M_initialize_numpunct(__c_locale __cloc);
+
+
+
+  template<typename _CharT>
+    class numpunct_byname : public numpunct<_CharT>
+    {
+    public:
+      typedef _CharT char_type;
+      typedef basic_string<_CharT> string_type;
+
+      explicit
+      numpunct_byname(const char* __s, size_t __refs = 0)
+      : numpunct<_CharT>(__refs)
+      {
+ if (__builtin_strcmp(__s, "C") != 0
+     && __builtin_strcmp(__s, "POSIX") != 0)
+   {
+     __c_locale __tmp;
+     this->_S_create_c_locale(__tmp, __s);
+     this->_M_initialize_numpunct(__tmp);
+     this->_S_destroy_c_locale(__tmp);
+   }
+      }
+
+
+      explicit
+      numpunct_byname(const string& __s, size_t __refs = 0)
+      : numpunct_byname(__s.c_str(), __refs) { }
+
+
+    protected:
+      virtual
+      ~numpunct_byname() { }
+    };
+
+}
+
+
+# 1951 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+  template<typename _CharT, typename _InIter>
+    class num_get : public locale::facet
+    {
+    public:
+
+
+
+      typedef _CharT char_type;
+      typedef _InIter iter_type;
+
+
+
+      static locale::id id;
+# 1972 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      explicit
+      num_get(size_t __refs = 0) : facet(__refs) { }
+# 1998 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, bool& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+# 2035 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, long& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, unsigned short& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, unsigned int& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, unsigned long& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+
+
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, long long& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, unsigned long long& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+# 2095 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, float& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, double& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, long double& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+# 2138 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, void*& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+
+    protected:
+
+      virtual ~num_get() { }
+
+      __attribute ((__abi_tag__ ("cxx11")))
+      iter_type
+      _M_extract_float(iter_type, iter_type, ios_base&, ios_base::iostate&,
+         string&) const;
+
+      template<typename _ValueT>
+ __attribute ((__abi_tag__ ("cxx11")))
+ iter_type
+ _M_extract_int(iter_type, iter_type, ios_base&, ios_base::iostate&,
+         _ValueT&) const;
+
+      template<typename _CharT2>
+      typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, int>::__type
+ _M_find(const _CharT2*, size_t __len, _CharT2 __c) const
+ {
+   int __ret = -1;
+   if (__len <= 10)
+     {
+       if (__c >= _CharT2('0') && __c < _CharT2(_CharT2('0') + __len))
+  __ret = __c - _CharT2('0');
+     }
+   else
+     {
+       if (__c >= _CharT2('0') && __c <= _CharT2('9'))
+  __ret = __c - _CharT2('0');
+       else if (__c >= _CharT2('a') && __c <= _CharT2('f'))
+  __ret = 10 + (__c - _CharT2('a'));
+       else if (__c >= _CharT2('A') && __c <= _CharT2('F'))
+  __ret = 10 + (__c - _CharT2('A'));
+     }
+   return __ret;
+ }
+
+      template<typename _CharT2>
+      typename __gnu_cxx::__enable_if<!__is_char<_CharT2>::__value,
+          int>::__type
+ _M_find(const _CharT2* __zero, size_t __len, _CharT2 __c) const
+ {
+   int __ret = -1;
+   const char_type* __q = char_traits<_CharT2>::find(__zero, __len, __c);
+   if (__q)
+     {
+       __ret = __q - __zero;
+       if (__ret > 15)
+  __ret -= 6;
+     }
+   return __ret;
+ }
+# 2211 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual iter_type
+      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, bool&) const;
+
+      virtual iter_type
+      do_get(iter_type __beg, iter_type __end, ios_base& __io,
+      ios_base::iostate& __err, long& __v) const
+      { return _M_extract_int(__beg, __end, __io, __err, __v); }
+
+      virtual iter_type
+      do_get(iter_type __beg, iter_type __end, ios_base& __io,
+      ios_base::iostate& __err, unsigned short& __v) const
+      { return _M_extract_int(__beg, __end, __io, __err, __v); }
+
+      virtual iter_type
+      do_get(iter_type __beg, iter_type __end, ios_base& __io,
+      ios_base::iostate& __err, unsigned int& __v) const
+      { return _M_extract_int(__beg, __end, __io, __err, __v); }
+
+      virtual iter_type
+      do_get(iter_type __beg, iter_type __end, ios_base& __io,
+      ios_base::iostate& __err, unsigned long& __v) const
+      { return _M_extract_int(__beg, __end, __io, __err, __v); }
+
+
+      virtual iter_type
+      do_get(iter_type __beg, iter_type __end, ios_base& __io,
+      ios_base::iostate& __err, long long& __v) const
+      { return _M_extract_int(__beg, __end, __io, __err, __v); }
+
+      virtual iter_type
+      do_get(iter_type __beg, iter_type __end, ios_base& __io,
+      ios_base::iostate& __err, unsigned long long& __v) const
+      { return _M_extract_int(__beg, __end, __io, __err, __v); }
+
+
+      virtual iter_type
+      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, float&) const;
+
+      virtual iter_type
+      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&,
+      double&) const;
+
+
+
+
+
+
+
+      virtual iter_type
+      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&,
+      long double&) const;
+
+
+      virtual iter_type
+      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, void*&) const;
+# 2274 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+    };
+
+  template<typename _CharT, typename _InIter>
+    locale::id num_get<_CharT, _InIter>::id;
+# 2292 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+  template<typename _CharT, typename _OutIter>
+    class num_put : public locale::facet
+    {
+    public:
+
+
+
+      typedef _CharT char_type;
+      typedef _OutIter iter_type;
+
+
+
+      static locale::id id;
+# 2313 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      explicit
+      num_put(size_t __refs = 0) : facet(__refs) { }
+# 2331 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      iter_type
+      put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const
+      { return this->do_put(__s, __io, __fill, __v); }
+# 2373 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      iter_type
+      put(iter_type __s, ios_base& __io, char_type __fill, long __v) const
+      { return this->do_put(__s, __io, __fill, __v); }
+
+      iter_type
+      put(iter_type __s, ios_base& __io, char_type __fill,
+   unsigned long __v) const
+      { return this->do_put(__s, __io, __fill, __v); }
+
+
+      iter_type
+      put(iter_type __s, ios_base& __io, char_type __fill, long long __v) const
+      { return this->do_put(__s, __io, __fill, __v); }
+
+      iter_type
+      put(iter_type __s, ios_base& __io, char_type __fill,
+   unsigned long long __v) const
+      { return this->do_put(__s, __io, __fill, __v); }
+# 2436 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      iter_type
+      put(iter_type __s, ios_base& __io, char_type __fill, double __v) const
+      { return this->do_put(__s, __io, __fill, __v); }
+
+      iter_type
+      put(iter_type __s, ios_base& __io, char_type __fill,
+   long double __v) const
+      { return this->do_put(__s, __io, __fill, __v); }
+# 2461 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      iter_type
+      put(iter_type __s, ios_base& __io, char_type __fill,
+   const void* __v) const
+      { return this->do_put(__s, __io, __fill, __v); }
+
+    protected:
+      template<typename _ValueT>
+ iter_type
+ _M_insert_float(iter_type, ios_base& __io, char_type __fill,
+   char __mod, _ValueT __v) const;
+
+      void
+      _M_group_float(const char* __grouping, size_t __grouping_size,
+       char_type __sep, const char_type* __p, char_type* __new,
+       char_type* __cs, int& __len) const;
+
+      template<typename _ValueT>
+ iter_type
+ _M_insert_int(iter_type, ios_base& __io, char_type __fill,
+        _ValueT __v) const;
+
+      void
+      _M_group_int(const char* __grouping, size_t __grouping_size,
+     char_type __sep, ios_base& __io, char_type* __new,
+     char_type* __cs, int& __len) const;
+
+      void
+      _M_pad(char_type __fill, streamsize __w, ios_base& __io,
+      char_type* __new, const char_type* __cs, int& __len) const;
+
+
+      virtual
+      ~num_put() { }
+# 2509 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual iter_type
+      do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const;
+
+      virtual iter_type
+      do_put(iter_type __s, ios_base& __io, char_type __fill, long __v) const
+      { return _M_insert_int(__s, __io, __fill, __v); }
+
+      virtual iter_type
+      do_put(iter_type __s, ios_base& __io, char_type __fill,
+      unsigned long __v) const
+      { return _M_insert_int(__s, __io, __fill, __v); }
+
+
+      virtual iter_type
+      do_put(iter_type __s, ios_base& __io, char_type __fill,
+      long long __v) const
+      { return _M_insert_int(__s, __io, __fill, __v); }
+
+      virtual iter_type
+      do_put(iter_type __s, ios_base& __io, char_type __fill,
+      unsigned long long __v) const
+      { return _M_insert_int(__s, __io, __fill, __v); }
+
+
+      virtual iter_type
+      do_put(iter_type, ios_base&, char_type, double) const;
+
+
+
+
+
+
+      virtual iter_type
+      do_put(iter_type, ios_base&, char_type, long double) const;
+
+
+      virtual iter_type
+      do_put(iter_type, ios_base&, char_type, const void*) const;
+
+
+
+
+
+
+
+    };
+
+  template <typename _CharT, typename _OutIter>
+    locale::id num_put<_CharT, _OutIter>::id;
+
+
+
+
+
+
+
+
+
+  template<typename _CharT>
+    inline bool
+    isspace(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::space, __c); }
+
+
+  template<typename _CharT>
+    inline bool
+    isprint(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::print, __c); }
+
+
+  template<typename _CharT>
+    inline bool
+    iscntrl(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::cntrl, __c); }
+
+
+  template<typename _CharT>
+    inline bool
+    isupper(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::upper, __c); }
+
+
+  template<typename _CharT>
+    inline bool
+    islower(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::lower, __c); }
+
+
+  template<typename _CharT>
+    inline bool
+    isalpha(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alpha, __c); }
+
+
+  template<typename _CharT>
+    inline bool
+    isdigit(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::digit, __c); }
+
+
+  template<typename _CharT>
+    inline bool
+    ispunct(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::punct, __c); }
+
+
+  template<typename _CharT>
+    inline bool
+    isxdigit(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::xdigit, __c); }
+
+
+  template<typename _CharT>
+    inline bool
+    isalnum(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alnum, __c); }
+
+
+  template<typename _CharT>
+    inline bool
+    isgraph(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::graph, __c); }
+
+
+
+  template<typename _CharT>
+    inline bool
+    isblank(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::blank, __c); }
+
+
+
+  template<typename _CharT>
+    inline _CharT
+    toupper(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).toupper(__c); }
+
+
+  template<typename _CharT>
+    inline _CharT
+    tolower(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).tolower(__c); }
+
+
+}
+
+# 1 "/usr/include/c++/10.2.0/bits/locale_facets.tcc" 1 3
+# 31 "/usr/include/c++/10.2.0/bits/locale_facets.tcc" 3
+#define _LOCALE_FACETS_TCC 1
+
+       
+# 34 "/usr/include/c++/10.2.0/bits/locale_facets.tcc" 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+  template<typename _Facet>
+    struct __use_cache
+    {
+      const _Facet*
+      operator() (const locale& __loc) const;
+    };
+
+
+  template<typename _CharT>
+    struct __use_cache<__numpunct_cache<_CharT> >
+    {
+      const __numpunct_cache<_CharT>*
+      operator() (const locale& __loc) const
+      {
+ const size_t __i = numpunct<_CharT>::id._M_id();
+ const locale::facet** __caches = __loc._M_impl->_M_caches;
+ if (!__caches[__i])
+   {
+     __numpunct_cache<_CharT>* __tmp = 0;
+     try
+       {
+  __tmp = new __numpunct_cache<_CharT>;
+  __tmp->_M_cache(__loc);
+       }
+     catch(...)
+       {
+  delete __tmp;
+  throw;
+       }
+     __loc._M_impl->_M_install_cache(__tmp, __i);
+   }
+ return static_cast<const __numpunct_cache<_CharT>*>(__caches[__i]);
+      }
+    };
+
+  template<typename _CharT>
+    void
+    __numpunct_cache<_CharT>::_M_cache(const locale& __loc)
+    {
+      const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
+
+      char* __grouping = 0;
+      _CharT* __truename = 0;
+      _CharT* __falsename = 0;
+      try
+ {
+   const string& __g = __np.grouping();
+   _M_grouping_size = __g.size();
+   __grouping = new char[_M_grouping_size];
+   __g.copy(__grouping, _M_grouping_size);
+   _M_use_grouping = (_M_grouping_size
+        && static_cast<signed char>(__grouping[0]) > 0
+        && (__grouping[0]
+     != __gnu_cxx::__numeric_traits<char>::__max));
+
+   const basic_string<_CharT>& __tn = __np.truename();
+   _M_truename_size = __tn.size();
+   __truename = new _CharT[_M_truename_size];
+   __tn.copy(__truename, _M_truename_size);
+
+   const basic_string<_CharT>& __fn = __np.falsename();
+   _M_falsename_size = __fn.size();
+   __falsename = new _CharT[_M_falsename_size];
+   __fn.copy(__falsename, _M_falsename_size);
+
+   _M_decimal_point = __np.decimal_point();
+   _M_thousands_sep = __np.thousands_sep();
+
+   const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__loc);
+   __ct.widen(__num_base::_S_atoms_out,
+       __num_base::_S_atoms_out
+       + __num_base::_S_oend, _M_atoms_out);
+   __ct.widen(__num_base::_S_atoms_in,
+       __num_base::_S_atoms_in
+       + __num_base::_S_iend, _M_atoms_in);
+
+   _M_grouping = __grouping;
+   _M_truename = __truename;
+   _M_falsename = __falsename;
+   _M_allocated = true;
+ }
+      catch(...)
+ {
+   delete [] __grouping;
+   delete [] __truename;
+   delete [] __falsename;
+   throw;
+ }
+    }
+# 139 "/usr/include/c++/10.2.0/bits/locale_facets.tcc" 3
+  __attribute__ ((__pure__)) bool
+  __verify_grouping(const char* __grouping, size_t __grouping_size,
+      const string& __grouping_tmp) throw ();
+
+
+
+  template<typename _CharT, typename _InIter>
+    __attribute ((__abi_tag__ ("cxx11")))
+    _InIter
+    num_get<_CharT, _InIter>::
+    _M_extract_float(_InIter __beg, _InIter __end, ios_base& __io,
+       ios_base::iostate& __err, string& __xtrc) const
+    {
+      typedef char_traits<_CharT> __traits_type;
+      typedef __numpunct_cache<_CharT> __cache_type;
+      __use_cache<__cache_type> __uc;
+      const locale& __loc = __io._M_getloc();
+      const __cache_type* __lc = __uc(__loc);
+      const _CharT* __lit = __lc->_M_atoms_in;
+      char_type __c = char_type();
+
+
+      bool __testeof = __beg == __end;
+
+
+      if (!__testeof)
+ {
+   __c = *__beg;
+   const bool __plus = __c == __lit[__num_base::_S_iplus];
+   if ((__plus || __c == __lit[__num_base::_S_iminus])
+       && !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
+       && !(__c == __lc->_M_decimal_point))
+     {
+       __xtrc += __plus ? '+' : '-';
+       if (++__beg != __end)
+  __c = *__beg;
+       else
+  __testeof = true;
+     }
+ }
+
+
+      bool __found_mantissa = false;
+      int __sep_pos = 0;
+      while (!__testeof)
+ {
+   if ((__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
+       || __c == __lc->_M_decimal_point)
+     break;
+   else if (__c == __lit[__num_base::_S_izero])
+     {
+       if (!__found_mantissa)
+  {
+    __xtrc += '0';
+    __found_mantissa = true;
+  }
+       ++__sep_pos;
+
+       if (++__beg != __end)
+  __c = *__beg;
+       else
+  __testeof = true;
+     }
+   else
+     break;
+ }
+
+
+      bool __found_dec = false;
+      bool __found_sci = false;
+      string __found_grouping;
+      if (__lc->_M_use_grouping)
+ __found_grouping.reserve(32);
+      const char_type* __lit_zero = __lit + __num_base::_S_izero;
+
+      if (!__lc->_M_allocated)
+
+ while (!__testeof)
+   {
+     const int __digit = _M_find(__lit_zero, 10, __c);
+     if (__digit != -1)
+       {
+  __xtrc += '0' + __digit;
+  __found_mantissa = true;
+       }
+     else if (__c == __lc->_M_decimal_point
+       && !__found_dec && !__found_sci)
+       {
+  __xtrc += '.';
+  __found_dec = true;
+       }
+     else if ((__c == __lit[__num_base::_S_ie]
+        || __c == __lit[__num_base::_S_iE])
+       && !__found_sci && __found_mantissa)
+       {
+
+  __xtrc += 'e';
+  __found_sci = true;
+
+
+  if (++__beg != __end)
+    {
+      __c = *__beg;
+      const bool __plus = __c == __lit[__num_base::_S_iplus];
+      if (__plus || __c == __lit[__num_base::_S_iminus])
+        __xtrc += __plus ? '+' : '-';
+      else
+        continue;
+    }
+  else
+    {
+      __testeof = true;
+      break;
+    }
+       }
+     else
+       break;
+
+     if (++__beg != __end)
+       __c = *__beg;
+     else
+       __testeof = true;
+   }
+      else
+ while (!__testeof)
+   {
+
+
+     if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
+       {
+  if (!__found_dec && !__found_sci)
+    {
+
+
+      if (__sep_pos)
+        {
+   __found_grouping += static_cast<char>(__sep_pos);
+   __sep_pos = 0;
+        }
+      else
+        {
+
+
+   __xtrc.clear();
+   break;
+        }
+    }
+  else
+    break;
+       }
+     else if (__c == __lc->_M_decimal_point)
+       {
+  if (!__found_dec && !__found_sci)
+    {
+
+
+
+      if (__found_grouping.size())
+        __found_grouping += static_cast<char>(__sep_pos);
+      __xtrc += '.';
+      __found_dec = true;
+    }
+  else
+    break;
+       }
+     else
+       {
+  const char_type* __q =
+    __traits_type::find(__lit_zero, 10, __c);
+  if (__q)
+    {
+      __xtrc += '0' + (__q - __lit_zero);
+      __found_mantissa = true;
+      ++__sep_pos;
+    }
+  else if ((__c == __lit[__num_base::_S_ie]
+     || __c == __lit[__num_base::_S_iE])
+    && !__found_sci && __found_mantissa)
+    {
+
+      if (__found_grouping.size() && !__found_dec)
+        __found_grouping += static_cast<char>(__sep_pos);
+      __xtrc += 'e';
+      __found_sci = true;
+
+
+      if (++__beg != __end)
+        {
+   __c = *__beg;
+   const bool __plus = __c == __lit[__num_base::_S_iplus];
+   if ((__plus || __c == __lit[__num_base::_S_iminus])
+       && !(__lc->_M_use_grouping
+     && __c == __lc->_M_thousands_sep)
+       && !(__c == __lc->_M_decimal_point))
+        __xtrc += __plus ? '+' : '-';
+   else
+     continue;
+        }
+      else
+        {
+   __testeof = true;
+   break;
+        }
+    }
+  else
+    break;
+       }
+
+     if (++__beg != __end)
+       __c = *__beg;
+     else
+       __testeof = true;
+   }
+
+
+
+      if (__found_grouping.size())
+        {
+
+   if (!__found_dec && !__found_sci)
+     __found_grouping += static_cast<char>(__sep_pos);
+
+          if (!std::__verify_grouping(__lc->_M_grouping,
+          __lc->_M_grouping_size,
+          __found_grouping))
+     __err = ios_base::failbit;
+        }
+
+      return __beg;
+    }
+
+  template<typename _CharT, typename _InIter>
+    template<typename _ValueT>
+      __attribute ((__abi_tag__ ("cxx11")))
+      _InIter
+      num_get<_CharT, _InIter>::
+      _M_extract_int(_InIter __beg, _InIter __end, ios_base& __io,
+       ios_base::iostate& __err, _ValueT& __v) const
+      {
+        typedef char_traits<_CharT> __traits_type;
+ using __gnu_cxx::__add_unsigned;
+ typedef typename __add_unsigned<_ValueT>::__type __unsigned_type;
+ typedef __numpunct_cache<_CharT> __cache_type;
+ __use_cache<__cache_type> __uc;
+ const locale& __loc = __io._M_getloc();
+ const __cache_type* __lc = __uc(__loc);
+ const _CharT* __lit = __lc->_M_atoms_in;
+ char_type __c = char_type();
+
+
+ const ios_base::fmtflags __basefield = __io.flags()
+                                        & ios_base::basefield;
+ const bool __oct = __basefield == ios_base::oct;
+ int __base = __oct ? 8 : (__basefield == ios_base::hex ? 16 : 10);
+
+
+ bool __testeof = __beg == __end;
+
+
+ bool __negative = false;
+ if (!__testeof)
+   {
+     __c = *__beg;
+     __negative = __c == __lit[__num_base::_S_iminus];
+     if ((__negative || __c == __lit[__num_base::_S_iplus])
+  && !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
+  && !(__c == __lc->_M_decimal_point))
+       {
+  if (++__beg != __end)
+    __c = *__beg;
+  else
+    __testeof = true;
+       }
+   }
+
+
+
+ bool __found_zero = false;
+ int __sep_pos = 0;
+ while (!__testeof)
+   {
+     if ((__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
+  || __c == __lc->_M_decimal_point)
+       break;
+     else if (__c == __lit[__num_base::_S_izero]
+       && (!__found_zero || __base == 10))
+       {
+  __found_zero = true;
+  ++__sep_pos;
+  if (__basefield == 0)
+    __base = 8;
+  if (__base == 8)
+    __sep_pos = 0;
+       }
+     else if (__found_zero
+       && (__c == __lit[__num_base::_S_ix]
+    || __c == __lit[__num_base::_S_iX]))
+       {
+  if (__basefield == 0)
+    __base = 16;
+  if (__base == 16)
+    {
+      __found_zero = false;
+      __sep_pos = 0;
+    }
+  else
+    break;
+       }
+     else
+       break;
+
+     if (++__beg != __end)
+       {
+  __c = *__beg;
+  if (!__found_zero)
+    break;
+       }
+     else
+       __testeof = true;
+   }
+
+
+
+ const size_t __len = (__base == 16 ? __num_base::_S_iend
+         - __num_base::_S_izero : __base);
+
+
+ typedef __gnu_cxx::__numeric_traits<_ValueT> __num_traits;
+ string __found_grouping;
+ if (__lc->_M_use_grouping)
+   __found_grouping.reserve(32);
+ bool __testfail = false;
+ bool __testoverflow = false;
+ const __unsigned_type __max =
+   (__negative && __num_traits::__is_signed)
+   ? -static_cast<__unsigned_type>(__num_traits::__min)
+   : __num_traits::__max;
+ const __unsigned_type __smax = __max / __base;
+ __unsigned_type __result = 0;
+ int __digit = 0;
+ const char_type* __lit_zero = __lit + __num_base::_S_izero;
+
+ if (!__lc->_M_allocated)
+
+   while (!__testeof)
+     {
+       __digit = _M_find(__lit_zero, __len, __c);
+       if (__digit == -1)
+  break;
+
+       if (__result > __smax)
+  __testoverflow = true;
+       else
+  {
+    __result *= __base;
+    __testoverflow |= __result > __max - __digit;
+    __result += __digit;
+    ++__sep_pos;
+  }
+
+       if (++__beg != __end)
+  __c = *__beg;
+       else
+  __testeof = true;
+     }
+ else
+   while (!__testeof)
+     {
+
+
+       if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
+  {
+
+
+    if (__sep_pos)
+      {
+        __found_grouping += static_cast<char>(__sep_pos);
+        __sep_pos = 0;
+      }
+    else
+      {
+        __testfail = true;
+        break;
+      }
+  }
+       else if (__c == __lc->_M_decimal_point)
+  break;
+       else
+  {
+    const char_type* __q =
+      __traits_type::find(__lit_zero, __len, __c);
+    if (!__q)
+      break;
+
+    __digit = __q - __lit_zero;
+    if (__digit > 15)
+      __digit -= 6;
+    if (__result > __smax)
+      __testoverflow = true;
+    else
+      {
+        __result *= __base;
+        __testoverflow |= __result > __max - __digit;
+        __result += __digit;
+        ++__sep_pos;
+      }
+  }
+
+       if (++__beg != __end)
+  __c = *__beg;
+       else
+  __testeof = true;
+     }
+
+
+
+ if (__found_grouping.size())
+   {
+
+     __found_grouping += static_cast<char>(__sep_pos);
+
+     if (!std::__verify_grouping(__lc->_M_grouping,
+     __lc->_M_grouping_size,
+     __found_grouping))
+       __err = ios_base::failbit;
+   }
+
+
+
+ if ((!__sep_pos && !__found_zero && !__found_grouping.size())
+     || __testfail)
+   {
+     __v = 0;
+     __err = ios_base::failbit;
+   }
+ else if (__testoverflow)
+   {
+     if (__negative && __num_traits::__is_signed)
+       __v = __num_traits::__min;
+     else
+       __v = __num_traits::__max;
+     __err = ios_base::failbit;
+   }
+ else
+   __v = __negative ? -__result : __result;
+
+ if (__testeof)
+   __err |= ios_base::eofbit;
+ return __beg;
+      }
+
+
+
+  template<typename _CharT, typename _InIter>
+    _InIter
+    num_get<_CharT, _InIter>::
+    do_get(iter_type __beg, iter_type __end, ios_base& __io,
+           ios_base::iostate& __err, bool& __v) const
+    {
+      if (!(__io.flags() & ios_base::boolalpha))
+        {
+
+
+
+   long __l = -1;
+          __beg = _M_extract_int(__beg, __end, __io, __err, __l);
+   if (__l == 0 || __l == 1)
+     __v = bool(__l);
+   else
+     {
+
+
+       __v = true;
+       __err = ios_base::failbit;
+       if (__beg == __end)
+  __err |= ios_base::eofbit;
+     }
+        }
+      else
+        {
+
+   typedef __numpunct_cache<_CharT> __cache_type;
+   __use_cache<__cache_type> __uc;
+   const locale& __loc = __io._M_getloc();
+   const __cache_type* __lc = __uc(__loc);
+
+   bool __testf = true;
+   bool __testt = true;
+   bool __donef = __lc->_M_falsename_size == 0;
+   bool __donet = __lc->_M_truename_size == 0;
+   bool __testeof = false;
+   size_t __n = 0;
+   while (!__donef || !__donet)
+     {
+       if (__beg == __end)
+  {
+    __testeof = true;
+    break;
+  }
+
+       const char_type __c = *__beg;
+
+       if (!__donef)
+  __testf = __c == __lc->_M_falsename[__n];
+
+       if (!__testf && __donet)
+  break;
+
+       if (!__donet)
+  __testt = __c == __lc->_M_truename[__n];
+
+       if (!__testt && __donef)
+  break;
+
+       if (!__testt && !__testf)
+  break;
+
+       ++__n;
+       ++__beg;
+
+       __donef = !__testf || __n >= __lc->_M_falsename_size;
+       __donet = !__testt || __n >= __lc->_M_truename_size;
+     }
+   if (__testf && __n == __lc->_M_falsename_size && __n)
+     {
+       __v = false;
+       if (__testt && __n == __lc->_M_truename_size)
+  __err = ios_base::failbit;
+       else
+  __err = __testeof ? ios_base::eofbit : ios_base::goodbit;
+     }
+   else if (__testt && __n == __lc->_M_truename_size && __n)
+     {
+       __v = true;
+       __err = __testeof ? ios_base::eofbit : ios_base::goodbit;
+     }
+   else
+     {
+
+
+       __v = false;
+       __err = ios_base::failbit;
+       if (__testeof)
+  __err |= ios_base::eofbit;
+     }
+ }
+      return __beg;
+    }
+
+  template<typename _CharT, typename _InIter>
+    _InIter
+    num_get<_CharT, _InIter>::
+    do_get(iter_type __beg, iter_type __end, ios_base& __io,
+    ios_base::iostate& __err, float& __v) const
+    {
+      string __xtrc;
+      __xtrc.reserve(32);
+      __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
+      std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
+      if (__beg == __end)
+ __err |= ios_base::eofbit;
+      return __beg;
+    }
+
+  template<typename _CharT, typename _InIter>
+    _InIter
+    num_get<_CharT, _InIter>::
+    do_get(iter_type __beg, iter_type __end, ios_base& __io,
+           ios_base::iostate& __err, double& __v) const
+    {
+      string __xtrc;
+      __xtrc.reserve(32);
+      __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
+      std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
+      if (__beg == __end)
+ __err |= ios_base::eofbit;
+      return __beg;
+    }
+# 735 "/usr/include/c++/10.2.0/bits/locale_facets.tcc" 3
+  template<typename _CharT, typename _InIter>
+    _InIter
+    num_get<_CharT, _InIter>::
+    do_get(iter_type __beg, iter_type __end, ios_base& __io,
+           ios_base::iostate& __err, long double& __v) const
+    {
+      string __xtrc;
+      __xtrc.reserve(32);
+      __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
+      std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
+      if (__beg == __end)
+ __err |= ios_base::eofbit;
+      return __beg;
+    }
+
+  template<typename _CharT, typename _InIter>
+    _InIter
+    num_get<_CharT, _InIter>::
+    do_get(iter_type __beg, iter_type __end, ios_base& __io,
+           ios_base::iostate& __err, void*& __v) const
+    {
+
+      typedef ios_base::fmtflags fmtflags;
+      const fmtflags __fmt = __io.flags();
+      __io.flags((__fmt & ~ios_base::basefield) | ios_base::hex);
+
+      typedef __gnu_cxx::__conditional_type<(sizeof(void*)
+          <= sizeof(unsigned long)),
+ unsigned long, unsigned long long>::__type _UIntPtrType;
+
+      _UIntPtrType __ul;
+      __beg = _M_extract_int(__beg, __end, __io, __err, __ul);
+
+
+      __io.flags(__fmt);
+
+      __v = reinterpret_cast<void*>(__ul);
+      return __beg;
+    }
+
+
+
+  template<typename _CharT, typename _OutIter>
+    void
+    num_put<_CharT, _OutIter>::
+    _M_pad(_CharT __fill, streamsize __w, ios_base& __io,
+    _CharT* __new, const _CharT* __cs, int& __len) const
+    {
+
+
+      __pad<_CharT, char_traits<_CharT> >::_S_pad(__io, __fill, __new,
+        __cs, __w, __len);
+      __len = static_cast<int>(__w);
+    }
+
+
+
+  template<typename _CharT, typename _ValueT>
+    int
+    __int_to_char(_CharT* __bufend, _ValueT __v, const _CharT* __lit,
+    ios_base::fmtflags __flags, bool __dec)
+    {
+      _CharT* __buf = __bufend;
+      if (__builtin_expect(__dec, true))
+ {
+
+   do
+     {
+       *--__buf = __lit[(__v % 10) + __num_base::_S_odigits];
+       __v /= 10;
+     }
+   while (__v != 0);
+ }
+      else if ((__flags & ios_base::basefield) == ios_base::oct)
+ {
+
+   do
+     {
+       *--__buf = __lit[(__v & 0x7) + __num_base::_S_odigits];
+       __v >>= 3;
+     }
+   while (__v != 0);
+ }
+      else
+ {
+
+   const bool __uppercase = __flags & ios_base::uppercase;
+   const int __case_offset = __uppercase ? __num_base::_S_oudigits
+                                         : __num_base::_S_odigits;
+   do
+     {
+       *--__buf = __lit[(__v & 0xf) + __case_offset];
+       __v >>= 4;
+     }
+   while (__v != 0);
+ }
+      return __bufend - __buf;
+    }
+
+
+
+  template<typename _CharT, typename _OutIter>
+    void
+    num_put<_CharT, _OutIter>::
+    _M_group_int(const char* __grouping, size_t __grouping_size, _CharT __sep,
+   ios_base&, _CharT* __new, _CharT* __cs, int& __len) const
+    {
+      _CharT* __p = std::__add_grouping(__new, __sep, __grouping,
+     __grouping_size, __cs, __cs + __len);
+      __len = __p - __new;
+    }
+
+  template<typename _CharT, typename _OutIter>
+    template<typename _ValueT>
+      _OutIter
+      num_put<_CharT, _OutIter>::
+      _M_insert_int(_OutIter __s, ios_base& __io, _CharT __fill,
+      _ValueT __v) const
+      {
+ using __gnu_cxx::__add_unsigned;
+ typedef typename __add_unsigned<_ValueT>::__type __unsigned_type;
+ typedef __numpunct_cache<_CharT> __cache_type;
+ __use_cache<__cache_type> __uc;
+ const locale& __loc = __io._M_getloc();
+ const __cache_type* __lc = __uc(__loc);
+ const _CharT* __lit = __lc->_M_atoms_out;
+ const ios_base::fmtflags __flags = __io.flags();
+
+
+ const int __ilen = 5 * sizeof(_ValueT);
+ _CharT* __cs = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
+            * __ilen));
+
+
+
+ const ios_base::fmtflags __basefield = __flags & ios_base::basefield;
+ const bool __dec = (__basefield != ios_base::oct
+       && __basefield != ios_base::hex);
+ const __unsigned_type __u = ((__v > 0 || !__dec)
+         ? __unsigned_type(__v)
+         : -__unsigned_type(__v));
+  int __len = __int_to_char(__cs + __ilen, __u, __lit, __flags, __dec);
+ __cs += __ilen - __len;
+
+
+ if (__lc->_M_use_grouping)
+   {
+
+
+     _CharT* __cs2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
+          * (__len + 1)
+          * 2));
+     _M_group_int(__lc->_M_grouping, __lc->_M_grouping_size,
+    __lc->_M_thousands_sep, __io, __cs2 + 2, __cs, __len);
+     __cs = __cs2 + 2;
+   }
+
+
+ if (__builtin_expect(__dec, true))
+   {
+
+     if (__v >= 0)
+       {
+  if (bool(__flags & ios_base::showpos)
+      && __gnu_cxx::__numeric_traits<_ValueT>::__is_signed)
+    *--__cs = __lit[__num_base::_S_oplus], ++__len;
+       }
+     else
+       *--__cs = __lit[__num_base::_S_ominus], ++__len;
+   }
+ else if (bool(__flags & ios_base::showbase) && __v)
+   {
+     if (__basefield == ios_base::oct)
+       *--__cs = __lit[__num_base::_S_odigits], ++__len;
+     else
+       {
+
+  const bool __uppercase = __flags & ios_base::uppercase;
+  *--__cs = __lit[__num_base::_S_ox + __uppercase];
+
+  *--__cs = __lit[__num_base::_S_odigits];
+  __len += 2;
+       }
+   }
+
+
+ const streamsize __w = __io.width();
+ if (__w > static_cast<streamsize>(__len))
+   {
+     _CharT* __cs3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
+          * __w));
+     _M_pad(__fill, __w, __io, __cs3, __cs, __len);
+     __cs = __cs3;
+   }
+ __io.width(0);
+
+
+
+ return std::__write(__s, __cs, __len);
+      }
+
+  template<typename _CharT, typename _OutIter>
+    void
+    num_put<_CharT, _OutIter>::
+    _M_group_float(const char* __grouping, size_t __grouping_size,
+     _CharT __sep, const _CharT* __p, _CharT* __new,
+     _CharT* __cs, int& __len) const
+    {
+
+
+
+      const int __declen = __p ? __p - __cs : __len;
+      _CharT* __p2 = std::__add_grouping(__new, __sep, __grouping,
+      __grouping_size,
+      __cs, __cs + __declen);
+
+
+      int __newlen = __p2 - __new;
+      if (__p)
+ {
+   char_traits<_CharT>::copy(__p2, __p, __len - __declen);
+   __newlen += __len - __declen;
+ }
+      __len = __newlen;
+    }
+# 971 "/usr/include/c++/10.2.0/bits/locale_facets.tcc" 3
+  template<typename _CharT, typename _OutIter>
+    template<typename _ValueT>
+      _OutIter
+      num_put<_CharT, _OutIter>::
+      _M_insert_float(_OutIter __s, ios_base& __io, _CharT __fill, char __mod,
+         _ValueT __v) const
+      {
+ typedef __numpunct_cache<_CharT> __cache_type;
+ __use_cache<__cache_type> __uc;
+ const locale& __loc = __io._M_getloc();
+ const __cache_type* __lc = __uc(__loc);
+
+
+ const streamsize __prec = __io.precision() < 0 ? 6 : __io.precision();
+
+ const int __max_digits =
+   __gnu_cxx::__numeric_traits<_ValueT>::__digits10;
+
+
+ int __len;
+
+ char __fbuf[16];
+ __num_base::_S_format_float(__io, __fbuf, __mod);
+
+
+
+ const bool __use_prec =
+   (__io.flags() & ios_base::floatfield) != ios_base::floatfield;
+
+
+
+ int __cs_size = __max_digits * 3;
+ char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
+ if (__use_prec)
+   __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
+     __fbuf, __prec, __v);
+ else
+   __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
+     __fbuf, __v);
+
+
+ if (__len >= __cs_size)
+   {
+     __cs_size = __len + 1;
+     __cs = static_cast<char*>(__builtin_alloca(__cs_size));
+     if (__use_prec)
+       __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
+         __fbuf, __prec, __v);
+     else
+       __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
+         __fbuf, __v);
+   }
+# 1044 "/usr/include/c++/10.2.0/bits/locale_facets.tcc" 3
+ const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
+
+ _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
+            * __len));
+ __ctype.widen(__cs, __cs + __len, __ws);
+
+
+ _CharT* __wp = 0;
+ const char* __p = char_traits<char>::find(__cs, __len, '.');
+ if (__p)
+   {
+     __wp = __ws + (__p - __cs);
+     *__wp = __lc->_M_decimal_point;
+   }
+
+
+
+
+ if (__lc->_M_use_grouping
+     && (__wp || __len < 3 || (__cs[1] <= '9' && __cs[2] <= '9'
+          && __cs[1] >= '0' && __cs[2] >= '0')))
+   {
+
+
+     _CharT* __ws2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
+          * __len * 2));
+
+     streamsize __off = 0;
+     if (__cs[0] == '-' || __cs[0] == '+')
+       {
+  __off = 1;
+  __ws2[0] = __ws[0];
+  __len -= 1;
+       }
+
+     _M_group_float(__lc->_M_grouping, __lc->_M_grouping_size,
+      __lc->_M_thousands_sep, __wp, __ws2 + __off,
+      __ws + __off, __len);
+     __len += __off;
+
+     __ws = __ws2;
+   }
+
+
+ const streamsize __w = __io.width();
+ if (__w > static_cast<streamsize>(__len))
+   {
+     _CharT* __ws3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
+          * __w));
+     _M_pad(__fill, __w, __io, __ws3, __ws, __len);
+     __ws = __ws3;
+   }
+ __io.width(0);
+
+
+
+ return std::__write(__s, __ws, __len);
+      }
+
+  template<typename _CharT, typename _OutIter>
+    _OutIter
+    num_put<_CharT, _OutIter>::
+    do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const
+    {
+      const ios_base::fmtflags __flags = __io.flags();
+      if ((__flags & ios_base::boolalpha) == 0)
+        {
+          const long __l = __v;
+          __s = _M_insert_int(__s, __io, __fill, __l);
+        }
+      else
+        {
+   typedef __numpunct_cache<_CharT> __cache_type;
+   __use_cache<__cache_type> __uc;
+   const locale& __loc = __io._M_getloc();
+   const __cache_type* __lc = __uc(__loc);
+
+   const _CharT* __name = __v ? __lc->_M_truename
+                              : __lc->_M_falsename;
+   int __len = __v ? __lc->_M_truename_size
+                   : __lc->_M_falsename_size;
+
+   const streamsize __w = __io.width();
+   if (__w > static_cast<streamsize>(__len))
+     {
+       const streamsize __plen = __w - __len;
+       _CharT* __ps
+  = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
+       * __plen));
+
+       char_traits<_CharT>::assign(__ps, __plen, __fill);
+       __io.width(0);
+
+       if ((__flags & ios_base::adjustfield) == ios_base::left)
+  {
+    __s = std::__write(__s, __name, __len);
+    __s = std::__write(__s, __ps, __plen);
+  }
+       else
+  {
+    __s = std::__write(__s, __ps, __plen);
+    __s = std::__write(__s, __name, __len);
+  }
+       return __s;
+     }
+   __io.width(0);
+   __s = std::__write(__s, __name, __len);
+ }
+      return __s;
+    }
+
+  template<typename _CharT, typename _OutIter>
+    _OutIter
+    num_put<_CharT, _OutIter>::
+    do_put(iter_type __s, ios_base& __io, char_type __fill, double __v) const
+    { return _M_insert_float(__s, __io, __fill, char(), __v); }
+# 1169 "/usr/include/c++/10.2.0/bits/locale_facets.tcc" 3
+  template<typename _CharT, typename _OutIter>
+    _OutIter
+    num_put<_CharT, _OutIter>::
+    do_put(iter_type __s, ios_base& __io, char_type __fill,
+    long double __v) const
+    { return _M_insert_float(__s, __io, __fill, 'L', __v); }
+
+  template<typename _CharT, typename _OutIter>
+    _OutIter
+    num_put<_CharT, _OutIter>::
+    do_put(iter_type __s, ios_base& __io, char_type __fill,
+           const void* __v) const
+    {
+      const ios_base::fmtflags __flags = __io.flags();
+      const ios_base::fmtflags __fmt = ~(ios_base::basefield
+      | ios_base::uppercase);
+      __io.flags((__flags & __fmt) | (ios_base::hex | ios_base::showbase));
+
+      typedef __gnu_cxx::__conditional_type<(sizeof(const void*)
+          <= sizeof(unsigned long)),
+ unsigned long, unsigned long long>::__type _UIntPtrType;
+
+      __s = _M_insert_int(__s, __io, __fill,
+     reinterpret_cast<_UIntPtrType>(__v));
+      __io.flags(__flags);
+      return __s;
+    }
+
+
+# 1206 "/usr/include/c++/10.2.0/bits/locale_facets.tcc" 3
+  template<typename _CharT, typename _Traits>
+    void
+    __pad<_CharT, _Traits>::_S_pad(ios_base& __io, _CharT __fill,
+       _CharT* __news, const _CharT* __olds,
+       streamsize __newlen, streamsize __oldlen)
+    {
+      const size_t __plen = static_cast<size_t>(__newlen - __oldlen);
+      const ios_base::fmtflags __adjust = __io.flags() & ios_base::adjustfield;
+
+
+      if (__adjust == ios_base::left)
+ {
+   _Traits::copy(__news, __olds, __oldlen);
+   _Traits::assign(__news + __oldlen, __plen, __fill);
+   return;
+ }
+
+      size_t __mod = 0;
+      if (__adjust == ios_base::internal)
+ {
+
+
+
+          const locale& __loc = __io._M_getloc();
+   const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
+
+   if (__ctype.widen('-') == __olds[0]
+       || __ctype.widen('+') == __olds[0])
+     {
+       __news[0] = __olds[0];
+       __mod = 1;
+       ++__news;
+     }
+   else if (__ctype.widen('0') == __olds[0]
+     && __oldlen > 1
+     && (__ctype.widen('x') == __olds[1]
+         || __ctype.widen('X') == __olds[1]))
+     {
+       __news[0] = __olds[0];
+       __news[1] = __olds[1];
+       __mod = 2;
+       __news += 2;
+     }
+
+ }
+      _Traits::assign(__news, __plen, __fill);
+      _Traits::copy(__news + __plen, __olds + __mod, __oldlen - __mod);
+    }
+
+  template<typename _CharT>
+    _CharT*
+    __add_grouping(_CharT* __s, _CharT __sep,
+     const char* __gbeg, size_t __gsize,
+     const _CharT* __first, const _CharT* __last)
+    {
+      size_t __idx = 0;
+      size_t __ctr = 0;
+
+      while (__last - __first > __gbeg[__idx]
+      && static_cast<signed char>(__gbeg[__idx]) > 0
+      && __gbeg[__idx] != __gnu_cxx::__numeric_traits<char>::__max)
+ {
+   __last -= __gbeg[__idx];
+   __idx < __gsize - 1 ? ++__idx : ++__ctr;
+ }
+
+      while (__first != __last)
+ *__s++ = *__first++;
+
+      while (__ctr--)
+ {
+   *__s++ = __sep;
+   for (char __i = __gbeg[__idx]; __i > 0; --__i)
+     *__s++ = *__first++;
+ }
+
+      while (__idx--)
+ {
+   *__s++ = __sep;
+   for (char __i = __gbeg[__idx]; __i > 0; --__i)
+     *__s++ = *__first++;
+ }
+
+      return __s;
+    }
+
+
+
+
+  extern template class __cxx11:: numpunct<char>;
+  extern template class __cxx11:: numpunct_byname<char>;
+  extern template class num_get<char>;
+  extern template class num_put<char>;
+  extern template class ctype_byname<char>;
+
+  extern template
+    const ctype<char>&
+    use_facet<ctype<char> >(const locale&);
+
+  extern template
+    const numpunct<char>&
+    use_facet<numpunct<char> >(const locale&);
+
+  extern template
+    const num_put<char>&
+    use_facet<num_put<char> >(const locale&);
+
+  extern template
+    const num_get<char>&
+    use_facet<num_get<char> >(const locale&);
+
+  extern template
+    bool
+    has_facet<ctype<char> >(const locale&);
+
+  extern template
+    bool
+    has_facet<numpunct<char> >(const locale&);
+
+  extern template
+    bool
+    has_facet<num_put<char> >(const locale&);
+
+  extern template
+    bool
+    has_facet<num_get<char> >(const locale&);
+
+
+  extern template class __cxx11:: numpunct<wchar_t>;
+  extern template class __cxx11:: numpunct_byname<wchar_t>;
+  extern template class num_get<wchar_t>;
+  extern template class num_put<wchar_t>;
+  extern template class ctype_byname<wchar_t>;
+
+  extern template
+    const ctype<wchar_t>&
+    use_facet<ctype<wchar_t> >(const locale&);
+
+  extern template
+    const numpunct<wchar_t>&
+    use_facet<numpunct<wchar_t> >(const locale&);
+
+  extern template
+    const num_put<wchar_t>&
+    use_facet<num_put<wchar_t> >(const locale&);
+
+  extern template
+    const num_get<wchar_t>&
+    use_facet<num_get<wchar_t> >(const locale&);
+
+ extern template
+    bool
+    has_facet<ctype<wchar_t> >(const locale&);
+
+  extern template
+    bool
+    has_facet<numpunct<wchar_t> >(const locale&);
+
+  extern template
+    bool
+    has_facet<num_put<wchar_t> >(const locale&);
+
+  extern template
+    bool
+    has_facet<num_get<wchar_t> >(const locale&);
+
+
+
+
+}
+# 2656 "/usr/include/c++/10.2.0/bits/locale_facets.h" 2 3
+# 38 "/usr/include/c++/10.2.0/bits/basic_ios.h" 2 3
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  template<typename _Facet>
+    inline const _Facet&
+    __check_facet(const _Facet* __f)
+    {
+      if (!__f)
+ __throw_bad_cast();
+      return *__f;
+    }
+# 66 "/usr/include/c++/10.2.0/bits/basic_ios.h" 3
+  template<typename _CharT, typename _Traits>
+    class basic_ios : public ios_base
+    {
+    public:
+
+
+
+
+
+
+      typedef _CharT char_type;
+      typedef typename _Traits::int_type int_type;
+      typedef typename _Traits::pos_type pos_type;
+      typedef typename _Traits::off_type off_type;
+      typedef _Traits traits_type;
+
+
+
+
+
+
+      typedef ctype<_CharT> __ctype_type;
+      typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> >
+           __num_put_type;
+      typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> >
+           __num_get_type;
+
+
+
+    protected:
+      basic_ostream<_CharT, _Traits>* _M_tie;
+      mutable char_type _M_fill;
+      mutable bool _M_fill_init;
+      basic_streambuf<_CharT, _Traits>* _M_streambuf;
+
+
+      const __ctype_type* _M_ctype;
+
+      const __num_put_type* _M_num_put;
+
+      const __num_get_type* _M_num_get;
+
+    public:
+# 117 "/usr/include/c++/10.2.0/bits/basic_ios.h" 3
+      explicit operator bool() const
+      { return !this->fail(); }
+
+
+
+
+
+      bool
+      operator!() const
+      { return this->fail(); }
+# 136 "/usr/include/c++/10.2.0/bits/basic_ios.h" 3
+      iostate
+      rdstate() const
+      { return _M_streambuf_state; }
+# 147 "/usr/include/c++/10.2.0/bits/basic_ios.h" 3
+      void
+      clear(iostate __state = goodbit);
+
+
+
+
+
+
+
+      void
+      setstate(iostate __state)
+      { this->clear(this->rdstate() | __state); }
+
+
+
+
+      void
+      _M_setstate(iostate __state)
+      {
+
+
+ _M_streambuf_state |= __state;
+ if (this->exceptions() & __state)
+   throw;
+      }
+
+
+
+
+
+
+
+      bool
+      good() const
+      { return this->rdstate() == 0; }
+
+
+
+
+
+
+
+      bool
+      eof() const
+      { return (this->rdstate() & eofbit) != 0; }
+# 200 "/usr/include/c++/10.2.0/bits/basic_ios.h" 3
+      bool
+      fail() const
+      { return (this->rdstate() & (badbit | failbit)) != 0; }
+
+
+
+
+
+
+
+      bool
+      bad() const
+      { return (this->rdstate() & badbit) != 0; }
+# 221 "/usr/include/c++/10.2.0/bits/basic_ios.h" 3
+      iostate
+      exceptions() const
+      { return _M_exception; }
+# 256 "/usr/include/c++/10.2.0/bits/basic_ios.h" 3
+      void
+      exceptions(iostate __except)
+      {
+        _M_exception = __except;
+        this->clear(_M_streambuf_state);
+      }
+
+
+
+
+
+
+
+      explicit
+      basic_ios(basic_streambuf<_CharT, _Traits>* __sb)
+      : ios_base(), _M_tie(0), _M_fill(), _M_fill_init(false), _M_streambuf(0),
+ _M_ctype(0), _M_num_put(0), _M_num_get(0)
+      { this->init(__sb); }
+
+
+
+
+
+
+
+      virtual
+      ~basic_ios() { }
+# 294 "/usr/include/c++/10.2.0/bits/basic_ios.h" 3
+      basic_ostream<_CharT, _Traits>*
+      tie() const
+      { return _M_tie; }
+# 306 "/usr/include/c++/10.2.0/bits/basic_ios.h" 3
+      basic_ostream<_CharT, _Traits>*
+      tie(basic_ostream<_CharT, _Traits>* __tiestr)
+      {
+        basic_ostream<_CharT, _Traits>* __old = _M_tie;
+        _M_tie = __tiestr;
+        return __old;
+      }
+
+
+
+
+
+
+
+      basic_streambuf<_CharT, _Traits>*
+      rdbuf() const
+      { return _M_streambuf; }
+# 346 "/usr/include/c++/10.2.0/bits/basic_ios.h" 3
+      basic_streambuf<_CharT, _Traits>*
+      rdbuf(basic_streambuf<_CharT, _Traits>* __sb);
+# 360 "/usr/include/c++/10.2.0/bits/basic_ios.h" 3
+      basic_ios&
+      copyfmt(const basic_ios& __rhs);
+
+
+
+
+
+
+
+      char_type
+      fill() const
+      {
+ if (!_M_fill_init)
+   {
+     _M_fill = this->widen(' ');
+     _M_fill_init = true;
+   }
+ return _M_fill;
+      }
+# 389 "/usr/include/c++/10.2.0/bits/basic_ios.h" 3
+      char_type
+      fill(char_type __ch)
+      {
+ char_type __old = this->fill();
+ _M_fill = __ch;
+ return __old;
+      }
+# 409 "/usr/include/c++/10.2.0/bits/basic_ios.h" 3
+      locale
+      imbue(const locale& __loc);
+# 429 "/usr/include/c++/10.2.0/bits/basic_ios.h" 3
+      char
+      narrow(char_type __c, char __dfault) const
+      { return __check_facet(_M_ctype).narrow(__c, __dfault); }
+# 448 "/usr/include/c++/10.2.0/bits/basic_ios.h" 3
+      char_type
+      widen(char __c) const
+      { return __check_facet(_M_ctype).widen(__c); }
+
+    protected:
+
+
+
+
+
+
+
+      basic_ios()
+      : ios_base(), _M_tie(0), _M_fill(char_type()), _M_fill_init(false),
+ _M_streambuf(0), _M_ctype(0), _M_num_put(0), _M_num_get(0)
+      { }
+
+
+
+
+
+
+
+      void
+      init(basic_streambuf<_CharT, _Traits>* __sb);
+
+
+      basic_ios(const basic_ios&) = delete;
+      basic_ios& operator=(const basic_ios&) = delete;
+
+      void
+      move(basic_ios& __rhs)
+      {
+ ios_base::_M_move(__rhs);
+ _M_cache_locale(_M_ios_locale);
+ this->tie(__rhs.tie(nullptr));
+ _M_fill = __rhs._M_fill;
+ _M_fill_init = __rhs._M_fill_init;
+ _M_streambuf = nullptr;
+      }
+
+      void
+      move(basic_ios&& __rhs)
+      { this->move(__rhs); }
+
+      void
+      swap(basic_ios& __rhs) noexcept
+      {
+ ios_base::_M_swap(__rhs);
+ _M_cache_locale(_M_ios_locale);
+ __rhs._M_cache_locale(__rhs._M_ios_locale);
+ std::swap(_M_tie, __rhs._M_tie);
+ std::swap(_M_fill, __rhs._M_fill);
+ std::swap(_M_fill_init, __rhs._M_fill_init);
+      }
+
+      void
+      set_rdbuf(basic_streambuf<_CharT, _Traits>* __sb)
+      { _M_streambuf = __sb; }
+
+
+      void
+      _M_cache_locale(const locale& __loc);
+    };
+
+
+}
+
+# 1 "/usr/include/c++/10.2.0/bits/basic_ios.tcc" 1 3
+# 31 "/usr/include/c++/10.2.0/bits/basic_ios.tcc" 3
+#define _BASIC_IOS_TCC 1
+
+       
+# 34 "/usr/include/c++/10.2.0/bits/basic_ios.tcc" 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  template<typename _CharT, typename _Traits>
+    void
+    basic_ios<_CharT, _Traits>::clear(iostate __state)
+    {
+      if (this->rdbuf())
+ _M_streambuf_state = __state;
+      else
+   _M_streambuf_state = __state | badbit;
+      if (this->exceptions() & this->rdstate())
+ __throw_ios_failure(("basic_ios::clear"));
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_streambuf<_CharT, _Traits>*
+    basic_ios<_CharT, _Traits>::rdbuf(basic_streambuf<_CharT, _Traits>* __sb)
+    {
+      basic_streambuf<_CharT, _Traits>* __old = _M_streambuf;
+      _M_streambuf = __sb;
+      this->clear();
+      return __old;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_ios<_CharT, _Traits>&
+    basic_ios<_CharT, _Traits>::copyfmt(const basic_ios& __rhs)
+    {
+
+
+      if (this != &__rhs)
+ {
+
+
+
+
+   _Words* __words = (__rhs._M_word_size <= _S_local_word_size) ?
+                      _M_local_word : new _Words[__rhs._M_word_size];
+
+
+   _Callback_list* __cb = __rhs._M_callbacks;
+   if (__cb)
+     __cb->_M_add_reference();
+   _M_call_callbacks(erase_event);
+   if (_M_word != _M_local_word)
+     {
+       delete [] _M_word;
+       _M_word = 0;
+     }
+   _M_dispose_callbacks();
+
+
+   _M_callbacks = __cb;
+   for (int __i = 0; __i < __rhs._M_word_size; ++__i)
+     __words[__i] = __rhs._M_word[__i];
+   _M_word = __words;
+   _M_word_size = __rhs._M_word_size;
+
+   this->flags(__rhs.flags());
+   this->width(__rhs.width());
+   this->precision(__rhs.precision());
+   this->tie(__rhs.tie());
+   this->fill(__rhs.fill());
+   _M_ios_locale = __rhs.getloc();
+   _M_cache_locale(_M_ios_locale);
+
+   _M_call_callbacks(copyfmt_event);
+
+
+   this->exceptions(__rhs.exceptions());
+ }
+      return *this;
+    }
+
+
+  template<typename _CharT, typename _Traits>
+    locale
+    basic_ios<_CharT, _Traits>::imbue(const locale& __loc)
+    {
+      locale __old(this->getloc());
+      ios_base::imbue(__loc);
+      _M_cache_locale(__loc);
+      if (this->rdbuf() != 0)
+ this->rdbuf()->pubimbue(__loc);
+      return __old;
+    }
+
+  template<typename _CharT, typename _Traits>
+    void
+    basic_ios<_CharT, _Traits>::init(basic_streambuf<_CharT, _Traits>* __sb)
+    {
+
+      ios_base::_M_init();
+
+
+      _M_cache_locale(_M_ios_locale);
+# 146 "/usr/include/c++/10.2.0/bits/basic_ios.tcc" 3
+      _M_fill = _CharT();
+      _M_fill_init = false;
+
+      _M_tie = 0;
+      _M_exception = goodbit;
+      _M_streambuf = __sb;
+      _M_streambuf_state = __sb ? goodbit : badbit;
+    }
+
+  template<typename _CharT, typename _Traits>
+    void
+    basic_ios<_CharT, _Traits>::_M_cache_locale(const locale& __loc)
+    {
+      if (__builtin_expect(has_facet<__ctype_type>(__loc), true))
+ _M_ctype = std::__addressof(use_facet<__ctype_type>(__loc));
+      else
+ _M_ctype = 0;
+
+      if (__builtin_expect(has_facet<__num_put_type>(__loc), true))
+ _M_num_put = std::__addressof(use_facet<__num_put_type>(__loc));
+      else
+ _M_num_put = 0;
+
+      if (__builtin_expect(has_facet<__num_get_type>(__loc), true))
+ _M_num_get = std::__addressof(use_facet<__num_get_type>(__loc));
+      else
+ _M_num_get = 0;
+    }
+
+
+
+
+  extern template class basic_ios<char>;
+
+
+  extern template class basic_ios<wchar_t>;
+
+
+
+
+}
+# 517 "/usr/include/c++/10.2.0/bits/basic_ios.h" 2 3
+# 45 "/usr/include/c++/10.2.0/ios" 2 3
+# 39 "/usr/include/c++/10.2.0/ostream" 2 3
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 57 "/usr/include/c++/10.2.0/ostream" 3
+  template<typename _CharT, typename _Traits>
+    class basic_ostream : virtual public basic_ios<_CharT, _Traits>
+    {
+    public:
+
+      typedef _CharT char_type;
+      typedef typename _Traits::int_type int_type;
+      typedef typename _Traits::pos_type pos_type;
+      typedef typename _Traits::off_type off_type;
+      typedef _Traits traits_type;
+
+
+      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
+      typedef basic_ios<_CharT, _Traits> __ios_type;
+      typedef basic_ostream<_CharT, _Traits> __ostream_type;
+      typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> >
+             __num_put_type;
+      typedef ctype<_CharT> __ctype_type;
+# 83 "/usr/include/c++/10.2.0/ostream" 3
+      explicit
+      basic_ostream(__streambuf_type* __sb)
+      { this->init(__sb); }
+
+
+
+
+
+
+      virtual
+      ~basic_ostream() { }
+
+
+      class sentry;
+      friend class sentry;
+# 107 "/usr/include/c++/10.2.0/ostream" 3
+      __ostream_type&
+      operator<<(__ostream_type& (*__pf)(__ostream_type&))
+      {
+
+
+
+ return __pf(*this);
+      }
+
+      __ostream_type&
+      operator<<(__ios_type& (*__pf)(__ios_type&))
+      {
+
+
+
+ __pf(*this);
+ return *this;
+      }
+
+      __ostream_type&
+      operator<<(ios_base& (*__pf) (ios_base&))
+      {
+
+
+
+ __pf(*this);
+ return *this;
+      }
+# 165 "/usr/include/c++/10.2.0/ostream" 3
+      __ostream_type&
+      operator<<(long __n)
+      { return _M_insert(__n); }
+
+      __ostream_type&
+      operator<<(unsigned long __n)
+      { return _M_insert(__n); }
+
+      __ostream_type&
+      operator<<(bool __n)
+      { return _M_insert(__n); }
+
+      __ostream_type&
+      operator<<(short __n);
+
+      __ostream_type&
+      operator<<(unsigned short __n)
+      {
+
+
+ return _M_insert(static_cast<unsigned long>(__n));
+      }
+
+      __ostream_type&
+      operator<<(int __n);
+
+      __ostream_type&
+      operator<<(unsigned int __n)
+      {
+
+
+ return _M_insert(static_cast<unsigned long>(__n));
+      }
+
+
+      __ostream_type&
+      operator<<(long long __n)
+      { return _M_insert(__n); }
+
+      __ostream_type&
+      operator<<(unsigned long long __n)
+      { return _M_insert(__n); }
+# 219 "/usr/include/c++/10.2.0/ostream" 3
+      __ostream_type&
+      operator<<(double __f)
+      { return _M_insert(__f); }
+
+      __ostream_type&
+      operator<<(float __f)
+      {
+
+
+ return _M_insert(static_cast<double>(__f));
+      }
+
+      __ostream_type&
+      operator<<(long double __f)
+      { return _M_insert(__f); }
+# 244 "/usr/include/c++/10.2.0/ostream" 3
+      __ostream_type&
+      operator<<(const void* __p)
+      { return _M_insert(__p); }
+
+
+      __ostream_type&
+      operator<<(nullptr_t)
+      { return *this << "nullptr"; }
+# 275 "/usr/include/c++/10.2.0/ostream" 3
+      __ostream_type&
+      operator<<(__streambuf_type* __sb);
+# 308 "/usr/include/c++/10.2.0/ostream" 3
+      __ostream_type&
+      put(char_type __c);
+
+
+
+
+
+
+      void
+      _M_write(const char_type* __s, streamsize __n)
+      {
+ const streamsize __put = this->rdbuf()->sputn(__s, __n);
+ if (__put != __n)
+   this->setstate(ios_base::badbit);
+      }
+# 340 "/usr/include/c++/10.2.0/ostream" 3
+      __ostream_type&
+      write(const char_type* __s, streamsize __n);
+# 353 "/usr/include/c++/10.2.0/ostream" 3
+      __ostream_type&
+      flush();
+# 363 "/usr/include/c++/10.2.0/ostream" 3
+      pos_type
+      tellp();
+# 374 "/usr/include/c++/10.2.0/ostream" 3
+      __ostream_type&
+      seekp(pos_type);
+# 386 "/usr/include/c++/10.2.0/ostream" 3
+       __ostream_type&
+      seekp(off_type, ios_base::seekdir);
+
+    protected:
+      basic_ostream()
+      { this->init(0); }
+
+
+
+      basic_ostream(basic_iostream<_CharT, _Traits>&) { }
+
+      basic_ostream(const basic_ostream&) = delete;
+
+      basic_ostream(basic_ostream&& __rhs)
+      : __ios_type()
+      { __ios_type::move(__rhs); }
+
+
+
+      basic_ostream& operator=(const basic_ostream&) = delete;
+
+      basic_ostream&
+      operator=(basic_ostream&& __rhs)
+      {
+ swap(__rhs);
+ return *this;
+      }
+
+      void
+      swap(basic_ostream& __rhs)
+      { __ios_type::swap(__rhs); }
+
+
+      template<typename _ValueT>
+ __ostream_type&
+ _M_insert(_ValueT __v);
+    };
+# 431 "/usr/include/c++/10.2.0/ostream" 3
+  template <typename _CharT, typename _Traits>
+    class basic_ostream<_CharT, _Traits>::sentry
+    {
+
+      bool _M_ok;
+      basic_ostream<_CharT, _Traits>& _M_os;
+
+    public:
+# 450 "/usr/include/c++/10.2.0/ostream" 3
+      explicit
+      sentry(basic_ostream<_CharT, _Traits>& __os);
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+
+
+
+
+
+
+      ~sentry()
+      {
+
+ if (bool(_M_os.flags() & ios_base::unitbuf) && !uncaught_exception())
+   {
+
+     if (_M_os.rdbuf() && _M_os.rdbuf()->pubsync() == -1)
+       _M_os.setstate(ios_base::badbit);
+   }
+      }
+#pragma GCC diagnostic pop
+# 482 "/usr/include/c++/10.2.0/ostream" 3
+      explicit
+
+      operator bool() const
+      { return _M_ok; }
+    };
+# 504 "/usr/include/c++/10.2.0/ostream" 3
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c)
+    { return __ostream_insert(__out, &__c, 1); }
+
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __out, char __c)
+    { return (__out << __out.widen(__c)); }
+
+
+  template<typename _Traits>
+    inline basic_ostream<char, _Traits>&
+    operator<<(basic_ostream<char, _Traits>& __out, char __c)
+    { return __ostream_insert(__out, &__c, 1); }
+
+
+  template<typename _Traits>
+    inline basic_ostream<char, _Traits>&
+    operator<<(basic_ostream<char, _Traits>& __out, signed char __c)
+    { return (__out << static_cast<char>(__c)); }
+
+  template<typename _Traits>
+    inline basic_ostream<char, _Traits>&
+    operator<<(basic_ostream<char, _Traits>& __out, unsigned char __c)
+    { return (__out << static_cast<char>(__c)); }
+# 587 "/usr/include/c++/10.2.0/ostream" 3
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s)
+    {
+      if (!__s)
+ __out.setstate(ios_base::badbit);
+      else
+ __ostream_insert(__out, __s,
+    static_cast<streamsize>(_Traits::length(__s)));
+      return __out;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits> &
+    operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s);
+
+
+  template<typename _Traits>
+    inline basic_ostream<char, _Traits>&
+    operator<<(basic_ostream<char, _Traits>& __out, const char* __s)
+    {
+      if (!__s)
+ __out.setstate(ios_base::badbit);
+      else
+ __ostream_insert(__out, __s,
+    static_cast<streamsize>(_Traits::length(__s)));
+      return __out;
+    }
+
+
+  template<typename _Traits>
+    inline basic_ostream<char, _Traits>&
+    operator<<(basic_ostream<char, _Traits>& __out, const signed char* __s)
+    { return (__out << reinterpret_cast<const char*>(__s)); }
+
+  template<typename _Traits>
+    inline basic_ostream<char, _Traits> &
+    operator<<(basic_ostream<char, _Traits>& __out, const unsigned char* __s)
+    { return (__out << reinterpret_cast<const char*>(__s)); }
+# 679 "/usr/include/c++/10.2.0/ostream" 3
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>&
+    endl(basic_ostream<_CharT, _Traits>& __os)
+    { return flush(__os.put(__os.widen('\n'))); }
+# 691 "/usr/include/c++/10.2.0/ostream" 3
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>&
+    ends(basic_ostream<_CharT, _Traits>& __os)
+    { return __os.put(_CharT()); }
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>&
+    flush(basic_ostream<_CharT, _Traits>& __os)
+    { return __os.flush(); }
+
+
+  template<typename _Ch, typename _Up>
+    basic_ostream<_Ch, _Up>&
+    __is_convertible_to_basic_ostream_test(basic_ostream<_Ch, _Up>*);
+
+  template<typename _Tp, typename = void>
+    struct __is_convertible_to_basic_ostream_impl
+    {
+      using __ostream_type = void;
+    };
+
+  template<typename _Tp>
+    using __do_is_convertible_to_basic_ostream_impl =
+    decltype(__is_convertible_to_basic_ostream_test
+      (declval<typename remove_reference<_Tp>::type*>()));
+
+  template<typename _Tp>
+    struct __is_convertible_to_basic_ostream_impl
+    <_Tp,
+     __void_t<__do_is_convertible_to_basic_ostream_impl<_Tp>>>
+    {
+      using __ostream_type =
+ __do_is_convertible_to_basic_ostream_impl<_Tp>;
+    };
+
+  template<typename _Tp>
+    struct __is_convertible_to_basic_ostream
+    : __is_convertible_to_basic_ostream_impl<_Tp>
+    {
+    public:
+      using type = __not_<is_void<
+        typename __is_convertible_to_basic_ostream_impl<_Tp>::__ostream_type>>;
+      constexpr static bool value = type::value;
+    };
+
+  template<typename _Ostream, typename _Tp, typename = void>
+    struct __is_insertable : false_type {};
+
+  template<typename _Ostream, typename _Tp>
+    struct __is_insertable<_Ostream, _Tp,
+      __void_t<decltype(declval<_Ostream&>()
+          << declval<const _Tp&>())>>
+        : true_type {};
+
+  template<typename _Ostream>
+    using __rvalue_ostream_type =
+      typename __is_convertible_to_basic_ostream<
+ _Ostream>::__ostream_type;
+# 765 "/usr/include/c++/10.2.0/ostream" 3
+  template<typename _Ostream, typename _Tp>
+    inline
+    typename enable_if<__and_<__not_<is_lvalue_reference<_Ostream>>,
+         __is_convertible_to_basic_ostream<_Ostream>,
+         __is_insertable<
+    __rvalue_ostream_type<_Ostream>,
+    const _Tp&>>::value,
+         __rvalue_ostream_type<_Ostream>>::type
+    operator<<(_Ostream&& __os, const _Tp& __x)
+    {
+      __rvalue_ostream_type<_Ostream> __ret_os = __os;
+      __ret_os << __x;
+      return __ret_os;
+    }
+
+
+
+}
+
+# 1 "/usr/include/c++/10.2.0/bits/ostream.tcc" 1 3
+# 35 "/usr/include/c++/10.2.0/bits/ostream.tcc" 3
+#define _OSTREAM_TCC 1
+
+       
+# 38 "/usr/include/c++/10.2.0/bits/ostream.tcc" 3
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>::sentry::
+    sentry(basic_ostream<_CharT, _Traits>& __os)
+    : _M_ok(false), _M_os(__os)
+    {
+
+      if (__os.tie() && __os.good())
+ __os.tie()->flush();
+
+      if (__os.good())
+ _M_ok = true;
+      else
+ __os.setstate(ios_base::failbit);
+    }
+
+  template<typename _CharT, typename _Traits>
+    template<typename _ValueT>
+      basic_ostream<_CharT, _Traits>&
+      basic_ostream<_CharT, _Traits>::
+      _M_insert(_ValueT __v)
+      {
+ sentry __cerb(*this);
+ if (__cerb)
+   {
+     ios_base::iostate __err = ios_base::goodbit;
+     try
+       {
+  const __num_put_type& __np = __check_facet(this->_M_num_put);
+  if (__np.put(*this, *this, this->fill(), __v).failed())
+    __err |= ios_base::badbit;
+       }
+     catch(__cxxabiv1::__forced_unwind&)
+       {
+  this->_M_setstate(ios_base::badbit);
+  throw;
+       }
+     catch(...)
+       { this->_M_setstate(ios_base::badbit); }
+     if (__err)
+       this->setstate(__err);
+   }
+ return *this;
+      }
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    basic_ostream<_CharT, _Traits>::
+    operator<<(short __n)
+    {
+
+
+      const ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
+      if (__fmt == ios_base::oct || __fmt == ios_base::hex)
+ return _M_insert(static_cast<long>(static_cast<unsigned short>(__n)));
+      else
+ return _M_insert(static_cast<long>(__n));
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    basic_ostream<_CharT, _Traits>::
+    operator<<(int __n)
+    {
+
+
+      const ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
+      if (__fmt == ios_base::oct || __fmt == ios_base::hex)
+ return _M_insert(static_cast<long>(static_cast<unsigned int>(__n)));
+      else
+ return _M_insert(static_cast<long>(__n));
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    basic_ostream<_CharT, _Traits>::
+    operator<<(__streambuf_type* __sbin)
+    {
+      ios_base::iostate __err = ios_base::goodbit;
+      sentry __cerb(*this);
+      if (__cerb && __sbin)
+ {
+   try
+     {
+       if (!__copy_streambufs(__sbin, this->rdbuf()))
+  __err |= ios_base::failbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::failbit); }
+ }
+      else if (!__sbin)
+ __err |= ios_base::badbit;
+      if (__err)
+ this->setstate(__err);
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    basic_ostream<_CharT, _Traits>::
+    put(char_type __c)
+    {
+
+
+
+
+
+
+      sentry __cerb(*this);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       const int_type __put = this->rdbuf()->sputc(__c);
+       if (traits_type::eq_int_type(__put, traits_type::eof()))
+  __err |= ios_base::badbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    basic_ostream<_CharT, _Traits>::
+    write(const _CharT* __s, streamsize __n)
+    {
+
+
+
+
+
+
+
+      sentry __cerb(*this);
+      if (__cerb)
+ {
+   try
+     { _M_write(__s, __n); }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+ }
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    basic_ostream<_CharT, _Traits>::
+    flush()
+    {
+
+
+
+      ios_base::iostate __err = ios_base::goodbit;
+      try
+ {
+   if (this->rdbuf() && this->rdbuf()->pubsync() == -1)
+     __err |= ios_base::badbit;
+ }
+      catch(__cxxabiv1::__forced_unwind&)
+ {
+   this->_M_setstate(ios_base::badbit);
+   throw;
+ }
+      catch(...)
+ { this->_M_setstate(ios_base::badbit); }
+      if (__err)
+ this->setstate(__err);
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    typename basic_ostream<_CharT, _Traits>::pos_type
+    basic_ostream<_CharT, _Traits>::
+    tellp()
+    {
+      pos_type __ret = pos_type(-1);
+      try
+ {
+   if (!this->fail())
+     __ret = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::out);
+ }
+      catch(__cxxabiv1::__forced_unwind&)
+ {
+   this->_M_setstate(ios_base::badbit);
+   throw;
+ }
+      catch(...)
+ { this->_M_setstate(ios_base::badbit); }
+      return __ret;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    basic_ostream<_CharT, _Traits>::
+    seekp(pos_type __pos)
+    {
+      ios_base::iostate __err = ios_base::goodbit;
+      try
+ {
+   if (!this->fail())
+     {
+
+
+       const pos_type __p = this->rdbuf()->pubseekpos(__pos,
+            ios_base::out);
+
+
+       if (__p == pos_type(off_type(-1)))
+  __err |= ios_base::failbit;
+     }
+ }
+      catch(__cxxabiv1::__forced_unwind&)
+ {
+   this->_M_setstate(ios_base::badbit);
+   throw;
+ }
+      catch(...)
+ { this->_M_setstate(ios_base::badbit); }
+      if (__err)
+ this->setstate(__err);
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    basic_ostream<_CharT, _Traits>::
+    seekp(off_type __off, ios_base::seekdir __dir)
+    {
+      ios_base::iostate __err = ios_base::goodbit;
+      try
+ {
+   if (!this->fail())
+     {
+
+
+       const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
+            ios_base::out);
+
+
+       if (__p == pos_type(off_type(-1)))
+  __err |= ios_base::failbit;
+     }
+ }
+      catch(__cxxabiv1::__forced_unwind&)
+ {
+   this->_M_setstate(ios_base::badbit);
+   throw;
+ }
+      catch(...)
+ { this->_M_setstate(ios_base::badbit); }
+      if (__err)
+ this->setstate(__err);
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s)
+    {
+      if (!__s)
+ __out.setstate(ios_base::badbit);
+      else
+ {
+
+
+   const size_t __clen = char_traits<char>::length(__s);
+   try
+     {
+       struct __ptr_guard
+       {
+  _CharT *__p;
+  __ptr_guard (_CharT *__ip): __p(__ip) { }
+  ~__ptr_guard() { delete[] __p; }
+  _CharT* __get() { return __p; }
+       } __pg (new _CharT[__clen]);
+
+       _CharT *__ws = __pg.__get();
+       for (size_t __i = 0; __i < __clen; ++__i)
+  __ws[__i] = __out.widen(__s[__i]);
+       __ostream_insert(__out, __ws, __clen);
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       __out._M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { __out._M_setstate(ios_base::badbit); }
+ }
+      return __out;
+    }
+
+
+
+
+  extern template class basic_ostream<char>;
+  extern template ostream& endl(ostream&);
+  extern template ostream& ends(ostream&);
+  extern template ostream& flush(ostream&);
+  extern template ostream& operator<<(ostream&, char);
+  extern template ostream& operator<<(ostream&, unsigned char);
+  extern template ostream& operator<<(ostream&, signed char);
+  extern template ostream& operator<<(ostream&, const char*);
+  extern template ostream& operator<<(ostream&, const unsigned char*);
+  extern template ostream& operator<<(ostream&, const signed char*);
+
+  extern template ostream& ostream::_M_insert(long);
+  extern template ostream& ostream::_M_insert(unsigned long);
+  extern template ostream& ostream::_M_insert(bool);
+
+  extern template ostream& ostream::_M_insert(long long);
+  extern template ostream& ostream::_M_insert(unsigned long long);
+
+  extern template ostream& ostream::_M_insert(double);
+  extern template ostream& ostream::_M_insert(long double);
+  extern template ostream& ostream::_M_insert(const void*);
+
+
+  extern template class basic_ostream<wchar_t>;
+  extern template wostream& endl(wostream&);
+  extern template wostream& ends(wostream&);
+  extern template wostream& flush(wostream&);
+  extern template wostream& operator<<(wostream&, wchar_t);
+  extern template wostream& operator<<(wostream&, char);
+  extern template wostream& operator<<(wostream&, const wchar_t*);
+  extern template wostream& operator<<(wostream&, const char*);
+
+  extern template wostream& wostream::_M_insert(long);
+  extern template wostream& wostream::_M_insert(unsigned long);
+  extern template wostream& wostream::_M_insert(bool);
+
+  extern template wostream& wostream::_M_insert(long long);
+  extern template wostream& wostream::_M_insert(unsigned long long);
+
+  extern template wostream& wostream::_M_insert(double);
+  extern template wostream& wostream::_M_insert(long double);
+  extern template wostream& wostream::_M_insert(const void*);
+
+
+
+
+}
+# 785 "/usr/include/c++/10.2.0/ostream" 2 3
+# 40 "/usr/include/c++/10.2.0/iostream" 2 3
+# 1 "/usr/include/c++/10.2.0/istream" 1 3
+# 34 "/usr/include/c++/10.2.0/istream" 3
+#define _GLIBCXX_ISTREAM 1
+
+       
+# 37 "/usr/include/c++/10.2.0/istream" 3
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 57 "/usr/include/c++/10.2.0/istream" 3
+  template<typename _CharT, typename _Traits>
+    class basic_istream : virtual public basic_ios<_CharT, _Traits>
+    {
+    public:
+
+      typedef _CharT char_type;
+      typedef typename _Traits::int_type int_type;
+      typedef typename _Traits::pos_type pos_type;
+      typedef typename _Traits::off_type off_type;
+      typedef _Traits traits_type;
+
+
+      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
+      typedef basic_ios<_CharT, _Traits> __ios_type;
+      typedef basic_istream<_CharT, _Traits> __istream_type;
+      typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> >
+        __num_get_type;
+      typedef ctype<_CharT> __ctype_type;
+
+    protected:
+
+
+
+
+
+      streamsize _M_gcount;
+
+    public:
+
+
+
+
+
+
+
+      explicit
+      basic_istream(__streambuf_type* __sb)
+      : _M_gcount(streamsize(0))
+      { this->init(__sb); }
+
+
+
+
+
+
+      virtual
+      ~basic_istream()
+      { _M_gcount = streamsize(0); }
+
+
+      class sentry;
+      friend class sentry;
+# 119 "/usr/include/c++/10.2.0/istream" 3
+      __istream_type&
+      operator>>(__istream_type& (*__pf)(__istream_type&))
+      { return __pf(*this); }
+
+      __istream_type&
+      operator>>(__ios_type& (*__pf)(__ios_type&))
+      {
+ __pf(*this);
+ return *this;
+      }
+
+      __istream_type&
+      operator>>(ios_base& (*__pf)(ios_base&))
+      {
+ __pf(*this);
+ return *this;
+      }
+# 167 "/usr/include/c++/10.2.0/istream" 3
+      __istream_type&
+      operator>>(bool& __n)
+      { return _M_extract(__n); }
+
+      __istream_type&
+      operator>>(short& __n);
+
+      __istream_type&
+      operator>>(unsigned short& __n)
+      { return _M_extract(__n); }
+
+      __istream_type&
+      operator>>(int& __n);
+
+      __istream_type&
+      operator>>(unsigned int& __n)
+      { return _M_extract(__n); }
+
+      __istream_type&
+      operator>>(long& __n)
+      { return _M_extract(__n); }
+
+      __istream_type&
+      operator>>(unsigned long& __n)
+      { return _M_extract(__n); }
+
+
+      __istream_type&
+      operator>>(long long& __n)
+      { return _M_extract(__n); }
+
+      __istream_type&
+      operator>>(unsigned long long& __n)
+      { return _M_extract(__n); }
+# 213 "/usr/include/c++/10.2.0/istream" 3
+      __istream_type&
+      operator>>(float& __f)
+      { return _M_extract(__f); }
+
+      __istream_type&
+      operator>>(double& __f)
+      { return _M_extract(__f); }
+
+      __istream_type&
+      operator>>(long double& __f)
+      { return _M_extract(__f); }
+# 234 "/usr/include/c++/10.2.0/istream" 3
+      __istream_type&
+      operator>>(void*& __p)
+      { return _M_extract(__p); }
+# 258 "/usr/include/c++/10.2.0/istream" 3
+      __istream_type&
+      operator>>(__streambuf_type* __sb);
+# 268 "/usr/include/c++/10.2.0/istream" 3
+      streamsize
+      gcount() const
+      { return _M_gcount; }
+# 301 "/usr/include/c++/10.2.0/istream" 3
+      int_type
+      get();
+# 315 "/usr/include/c++/10.2.0/istream" 3
+      __istream_type&
+      get(char_type& __c);
+# 342 "/usr/include/c++/10.2.0/istream" 3
+      __istream_type&
+      get(char_type* __s, streamsize __n, char_type __delim);
+# 353 "/usr/include/c++/10.2.0/istream" 3
+      __istream_type&
+      get(char_type* __s, streamsize __n)
+      { return this->get(__s, __n, this->widen('\n')); }
+# 376 "/usr/include/c++/10.2.0/istream" 3
+      __istream_type&
+      get(__streambuf_type& __sb, char_type __delim);
+# 386 "/usr/include/c++/10.2.0/istream" 3
+      __istream_type&
+      get(__streambuf_type& __sb)
+      { return this->get(__sb, this->widen('\n')); }
+# 415 "/usr/include/c++/10.2.0/istream" 3
+      __istream_type&
+      getline(char_type* __s, streamsize __n, char_type __delim);
+# 426 "/usr/include/c++/10.2.0/istream" 3
+      __istream_type&
+      getline(char_type* __s, streamsize __n)
+      { return this->getline(__s, __n, this->widen('\n')); }
+# 450 "/usr/include/c++/10.2.0/istream" 3
+      __istream_type&
+      ignore(streamsize __n, int_type __delim);
+
+      __istream_type&
+      ignore(streamsize __n);
+
+      __istream_type&
+      ignore();
+# 467 "/usr/include/c++/10.2.0/istream" 3
+      int_type
+      peek();
+# 485 "/usr/include/c++/10.2.0/istream" 3
+      __istream_type&
+      read(char_type* __s, streamsize __n);
+# 504 "/usr/include/c++/10.2.0/istream" 3
+      streamsize
+      readsome(char_type* __s, streamsize __n);
+# 521 "/usr/include/c++/10.2.0/istream" 3
+      __istream_type&
+      putback(char_type __c);
+# 537 "/usr/include/c++/10.2.0/istream" 3
+      __istream_type&
+      unget();
+# 555 "/usr/include/c++/10.2.0/istream" 3
+      int
+      sync();
+# 570 "/usr/include/c++/10.2.0/istream" 3
+      pos_type
+      tellg();
+# 585 "/usr/include/c++/10.2.0/istream" 3
+      __istream_type&
+      seekg(pos_type);
+# 601 "/usr/include/c++/10.2.0/istream" 3
+      __istream_type&
+      seekg(off_type, ios_base::seekdir);
+
+
+    protected:
+      basic_istream()
+      : _M_gcount(streamsize(0))
+      { this->init(0); }
+
+
+      basic_istream(const basic_istream&) = delete;
+
+      basic_istream(basic_istream&& __rhs)
+      : __ios_type(), _M_gcount(__rhs._M_gcount)
+      {
+ __ios_type::move(__rhs);
+ __rhs._M_gcount = 0;
+      }
+
+
+
+      basic_istream& operator=(const basic_istream&) = delete;
+
+      basic_istream&
+      operator=(basic_istream&& __rhs)
+      {
+ swap(__rhs);
+ return *this;
+      }
+
+      void
+      swap(basic_istream& __rhs)
+      {
+ __ios_type::swap(__rhs);
+ std::swap(_M_gcount, __rhs._M_gcount);
+      }
+
+
+      template<typename _ValueT>
+ __istream_type&
+ _M_extract(_ValueT& __v);
+    };
+
+
+  template<>
+    basic_istream<char>&
+    basic_istream<char>::
+    getline(char_type* __s, streamsize __n, char_type __delim);
+
+  template<>
+    basic_istream<char>&
+    basic_istream<char>::
+    ignore(streamsize __n);
+
+  template<>
+    basic_istream<char>&
+    basic_istream<char>::
+    ignore(streamsize __n, int_type __delim);
+
+
+  template<>
+    basic_istream<wchar_t>&
+    basic_istream<wchar_t>::
+    getline(char_type* __s, streamsize __n, char_type __delim);
+
+  template<>
+    basic_istream<wchar_t>&
+    basic_istream<wchar_t>::
+    ignore(streamsize __n);
+
+  template<>
+    basic_istream<wchar_t>&
+    basic_istream<wchar_t>::
+    ignore(streamsize __n, int_type __delim);
+# 685 "/usr/include/c++/10.2.0/istream" 3
+  template<typename _CharT, typename _Traits>
+    class basic_istream<_CharT, _Traits>::sentry
+    {
+
+      bool _M_ok;
+
+    public:
+
+      typedef _Traits traits_type;
+      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
+      typedef basic_istream<_CharT, _Traits> __istream_type;
+      typedef typename __istream_type::__ctype_type __ctype_type;
+      typedef typename _Traits::int_type __int_type;
+# 721 "/usr/include/c++/10.2.0/istream" 3
+      explicit
+      sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false);
+# 732 "/usr/include/c++/10.2.0/istream" 3
+      explicit
+
+      operator bool() const
+      { return _M_ok; }
+    };
+# 750 "/usr/include/c++/10.2.0/istream" 3
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c);
+
+  template<class _Traits>
+    inline basic_istream<char, _Traits>&
+    operator>>(basic_istream<char, _Traits>& __in, unsigned char& __c)
+    { return (__in >> reinterpret_cast<char&>(__c)); }
+
+  template<class _Traits>
+    inline basic_istream<char, _Traits>&
+    operator>>(basic_istream<char, _Traits>& __in, signed char& __c)
+    { return (__in >> reinterpret_cast<char&>(__c)); }
+# 792 "/usr/include/c++/10.2.0/istream" 3
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s);
+
+
+  template<>
+    basic_istream<char>&
+    operator>>(basic_istream<char>& __in, char* __s);
+
+  template<class _Traits>
+    inline basic_istream<char, _Traits>&
+    operator>>(basic_istream<char, _Traits>& __in, unsigned char* __s)
+    { return (__in >> reinterpret_cast<char*>(__s)); }
+
+  template<class _Traits>
+    inline basic_istream<char, _Traits>&
+    operator>>(basic_istream<char, _Traits>& __in, signed char* __s)
+    { return (__in >> reinterpret_cast<char*>(__s)); }
+# 823 "/usr/include/c++/10.2.0/istream" 3
+  template<typename _CharT, typename _Traits>
+    class basic_iostream
+    : public basic_istream<_CharT, _Traits>,
+      public basic_ostream<_CharT, _Traits>
+    {
+    public:
+
+
+
+      typedef _CharT char_type;
+      typedef typename _Traits::int_type int_type;
+      typedef typename _Traits::pos_type pos_type;
+      typedef typename _Traits::off_type off_type;
+      typedef _Traits traits_type;
+
+
+      typedef basic_istream<_CharT, _Traits> __istream_type;
+      typedef basic_ostream<_CharT, _Traits> __ostream_type;
+
+
+
+
+
+
+
+      explicit
+      basic_iostream(basic_streambuf<_CharT, _Traits>* __sb)
+      : __istream_type(__sb), __ostream_type(__sb) { }
+
+
+
+
+      virtual
+      ~basic_iostream() { }
+
+    protected:
+      basic_iostream()
+      : __istream_type(), __ostream_type() { }
+
+
+      basic_iostream(const basic_iostream&) = delete;
+
+      basic_iostream(basic_iostream&& __rhs)
+      : __istream_type(std::move(__rhs)), __ostream_type(*this)
+      { }
+
+
+
+      basic_iostream& operator=(const basic_iostream&) = delete;
+
+      basic_iostream&
+      operator=(basic_iostream&& __rhs)
+      {
+ swap(__rhs);
+ return *this;
+      }
+
+      void
+      swap(basic_iostream& __rhs)
+      { __istream_type::swap(__rhs); }
+
+    };
+# 906 "/usr/include/c++/10.2.0/istream" 3
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    ws(basic_istream<_CharT, _Traits>& __is);
+
+
+  template<typename _Ch, typename _Up>
+    basic_istream<_Ch, _Up>&
+    __is_convertible_to_basic_istream_test(basic_istream<_Ch, _Up>*);
+
+  template<typename _Tp, typename = void>
+    struct __is_convertible_to_basic_istream_impl
+    {
+      using __istream_type = void;
+    };
+
+  template<typename _Tp>
+    using __do_is_convertible_to_basic_istream_impl =
+    decltype(__is_convertible_to_basic_istream_test
+      (declval<typename remove_reference<_Tp>::type*>()));
+
+  template<typename _Tp>
+    struct __is_convertible_to_basic_istream_impl
+    <_Tp,
+     __void_t<__do_is_convertible_to_basic_istream_impl<_Tp>>>
+    {
+      using __istream_type =
+ __do_is_convertible_to_basic_istream_impl<_Tp>;
+    };
+
+  template<typename _Tp>
+    struct __is_convertible_to_basic_istream
+    : __is_convertible_to_basic_istream_impl<_Tp>
+    {
+    public:
+      using type = __not_<is_void<
+        typename __is_convertible_to_basic_istream_impl<_Tp>::__istream_type>>;
+      constexpr static bool value = type::value;
+    };
+
+  template<typename _Istream, typename _Tp, typename = void>
+    struct __is_extractable : false_type {};
+
+  template<typename _Istream, typename _Tp>
+    struct __is_extractable<_Istream, _Tp,
+       __void_t<decltype(declval<_Istream&>()
+           >> declval<_Tp>())>>
+    : true_type {};
+
+  template<typename _Istream>
+    using __rvalue_istream_type =
+      typename __is_convertible_to_basic_istream<
+ _Istream>::__istream_type;
+# 972 "/usr/include/c++/10.2.0/istream" 3
+  template<typename _Istream, typename _Tp>
+    inline
+    typename enable_if<__and_<__not_<is_lvalue_reference<_Istream>>,
+         __is_convertible_to_basic_istream<_Istream>,
+         __is_extractable<
+    __rvalue_istream_type<_Istream>,
+    _Tp&&>>::value,
+         __rvalue_istream_type<_Istream>>::type
+    operator>>(_Istream&& __is, _Tp&& __x)
+    {
+      __rvalue_istream_type<_Istream> __ret_is = __is;
+      __ret_is >> std::forward<_Tp>(__x);
+      return __ret_is;
+    }
+
+
+
+}
+
+# 1 "/usr/include/c++/10.2.0/bits/istream.tcc" 1 3
+# 35 "/usr/include/c++/10.2.0/bits/istream.tcc" 3
+#define _ISTREAM_TCC 1
+
+       
+# 38 "/usr/include/c++/10.2.0/bits/istream.tcc" 3
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>::sentry::
+    sentry(basic_istream<_CharT, _Traits>& __in, bool __noskip) : _M_ok(false)
+    {
+      ios_base::iostate __err = ios_base::goodbit;
+      if (__in.good())
+ try
+   {
+     if (__in.tie())
+       __in.tie()->flush();
+     if (!__noskip && bool(__in.flags() & ios_base::skipws))
+       {
+  const __int_type __eof = traits_type::eof();
+  __streambuf_type* __sb = __in.rdbuf();
+  __int_type __c = __sb->sgetc();
+
+  const __ctype_type& __ct = __check_facet(__in._M_ctype);
+  while (!traits_type::eq_int_type(__c, __eof)
+         && __ct.is(ctype_base::space,
+      traits_type::to_char_type(__c)))
+    __c = __sb->snextc();
+
+
+
+
+  if (traits_type::eq_int_type(__c, __eof))
+    __err |= ios_base::eofbit;
+       }
+   }
+ catch(__cxxabiv1::__forced_unwind&)
+   {
+     __in._M_setstate(ios_base::badbit);
+     throw;
+   }
+ catch(...)
+   { __in._M_setstate(ios_base::badbit); }
+
+      if (__in.good() && __err == ios_base::goodbit)
+ _M_ok = true;
+      else
+ {
+   __err |= ios_base::failbit;
+   __in.setstate(__err);
+ }
+    }
+
+  template<typename _CharT, typename _Traits>
+    template<typename _ValueT>
+      basic_istream<_CharT, _Traits>&
+      basic_istream<_CharT, _Traits>::
+      _M_extract(_ValueT& __v)
+      {
+ sentry __cerb(*this, false);
+ if (__cerb)
+   {
+     ios_base::iostate __err = ios_base::goodbit;
+     try
+       {
+  const __num_get_type& __ng = __check_facet(this->_M_num_get);
+  __ng.get(*this, 0, *this, __err, __v);
+       }
+     catch(__cxxabiv1::__forced_unwind&)
+       {
+  this->_M_setstate(ios_base::badbit);
+  throw;
+       }
+     catch(...)
+       { this->_M_setstate(ios_base::badbit); }
+     if (__err)
+       this->setstate(__err);
+   }
+ return *this;
+      }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    operator>>(short& __n)
+    {
+
+
+      sentry __cerb(*this, false);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       long __l;
+       const __num_get_type& __ng = __check_facet(this->_M_num_get);
+       __ng.get(*this, 0, *this, __err, __l);
+
+
+
+       if (__l < __gnu_cxx::__numeric_traits<short>::__min)
+  {
+    __err |= ios_base::failbit;
+    __n = __gnu_cxx::__numeric_traits<short>::__min;
+  }
+       else if (__l > __gnu_cxx::__numeric_traits<short>::__max)
+  {
+    __err |= ios_base::failbit;
+    __n = __gnu_cxx::__numeric_traits<short>::__max;
+  }
+       else
+  __n = short(__l);
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    operator>>(int& __n)
+    {
+
+
+      sentry __cerb(*this, false);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       long __l;
+       const __num_get_type& __ng = __check_facet(this->_M_num_get);
+       __ng.get(*this, 0, *this, __err, __l);
+
+
+
+       if (__l < __gnu_cxx::__numeric_traits<int>::__min)
+  {
+    __err |= ios_base::failbit;
+    __n = __gnu_cxx::__numeric_traits<int>::__min;
+  }
+       else if (__l > __gnu_cxx::__numeric_traits<int>::__max)
+  {
+    __err |= ios_base::failbit;
+    __n = __gnu_cxx::__numeric_traits<int>::__max;
+  }
+       else
+  __n = int(__l);
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    operator>>(__streambuf_type* __sbout)
+    {
+      ios_base::iostate __err = ios_base::goodbit;
+      sentry __cerb(*this, false);
+      if (__cerb && __sbout)
+ {
+   try
+     {
+       bool __ineof;
+       if (!__copy_streambufs_eof(this->rdbuf(), __sbout, __ineof))
+  __err |= ios_base::failbit;
+       if (__ineof)
+  __err |= ios_base::eofbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::failbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::failbit); }
+ }
+      else if (!__sbout)
+ __err |= ios_base::failbit;
+      if (__err)
+ this->setstate(__err);
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    typename basic_istream<_CharT, _Traits>::int_type
+    basic_istream<_CharT, _Traits>::
+    get(void)
+    {
+      const int_type __eof = traits_type::eof();
+      int_type __c = __eof;
+      _M_gcount = 0;
+      ios_base::iostate __err = ios_base::goodbit;
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   try
+     {
+       __c = this->rdbuf()->sbumpc();
+
+       if (!traits_type::eq_int_type(__c, __eof))
+  _M_gcount = 1;
+       else
+  __err |= ios_base::eofbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+ }
+      if (!_M_gcount)
+ __err |= ios_base::failbit;
+      if (__err)
+ this->setstate(__err);
+      return __c;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    get(char_type& __c)
+    {
+      _M_gcount = 0;
+      ios_base::iostate __err = ios_base::goodbit;
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   try
+     {
+       const int_type __cb = this->rdbuf()->sbumpc();
+
+       if (!traits_type::eq_int_type(__cb, traits_type::eof()))
+  {
+    _M_gcount = 1;
+    __c = traits_type::to_char_type(__cb);
+  }
+       else
+  __err |= ios_base::eofbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+ }
+      if (!_M_gcount)
+ __err |= ios_base::failbit;
+      if (__err)
+ this->setstate(__err);
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    get(char_type* __s, streamsize __n, char_type __delim)
+    {
+      _M_gcount = 0;
+      ios_base::iostate __err = ios_base::goodbit;
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   try
+     {
+       const int_type __idelim = traits_type::to_int_type(__delim);
+       const int_type __eof = traits_type::eof();
+       __streambuf_type* __sb = this->rdbuf();
+       int_type __c = __sb->sgetc();
+
+       while (_M_gcount + 1 < __n
+       && !traits_type::eq_int_type(__c, __eof)
+       && !traits_type::eq_int_type(__c, __idelim))
+  {
+    *__s++ = traits_type::to_char_type(__c);
+    ++_M_gcount;
+    __c = __sb->snextc();
+  }
+       if (traits_type::eq_int_type(__c, __eof))
+  __err |= ios_base::eofbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+ }
+
+
+      if (__n > 0)
+ *__s = char_type();
+      if (!_M_gcount)
+ __err |= ios_base::failbit;
+      if (__err)
+ this->setstate(__err);
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    get(__streambuf_type& __sb, char_type __delim)
+    {
+      _M_gcount = 0;
+      ios_base::iostate __err = ios_base::goodbit;
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   try
+     {
+       const int_type __idelim = traits_type::to_int_type(__delim);
+       const int_type __eof = traits_type::eof();
+       __streambuf_type* __this_sb = this->rdbuf();
+       int_type __c = __this_sb->sgetc();
+       char_type __c2 = traits_type::to_char_type(__c);
+
+       while (!traits_type::eq_int_type(__c, __eof)
+       && !traits_type::eq_int_type(__c, __idelim)
+       && !traits_type::eq_int_type(__sb.sputc(__c2), __eof))
+  {
+    ++_M_gcount;
+    __c = __this_sb->snextc();
+    __c2 = traits_type::to_char_type(__c);
+  }
+       if (traits_type::eq_int_type(__c, __eof))
+  __err |= ios_base::eofbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+ }
+      if (!_M_gcount)
+ __err |= ios_base::failbit;
+      if (__err)
+ this->setstate(__err);
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    getline(char_type* __s, streamsize __n, char_type __delim)
+    {
+      _M_gcount = 0;
+      ios_base::iostate __err = ios_base::goodbit;
+      sentry __cerb(*this, true);
+      if (__cerb)
+        {
+          try
+            {
+              const int_type __idelim = traits_type::to_int_type(__delim);
+              const int_type __eof = traits_type::eof();
+              __streambuf_type* __sb = this->rdbuf();
+              int_type __c = __sb->sgetc();
+
+              while (_M_gcount + 1 < __n
+                     && !traits_type::eq_int_type(__c, __eof)
+                     && !traits_type::eq_int_type(__c, __idelim))
+                {
+                  *__s++ = traits_type::to_char_type(__c);
+                  __c = __sb->snextc();
+                  ++_M_gcount;
+                }
+              if (traits_type::eq_int_type(__c, __eof))
+                __err |= ios_base::eofbit;
+              else
+                {
+                  if (traits_type::eq_int_type(__c, __idelim))
+                    {
+                      __sb->sbumpc();
+                      ++_M_gcount;
+                    }
+                  else
+                    __err |= ios_base::failbit;
+                }
+            }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+          catch(...)
+            { this->_M_setstate(ios_base::badbit); }
+        }
+
+
+      if (__n > 0)
+ *__s = char_type();
+      if (!_M_gcount)
+        __err |= ios_base::failbit;
+      if (__err)
+        this->setstate(__err);
+      return *this;
+    }
+
+
+
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    ignore(void)
+    {
+      _M_gcount = 0;
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       const int_type __eof = traits_type::eof();
+       __streambuf_type* __sb = this->rdbuf();
+
+       if (traits_type::eq_int_type(__sb->sbumpc(), __eof))
+  __err |= ios_base::eofbit;
+       else
+  _M_gcount = 1;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    ignore(streamsize __n)
+    {
+      _M_gcount = 0;
+      sentry __cerb(*this, true);
+      if (__cerb && __n > 0)
+        {
+          ios_base::iostate __err = ios_base::goodbit;
+          try
+            {
+              const int_type __eof = traits_type::eof();
+              __streambuf_type* __sb = this->rdbuf();
+              int_type __c = __sb->sgetc();
+# 521 "/usr/include/c++/10.2.0/bits/istream.tcc" 3
+       bool __large_ignore = false;
+       while (true)
+  {
+    while (_M_gcount < __n
+    && !traits_type::eq_int_type(__c, __eof))
+      {
+        ++_M_gcount;
+        __c = __sb->snextc();
+      }
+    if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
+        && !traits_type::eq_int_type(__c, __eof))
+      {
+        _M_gcount =
+   __gnu_cxx::__numeric_traits<streamsize>::__min;
+        __large_ignore = true;
+      }
+    else
+      break;
+  }
+
+       if (__large_ignore)
+  _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;
+
+       if (traits_type::eq_int_type(__c, __eof))
+                __err |= ios_base::eofbit;
+            }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+          catch(...)
+            { this->_M_setstate(ios_base::badbit); }
+          if (__err)
+            this->setstate(__err);
+        }
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    ignore(streamsize __n, int_type __delim)
+    {
+      _M_gcount = 0;
+      sentry __cerb(*this, true);
+      if (__cerb && __n > 0)
+        {
+          ios_base::iostate __err = ios_base::goodbit;
+          try
+            {
+              const int_type __eof = traits_type::eof();
+              __streambuf_type* __sb = this->rdbuf();
+              int_type __c = __sb->sgetc();
+
+
+       bool __large_ignore = false;
+       while (true)
+  {
+    while (_M_gcount < __n
+    && !traits_type::eq_int_type(__c, __eof)
+    && !traits_type::eq_int_type(__c, __delim))
+      {
+        ++_M_gcount;
+        __c = __sb->snextc();
+      }
+    if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
+        && !traits_type::eq_int_type(__c, __eof)
+        && !traits_type::eq_int_type(__c, __delim))
+      {
+        _M_gcount =
+   __gnu_cxx::__numeric_traits<streamsize>::__min;
+        __large_ignore = true;
+      }
+    else
+      break;
+  }
+
+       if (__large_ignore)
+  _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;
+
+              if (traits_type::eq_int_type(__c, __eof))
+                __err |= ios_base::eofbit;
+       else if (traits_type::eq_int_type(__c, __delim))
+  {
+    if (_M_gcount
+        < __gnu_cxx::__numeric_traits<streamsize>::__max)
+      ++_M_gcount;
+    __sb->sbumpc();
+  }
+            }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+          catch(...)
+            { this->_M_setstate(ios_base::badbit); }
+          if (__err)
+            this->setstate(__err);
+        }
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    typename basic_istream<_CharT, _Traits>::int_type
+    basic_istream<_CharT, _Traits>::
+    peek(void)
+    {
+      int_type __c = traits_type::eof();
+      _M_gcount = 0;
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       __c = this->rdbuf()->sgetc();
+       if (traits_type::eq_int_type(__c, traits_type::eof()))
+  __err |= ios_base::eofbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return __c;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    read(char_type* __s, streamsize __n)
+    {
+      _M_gcount = 0;
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       _M_gcount = this->rdbuf()->sgetn(__s, __n);
+       if (_M_gcount != __n)
+  __err |= (ios_base::eofbit | ios_base::failbit);
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    streamsize
+    basic_istream<_CharT, _Traits>::
+    readsome(char_type* __s, streamsize __n)
+    {
+      _M_gcount = 0;
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+
+       const streamsize __num = this->rdbuf()->in_avail();
+       if (__num > 0)
+  _M_gcount = this->rdbuf()->sgetn(__s, std::min(__num, __n));
+       else if (__num == -1)
+  __err |= ios_base::eofbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return _M_gcount;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    putback(char_type __c)
+    {
+
+
+      _M_gcount = 0;
+
+      this->clear(this->rdstate() & ~ios_base::eofbit);
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       const int_type __eof = traits_type::eof();
+       __streambuf_type* __sb = this->rdbuf();
+       if (!__sb
+    || traits_type::eq_int_type(__sb->sputbackc(__c), __eof))
+  __err |= ios_base::badbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    unget(void)
+    {
+
+
+      _M_gcount = 0;
+
+      this->clear(this->rdstate() & ~ios_base::eofbit);
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       const int_type __eof = traits_type::eof();
+       __streambuf_type* __sb = this->rdbuf();
+       if (!__sb
+    || traits_type::eq_int_type(__sb->sungetc(), __eof))
+  __err |= ios_base::badbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    int
+    basic_istream<_CharT, _Traits>::
+    sync(void)
+    {
+
+
+      int __ret = -1;
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       __streambuf_type* __sb = this->rdbuf();
+       if (__sb)
+  {
+    if (__sb->pubsync() == -1)
+      __err |= ios_base::badbit;
+    else
+      __ret = 0;
+  }
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return __ret;
+    }
+
+  template<typename _CharT, typename _Traits>
+    typename basic_istream<_CharT, _Traits>::pos_type
+    basic_istream<_CharT, _Traits>::
+    tellg(void)
+    {
+
+
+      pos_type __ret = pos_type(-1);
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   try
+     {
+       if (!this->fail())
+  __ret = this->rdbuf()->pubseekoff(0, ios_base::cur,
+        ios_base::in);
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+ }
+      return __ret;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    seekg(pos_type __pos)
+    {
+
+
+
+      this->clear(this->rdstate() & ~ios_base::eofbit);
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       if (!this->fail())
+  {
+
+    const pos_type __p = this->rdbuf()->pubseekpos(__pos,
+         ios_base::in);
+
+
+    if (__p == pos_type(off_type(-1)))
+      __err |= ios_base::failbit;
+  }
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    seekg(off_type __off, ios_base::seekdir __dir)
+    {
+
+
+
+      this->clear(this->rdstate() & ~ios_base::eofbit);
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       if (!this->fail())
+  {
+
+    const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
+         ios_base::in);
+
+
+    if (__p == pos_type(off_type(-1)))
+      __err |= ios_base::failbit;
+  }
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return *this;
+    }
+
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c)
+    {
+      typedef basic_istream<_CharT, _Traits> __istream_type;
+      typedef typename __istream_type::int_type __int_type;
+
+      typename __istream_type::sentry __cerb(__in, false);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       const __int_type __cb = __in.rdbuf()->sbumpc();
+       if (!_Traits::eq_int_type(__cb, _Traits::eof()))
+  __c = _Traits::to_char_type(__cb);
+       else
+  __err |= (ios_base::eofbit | ios_base::failbit);
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       __in._M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { __in._M_setstate(ios_base::badbit); }
+   if (__err)
+     __in.setstate(__err);
+ }
+      return __in;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s)
+    {
+      typedef basic_istream<_CharT, _Traits> __istream_type;
+      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
+      typedef typename _Traits::int_type int_type;
+      typedef _CharT char_type;
+      typedef ctype<_CharT> __ctype_type;
+
+      streamsize __extracted = 0;
+      ios_base::iostate __err = ios_base::goodbit;
+      typename __istream_type::sentry __cerb(__in, false);
+      if (__cerb)
+ {
+   try
+     {
+
+       streamsize __num = __in.width();
+       if (__num <= 0)
+  __num = __gnu_cxx::__numeric_traits<streamsize>::__max;
+
+       const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
+
+       const int_type __eof = _Traits::eof();
+       __streambuf_type* __sb = __in.rdbuf();
+       int_type __c = __sb->sgetc();
+
+       while (__extracted < __num - 1
+       && !_Traits::eq_int_type(__c, __eof)
+       && !__ct.is(ctype_base::space,
+     _Traits::to_char_type(__c)))
+  {
+    *__s++ = _Traits::to_char_type(__c);
+    ++__extracted;
+    __c = __sb->snextc();
+  }
+       if (_Traits::eq_int_type(__c, __eof))
+  __err |= ios_base::eofbit;
+
+
+
+       *__s = char_type();
+       __in.width(0);
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       __in._M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { __in._M_setstate(ios_base::badbit); }
+ }
+      if (!__extracted)
+ __err |= ios_base::failbit;
+      if (__err)
+ __in.setstate(__err);
+      return __in;
+    }
+
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    ws(basic_istream<_CharT, _Traits>& __in)
+    {
+      typedef basic_istream<_CharT, _Traits> __istream_type;
+      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
+      typedef typename __istream_type::int_type __int_type;
+      typedef ctype<_CharT> __ctype_type;
+
+      const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
+      const __int_type __eof = _Traits::eof();
+      __streambuf_type* __sb = __in.rdbuf();
+      __int_type __c = __sb->sgetc();
+
+      while (!_Traits::eq_int_type(__c, __eof)
+      && __ct.is(ctype_base::space, _Traits::to_char_type(__c)))
+ __c = __sb->snextc();
+
+       if (_Traits::eq_int_type(__c, __eof))
+  __in.setstate(ios_base::eofbit);
+      return __in;
+    }
+
+
+
+
+  extern template class basic_istream<char>;
+  extern template istream& ws(istream&);
+  extern template istream& operator>>(istream&, char&);
+  extern template istream& operator>>(istream&, char*);
+  extern template istream& operator>>(istream&, unsigned char&);
+  extern template istream& operator>>(istream&, signed char&);
+  extern template istream& operator>>(istream&, unsigned char*);
+  extern template istream& operator>>(istream&, signed char*);
+
+  extern template istream& istream::_M_extract(unsigned short&);
+  extern template istream& istream::_M_extract(unsigned int&);
+  extern template istream& istream::_M_extract(long&);
+  extern template istream& istream::_M_extract(unsigned long&);
+  extern template istream& istream::_M_extract(bool&);
+
+  extern template istream& istream::_M_extract(long long&);
+  extern template istream& istream::_M_extract(unsigned long long&);
+
+  extern template istream& istream::_M_extract(float&);
+  extern template istream& istream::_M_extract(double&);
+  extern template istream& istream::_M_extract(long double&);
+  extern template istream& istream::_M_extract(void*&);
+
+  extern template class basic_iostream<char>;
+
+
+  extern template class basic_istream<wchar_t>;
+  extern template wistream& ws(wistream&);
+  extern template wistream& operator>>(wistream&, wchar_t&);
+  extern template wistream& operator>>(wistream&, wchar_t*);
+
+  extern template wistream& wistream::_M_extract(unsigned short&);
+  extern template wistream& wistream::_M_extract(unsigned int&);
+  extern template wistream& wistream::_M_extract(long&);
+  extern template wistream& wistream::_M_extract(unsigned long&);
+  extern template wistream& wistream::_M_extract(bool&);
+
+  extern template wistream& wistream::_M_extract(long long&);
+  extern template wistream& wistream::_M_extract(unsigned long long&);
+
+  extern template wistream& wistream::_M_extract(float&);
+  extern template wistream& wistream::_M_extract(double&);
+  extern template wistream& wistream::_M_extract(long double&);
+  extern template wistream& wistream::_M_extract(void*&);
+
+  extern template class basic_iostream<wchar_t>;
+
+
+
+
+}
+# 992 "/usr/include/c++/10.2.0/istream" 2 3
+# 41 "/usr/include/c++/10.2.0/iostream" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 60 "/usr/include/c++/10.2.0/iostream" 3
+  extern istream cin;
+  extern ostream cout;
+  extern ostream cerr;
+  extern ostream clog;
+
+
+  extern wistream wcin;
+  extern wostream wcout;
+  extern wostream wcerr;
+  extern wostream wclog;
+
+
+
+
+  static ios_base::Init __ioinit;
+
+
+}
+# 27 "/usr/include/boost/test/unit_test_log_formatter.hpp" 2 3 4
+
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 29 "/usr/include/boost/test/unit_test_log_formatter.hpp" 2 3 4
+
+
+
+namespace boost {
+namespace unit_test {
+
+
+
+
+
+struct __attribute__((__visibility__("default"))) log_entry_data {
+    log_entry_data()
+    {
+        m_file_name.reserve( 200 );
+    }
+
+    std::string m_file_name;
+    std::size_t m_line_num;
+    log_level m_level;
+
+    void clear()
+    {
+        m_file_name.erase();
+        m_line_num = 0;
+        m_level = log_nothing;
+    }
+};
+
+
+
+
+
+struct __attribute__((__visibility__("default"))) log_checkpoint_data
+{
+    const_string m_file_name;
+    std::size_t m_line_num;
+    std::string m_message;
+
+    void clear()
+    {
+        m_file_name.clear();
+        m_line_num = 0;
+        m_message = std::string();
+    }
+};
+# 107 "/usr/include/boost/test/unit_test_log_formatter.hpp" 3 4
+class __attribute__((__visibility__("default"))) unit_test_log_formatter {
+public:
+
+    enum log_entry_types { BOOST_UTL_ET_INFO,
+                           BOOST_UTL_ET_MESSAGE,
+                           BOOST_UTL_ET_WARNING,
+                           BOOST_UTL_ET_ERROR,
+                           BOOST_UTL_ET_FATAL_ERROR
+    };
+
+
+    unit_test_log_formatter()
+        : m_log_level(log_all_errors)
+    {}
+
+
+    virtual ~unit_test_log_formatter() {}
+# 132 "/usr/include/boost/test/unit_test_log_formatter.hpp" 3 4
+    virtual void log_start( std::ostream& os, counter_t test_cases_amount ) = 0;
+
+
+
+
+
+    virtual void log_finish( std::ostream& os ) = 0;
+
+
+
+
+
+    virtual void log_build_info( std::ostream& os, bool log_build_info = true ) = 0;
+# 154 "/usr/include/boost/test/unit_test_log_formatter.hpp" 3 4
+    virtual void test_unit_start( std::ostream& os, test_unit const& tu ) = 0;
+
+
+
+
+
+
+
+    virtual void test_unit_finish( std::ostream& os, test_unit const& tu, unsigned long elapsed ) = 0;
+
+
+
+
+
+
+    virtual void test_unit_skipped( std::ostream& os, test_unit const& tu, const_string )
+    {
+        test_unit_skipped( os, tu );
+    }
+
+
+
+    virtual void test_unit_skipped( std::ostream& , test_unit const& ) {}
+
+
+    virtual void test_unit_aborted( std::ostream& , test_unit const& ) {}
+
+
+    virtual void test_unit_timed_out( std::ostream& , test_unit const& ) {}
+# 203 "/usr/include/boost/test/unit_test_log_formatter.hpp" 3 4
+    virtual void log_exception_start( std::ostream& os, log_checkpoint_data const& lcd, execution_exception const& ex ) = 0;
+
+
+
+
+
+
+    virtual void log_exception_finish( std::ostream& os ) = 0;
+# 227 "/usr/include/boost/test/unit_test_log_formatter.hpp" 3 4
+    virtual void log_entry_start( std::ostream& os, log_entry_data const& led, log_entry_types let ) = 0;
+
+
+
+
+
+
+
+    virtual void log_entry_value( std::ostream& os, const_string value ) = 0;
+# 245 "/usr/include/boost/test/unit_test_log_formatter.hpp" 3 4
+    virtual void log_entry_value( std::ostream& os, lazy_ostream const& value );
+
+
+
+
+
+    virtual void log_entry_finish( std::ostream& os ) = 0;
+# 264 "/usr/include/boost/test/unit_test_log_formatter.hpp" 3 4
+    virtual void entry_context_start( std::ostream& os, log_level l ) = 0;
+# 273 "/usr/include/boost/test/unit_test_log_formatter.hpp" 3 4
+    virtual void log_entry_context( std::ostream& os, log_level l, const_string value ) = 0;
+
+
+
+
+
+
+    virtual void entry_context_finish( std::ostream& os, log_level l ) = 0;
+# 290 "/usr/include/boost/test/unit_test_log_formatter.hpp" 3 4
+    virtual void set_log_level(log_level new_log_level);
+
+
+
+    virtual log_level get_log_level() const;
+# 307 "/usr/include/boost/test/unit_test_log_formatter.hpp" 3 4
+    virtual std::string get_default_stream_description() const
+    {
+        return "stdout";
+    }
+
+
+
+
+protected:
+    log_level m_log_level;
+
+};
+
+}
+}
+
+
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 326 "/usr/include/boost/test/unit_test_log_formatter.hpp" 2 3 4
+# 18 "/usr/include/boost/test/output/compiler_log_formatter.hpp" 2 3 4
+
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 20 "/usr/include/boost/test/output/compiler_log_formatter.hpp" 2 3 4
+
+
+
+namespace boost {
+namespace unit_test {
+namespace output {
+
+
+
+
+
+
+class __attribute__((__visibility__("default"))) compiler_log_formatter : public unit_test_log_formatter {
+public:
+    compiler_log_formatter() : m_color_output( false ) {}
+
+
+    void log_start( std::ostream&, counter_t test_cases_amount );
+    void log_finish( std::ostream& );
+    void log_build_info( std::ostream&, bool );
+
+    void test_unit_start( std::ostream&, test_unit const& tu );
+    void test_unit_finish( std::ostream&, test_unit const& tu, unsigned long elapsed );
+    void test_unit_skipped( std::ostream&, test_unit const& tu, const_string reason );
+
+    void log_exception_start( std::ostream&, log_checkpoint_data const&, execution_exception const& ex );
+    void log_exception_finish( std::ostream& );
+
+    void log_entry_start( std::ostream&, log_entry_data const&, log_entry_types let );
+    void log_entry_value( std::ostream&, const_string value );
+    void log_entry_value( std::ostream&, lazy_ostream const& value );
+    void log_entry_finish( std::ostream& );
+
+    void entry_context_start( std::ostream&, log_level );
+    void log_entry_context( std::ostream&, log_level l, const_string );
+    void entry_context_finish( std::ostream&, log_level l );
+
+protected:
+    virtual void print_prefix( std::ostream&, const_string file, std::size_t line );
+
+
+    bool m_color_output;
+};
+
+}
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 69 "/usr/include/boost/test/output/compiler_log_formatter.hpp" 2 3 4
+# 20 "/usr/include/boost/test/impl/compiler_log_formatter.ipp" 2 3 4
+
+# 1 "/usr/include/boost/test/framework.hpp" 1 3 4
+# 14 "/usr/include/boost/test/framework.hpp" 3 4
+#define BOOST_TEST_FRAMEWORK_HPP_020805GER 
+
+
+
+
+# 1 "/usr/include/boost/test/detail/throw_exception.hpp" 1 3 4
+# 13 "/usr/include/boost/test/detail/throw_exception.hpp" 3 4
+#define BOOST_TEST_DETAIL_THROW_EXCEPTION_HPP 
+# 24 "/usr/include/boost/test/detail/throw_exception.hpp" 3 4
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 25 "/usr/include/boost/test/detail/throw_exception.hpp" 2 3 4
+
+
+
+namespace boost {
+namespace unit_test {
+namespace ut_detail {
+# 46 "/usr/include/boost/test/detail/throw_exception.hpp" 3 4
+template<typename E>
+__attribute__ ((__noreturn__)) inline void
+throw_exception(E const& e) { throw e; }
+
+#define BOOST_TEST_I_TRY try
+#define BOOST_TEST_I_CATCH(T,var) catch( T const& var )
+#define BOOST_TEST_I_CATCH0(T) catch( T const& )
+#define BOOST_TEST_I_CATCHALL() catch(...)
+#define BOOST_TEST_I_RETHROW throw
+
+
+
+
+#define BOOST_TEST_I_THROW(E) unit_test::ut_detail::throw_exception( E )
+#define BOOST_TEST_I_ASSRT(cond,ex) if( cond ) {} else BOOST_TEST_I_THROW( ex )
+
+
+}
+}
+}
+
+
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 70 "/usr/include/boost/test/detail/throw_exception.hpp" 2 3 4
+# 20 "/usr/include/boost/test/framework.hpp" 2 3 4
+
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 22 "/usr/include/boost/test/framework.hpp" 2 3 4
+
+
+
+
+
+
+namespace boost {
+
+
+namespace unit_test {
+# 43 "/usr/include/boost/test/framework.hpp" 3 4
+typedef test_suite* (*init_unit_test_func)( int, char* [] );
+
+
+
+
+
+
+
+namespace framework {
+# 62 "/usr/include/boost/test/framework.hpp" 3 4
+__attribute__((__visibility__("default"))) void init( init_unit_test_func init_func, int argc, char* argv[] );
+
+
+
+
+__attribute__((__visibility__("default"))) void finalize_setup_phase( test_unit_id tu = INV_TEST_UNIT_ID);
+
+
+__attribute__((__visibility__("default"))) bool test_in_progress();
+
+
+
+
+__attribute__((__visibility__("default"))) void shutdown();
+# 96 "/usr/include/boost/test/framework.hpp" 3 4
+__attribute__((__visibility__("default"))) test_suite& current_auto_test_suite( test_suite* ts = 0, bool push_or_pop = true );
+
+
+
+
+
+
+__attribute__((__visibility__("default"))) void register_test_unit( test_case* tc );
+
+
+
+
+
+
+__attribute__((__visibility__("default"))) void register_test_unit( test_suite* ts );
+
+
+
+
+
+
+__attribute__((__visibility__("default"))) void deregister_test_unit( test_unit* tu );
+
+
+
+
+__attribute__((__visibility__("default"))) void clear();
+# 131 "/usr/include/boost/test/framework.hpp" 3 4
+__attribute__((__visibility__("default"))) void register_observer( test_observer& to );
+
+
+
+__attribute__((__visibility__("default"))) void deregister_observer( test_observer& to );
+# 146 "/usr/include/boost/test/framework.hpp" 3 4
+__attribute__((__visibility__("default"))) void register_global_fixture( global_fixture& tuf );
+
+
+
+
+
+__attribute__((__visibility__("default"))) void deregister_global_fixture( global_fixture& tuf );
+
+
+
+
+
+struct __attribute__((__visibility__("default"))) context_generator {
+    context_generator() : m_curr_frame( 0 ) {}
+
+
+    bool is_empty() const;
+
+
+    const_string next() const;
+
+private:
+
+    mutable unsigned m_curr_frame;
+};
+
+
+
+
+
+
+
+__attribute__((__visibility__("default"))) int add_context( lazy_ostream const& context_descr, bool sticky );
+
+
+
+__attribute__((__visibility__("default"))) void clear_context( int context_id = -1 );
+
+__attribute__((__visibility__("default"))) context_generator get_context();
+# 193 "/usr/include/boost/test/framework.hpp" 3 4
+__attribute__((__visibility__("default"))) master_test_suite_t& master_test_suite();
+# 202 "/usr/include/boost/test/framework.hpp" 3 4
+__attribute__((__visibility__("default"))) test_unit const& current_test_unit();
+
+
+
+
+
+__attribute__((__visibility__("default"))) test_case const& current_test_case();
+
+
+
+
+
+__attribute__((__visibility__("default"))) test_unit_id current_test_case_id();
+
+
+
+
+
+__attribute__((__visibility__("default"))) test_unit& get( test_unit_id tu_id, test_unit_type tu_type );
+
+
+
+
+
+
+template<typename UnitType>
+inline UnitType& get( test_unit_id id )
+{
+    return static_cast<UnitType&>( get( id, static_cast<test_unit_type>(UnitType::type) ) );
+}
+# 244 "/usr/include/boost/test/framework.hpp" 3 4
+__attribute__((__visibility__("default"))) void run( test_unit_id tu = INV_TEST_UNIT_ID, bool continue_test = true );
+
+__attribute__((__visibility__("default"))) void run( test_unit const* tu, bool continue_test = true );
+
+
+
+
+
+__attribute__((__visibility__("default"))) void assertion_result( unit_test::assertion_result ar );
+
+__attribute__((__visibility__("default"))) void exception_caught( execution_exception const& );
+
+__attribute__((__visibility__("default"))) void test_unit_aborted( test_unit const& );
+
+__attribute__((__visibility__("default"))) void test_aborted( );
+
+
+namespace impl {
+
+__attribute__((__visibility__("default"))) void setup_for_execution( test_unit const& );
+__attribute__((__visibility__("default"))) void setup_loggers( );
+
+
+struct __attribute__((__visibility__("default"))) master_test_suite_name_setter {
+  master_test_suite_name_setter( const_string name );
+};
+
+}
+
+
+
+
+
+
+struct __attribute__((__visibility__("default"))) internal_error : public std::runtime_error {
+    internal_error( const_string m ) : std::runtime_error( std::string( m.begin(), m.size() ) ) {}
+};
+
+
+
+
+struct __attribute__((__visibility__("default"))) setup_error : public std::runtime_error {
+    setup_error( const_string m ) : std::runtime_error( std::string( m.begin(), m.size() ) ) {}
+};
+
+#define BOOST_TEST_SETUP_ASSERT(cond,msg) BOOST_TEST_I_ASSRT( cond, unit_test::framework::setup_error( msg ) )
+
+
+
+struct nothing_to_test {
+    explicit nothing_to_test( int rc ) : m_result_code( rc ) {}
+
+    int m_result_code;
+};
+
+
+
+}
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 306 "/usr/include/boost/test/framework.hpp" 2 3 4
+# 22 "/usr/include/boost/test/impl/compiler_log_formatter.ipp" 2 3 4
+# 1 "/usr/include/boost/test/execution_monitor.hpp" 1 3 4
+# 14 "/usr/include/boost/test/execution_monitor.hpp" 3 4
+#define BOOST_TEST_EXECUTION_MONITOR_HPP_071894GER 
+
+
+
+
+
+
+# 1 "/usr/include/boost/test/utils/class_properties.hpp" 1 3 4
+# 17 "/usr/include/boost/test/utils/class_properties.hpp" 3 4
+#define BOOST_TEST_UTILS_CLASS_PROPERTIES_HPP 
+
+
+
+
+
+
+# 1 "/usr/include/boost/preprocessor/seq/for_each.hpp" 1 3 4
+# 13 "/usr/include/boost/preprocessor/seq/for_each.hpp" 3 4
+#define BOOST_PREPROCESSOR_SEQ_FOR_EACH_HPP 
+
+# 1 "/usr/include/boost/preprocessor/arithmetic/dec.hpp" 1 3 4
+# 15 "/usr/include/boost/preprocessor/arithmetic/dec.hpp" 3 4
+#define BOOST_PREPROCESSOR_ARITHMETIC_DEC_HPP 
+
+# 1 "/usr/include/boost/preprocessor/config/config.hpp" 1 3 4
+# 14 "/usr/include/boost/preprocessor/config/config.hpp" 3 4
+#define BOOST_PREPROCESSOR_CONFIG_CONFIG_HPP 
+
+
+
+#define BOOST_PP_CONFIG_STRICT() 0x0001
+#define BOOST_PP_CONFIG_IDEAL() 0x0002
+
+#define BOOST_PP_CONFIG_MSVC() 0x0004
+#define BOOST_PP_CONFIG_MWCC() 0x0008
+#define BOOST_PP_CONFIG_BCC() 0x0010
+#define BOOST_PP_CONFIG_EDG() 0x0020
+#define BOOST_PP_CONFIG_DMC() 0x0040
+# 57 "/usr/include/boost/preprocessor/config/config.hpp" 3 4
+#define BOOST_PP_CONFIG_FLAGS() (BOOST_PP_CONFIG_STRICT())
+
+
+
+
+
+
+#define BOOST_PP_CONFIG_EXTENDED_LINE_INFO 0
+# 73 "/usr/include/boost/preprocessor/config/config.hpp" 3 4
+#define BOOST_PP_CONFIG_ERRORS 1
+
+
+
+
+
+#define BOOST_PP_VARIADICS_MSVC 0
+# 104 "/usr/include/boost/preprocessor/config/config.hpp" 3 4
+#undef BOOST_PP_VARIADICS
+#define BOOST_PP_VARIADICS 1
+# 18 "/usr/include/boost/preprocessor/arithmetic/dec.hpp" 2 3 4
+
+
+
+
+#define BOOST_PP_DEC(x) BOOST_PP_DEC_I(x)
+
+
+
+
+
+#define BOOST_PP_DEC_I(x) BOOST_PP_DEC_ ## x
+
+#define BOOST_PP_DEC_0 0
+#define BOOST_PP_DEC_1 0
+#define BOOST_PP_DEC_2 1
+#define BOOST_PP_DEC_3 2
+#define BOOST_PP_DEC_4 3
+#define BOOST_PP_DEC_5 4
+#define BOOST_PP_DEC_6 5
+#define BOOST_PP_DEC_7 6
+#define BOOST_PP_DEC_8 7
+#define BOOST_PP_DEC_9 8
+#define BOOST_PP_DEC_10 9
+#define BOOST_PP_DEC_11 10
+#define BOOST_PP_DEC_12 11
+#define BOOST_PP_DEC_13 12
+#define BOOST_PP_DEC_14 13
+#define BOOST_PP_DEC_15 14
+#define BOOST_PP_DEC_16 15
+#define BOOST_PP_DEC_17 16
+#define BOOST_PP_DEC_18 17
+#define BOOST_PP_DEC_19 18
+#define BOOST_PP_DEC_20 19
+#define BOOST_PP_DEC_21 20
+#define BOOST_PP_DEC_22 21
+#define BOOST_PP_DEC_23 22
+#define BOOST_PP_DEC_24 23
+#define BOOST_PP_DEC_25 24
+#define BOOST_PP_DEC_26 25
+#define BOOST_PP_DEC_27 26
+#define BOOST_PP_DEC_28 27
+#define BOOST_PP_DEC_29 28
+#define BOOST_PP_DEC_30 29
+#define BOOST_PP_DEC_31 30
+#define BOOST_PP_DEC_32 31
+#define BOOST_PP_DEC_33 32
+#define BOOST_PP_DEC_34 33
+#define BOOST_PP_DEC_35 34
+#define BOOST_PP_DEC_36 35
+#define BOOST_PP_DEC_37 36
+#define BOOST_PP_DEC_38 37
+#define BOOST_PP_DEC_39 38
+#define BOOST_PP_DEC_40 39
+#define BOOST_PP_DEC_41 40
+#define BOOST_PP_DEC_42 41
+#define BOOST_PP_DEC_43 42
+#define BOOST_PP_DEC_44 43
+#define BOOST_PP_DEC_45 44
+#define BOOST_PP_DEC_46 45
+#define BOOST_PP_DEC_47 46
+#define BOOST_PP_DEC_48 47
+#define BOOST_PP_DEC_49 48
+#define BOOST_PP_DEC_50 49
+#define BOOST_PP_DEC_51 50
+#define BOOST_PP_DEC_52 51
+#define BOOST_PP_DEC_53 52
+#define BOOST_PP_DEC_54 53
+#define BOOST_PP_DEC_55 54
+#define BOOST_PP_DEC_56 55
+#define BOOST_PP_DEC_57 56
+#define BOOST_PP_DEC_58 57
+#define BOOST_PP_DEC_59 58
+#define BOOST_PP_DEC_60 59
+#define BOOST_PP_DEC_61 60
+#define BOOST_PP_DEC_62 61
+#define BOOST_PP_DEC_63 62
+#define BOOST_PP_DEC_64 63
+#define BOOST_PP_DEC_65 64
+#define BOOST_PP_DEC_66 65
+#define BOOST_PP_DEC_67 66
+#define BOOST_PP_DEC_68 67
+#define BOOST_PP_DEC_69 68
+#define BOOST_PP_DEC_70 69
+#define BOOST_PP_DEC_71 70
+#define BOOST_PP_DEC_72 71
+#define BOOST_PP_DEC_73 72
+#define BOOST_PP_DEC_74 73
+#define BOOST_PP_DEC_75 74
+#define BOOST_PP_DEC_76 75
+#define BOOST_PP_DEC_77 76
+#define BOOST_PP_DEC_78 77
+#define BOOST_PP_DEC_79 78
+#define BOOST_PP_DEC_80 79
+#define BOOST_PP_DEC_81 80
+#define BOOST_PP_DEC_82 81
+#define BOOST_PP_DEC_83 82
+#define BOOST_PP_DEC_84 83
+#define BOOST_PP_DEC_85 84
+#define BOOST_PP_DEC_86 85
+#define BOOST_PP_DEC_87 86
+#define BOOST_PP_DEC_88 87
+#define BOOST_PP_DEC_89 88
+#define BOOST_PP_DEC_90 89
+#define BOOST_PP_DEC_91 90
+#define BOOST_PP_DEC_92 91
+#define BOOST_PP_DEC_93 92
+#define BOOST_PP_DEC_94 93
+#define BOOST_PP_DEC_95 94
+#define BOOST_PP_DEC_96 95
+#define BOOST_PP_DEC_97 96
+#define BOOST_PP_DEC_98 97
+#define BOOST_PP_DEC_99 98
+#define BOOST_PP_DEC_100 99
+#define BOOST_PP_DEC_101 100
+#define BOOST_PP_DEC_102 101
+#define BOOST_PP_DEC_103 102
+#define BOOST_PP_DEC_104 103
+#define BOOST_PP_DEC_105 104
+#define BOOST_PP_DEC_106 105
+#define BOOST_PP_DEC_107 106
+#define BOOST_PP_DEC_108 107
+#define BOOST_PP_DEC_109 108
+#define BOOST_PP_DEC_110 109
+#define BOOST_PP_DEC_111 110
+#define BOOST_PP_DEC_112 111
+#define BOOST_PP_DEC_113 112
+#define BOOST_PP_DEC_114 113
+#define BOOST_PP_DEC_115 114
+#define BOOST_PP_DEC_116 115
+#define BOOST_PP_DEC_117 116
+#define BOOST_PP_DEC_118 117
+#define BOOST_PP_DEC_119 118
+#define BOOST_PP_DEC_120 119
+#define BOOST_PP_DEC_121 120
+#define BOOST_PP_DEC_122 121
+#define BOOST_PP_DEC_123 122
+#define BOOST_PP_DEC_124 123
+#define BOOST_PP_DEC_125 124
+#define BOOST_PP_DEC_126 125
+#define BOOST_PP_DEC_127 126
+#define BOOST_PP_DEC_128 127
+#define BOOST_PP_DEC_129 128
+#define BOOST_PP_DEC_130 129
+#define BOOST_PP_DEC_131 130
+#define BOOST_PP_DEC_132 131
+#define BOOST_PP_DEC_133 132
+#define BOOST_PP_DEC_134 133
+#define BOOST_PP_DEC_135 134
+#define BOOST_PP_DEC_136 135
+#define BOOST_PP_DEC_137 136
+#define BOOST_PP_DEC_138 137
+#define BOOST_PP_DEC_139 138
+#define BOOST_PP_DEC_140 139
+#define BOOST_PP_DEC_141 140
+#define BOOST_PP_DEC_142 141
+#define BOOST_PP_DEC_143 142
+#define BOOST_PP_DEC_144 143
+#define BOOST_PP_DEC_145 144
+#define BOOST_PP_DEC_146 145
+#define BOOST_PP_DEC_147 146
+#define BOOST_PP_DEC_148 147
+#define BOOST_PP_DEC_149 148
+#define BOOST_PP_DEC_150 149
+#define BOOST_PP_DEC_151 150
+#define BOOST_PP_DEC_152 151
+#define BOOST_PP_DEC_153 152
+#define BOOST_PP_DEC_154 153
+#define BOOST_PP_DEC_155 154
+#define BOOST_PP_DEC_156 155
+#define BOOST_PP_DEC_157 156
+#define BOOST_PP_DEC_158 157
+#define BOOST_PP_DEC_159 158
+#define BOOST_PP_DEC_160 159
+#define BOOST_PP_DEC_161 160
+#define BOOST_PP_DEC_162 161
+#define BOOST_PP_DEC_163 162
+#define BOOST_PP_DEC_164 163
+#define BOOST_PP_DEC_165 164
+#define BOOST_PP_DEC_166 165
+#define BOOST_PP_DEC_167 166
+#define BOOST_PP_DEC_168 167
+#define BOOST_PP_DEC_169 168
+#define BOOST_PP_DEC_170 169
+#define BOOST_PP_DEC_171 170
+#define BOOST_PP_DEC_172 171
+#define BOOST_PP_DEC_173 172
+#define BOOST_PP_DEC_174 173
+#define BOOST_PP_DEC_175 174
+#define BOOST_PP_DEC_176 175
+#define BOOST_PP_DEC_177 176
+#define BOOST_PP_DEC_178 177
+#define BOOST_PP_DEC_179 178
+#define BOOST_PP_DEC_180 179
+#define BOOST_PP_DEC_181 180
+#define BOOST_PP_DEC_182 181
+#define BOOST_PP_DEC_183 182
+#define BOOST_PP_DEC_184 183
+#define BOOST_PP_DEC_185 184
+#define BOOST_PP_DEC_186 185
+#define BOOST_PP_DEC_187 186
+#define BOOST_PP_DEC_188 187
+#define BOOST_PP_DEC_189 188
+#define BOOST_PP_DEC_190 189
+#define BOOST_PP_DEC_191 190
+#define BOOST_PP_DEC_192 191
+#define BOOST_PP_DEC_193 192
+#define BOOST_PP_DEC_194 193
+#define BOOST_PP_DEC_195 194
+#define BOOST_PP_DEC_196 195
+#define BOOST_PP_DEC_197 196
+#define BOOST_PP_DEC_198 197
+#define BOOST_PP_DEC_199 198
+#define BOOST_PP_DEC_200 199
+#define BOOST_PP_DEC_201 200
+#define BOOST_PP_DEC_202 201
+#define BOOST_PP_DEC_203 202
+#define BOOST_PP_DEC_204 203
+#define BOOST_PP_DEC_205 204
+#define BOOST_PP_DEC_206 205
+#define BOOST_PP_DEC_207 206
+#define BOOST_PP_DEC_208 207
+#define BOOST_PP_DEC_209 208
+#define BOOST_PP_DEC_210 209
+#define BOOST_PP_DEC_211 210
+#define BOOST_PP_DEC_212 211
+#define BOOST_PP_DEC_213 212
+#define BOOST_PP_DEC_214 213
+#define BOOST_PP_DEC_215 214
+#define BOOST_PP_DEC_216 215
+#define BOOST_PP_DEC_217 216
+#define BOOST_PP_DEC_218 217
+#define BOOST_PP_DEC_219 218
+#define BOOST_PP_DEC_220 219
+#define BOOST_PP_DEC_221 220
+#define BOOST_PP_DEC_222 221
+#define BOOST_PP_DEC_223 222
+#define BOOST_PP_DEC_224 223
+#define BOOST_PP_DEC_225 224
+#define BOOST_PP_DEC_226 225
+#define BOOST_PP_DEC_227 226
+#define BOOST_PP_DEC_228 227
+#define BOOST_PP_DEC_229 228
+#define BOOST_PP_DEC_230 229
+#define BOOST_PP_DEC_231 230
+#define BOOST_PP_DEC_232 231
+#define BOOST_PP_DEC_233 232
+#define BOOST_PP_DEC_234 233
+#define BOOST_PP_DEC_235 234
+#define BOOST_PP_DEC_236 235
+#define BOOST_PP_DEC_237 236
+#define BOOST_PP_DEC_238 237
+#define BOOST_PP_DEC_239 238
+#define BOOST_PP_DEC_240 239
+#define BOOST_PP_DEC_241 240
+#define BOOST_PP_DEC_242 241
+#define BOOST_PP_DEC_243 242
+#define BOOST_PP_DEC_244 243
+#define BOOST_PP_DEC_245 244
+#define BOOST_PP_DEC_246 245
+#define BOOST_PP_DEC_247 246
+#define BOOST_PP_DEC_248 247
+#define BOOST_PP_DEC_249 248
+#define BOOST_PP_DEC_250 249
+#define BOOST_PP_DEC_251 250
+#define BOOST_PP_DEC_252 251
+#define BOOST_PP_DEC_253 252
+#define BOOST_PP_DEC_254 253
+#define BOOST_PP_DEC_255 254
+#define BOOST_PP_DEC_256 255
+#define BOOST_PP_DEC_257 256
+# 16 "/usr/include/boost/preprocessor/seq/for_each.hpp" 2 3 4
+
+# 1 "/usr/include/boost/preprocessor/control/if.hpp" 1 3 4
+# 15 "/usr/include/boost/preprocessor/control/if.hpp" 3 4
+#define BOOST_PREPROCESSOR_CONTROL_IF_HPP 
+
+
+# 1 "/usr/include/boost/preprocessor/control/iif.hpp" 1 3 4
+# 13 "/usr/include/boost/preprocessor/control/iif.hpp" 3 4
+#define BOOST_PREPROCESSOR_CONTROL_IIF_HPP 
+
+
+
+
+#define BOOST_PP_IIF(bit,t,f) BOOST_PP_IIF_I(bit, t, f)
+
+
+
+
+
+
+#define BOOST_PP_IIF_I(bit,t,f) BOOST_PP_IIF_ ## bit(t, f)
+
+
+
+
+
+#define BOOST_PP_IIF_0(t,f) f
+#define BOOST_PP_IIF_1(t,f) t
+# 19 "/usr/include/boost/preprocessor/control/if.hpp" 2 3 4
+# 1 "/usr/include/boost/preprocessor/logical/bool.hpp" 1 3 4
+# 15 "/usr/include/boost/preprocessor/logical/bool.hpp" 3 4
+#define BOOST_PREPROCESSOR_LOGICAL_BOOL_HPP 
+
+
+
+
+
+
+#define BOOST_PP_BOOL(x) BOOST_PP_BOOL_I(x)
+
+
+
+
+
+#define BOOST_PP_BOOL_I(x) BOOST_PP_BOOL_ ## x
+
+#define BOOST_PP_BOOL_0 0
+#define BOOST_PP_BOOL_1 1
+#define BOOST_PP_BOOL_2 1
+#define BOOST_PP_BOOL_3 1
+#define BOOST_PP_BOOL_4 1
+#define BOOST_PP_BOOL_5 1
+#define BOOST_PP_BOOL_6 1
+#define BOOST_PP_BOOL_7 1
+#define BOOST_PP_BOOL_8 1
+#define BOOST_PP_BOOL_9 1
+#define BOOST_PP_BOOL_10 1
+#define BOOST_PP_BOOL_11 1
+#define BOOST_PP_BOOL_12 1
+#define BOOST_PP_BOOL_13 1
+#define BOOST_PP_BOOL_14 1
+#define BOOST_PP_BOOL_15 1
+#define BOOST_PP_BOOL_16 1
+#define BOOST_PP_BOOL_17 1
+#define BOOST_PP_BOOL_18 1
+#define BOOST_PP_BOOL_19 1
+#define BOOST_PP_BOOL_20 1
+#define BOOST_PP_BOOL_21 1
+#define BOOST_PP_BOOL_22 1
+#define BOOST_PP_BOOL_23 1
+#define BOOST_PP_BOOL_24 1
+#define BOOST_PP_BOOL_25 1
+#define BOOST_PP_BOOL_26 1
+#define BOOST_PP_BOOL_27 1
+#define BOOST_PP_BOOL_28 1
+#define BOOST_PP_BOOL_29 1
+#define BOOST_PP_BOOL_30 1
+#define BOOST_PP_BOOL_31 1
+#define BOOST_PP_BOOL_32 1
+#define BOOST_PP_BOOL_33 1
+#define BOOST_PP_BOOL_34 1
+#define BOOST_PP_BOOL_35 1
+#define BOOST_PP_BOOL_36 1
+#define BOOST_PP_BOOL_37 1
+#define BOOST_PP_BOOL_38 1
+#define BOOST_PP_BOOL_39 1
+#define BOOST_PP_BOOL_40 1
+#define BOOST_PP_BOOL_41 1
+#define BOOST_PP_BOOL_42 1
+#define BOOST_PP_BOOL_43 1
+#define BOOST_PP_BOOL_44 1
+#define BOOST_PP_BOOL_45 1
+#define BOOST_PP_BOOL_46 1
+#define BOOST_PP_BOOL_47 1
+#define BOOST_PP_BOOL_48 1
+#define BOOST_PP_BOOL_49 1
+#define BOOST_PP_BOOL_50 1
+#define BOOST_PP_BOOL_51 1
+#define BOOST_PP_BOOL_52 1
+#define BOOST_PP_BOOL_53 1
+#define BOOST_PP_BOOL_54 1
+#define BOOST_PP_BOOL_55 1
+#define BOOST_PP_BOOL_56 1
+#define BOOST_PP_BOOL_57 1
+#define BOOST_PP_BOOL_58 1
+#define BOOST_PP_BOOL_59 1
+#define BOOST_PP_BOOL_60 1
+#define BOOST_PP_BOOL_61 1
+#define BOOST_PP_BOOL_62 1
+#define BOOST_PP_BOOL_63 1
+#define BOOST_PP_BOOL_64 1
+#define BOOST_PP_BOOL_65 1
+#define BOOST_PP_BOOL_66 1
+#define BOOST_PP_BOOL_67 1
+#define BOOST_PP_BOOL_68 1
+#define BOOST_PP_BOOL_69 1
+#define BOOST_PP_BOOL_70 1
+#define BOOST_PP_BOOL_71 1
+#define BOOST_PP_BOOL_72 1
+#define BOOST_PP_BOOL_73 1
+#define BOOST_PP_BOOL_74 1
+#define BOOST_PP_BOOL_75 1
+#define BOOST_PP_BOOL_76 1
+#define BOOST_PP_BOOL_77 1
+#define BOOST_PP_BOOL_78 1
+#define BOOST_PP_BOOL_79 1
+#define BOOST_PP_BOOL_80 1
+#define BOOST_PP_BOOL_81 1
+#define BOOST_PP_BOOL_82 1
+#define BOOST_PP_BOOL_83 1
+#define BOOST_PP_BOOL_84 1
+#define BOOST_PP_BOOL_85 1
+#define BOOST_PP_BOOL_86 1
+#define BOOST_PP_BOOL_87 1
+#define BOOST_PP_BOOL_88 1
+#define BOOST_PP_BOOL_89 1
+#define BOOST_PP_BOOL_90 1
+#define BOOST_PP_BOOL_91 1
+#define BOOST_PP_BOOL_92 1
+#define BOOST_PP_BOOL_93 1
+#define BOOST_PP_BOOL_94 1
+#define BOOST_PP_BOOL_95 1
+#define BOOST_PP_BOOL_96 1
+#define BOOST_PP_BOOL_97 1
+#define BOOST_PP_BOOL_98 1
+#define BOOST_PP_BOOL_99 1
+#define BOOST_PP_BOOL_100 1
+#define BOOST_PP_BOOL_101 1
+#define BOOST_PP_BOOL_102 1
+#define BOOST_PP_BOOL_103 1
+#define BOOST_PP_BOOL_104 1
+#define BOOST_PP_BOOL_105 1
+#define BOOST_PP_BOOL_106 1
+#define BOOST_PP_BOOL_107 1
+#define BOOST_PP_BOOL_108 1
+#define BOOST_PP_BOOL_109 1
+#define BOOST_PP_BOOL_110 1
+#define BOOST_PP_BOOL_111 1
+#define BOOST_PP_BOOL_112 1
+#define BOOST_PP_BOOL_113 1
+#define BOOST_PP_BOOL_114 1
+#define BOOST_PP_BOOL_115 1
+#define BOOST_PP_BOOL_116 1
+#define BOOST_PP_BOOL_117 1
+#define BOOST_PP_BOOL_118 1
+#define BOOST_PP_BOOL_119 1
+#define BOOST_PP_BOOL_120 1
+#define BOOST_PP_BOOL_121 1
+#define BOOST_PP_BOOL_122 1
+#define BOOST_PP_BOOL_123 1
+#define BOOST_PP_BOOL_124 1
+#define BOOST_PP_BOOL_125 1
+#define BOOST_PP_BOOL_126 1
+#define BOOST_PP_BOOL_127 1
+#define BOOST_PP_BOOL_128 1
+#define BOOST_PP_BOOL_129 1
+#define BOOST_PP_BOOL_130 1
+#define BOOST_PP_BOOL_131 1
+#define BOOST_PP_BOOL_132 1
+#define BOOST_PP_BOOL_133 1
+#define BOOST_PP_BOOL_134 1
+#define BOOST_PP_BOOL_135 1
+#define BOOST_PP_BOOL_136 1
+#define BOOST_PP_BOOL_137 1
+#define BOOST_PP_BOOL_138 1
+#define BOOST_PP_BOOL_139 1
+#define BOOST_PP_BOOL_140 1
+#define BOOST_PP_BOOL_141 1
+#define BOOST_PP_BOOL_142 1
+#define BOOST_PP_BOOL_143 1
+#define BOOST_PP_BOOL_144 1
+#define BOOST_PP_BOOL_145 1
+#define BOOST_PP_BOOL_146 1
+#define BOOST_PP_BOOL_147 1
+#define BOOST_PP_BOOL_148 1
+#define BOOST_PP_BOOL_149 1
+#define BOOST_PP_BOOL_150 1
+#define BOOST_PP_BOOL_151 1
+#define BOOST_PP_BOOL_152 1
+#define BOOST_PP_BOOL_153 1
+#define BOOST_PP_BOOL_154 1
+#define BOOST_PP_BOOL_155 1
+#define BOOST_PP_BOOL_156 1
+#define BOOST_PP_BOOL_157 1
+#define BOOST_PP_BOOL_158 1
+#define BOOST_PP_BOOL_159 1
+#define BOOST_PP_BOOL_160 1
+#define BOOST_PP_BOOL_161 1
+#define BOOST_PP_BOOL_162 1
+#define BOOST_PP_BOOL_163 1
+#define BOOST_PP_BOOL_164 1
+#define BOOST_PP_BOOL_165 1
+#define BOOST_PP_BOOL_166 1
+#define BOOST_PP_BOOL_167 1
+#define BOOST_PP_BOOL_168 1
+#define BOOST_PP_BOOL_169 1
+#define BOOST_PP_BOOL_170 1
+#define BOOST_PP_BOOL_171 1
+#define BOOST_PP_BOOL_172 1
+#define BOOST_PP_BOOL_173 1
+#define BOOST_PP_BOOL_174 1
+#define BOOST_PP_BOOL_175 1
+#define BOOST_PP_BOOL_176 1
+#define BOOST_PP_BOOL_177 1
+#define BOOST_PP_BOOL_178 1
+#define BOOST_PP_BOOL_179 1
+#define BOOST_PP_BOOL_180 1
+#define BOOST_PP_BOOL_181 1
+#define BOOST_PP_BOOL_182 1
+#define BOOST_PP_BOOL_183 1
+#define BOOST_PP_BOOL_184 1
+#define BOOST_PP_BOOL_185 1
+#define BOOST_PP_BOOL_186 1
+#define BOOST_PP_BOOL_187 1
+#define BOOST_PP_BOOL_188 1
+#define BOOST_PP_BOOL_189 1
+#define BOOST_PP_BOOL_190 1
+#define BOOST_PP_BOOL_191 1
+#define BOOST_PP_BOOL_192 1
+#define BOOST_PP_BOOL_193 1
+#define BOOST_PP_BOOL_194 1
+#define BOOST_PP_BOOL_195 1
+#define BOOST_PP_BOOL_196 1
+#define BOOST_PP_BOOL_197 1
+#define BOOST_PP_BOOL_198 1
+#define BOOST_PP_BOOL_199 1
+#define BOOST_PP_BOOL_200 1
+#define BOOST_PP_BOOL_201 1
+#define BOOST_PP_BOOL_202 1
+#define BOOST_PP_BOOL_203 1
+#define BOOST_PP_BOOL_204 1
+#define BOOST_PP_BOOL_205 1
+#define BOOST_PP_BOOL_206 1
+#define BOOST_PP_BOOL_207 1
+#define BOOST_PP_BOOL_208 1
+#define BOOST_PP_BOOL_209 1
+#define BOOST_PP_BOOL_210 1
+#define BOOST_PP_BOOL_211 1
+#define BOOST_PP_BOOL_212 1
+#define BOOST_PP_BOOL_213 1
+#define BOOST_PP_BOOL_214 1
+#define BOOST_PP_BOOL_215 1
+#define BOOST_PP_BOOL_216 1
+#define BOOST_PP_BOOL_217 1
+#define BOOST_PP_BOOL_218 1
+#define BOOST_PP_BOOL_219 1
+#define BOOST_PP_BOOL_220 1
+#define BOOST_PP_BOOL_221 1
+#define BOOST_PP_BOOL_222 1
+#define BOOST_PP_BOOL_223 1
+#define BOOST_PP_BOOL_224 1
+#define BOOST_PP_BOOL_225 1
+#define BOOST_PP_BOOL_226 1
+#define BOOST_PP_BOOL_227 1
+#define BOOST_PP_BOOL_228 1
+#define BOOST_PP_BOOL_229 1
+#define BOOST_PP_BOOL_230 1
+#define BOOST_PP_BOOL_231 1
+#define BOOST_PP_BOOL_232 1
+#define BOOST_PP_BOOL_233 1
+#define BOOST_PP_BOOL_234 1
+#define BOOST_PP_BOOL_235 1
+#define BOOST_PP_BOOL_236 1
+#define BOOST_PP_BOOL_237 1
+#define BOOST_PP_BOOL_238 1
+#define BOOST_PP_BOOL_239 1
+#define BOOST_PP_BOOL_240 1
+#define BOOST_PP_BOOL_241 1
+#define BOOST_PP_BOOL_242 1
+#define BOOST_PP_BOOL_243 1
+#define BOOST_PP_BOOL_244 1
+#define BOOST_PP_BOOL_245 1
+#define BOOST_PP_BOOL_246 1
+#define BOOST_PP_BOOL_247 1
+#define BOOST_PP_BOOL_248 1
+#define BOOST_PP_BOOL_249 1
+#define BOOST_PP_BOOL_250 1
+#define BOOST_PP_BOOL_251 1
+#define BOOST_PP_BOOL_252 1
+#define BOOST_PP_BOOL_253 1
+#define BOOST_PP_BOOL_254 1
+#define BOOST_PP_BOOL_255 1
+#define BOOST_PP_BOOL_256 1
+# 20 "/usr/include/boost/preprocessor/control/if.hpp" 2 3 4
+
+
+
+
+#define BOOST_PP_IF(cond,t,f) BOOST_PP_IIF(BOOST_PP_BOOL(cond), t, f)
+# 18 "/usr/include/boost/preprocessor/seq/for_each.hpp" 2 3 4
+
+# 1 "/usr/include/boost/preprocessor/repetition/for.hpp" 1 3 4
+# 15 "/usr/include/boost/preprocessor/repetition/for.hpp" 3 4
+#define BOOST_PREPROCESSOR_REPETITION_FOR_HPP 
+
+# 1 "/usr/include/boost/preprocessor/cat.hpp" 1 3 4
+# 15 "/usr/include/boost/preprocessor/cat.hpp" 3 4
+#define BOOST_PREPROCESSOR_CAT_HPP 
+
+
+
+
+
+
+#define BOOST_PP_CAT(a,b) BOOST_PP_CAT_I(a, b)
+
+
+
+
+
+
+#define BOOST_PP_CAT_I(a,b) a ## b
+# 18 "/usr/include/boost/preprocessor/repetition/for.hpp" 2 3 4
+# 1 "/usr/include/boost/preprocessor/debug/error.hpp" 1 3 4
+# 13 "/usr/include/boost/preprocessor/debug/error.hpp" 3 4
+#define BOOST_PREPROCESSOR_DEBUG_ERROR_HPP 
+
+
+
+
+
+
+
+#define BOOST_PP_ERROR(code) BOOST_PP_CAT(BOOST_PP_ERROR_, code)
+
+
+#define BOOST_PP_ERROR_0x0000 BOOST_PP_ERROR(0x0000, BOOST_PP_INDEX_OUT_OF_BOUNDS)
+#define BOOST_PP_ERROR_0x0001 BOOST_PP_ERROR(0x0001, BOOST_PP_WHILE_OVERFLOW)
+#define BOOST_PP_ERROR_0x0002 BOOST_PP_ERROR(0x0002, BOOST_PP_FOR_OVERFLOW)
+#define BOOST_PP_ERROR_0x0003 BOOST_PP_ERROR(0x0003, BOOST_PP_REPEAT_OVERFLOW)
+#define BOOST_PP_ERROR_0x0004 BOOST_PP_ERROR(0x0004, BOOST_PP_LIST_FOLD_OVERFLOW)
+#define BOOST_PP_ERROR_0x0005 BOOST_PP_ERROR(0x0005, BOOST_PP_SEQ_FOLD_OVERFLOW)
+#define BOOST_PP_ERROR_0x0006 BOOST_PP_ERROR(0x0006, BOOST_PP_ARITHMETIC_OVERFLOW)
+#define BOOST_PP_ERROR_0x0007 BOOST_PP_ERROR(0x0007, BOOST_PP_DIVISION_BY_ZERO)
+# 19 "/usr/include/boost/preprocessor/repetition/for.hpp" 2 3 4
+# 1 "/usr/include/boost/preprocessor/facilities/empty.hpp" 1 3 4
+# 15 "/usr/include/boost/preprocessor/facilities/empty.hpp" 3 4
+#define BOOST_PREPROCESSOR_FACILITIES_EMPTY_HPP 
+
+
+
+
+
+#define BOOST_PP_EMPTY() 
+# 20 "/usr/include/boost/preprocessor/repetition/for.hpp" 2 3 4
+
+# 1 "/usr/include/boost/preprocessor/detail/auto_rec.hpp" 1 3 4
+# 19 "/usr/include/boost/preprocessor/detail/auto_rec.hpp" 3 4
+#define BOOST_PREPROCESSOR_DETAIL_AUTO_REC_HPP 
+
+
+
+
+
+#define BOOST_PP_AUTO_REC(pred,n) BOOST_PP_NODE_ENTRY_ ## n(pred)
+
+#define BOOST_PP_NODE_ENTRY_256(p) BOOST_PP_NODE_128(p)(p)(p)(p)(p)(p)(p)(p)
+#define BOOST_PP_NODE_ENTRY_128(p) BOOST_PP_NODE_64(p)(p)(p)(p)(p)(p)(p)
+#define BOOST_PP_NODE_ENTRY_64(p) BOOST_PP_NODE_32(p)(p)(p)(p)(p)(p)
+#define BOOST_PP_NODE_ENTRY_32(p) BOOST_PP_NODE_16(p)(p)(p)(p)(p)
+#define BOOST_PP_NODE_ENTRY_16(p) BOOST_PP_NODE_8(p)(p)(p)(p)
+#define BOOST_PP_NODE_ENTRY_8(p) BOOST_PP_NODE_4(p)(p)(p)
+#define BOOST_PP_NODE_ENTRY_4(p) BOOST_PP_NODE_2(p)(p)
+#define BOOST_PP_NODE_ENTRY_2(p) BOOST_PP_NODE_1(p)
+
+#define BOOST_PP_NODE_128(p) BOOST_PP_IIF(p(128), BOOST_PP_NODE_64, BOOST_PP_NODE_192)
+#define BOOST_PP_NODE_64(p) BOOST_PP_IIF(p(64), BOOST_PP_NODE_32, BOOST_PP_NODE_96)
+#define BOOST_PP_NODE_32(p) BOOST_PP_IIF(p(32), BOOST_PP_NODE_16, BOOST_PP_NODE_48)
+#define BOOST_PP_NODE_16(p) BOOST_PP_IIF(p(16), BOOST_PP_NODE_8, BOOST_PP_NODE_24)
+#define BOOST_PP_NODE_8(p) BOOST_PP_IIF(p(8), BOOST_PP_NODE_4, BOOST_PP_NODE_12)
+#define BOOST_PP_NODE_4(p) BOOST_PP_IIF(p(4), BOOST_PP_NODE_2, BOOST_PP_NODE_6)
+#define BOOST_PP_NODE_2(p) BOOST_PP_IIF(p(2), BOOST_PP_NODE_1, BOOST_PP_NODE_3)
+#define BOOST_PP_NODE_1(p) BOOST_PP_IIF(p(1), 1, 2)
+#define BOOST_PP_NODE_3(p) BOOST_PP_IIF(p(3), 3, 4)
+#define BOOST_PP_NODE_6(p) BOOST_PP_IIF(p(6), BOOST_PP_NODE_5, BOOST_PP_NODE_7)
+#define BOOST_PP_NODE_5(p) BOOST_PP_IIF(p(5), 5, 6)
+#define BOOST_PP_NODE_7(p) BOOST_PP_IIF(p(7), 7, 8)
+#define BOOST_PP_NODE_12(p) BOOST_PP_IIF(p(12), BOOST_PP_NODE_10, BOOST_PP_NODE_14)
+#define BOOST_PP_NODE_10(p) BOOST_PP_IIF(p(10), BOOST_PP_NODE_9, BOOST_PP_NODE_11)
+#define BOOST_PP_NODE_9(p) BOOST_PP_IIF(p(9), 9, 10)
+#define BOOST_PP_NODE_11(p) BOOST_PP_IIF(p(11), 11, 12)
+#define BOOST_PP_NODE_14(p) BOOST_PP_IIF(p(14), BOOST_PP_NODE_13, BOOST_PP_NODE_15)
+#define BOOST_PP_NODE_13(p) BOOST_PP_IIF(p(13), 13, 14)
+#define BOOST_PP_NODE_15(p) BOOST_PP_IIF(p(15), 15, 16)
+#define BOOST_PP_NODE_24(p) BOOST_PP_IIF(p(24), BOOST_PP_NODE_20, BOOST_PP_NODE_28)
+#define BOOST_PP_NODE_20(p) BOOST_PP_IIF(p(20), BOOST_PP_NODE_18, BOOST_PP_NODE_22)
+#define BOOST_PP_NODE_18(p) BOOST_PP_IIF(p(18), BOOST_PP_NODE_17, BOOST_PP_NODE_19)
+#define BOOST_PP_NODE_17(p) BOOST_PP_IIF(p(17), 17, 18)
+#define BOOST_PP_NODE_19(p) BOOST_PP_IIF(p(19), 19, 20)
+#define BOOST_PP_NODE_22(p) BOOST_PP_IIF(p(22), BOOST_PP_NODE_21, BOOST_PP_NODE_23)
+#define BOOST_PP_NODE_21(p) BOOST_PP_IIF(p(21), 21, 22)
+#define BOOST_PP_NODE_23(p) BOOST_PP_IIF(p(23), 23, 24)
+#define BOOST_PP_NODE_28(p) BOOST_PP_IIF(p(28), BOOST_PP_NODE_26, BOOST_PP_NODE_30)
+#define BOOST_PP_NODE_26(p) BOOST_PP_IIF(p(26), BOOST_PP_NODE_25, BOOST_PP_NODE_27)
+#define BOOST_PP_NODE_25(p) BOOST_PP_IIF(p(25), 25, 26)
+#define BOOST_PP_NODE_27(p) BOOST_PP_IIF(p(27), 27, 28)
+#define BOOST_PP_NODE_30(p) BOOST_PP_IIF(p(30), BOOST_PP_NODE_29, BOOST_PP_NODE_31)
+#define BOOST_PP_NODE_29(p) BOOST_PP_IIF(p(29), 29, 30)
+#define BOOST_PP_NODE_31(p) BOOST_PP_IIF(p(31), 31, 32)
+#define BOOST_PP_NODE_48(p) BOOST_PP_IIF(p(48), BOOST_PP_NODE_40, BOOST_PP_NODE_56)
+#define BOOST_PP_NODE_40(p) BOOST_PP_IIF(p(40), BOOST_PP_NODE_36, BOOST_PP_NODE_44)
+#define BOOST_PP_NODE_36(p) BOOST_PP_IIF(p(36), BOOST_PP_NODE_34, BOOST_PP_NODE_38)
+#define BOOST_PP_NODE_34(p) BOOST_PP_IIF(p(34), BOOST_PP_NODE_33, BOOST_PP_NODE_35)
+#define BOOST_PP_NODE_33(p) BOOST_PP_IIF(p(33), 33, 34)
+#define BOOST_PP_NODE_35(p) BOOST_PP_IIF(p(35), 35, 36)
+#define BOOST_PP_NODE_38(p) BOOST_PP_IIF(p(38), BOOST_PP_NODE_37, BOOST_PP_NODE_39)
+#define BOOST_PP_NODE_37(p) BOOST_PP_IIF(p(37), 37, 38)
+#define BOOST_PP_NODE_39(p) BOOST_PP_IIF(p(39), 39, 40)
+#define BOOST_PP_NODE_44(p) BOOST_PP_IIF(p(44), BOOST_PP_NODE_42, BOOST_PP_NODE_46)
+#define BOOST_PP_NODE_42(p) BOOST_PP_IIF(p(42), BOOST_PP_NODE_41, BOOST_PP_NODE_43)
+#define BOOST_PP_NODE_41(p) BOOST_PP_IIF(p(41), 41, 42)
+#define BOOST_PP_NODE_43(p) BOOST_PP_IIF(p(43), 43, 44)
+#define BOOST_PP_NODE_46(p) BOOST_PP_IIF(p(46), BOOST_PP_NODE_45, BOOST_PP_NODE_47)
+#define BOOST_PP_NODE_45(p) BOOST_PP_IIF(p(45), 45, 46)
+#define BOOST_PP_NODE_47(p) BOOST_PP_IIF(p(47), 47, 48)
+#define BOOST_PP_NODE_56(p) BOOST_PP_IIF(p(56), BOOST_PP_NODE_52, BOOST_PP_NODE_60)
+#define BOOST_PP_NODE_52(p) BOOST_PP_IIF(p(52), BOOST_PP_NODE_50, BOOST_PP_NODE_54)
+#define BOOST_PP_NODE_50(p) BOOST_PP_IIF(p(50), BOOST_PP_NODE_49, BOOST_PP_NODE_51)
+#define BOOST_PP_NODE_49(p) BOOST_PP_IIF(p(49), 49, 50)
+#define BOOST_PP_NODE_51(p) BOOST_PP_IIF(p(51), 51, 52)
+#define BOOST_PP_NODE_54(p) BOOST_PP_IIF(p(54), BOOST_PP_NODE_53, BOOST_PP_NODE_55)
+#define BOOST_PP_NODE_53(p) BOOST_PP_IIF(p(53), 53, 54)
+#define BOOST_PP_NODE_55(p) BOOST_PP_IIF(p(55), 55, 56)
+#define BOOST_PP_NODE_60(p) BOOST_PP_IIF(p(60), BOOST_PP_NODE_58, BOOST_PP_NODE_62)
+#define BOOST_PP_NODE_58(p) BOOST_PP_IIF(p(58), BOOST_PP_NODE_57, BOOST_PP_NODE_59)
+#define BOOST_PP_NODE_57(p) BOOST_PP_IIF(p(57), 57, 58)
+#define BOOST_PP_NODE_59(p) BOOST_PP_IIF(p(59), 59, 60)
+#define BOOST_PP_NODE_62(p) BOOST_PP_IIF(p(62), BOOST_PP_NODE_61, BOOST_PP_NODE_63)
+#define BOOST_PP_NODE_61(p) BOOST_PP_IIF(p(61), 61, 62)
+#define BOOST_PP_NODE_63(p) BOOST_PP_IIF(p(63), 63, 64)
+#define BOOST_PP_NODE_96(p) BOOST_PP_IIF(p(96), BOOST_PP_NODE_80, BOOST_PP_NODE_112)
+#define BOOST_PP_NODE_80(p) BOOST_PP_IIF(p(80), BOOST_PP_NODE_72, BOOST_PP_NODE_88)
+#define BOOST_PP_NODE_72(p) BOOST_PP_IIF(p(72), BOOST_PP_NODE_68, BOOST_PP_NODE_76)
+#define BOOST_PP_NODE_68(p) BOOST_PP_IIF(p(68), BOOST_PP_NODE_66, BOOST_PP_NODE_70)
+#define BOOST_PP_NODE_66(p) BOOST_PP_IIF(p(66), BOOST_PP_NODE_65, BOOST_PP_NODE_67)
+#define BOOST_PP_NODE_65(p) BOOST_PP_IIF(p(65), 65, 66)
+#define BOOST_PP_NODE_67(p) BOOST_PP_IIF(p(67), 67, 68)
+#define BOOST_PP_NODE_70(p) BOOST_PP_IIF(p(70), BOOST_PP_NODE_69, BOOST_PP_NODE_71)
+#define BOOST_PP_NODE_69(p) BOOST_PP_IIF(p(69), 69, 70)
+#define BOOST_PP_NODE_71(p) BOOST_PP_IIF(p(71), 71, 72)
+#define BOOST_PP_NODE_76(p) BOOST_PP_IIF(p(76), BOOST_PP_NODE_74, BOOST_PP_NODE_78)
+#define BOOST_PP_NODE_74(p) BOOST_PP_IIF(p(74), BOOST_PP_NODE_73, BOOST_PP_NODE_75)
+#define BOOST_PP_NODE_73(p) BOOST_PP_IIF(p(73), 73, 74)
+#define BOOST_PP_NODE_75(p) BOOST_PP_IIF(p(75), 75, 76)
+#define BOOST_PP_NODE_78(p) BOOST_PP_IIF(p(78), BOOST_PP_NODE_77, BOOST_PP_NODE_79)
+#define BOOST_PP_NODE_77(p) BOOST_PP_IIF(p(77), 77, 78)
+#define BOOST_PP_NODE_79(p) BOOST_PP_IIF(p(79), 79, 80)
+#define BOOST_PP_NODE_88(p) BOOST_PP_IIF(p(88), BOOST_PP_NODE_84, BOOST_PP_NODE_92)
+#define BOOST_PP_NODE_84(p) BOOST_PP_IIF(p(84), BOOST_PP_NODE_82, BOOST_PP_NODE_86)
+#define BOOST_PP_NODE_82(p) BOOST_PP_IIF(p(82), BOOST_PP_NODE_81, BOOST_PP_NODE_83)
+#define BOOST_PP_NODE_81(p) BOOST_PP_IIF(p(81), 81, 82)
+#define BOOST_PP_NODE_83(p) BOOST_PP_IIF(p(83), 83, 84)
+#define BOOST_PP_NODE_86(p) BOOST_PP_IIF(p(86), BOOST_PP_NODE_85, BOOST_PP_NODE_87)
+#define BOOST_PP_NODE_85(p) BOOST_PP_IIF(p(85), 85, 86)
+#define BOOST_PP_NODE_87(p) BOOST_PP_IIF(p(87), 87, 88)
+#define BOOST_PP_NODE_92(p) BOOST_PP_IIF(p(92), BOOST_PP_NODE_90, BOOST_PP_NODE_94)
+#define BOOST_PP_NODE_90(p) BOOST_PP_IIF(p(90), BOOST_PP_NODE_89, BOOST_PP_NODE_91)
+#define BOOST_PP_NODE_89(p) BOOST_PP_IIF(p(89), 89, 90)
+#define BOOST_PP_NODE_91(p) BOOST_PP_IIF(p(91), 91, 92)
+#define BOOST_PP_NODE_94(p) BOOST_PP_IIF(p(94), BOOST_PP_NODE_93, BOOST_PP_NODE_95)
+#define BOOST_PP_NODE_93(p) BOOST_PP_IIF(p(93), 93, 94)
+#define BOOST_PP_NODE_95(p) BOOST_PP_IIF(p(95), 95, 96)
+#define BOOST_PP_NODE_112(p) BOOST_PP_IIF(p(112), BOOST_PP_NODE_104, BOOST_PP_NODE_120)
+#define BOOST_PP_NODE_104(p) BOOST_PP_IIF(p(104), BOOST_PP_NODE_100, BOOST_PP_NODE_108)
+#define BOOST_PP_NODE_100(p) BOOST_PP_IIF(p(100), BOOST_PP_NODE_98, BOOST_PP_NODE_102)
+#define BOOST_PP_NODE_98(p) BOOST_PP_IIF(p(98), BOOST_PP_NODE_97, BOOST_PP_NODE_99)
+#define BOOST_PP_NODE_97(p) BOOST_PP_IIF(p(97), 97, 98)
+#define BOOST_PP_NODE_99(p) BOOST_PP_IIF(p(99), 99, 100)
+#define BOOST_PP_NODE_102(p) BOOST_PP_IIF(p(102), BOOST_PP_NODE_101, BOOST_PP_NODE_103)
+#define BOOST_PP_NODE_101(p) BOOST_PP_IIF(p(101), 101, 102)
+#define BOOST_PP_NODE_103(p) BOOST_PP_IIF(p(103), 103, 104)
+#define BOOST_PP_NODE_108(p) BOOST_PP_IIF(p(108), BOOST_PP_NODE_106, BOOST_PP_NODE_110)
+#define BOOST_PP_NODE_106(p) BOOST_PP_IIF(p(106), BOOST_PP_NODE_105, BOOST_PP_NODE_107)
+#define BOOST_PP_NODE_105(p) BOOST_PP_IIF(p(105), 105, 106)
+#define BOOST_PP_NODE_107(p) BOOST_PP_IIF(p(107), 107, 108)
+#define BOOST_PP_NODE_110(p) BOOST_PP_IIF(p(110), BOOST_PP_NODE_109, BOOST_PP_NODE_111)
+#define BOOST_PP_NODE_109(p) BOOST_PP_IIF(p(109), 109, 110)
+#define BOOST_PP_NODE_111(p) BOOST_PP_IIF(p(111), 111, 112)
+#define BOOST_PP_NODE_120(p) BOOST_PP_IIF(p(120), BOOST_PP_NODE_116, BOOST_PP_NODE_124)
+#define BOOST_PP_NODE_116(p) BOOST_PP_IIF(p(116), BOOST_PP_NODE_114, BOOST_PP_NODE_118)
+#define BOOST_PP_NODE_114(p) BOOST_PP_IIF(p(114), BOOST_PP_NODE_113, BOOST_PP_NODE_115)
+#define BOOST_PP_NODE_113(p) BOOST_PP_IIF(p(113), 113, 114)
+#define BOOST_PP_NODE_115(p) BOOST_PP_IIF(p(115), 115, 116)
+#define BOOST_PP_NODE_118(p) BOOST_PP_IIF(p(118), BOOST_PP_NODE_117, BOOST_PP_NODE_119)
+#define BOOST_PP_NODE_117(p) BOOST_PP_IIF(p(117), 117, 118)
+#define BOOST_PP_NODE_119(p) BOOST_PP_IIF(p(119), 119, 120)
+#define BOOST_PP_NODE_124(p) BOOST_PP_IIF(p(124), BOOST_PP_NODE_122, BOOST_PP_NODE_126)
+#define BOOST_PP_NODE_122(p) BOOST_PP_IIF(p(122), BOOST_PP_NODE_121, BOOST_PP_NODE_123)
+#define BOOST_PP_NODE_121(p) BOOST_PP_IIF(p(121), 121, 122)
+#define BOOST_PP_NODE_123(p) BOOST_PP_IIF(p(123), 123, 124)
+#define BOOST_PP_NODE_126(p) BOOST_PP_IIF(p(126), BOOST_PP_NODE_125, BOOST_PP_NODE_127)
+#define BOOST_PP_NODE_125(p) BOOST_PP_IIF(p(125), 125, 126)
+#define BOOST_PP_NODE_127(p) BOOST_PP_IIF(p(127), 127, 128)
+#define BOOST_PP_NODE_192(p) BOOST_PP_IIF(p(192), BOOST_PP_NODE_160, BOOST_PP_NODE_224)
+#define BOOST_PP_NODE_160(p) BOOST_PP_IIF(p(160), BOOST_PP_NODE_144, BOOST_PP_NODE_176)
+#define BOOST_PP_NODE_144(p) BOOST_PP_IIF(p(144), BOOST_PP_NODE_136, BOOST_PP_NODE_152)
+#define BOOST_PP_NODE_136(p) BOOST_PP_IIF(p(136), BOOST_PP_NODE_132, BOOST_PP_NODE_140)
+#define BOOST_PP_NODE_132(p) BOOST_PP_IIF(p(132), BOOST_PP_NODE_130, BOOST_PP_NODE_134)
+#define BOOST_PP_NODE_130(p) BOOST_PP_IIF(p(130), BOOST_PP_NODE_129, BOOST_PP_NODE_131)
+#define BOOST_PP_NODE_129(p) BOOST_PP_IIF(p(129), 129, 130)
+#define BOOST_PP_NODE_131(p) BOOST_PP_IIF(p(131), 131, 132)
+#define BOOST_PP_NODE_134(p) BOOST_PP_IIF(p(134), BOOST_PP_NODE_133, BOOST_PP_NODE_135)
+#define BOOST_PP_NODE_133(p) BOOST_PP_IIF(p(133), 133, 134)
+#define BOOST_PP_NODE_135(p) BOOST_PP_IIF(p(135), 135, 136)
+#define BOOST_PP_NODE_140(p) BOOST_PP_IIF(p(140), BOOST_PP_NODE_138, BOOST_PP_NODE_142)
+#define BOOST_PP_NODE_138(p) BOOST_PP_IIF(p(138), BOOST_PP_NODE_137, BOOST_PP_NODE_139)
+#define BOOST_PP_NODE_137(p) BOOST_PP_IIF(p(137), 137, 138)
+#define BOOST_PP_NODE_139(p) BOOST_PP_IIF(p(139), 139, 140)
+#define BOOST_PP_NODE_142(p) BOOST_PP_IIF(p(142), BOOST_PP_NODE_141, BOOST_PP_NODE_143)
+#define BOOST_PP_NODE_141(p) BOOST_PP_IIF(p(141), 141, 142)
+#define BOOST_PP_NODE_143(p) BOOST_PP_IIF(p(143), 143, 144)
+#define BOOST_PP_NODE_152(p) BOOST_PP_IIF(p(152), BOOST_PP_NODE_148, BOOST_PP_NODE_156)
+#define BOOST_PP_NODE_148(p) BOOST_PP_IIF(p(148), BOOST_PP_NODE_146, BOOST_PP_NODE_150)
+#define BOOST_PP_NODE_146(p) BOOST_PP_IIF(p(146), BOOST_PP_NODE_145, BOOST_PP_NODE_147)
+#define BOOST_PP_NODE_145(p) BOOST_PP_IIF(p(145), 145, 146)
+#define BOOST_PP_NODE_147(p) BOOST_PP_IIF(p(147), 147, 148)
+#define BOOST_PP_NODE_150(p) BOOST_PP_IIF(p(150), BOOST_PP_NODE_149, BOOST_PP_NODE_151)
+#define BOOST_PP_NODE_149(p) BOOST_PP_IIF(p(149), 149, 150)
+#define BOOST_PP_NODE_151(p) BOOST_PP_IIF(p(151), 151, 152)
+#define BOOST_PP_NODE_156(p) BOOST_PP_IIF(p(156), BOOST_PP_NODE_154, BOOST_PP_NODE_158)
+#define BOOST_PP_NODE_154(p) BOOST_PP_IIF(p(154), BOOST_PP_NODE_153, BOOST_PP_NODE_155)
+#define BOOST_PP_NODE_153(p) BOOST_PP_IIF(p(153), 153, 154)
+#define BOOST_PP_NODE_155(p) BOOST_PP_IIF(p(155), 155, 156)
+#define BOOST_PP_NODE_158(p) BOOST_PP_IIF(p(158), BOOST_PP_NODE_157, BOOST_PP_NODE_159)
+#define BOOST_PP_NODE_157(p) BOOST_PP_IIF(p(157), 157, 158)
+#define BOOST_PP_NODE_159(p) BOOST_PP_IIF(p(159), 159, 160)
+#define BOOST_PP_NODE_176(p) BOOST_PP_IIF(p(176), BOOST_PP_NODE_168, BOOST_PP_NODE_184)
+#define BOOST_PP_NODE_168(p) BOOST_PP_IIF(p(168), BOOST_PP_NODE_164, BOOST_PP_NODE_172)
+#define BOOST_PP_NODE_164(p) BOOST_PP_IIF(p(164), BOOST_PP_NODE_162, BOOST_PP_NODE_166)
+#define BOOST_PP_NODE_162(p) BOOST_PP_IIF(p(162), BOOST_PP_NODE_161, BOOST_PP_NODE_163)
+#define BOOST_PP_NODE_161(p) BOOST_PP_IIF(p(161), 161, 162)
+#define BOOST_PP_NODE_163(p) BOOST_PP_IIF(p(163), 163, 164)
+#define BOOST_PP_NODE_166(p) BOOST_PP_IIF(p(166), BOOST_PP_NODE_165, BOOST_PP_NODE_167)
+#define BOOST_PP_NODE_165(p) BOOST_PP_IIF(p(165), 165, 166)
+#define BOOST_PP_NODE_167(p) BOOST_PP_IIF(p(167), 167, 168)
+#define BOOST_PP_NODE_172(p) BOOST_PP_IIF(p(172), BOOST_PP_NODE_170, BOOST_PP_NODE_174)
+#define BOOST_PP_NODE_170(p) BOOST_PP_IIF(p(170), BOOST_PP_NODE_169, BOOST_PP_NODE_171)
+#define BOOST_PP_NODE_169(p) BOOST_PP_IIF(p(169), 169, 170)
+#define BOOST_PP_NODE_171(p) BOOST_PP_IIF(p(171), 171, 172)
+#define BOOST_PP_NODE_174(p) BOOST_PP_IIF(p(174), BOOST_PP_NODE_173, BOOST_PP_NODE_175)
+#define BOOST_PP_NODE_173(p) BOOST_PP_IIF(p(173), 173, 174)
+#define BOOST_PP_NODE_175(p) BOOST_PP_IIF(p(175), 175, 176)
+#define BOOST_PP_NODE_184(p) BOOST_PP_IIF(p(184), BOOST_PP_NODE_180, BOOST_PP_NODE_188)
+#define BOOST_PP_NODE_180(p) BOOST_PP_IIF(p(180), BOOST_PP_NODE_178, BOOST_PP_NODE_182)
+#define BOOST_PP_NODE_178(p) BOOST_PP_IIF(p(178), BOOST_PP_NODE_177, BOOST_PP_NODE_179)
+#define BOOST_PP_NODE_177(p) BOOST_PP_IIF(p(177), 177, 178)
+#define BOOST_PP_NODE_179(p) BOOST_PP_IIF(p(179), 179, 180)
+#define BOOST_PP_NODE_182(p) BOOST_PP_IIF(p(182), BOOST_PP_NODE_181, BOOST_PP_NODE_183)
+#define BOOST_PP_NODE_181(p) BOOST_PP_IIF(p(181), 181, 182)
+#define BOOST_PP_NODE_183(p) BOOST_PP_IIF(p(183), 183, 184)
+#define BOOST_PP_NODE_188(p) BOOST_PP_IIF(p(188), BOOST_PP_NODE_186, BOOST_PP_NODE_190)
+#define BOOST_PP_NODE_186(p) BOOST_PP_IIF(p(186), BOOST_PP_NODE_185, BOOST_PP_NODE_187)
+#define BOOST_PP_NODE_185(p) BOOST_PP_IIF(p(185), 185, 186)
+#define BOOST_PP_NODE_187(p) BOOST_PP_IIF(p(187), 187, 188)
+#define BOOST_PP_NODE_190(p) BOOST_PP_IIF(p(190), BOOST_PP_NODE_189, BOOST_PP_NODE_191)
+#define BOOST_PP_NODE_189(p) BOOST_PP_IIF(p(189), 189, 190)
+#define BOOST_PP_NODE_191(p) BOOST_PP_IIF(p(191), 191, 192)
+#define BOOST_PP_NODE_224(p) BOOST_PP_IIF(p(224), BOOST_PP_NODE_208, BOOST_PP_NODE_240)
+#define BOOST_PP_NODE_208(p) BOOST_PP_IIF(p(208), BOOST_PP_NODE_200, BOOST_PP_NODE_216)
+#define BOOST_PP_NODE_200(p) BOOST_PP_IIF(p(200), BOOST_PP_NODE_196, BOOST_PP_NODE_204)
+#define BOOST_PP_NODE_196(p) BOOST_PP_IIF(p(196), BOOST_PP_NODE_194, BOOST_PP_NODE_198)
+#define BOOST_PP_NODE_194(p) BOOST_PP_IIF(p(194), BOOST_PP_NODE_193, BOOST_PP_NODE_195)
+#define BOOST_PP_NODE_193(p) BOOST_PP_IIF(p(193), 193, 194)
+#define BOOST_PP_NODE_195(p) BOOST_PP_IIF(p(195), 195, 196)
+#define BOOST_PP_NODE_198(p) BOOST_PP_IIF(p(198), BOOST_PP_NODE_197, BOOST_PP_NODE_199)
+#define BOOST_PP_NODE_197(p) BOOST_PP_IIF(p(197), 197, 198)
+#define BOOST_PP_NODE_199(p) BOOST_PP_IIF(p(199), 199, 200)
+#define BOOST_PP_NODE_204(p) BOOST_PP_IIF(p(204), BOOST_PP_NODE_202, BOOST_PP_NODE_206)
+#define BOOST_PP_NODE_202(p) BOOST_PP_IIF(p(202), BOOST_PP_NODE_201, BOOST_PP_NODE_203)
+#define BOOST_PP_NODE_201(p) BOOST_PP_IIF(p(201), 201, 202)
+#define BOOST_PP_NODE_203(p) BOOST_PP_IIF(p(203), 203, 204)
+#define BOOST_PP_NODE_206(p) BOOST_PP_IIF(p(206), BOOST_PP_NODE_205, BOOST_PP_NODE_207)
+#define BOOST_PP_NODE_205(p) BOOST_PP_IIF(p(205), 205, 206)
+#define BOOST_PP_NODE_207(p) BOOST_PP_IIF(p(207), 207, 208)
+#define BOOST_PP_NODE_216(p) BOOST_PP_IIF(p(216), BOOST_PP_NODE_212, BOOST_PP_NODE_220)
+#define BOOST_PP_NODE_212(p) BOOST_PP_IIF(p(212), BOOST_PP_NODE_210, BOOST_PP_NODE_214)
+#define BOOST_PP_NODE_210(p) BOOST_PP_IIF(p(210), BOOST_PP_NODE_209, BOOST_PP_NODE_211)
+#define BOOST_PP_NODE_209(p) BOOST_PP_IIF(p(209), 209, 210)
+#define BOOST_PP_NODE_211(p) BOOST_PP_IIF(p(211), 211, 212)
+#define BOOST_PP_NODE_214(p) BOOST_PP_IIF(p(214), BOOST_PP_NODE_213, BOOST_PP_NODE_215)
+#define BOOST_PP_NODE_213(p) BOOST_PP_IIF(p(213), 213, 214)
+#define BOOST_PP_NODE_215(p) BOOST_PP_IIF(p(215), 215, 216)
+#define BOOST_PP_NODE_220(p) BOOST_PP_IIF(p(220), BOOST_PP_NODE_218, BOOST_PP_NODE_222)
+#define BOOST_PP_NODE_218(p) BOOST_PP_IIF(p(218), BOOST_PP_NODE_217, BOOST_PP_NODE_219)
+#define BOOST_PP_NODE_217(p) BOOST_PP_IIF(p(217), 217, 218)
+#define BOOST_PP_NODE_219(p) BOOST_PP_IIF(p(219), 219, 220)
+#define BOOST_PP_NODE_222(p) BOOST_PP_IIF(p(222), BOOST_PP_NODE_221, BOOST_PP_NODE_223)
+#define BOOST_PP_NODE_221(p) BOOST_PP_IIF(p(221), 221, 222)
+#define BOOST_PP_NODE_223(p) BOOST_PP_IIF(p(223), 223, 224)
+#define BOOST_PP_NODE_240(p) BOOST_PP_IIF(p(240), BOOST_PP_NODE_232, BOOST_PP_NODE_248)
+#define BOOST_PP_NODE_232(p) BOOST_PP_IIF(p(232), BOOST_PP_NODE_228, BOOST_PP_NODE_236)
+#define BOOST_PP_NODE_228(p) BOOST_PP_IIF(p(228), BOOST_PP_NODE_226, BOOST_PP_NODE_230)
+#define BOOST_PP_NODE_226(p) BOOST_PP_IIF(p(226), BOOST_PP_NODE_225, BOOST_PP_NODE_227)
+#define BOOST_PP_NODE_225(p) BOOST_PP_IIF(p(225), 225, 226)
+#define BOOST_PP_NODE_227(p) BOOST_PP_IIF(p(227), 227, 228)
+#define BOOST_PP_NODE_230(p) BOOST_PP_IIF(p(230), BOOST_PP_NODE_229, BOOST_PP_NODE_231)
+#define BOOST_PP_NODE_229(p) BOOST_PP_IIF(p(229), 229, 230)
+#define BOOST_PP_NODE_231(p) BOOST_PP_IIF(p(231), 231, 232)
+#define BOOST_PP_NODE_236(p) BOOST_PP_IIF(p(236), BOOST_PP_NODE_234, BOOST_PP_NODE_238)
+#define BOOST_PP_NODE_234(p) BOOST_PP_IIF(p(234), BOOST_PP_NODE_233, BOOST_PP_NODE_235)
+#define BOOST_PP_NODE_233(p) BOOST_PP_IIF(p(233), 233, 234)
+#define BOOST_PP_NODE_235(p) BOOST_PP_IIF(p(235), 235, 236)
+#define BOOST_PP_NODE_238(p) BOOST_PP_IIF(p(238), BOOST_PP_NODE_237, BOOST_PP_NODE_239)
+#define BOOST_PP_NODE_237(p) BOOST_PP_IIF(p(237), 237, 238)
+#define BOOST_PP_NODE_239(p) BOOST_PP_IIF(p(239), 239, 240)
+#define BOOST_PP_NODE_248(p) BOOST_PP_IIF(p(248), BOOST_PP_NODE_244, BOOST_PP_NODE_252)
+#define BOOST_PP_NODE_244(p) BOOST_PP_IIF(p(244), BOOST_PP_NODE_242, BOOST_PP_NODE_246)
+#define BOOST_PP_NODE_242(p) BOOST_PP_IIF(p(242), BOOST_PP_NODE_241, BOOST_PP_NODE_243)
+#define BOOST_PP_NODE_241(p) BOOST_PP_IIF(p(241), 241, 242)
+#define BOOST_PP_NODE_243(p) BOOST_PP_IIF(p(243), 243, 244)
+#define BOOST_PP_NODE_246(p) BOOST_PP_IIF(p(246), BOOST_PP_NODE_245, BOOST_PP_NODE_247)
+#define BOOST_PP_NODE_245(p) BOOST_PP_IIF(p(245), 245, 246)
+#define BOOST_PP_NODE_247(p) BOOST_PP_IIF(p(247), 247, 248)
+#define BOOST_PP_NODE_252(p) BOOST_PP_IIF(p(252), BOOST_PP_NODE_250, BOOST_PP_NODE_254)
+#define BOOST_PP_NODE_250(p) BOOST_PP_IIF(p(250), BOOST_PP_NODE_249, BOOST_PP_NODE_251)
+#define BOOST_PP_NODE_249(p) BOOST_PP_IIF(p(249), 249, 250)
+#define BOOST_PP_NODE_251(p) BOOST_PP_IIF(p(251), 251, 252)
+#define BOOST_PP_NODE_254(p) BOOST_PP_IIF(p(254), BOOST_PP_NODE_253, BOOST_PP_NODE_255)
+#define BOOST_PP_NODE_253(p) BOOST_PP_IIF(p(253), 253, 254)
+#define BOOST_PP_NODE_255(p) BOOST_PP_IIF(p(255), 255, 256)
+# 22 "/usr/include/boost/preprocessor/repetition/for.hpp" 2 3 4
+
+
+
+
+
+
+
+#define BOOST_PP_FOR BOOST_PP_CAT(BOOST_PP_FOR_, BOOST_PP_AUTO_REC(BOOST_PP_FOR_P, 256))
+
+#define BOOST_PP_FOR_P(n) BOOST_PP_CAT(BOOST_PP_FOR_CHECK_, BOOST_PP_FOR_ ## n(1, BOOST_PP_FOR_SR_P, BOOST_PP_FOR_SR_O, BOOST_PP_FOR_SR_M))
+
+#define BOOST_PP_FOR_SR_P(r,s) s
+#define BOOST_PP_FOR_SR_O(r,s) 0
+#define BOOST_PP_FOR_SR_M(r,s) BOOST_PP_NIL
+# 44 "/usr/include/boost/preprocessor/repetition/for.hpp" 3 4
+# 1 "/usr/include/boost/preprocessor/repetition/detail/for.hpp" 1 3 4
+# 15 "/usr/include/boost/preprocessor/repetition/detail/for.hpp" 3 4
+#define BOOST_PREPROCESSOR_REPETITION_DETAIL_FOR_HPP 
+
+# 1 "/usr/include/boost/preprocessor/control/expr_iif.hpp" 1 3 4
+# 13 "/usr/include/boost/preprocessor/control/expr_iif.hpp" 3 4
+#define BOOST_PREPROCESSOR_CONTROL_EXPR_IIF_HPP 
+
+
+
+
+
+
+#define BOOST_PP_EXPR_IIF(bit,expr) BOOST_PP_EXPR_IIF_I(bit, expr)
+
+
+
+
+
+#define BOOST_PP_EXPR_IIF_I(bit,expr) BOOST_PP_EXPR_IIF_ ## bit(expr)
+
+#define BOOST_PP_EXPR_IIF_0(expr) 
+#define BOOST_PP_EXPR_IIF_1(expr) expr
+# 18 "/usr/include/boost/preprocessor/repetition/detail/for.hpp" 2 3 4
+
+
+# 1 "/usr/include/boost/preprocessor/tuple/eat.hpp" 1 3 4
+# 16 "/usr/include/boost/preprocessor/tuple/eat.hpp" 3 4
+#define BOOST_PREPROCESSOR_TUPLE_EAT_HPP 
+
+
+
+
+
+
+#define BOOST_PP_EAT(...) 
+
+
+
+
+
+
+
+#define BOOST_PP_TUPLE_EAT(size) BOOST_PP_EAT
+# 43 "/usr/include/boost/preprocessor/tuple/eat.hpp" 3 4
+#define BOOST_PP_TUPLE_EAT_N(size) BOOST_PP_TUPLE_EAT_N_I(size)
+
+
+
+
+#define BOOST_PP_TUPLE_EAT_N_I(size) BOOST_PP_TUPLE_EAT_ ## size
+
+#define BOOST_PP_TUPLE_EAT_1(e0) 
+#define BOOST_PP_TUPLE_EAT_2(e0,e1) 
+#define BOOST_PP_TUPLE_EAT_3(e0,e1,e2) 
+#define BOOST_PP_TUPLE_EAT_4(e0,e1,e2,e3) 
+#define BOOST_PP_TUPLE_EAT_5(e0,e1,e2,e3,e4) 
+#define BOOST_PP_TUPLE_EAT_6(e0,e1,e2,e3,e4,e5) 
+#define BOOST_PP_TUPLE_EAT_7(e0,e1,e2,e3,e4,e5,e6) 
+#define BOOST_PP_TUPLE_EAT_8(e0,e1,e2,e3,e4,e5,e6,e7) 
+#define BOOST_PP_TUPLE_EAT_9(e0,e1,e2,e3,e4,e5,e6,e7,e8) 
+#define BOOST_PP_TUPLE_EAT_10(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9) 
+#define BOOST_PP_TUPLE_EAT_11(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10) 
+#define BOOST_PP_TUPLE_EAT_12(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11) 
+#define BOOST_PP_TUPLE_EAT_13(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12) 
+#define BOOST_PP_TUPLE_EAT_14(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13) 
+#define BOOST_PP_TUPLE_EAT_15(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14) 
+#define BOOST_PP_TUPLE_EAT_16(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15) 
+#define BOOST_PP_TUPLE_EAT_17(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16) 
+#define BOOST_PP_TUPLE_EAT_18(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17) 
+#define BOOST_PP_TUPLE_EAT_19(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18) 
+#define BOOST_PP_TUPLE_EAT_20(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19) 
+#define BOOST_PP_TUPLE_EAT_21(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20) 
+#define BOOST_PP_TUPLE_EAT_22(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21) 
+#define BOOST_PP_TUPLE_EAT_23(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22) 
+#define BOOST_PP_TUPLE_EAT_24(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23) 
+#define BOOST_PP_TUPLE_EAT_25(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24) 
+#define BOOST_PP_TUPLE_EAT_26(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25) 
+#define BOOST_PP_TUPLE_EAT_27(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26) 
+#define BOOST_PP_TUPLE_EAT_28(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27) 
+#define BOOST_PP_TUPLE_EAT_29(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28) 
+#define BOOST_PP_TUPLE_EAT_30(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29) 
+#define BOOST_PP_TUPLE_EAT_31(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30) 
+#define BOOST_PP_TUPLE_EAT_32(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31) 
+#define BOOST_PP_TUPLE_EAT_33(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32) 
+#define BOOST_PP_TUPLE_EAT_34(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33) 
+#define BOOST_PP_TUPLE_EAT_35(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34) 
+#define BOOST_PP_TUPLE_EAT_36(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35) 
+#define BOOST_PP_TUPLE_EAT_37(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36) 
+#define BOOST_PP_TUPLE_EAT_38(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37) 
+#define BOOST_PP_TUPLE_EAT_39(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38) 
+#define BOOST_PP_TUPLE_EAT_40(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39) 
+#define BOOST_PP_TUPLE_EAT_41(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40) 
+#define BOOST_PP_TUPLE_EAT_42(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41) 
+#define BOOST_PP_TUPLE_EAT_43(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42) 
+#define BOOST_PP_TUPLE_EAT_44(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43) 
+#define BOOST_PP_TUPLE_EAT_45(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44) 
+#define BOOST_PP_TUPLE_EAT_46(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45) 
+#define BOOST_PP_TUPLE_EAT_47(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46) 
+#define BOOST_PP_TUPLE_EAT_48(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47) 
+#define BOOST_PP_TUPLE_EAT_49(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48) 
+#define BOOST_PP_TUPLE_EAT_50(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49) 
+#define BOOST_PP_TUPLE_EAT_51(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50) 
+#define BOOST_PP_TUPLE_EAT_52(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51) 
+#define BOOST_PP_TUPLE_EAT_53(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52) 
+#define BOOST_PP_TUPLE_EAT_54(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53) 
+#define BOOST_PP_TUPLE_EAT_55(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54) 
+#define BOOST_PP_TUPLE_EAT_56(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55) 
+#define BOOST_PP_TUPLE_EAT_57(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56) 
+#define BOOST_PP_TUPLE_EAT_58(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57) 
+#define BOOST_PP_TUPLE_EAT_59(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58) 
+#define BOOST_PP_TUPLE_EAT_60(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59) 
+#define BOOST_PP_TUPLE_EAT_61(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59,e60) 
+#define BOOST_PP_TUPLE_EAT_62(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59,e60,e61) 
+#define BOOST_PP_TUPLE_EAT_63(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59,e60,e61,e62) 
+#define BOOST_PP_TUPLE_EAT_64(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59,e60,e61,e62,e63) 
+# 21 "/usr/include/boost/preprocessor/repetition/detail/for.hpp" 2 3 4
+
+#define BOOST_PP_FOR_1(s,p,o,m) BOOST_PP_FOR_1_C(BOOST_PP_BOOL(p(2, s)), s, p, o, m)
+#define BOOST_PP_FOR_2(s,p,o,m) BOOST_PP_FOR_2_C(BOOST_PP_BOOL(p(3, s)), s, p, o, m)
+#define BOOST_PP_FOR_3(s,p,o,m) BOOST_PP_FOR_3_C(BOOST_PP_BOOL(p(4, s)), s, p, o, m)
+#define BOOST_PP_FOR_4(s,p,o,m) BOOST_PP_FOR_4_C(BOOST_PP_BOOL(p(5, s)), s, p, o, m)
+#define BOOST_PP_FOR_5(s,p,o,m) BOOST_PP_FOR_5_C(BOOST_PP_BOOL(p(6, s)), s, p, o, m)
+#define BOOST_PP_FOR_6(s,p,o,m) BOOST_PP_FOR_6_C(BOOST_PP_BOOL(p(7, s)), s, p, o, m)
+#define BOOST_PP_FOR_7(s,p,o,m) BOOST_PP_FOR_7_C(BOOST_PP_BOOL(p(8, s)), s, p, o, m)
+#define BOOST_PP_FOR_8(s,p,o,m) BOOST_PP_FOR_8_C(BOOST_PP_BOOL(p(9, s)), s, p, o, m)
+#define BOOST_PP_FOR_9(s,p,o,m) BOOST_PP_FOR_9_C(BOOST_PP_BOOL(p(10, s)), s, p, o, m)
+#define BOOST_PP_FOR_10(s,p,o,m) BOOST_PP_FOR_10_C(BOOST_PP_BOOL(p(11, s)), s, p, o, m)
+#define BOOST_PP_FOR_11(s,p,o,m) BOOST_PP_FOR_11_C(BOOST_PP_BOOL(p(12, s)), s, p, o, m)
+#define BOOST_PP_FOR_12(s,p,o,m) BOOST_PP_FOR_12_C(BOOST_PP_BOOL(p(13, s)), s, p, o, m)
+#define BOOST_PP_FOR_13(s,p,o,m) BOOST_PP_FOR_13_C(BOOST_PP_BOOL(p(14, s)), s, p, o, m)
+#define BOOST_PP_FOR_14(s,p,o,m) BOOST_PP_FOR_14_C(BOOST_PP_BOOL(p(15, s)), s, p, o, m)
+#define BOOST_PP_FOR_15(s,p,o,m) BOOST_PP_FOR_15_C(BOOST_PP_BOOL(p(16, s)), s, p, o, m)
+#define BOOST_PP_FOR_16(s,p,o,m) BOOST_PP_FOR_16_C(BOOST_PP_BOOL(p(17, s)), s, p, o, m)
+#define BOOST_PP_FOR_17(s,p,o,m) BOOST_PP_FOR_17_C(BOOST_PP_BOOL(p(18, s)), s, p, o, m)
+#define BOOST_PP_FOR_18(s,p,o,m) BOOST_PP_FOR_18_C(BOOST_PP_BOOL(p(19, s)), s, p, o, m)
+#define BOOST_PP_FOR_19(s,p,o,m) BOOST_PP_FOR_19_C(BOOST_PP_BOOL(p(20, s)), s, p, o, m)
+#define BOOST_PP_FOR_20(s,p,o,m) BOOST_PP_FOR_20_C(BOOST_PP_BOOL(p(21, s)), s, p, o, m)
+#define BOOST_PP_FOR_21(s,p,o,m) BOOST_PP_FOR_21_C(BOOST_PP_BOOL(p(22, s)), s, p, o, m)
+#define BOOST_PP_FOR_22(s,p,o,m) BOOST_PP_FOR_22_C(BOOST_PP_BOOL(p(23, s)), s, p, o, m)
+#define BOOST_PP_FOR_23(s,p,o,m) BOOST_PP_FOR_23_C(BOOST_PP_BOOL(p(24, s)), s, p, o, m)
+#define BOOST_PP_FOR_24(s,p,o,m) BOOST_PP_FOR_24_C(BOOST_PP_BOOL(p(25, s)), s, p, o, m)
+#define BOOST_PP_FOR_25(s,p,o,m) BOOST_PP_FOR_25_C(BOOST_PP_BOOL(p(26, s)), s, p, o, m)
+#define BOOST_PP_FOR_26(s,p,o,m) BOOST_PP_FOR_26_C(BOOST_PP_BOOL(p(27, s)), s, p, o, m)
+#define BOOST_PP_FOR_27(s,p,o,m) BOOST_PP_FOR_27_C(BOOST_PP_BOOL(p(28, s)), s, p, o, m)
+#define BOOST_PP_FOR_28(s,p,o,m) BOOST_PP_FOR_28_C(BOOST_PP_BOOL(p(29, s)), s, p, o, m)
+#define BOOST_PP_FOR_29(s,p,o,m) BOOST_PP_FOR_29_C(BOOST_PP_BOOL(p(30, s)), s, p, o, m)
+#define BOOST_PP_FOR_30(s,p,o,m) BOOST_PP_FOR_30_C(BOOST_PP_BOOL(p(31, s)), s, p, o, m)
+#define BOOST_PP_FOR_31(s,p,o,m) BOOST_PP_FOR_31_C(BOOST_PP_BOOL(p(32, s)), s, p, o, m)
+#define BOOST_PP_FOR_32(s,p,o,m) BOOST_PP_FOR_32_C(BOOST_PP_BOOL(p(33, s)), s, p, o, m)
+#define BOOST_PP_FOR_33(s,p,o,m) BOOST_PP_FOR_33_C(BOOST_PP_BOOL(p(34, s)), s, p, o, m)
+#define BOOST_PP_FOR_34(s,p,o,m) BOOST_PP_FOR_34_C(BOOST_PP_BOOL(p(35, s)), s, p, o, m)
+#define BOOST_PP_FOR_35(s,p,o,m) BOOST_PP_FOR_35_C(BOOST_PP_BOOL(p(36, s)), s, p, o, m)
+#define BOOST_PP_FOR_36(s,p,o,m) BOOST_PP_FOR_36_C(BOOST_PP_BOOL(p(37, s)), s, p, o, m)
+#define BOOST_PP_FOR_37(s,p,o,m) BOOST_PP_FOR_37_C(BOOST_PP_BOOL(p(38, s)), s, p, o, m)
+#define BOOST_PP_FOR_38(s,p,o,m) BOOST_PP_FOR_38_C(BOOST_PP_BOOL(p(39, s)), s, p, o, m)
+#define BOOST_PP_FOR_39(s,p,o,m) BOOST_PP_FOR_39_C(BOOST_PP_BOOL(p(40, s)), s, p, o, m)
+#define BOOST_PP_FOR_40(s,p,o,m) BOOST_PP_FOR_40_C(BOOST_PP_BOOL(p(41, s)), s, p, o, m)
+#define BOOST_PP_FOR_41(s,p,o,m) BOOST_PP_FOR_41_C(BOOST_PP_BOOL(p(42, s)), s, p, o, m)
+#define BOOST_PP_FOR_42(s,p,o,m) BOOST_PP_FOR_42_C(BOOST_PP_BOOL(p(43, s)), s, p, o, m)
+#define BOOST_PP_FOR_43(s,p,o,m) BOOST_PP_FOR_43_C(BOOST_PP_BOOL(p(44, s)), s, p, o, m)
+#define BOOST_PP_FOR_44(s,p,o,m) BOOST_PP_FOR_44_C(BOOST_PP_BOOL(p(45, s)), s, p, o, m)
+#define BOOST_PP_FOR_45(s,p,o,m) BOOST_PP_FOR_45_C(BOOST_PP_BOOL(p(46, s)), s, p, o, m)
+#define BOOST_PP_FOR_46(s,p,o,m) BOOST_PP_FOR_46_C(BOOST_PP_BOOL(p(47, s)), s, p, o, m)
+#define BOOST_PP_FOR_47(s,p,o,m) BOOST_PP_FOR_47_C(BOOST_PP_BOOL(p(48, s)), s, p, o, m)
+#define BOOST_PP_FOR_48(s,p,o,m) BOOST_PP_FOR_48_C(BOOST_PP_BOOL(p(49, s)), s, p, o, m)
+#define BOOST_PP_FOR_49(s,p,o,m) BOOST_PP_FOR_49_C(BOOST_PP_BOOL(p(50, s)), s, p, o, m)
+#define BOOST_PP_FOR_50(s,p,o,m) BOOST_PP_FOR_50_C(BOOST_PP_BOOL(p(51, s)), s, p, o, m)
+#define BOOST_PP_FOR_51(s,p,o,m) BOOST_PP_FOR_51_C(BOOST_PP_BOOL(p(52, s)), s, p, o, m)
+#define BOOST_PP_FOR_52(s,p,o,m) BOOST_PP_FOR_52_C(BOOST_PP_BOOL(p(53, s)), s, p, o, m)
+#define BOOST_PP_FOR_53(s,p,o,m) BOOST_PP_FOR_53_C(BOOST_PP_BOOL(p(54, s)), s, p, o, m)
+#define BOOST_PP_FOR_54(s,p,o,m) BOOST_PP_FOR_54_C(BOOST_PP_BOOL(p(55, s)), s, p, o, m)
+#define BOOST_PP_FOR_55(s,p,o,m) BOOST_PP_FOR_55_C(BOOST_PP_BOOL(p(56, s)), s, p, o, m)
+#define BOOST_PP_FOR_56(s,p,o,m) BOOST_PP_FOR_56_C(BOOST_PP_BOOL(p(57, s)), s, p, o, m)
+#define BOOST_PP_FOR_57(s,p,o,m) BOOST_PP_FOR_57_C(BOOST_PP_BOOL(p(58, s)), s, p, o, m)
+#define BOOST_PP_FOR_58(s,p,o,m) BOOST_PP_FOR_58_C(BOOST_PP_BOOL(p(59, s)), s, p, o, m)
+#define BOOST_PP_FOR_59(s,p,o,m) BOOST_PP_FOR_59_C(BOOST_PP_BOOL(p(60, s)), s, p, o, m)
+#define BOOST_PP_FOR_60(s,p,o,m) BOOST_PP_FOR_60_C(BOOST_PP_BOOL(p(61, s)), s, p, o, m)
+#define BOOST_PP_FOR_61(s,p,o,m) BOOST_PP_FOR_61_C(BOOST_PP_BOOL(p(62, s)), s, p, o, m)
+#define BOOST_PP_FOR_62(s,p,o,m) BOOST_PP_FOR_62_C(BOOST_PP_BOOL(p(63, s)), s, p, o, m)
+#define BOOST_PP_FOR_63(s,p,o,m) BOOST_PP_FOR_63_C(BOOST_PP_BOOL(p(64, s)), s, p, o, m)
+#define BOOST_PP_FOR_64(s,p,o,m) BOOST_PP_FOR_64_C(BOOST_PP_BOOL(p(65, s)), s, p, o, m)
+#define BOOST_PP_FOR_65(s,p,o,m) BOOST_PP_FOR_65_C(BOOST_PP_BOOL(p(66, s)), s, p, o, m)
+#define BOOST_PP_FOR_66(s,p,o,m) BOOST_PP_FOR_66_C(BOOST_PP_BOOL(p(67, s)), s, p, o, m)
+#define BOOST_PP_FOR_67(s,p,o,m) BOOST_PP_FOR_67_C(BOOST_PP_BOOL(p(68, s)), s, p, o, m)
+#define BOOST_PP_FOR_68(s,p,o,m) BOOST_PP_FOR_68_C(BOOST_PP_BOOL(p(69, s)), s, p, o, m)
+#define BOOST_PP_FOR_69(s,p,o,m) BOOST_PP_FOR_69_C(BOOST_PP_BOOL(p(70, s)), s, p, o, m)
+#define BOOST_PP_FOR_70(s,p,o,m) BOOST_PP_FOR_70_C(BOOST_PP_BOOL(p(71, s)), s, p, o, m)
+#define BOOST_PP_FOR_71(s,p,o,m) BOOST_PP_FOR_71_C(BOOST_PP_BOOL(p(72, s)), s, p, o, m)
+#define BOOST_PP_FOR_72(s,p,o,m) BOOST_PP_FOR_72_C(BOOST_PP_BOOL(p(73, s)), s, p, o, m)
+#define BOOST_PP_FOR_73(s,p,o,m) BOOST_PP_FOR_73_C(BOOST_PP_BOOL(p(74, s)), s, p, o, m)
+#define BOOST_PP_FOR_74(s,p,o,m) BOOST_PP_FOR_74_C(BOOST_PP_BOOL(p(75, s)), s, p, o, m)
+#define BOOST_PP_FOR_75(s,p,o,m) BOOST_PP_FOR_75_C(BOOST_PP_BOOL(p(76, s)), s, p, o, m)
+#define BOOST_PP_FOR_76(s,p,o,m) BOOST_PP_FOR_76_C(BOOST_PP_BOOL(p(77, s)), s, p, o, m)
+#define BOOST_PP_FOR_77(s,p,o,m) BOOST_PP_FOR_77_C(BOOST_PP_BOOL(p(78, s)), s, p, o, m)
+#define BOOST_PP_FOR_78(s,p,o,m) BOOST_PP_FOR_78_C(BOOST_PP_BOOL(p(79, s)), s, p, o, m)
+#define BOOST_PP_FOR_79(s,p,o,m) BOOST_PP_FOR_79_C(BOOST_PP_BOOL(p(80, s)), s, p, o, m)
+#define BOOST_PP_FOR_80(s,p,o,m) BOOST_PP_FOR_80_C(BOOST_PP_BOOL(p(81, s)), s, p, o, m)
+#define BOOST_PP_FOR_81(s,p,o,m) BOOST_PP_FOR_81_C(BOOST_PP_BOOL(p(82, s)), s, p, o, m)
+#define BOOST_PP_FOR_82(s,p,o,m) BOOST_PP_FOR_82_C(BOOST_PP_BOOL(p(83, s)), s, p, o, m)
+#define BOOST_PP_FOR_83(s,p,o,m) BOOST_PP_FOR_83_C(BOOST_PP_BOOL(p(84, s)), s, p, o, m)
+#define BOOST_PP_FOR_84(s,p,o,m) BOOST_PP_FOR_84_C(BOOST_PP_BOOL(p(85, s)), s, p, o, m)
+#define BOOST_PP_FOR_85(s,p,o,m) BOOST_PP_FOR_85_C(BOOST_PP_BOOL(p(86, s)), s, p, o, m)
+#define BOOST_PP_FOR_86(s,p,o,m) BOOST_PP_FOR_86_C(BOOST_PP_BOOL(p(87, s)), s, p, o, m)
+#define BOOST_PP_FOR_87(s,p,o,m) BOOST_PP_FOR_87_C(BOOST_PP_BOOL(p(88, s)), s, p, o, m)
+#define BOOST_PP_FOR_88(s,p,o,m) BOOST_PP_FOR_88_C(BOOST_PP_BOOL(p(89, s)), s, p, o, m)
+#define BOOST_PP_FOR_89(s,p,o,m) BOOST_PP_FOR_89_C(BOOST_PP_BOOL(p(90, s)), s, p, o, m)
+#define BOOST_PP_FOR_90(s,p,o,m) BOOST_PP_FOR_90_C(BOOST_PP_BOOL(p(91, s)), s, p, o, m)
+#define BOOST_PP_FOR_91(s,p,o,m) BOOST_PP_FOR_91_C(BOOST_PP_BOOL(p(92, s)), s, p, o, m)
+#define BOOST_PP_FOR_92(s,p,o,m) BOOST_PP_FOR_92_C(BOOST_PP_BOOL(p(93, s)), s, p, o, m)
+#define BOOST_PP_FOR_93(s,p,o,m) BOOST_PP_FOR_93_C(BOOST_PP_BOOL(p(94, s)), s, p, o, m)
+#define BOOST_PP_FOR_94(s,p,o,m) BOOST_PP_FOR_94_C(BOOST_PP_BOOL(p(95, s)), s, p, o, m)
+#define BOOST_PP_FOR_95(s,p,o,m) BOOST_PP_FOR_95_C(BOOST_PP_BOOL(p(96, s)), s, p, o, m)
+#define BOOST_PP_FOR_96(s,p,o,m) BOOST_PP_FOR_96_C(BOOST_PP_BOOL(p(97, s)), s, p, o, m)
+#define BOOST_PP_FOR_97(s,p,o,m) BOOST_PP_FOR_97_C(BOOST_PP_BOOL(p(98, s)), s, p, o, m)
+#define BOOST_PP_FOR_98(s,p,o,m) BOOST_PP_FOR_98_C(BOOST_PP_BOOL(p(99, s)), s, p, o, m)
+#define BOOST_PP_FOR_99(s,p,o,m) BOOST_PP_FOR_99_C(BOOST_PP_BOOL(p(100, s)), s, p, o, m)
+#define BOOST_PP_FOR_100(s,p,o,m) BOOST_PP_FOR_100_C(BOOST_PP_BOOL(p(101, s)), s, p, o, m)
+#define BOOST_PP_FOR_101(s,p,o,m) BOOST_PP_FOR_101_C(BOOST_PP_BOOL(p(102, s)), s, p, o, m)
+#define BOOST_PP_FOR_102(s,p,o,m) BOOST_PP_FOR_102_C(BOOST_PP_BOOL(p(103, s)), s, p, o, m)
+#define BOOST_PP_FOR_103(s,p,o,m) BOOST_PP_FOR_103_C(BOOST_PP_BOOL(p(104, s)), s, p, o, m)
+#define BOOST_PP_FOR_104(s,p,o,m) BOOST_PP_FOR_104_C(BOOST_PP_BOOL(p(105, s)), s, p, o, m)
+#define BOOST_PP_FOR_105(s,p,o,m) BOOST_PP_FOR_105_C(BOOST_PP_BOOL(p(106, s)), s, p, o, m)
+#define BOOST_PP_FOR_106(s,p,o,m) BOOST_PP_FOR_106_C(BOOST_PP_BOOL(p(107, s)), s, p, o, m)
+#define BOOST_PP_FOR_107(s,p,o,m) BOOST_PP_FOR_107_C(BOOST_PP_BOOL(p(108, s)), s, p, o, m)
+#define BOOST_PP_FOR_108(s,p,o,m) BOOST_PP_FOR_108_C(BOOST_PP_BOOL(p(109, s)), s, p, o, m)
+#define BOOST_PP_FOR_109(s,p,o,m) BOOST_PP_FOR_109_C(BOOST_PP_BOOL(p(110, s)), s, p, o, m)
+#define BOOST_PP_FOR_110(s,p,o,m) BOOST_PP_FOR_110_C(BOOST_PP_BOOL(p(111, s)), s, p, o, m)
+#define BOOST_PP_FOR_111(s,p,o,m) BOOST_PP_FOR_111_C(BOOST_PP_BOOL(p(112, s)), s, p, o, m)
+#define BOOST_PP_FOR_112(s,p,o,m) BOOST_PP_FOR_112_C(BOOST_PP_BOOL(p(113, s)), s, p, o, m)
+#define BOOST_PP_FOR_113(s,p,o,m) BOOST_PP_FOR_113_C(BOOST_PP_BOOL(p(114, s)), s, p, o, m)
+#define BOOST_PP_FOR_114(s,p,o,m) BOOST_PP_FOR_114_C(BOOST_PP_BOOL(p(115, s)), s, p, o, m)
+#define BOOST_PP_FOR_115(s,p,o,m) BOOST_PP_FOR_115_C(BOOST_PP_BOOL(p(116, s)), s, p, o, m)
+#define BOOST_PP_FOR_116(s,p,o,m) BOOST_PP_FOR_116_C(BOOST_PP_BOOL(p(117, s)), s, p, o, m)
+#define BOOST_PP_FOR_117(s,p,o,m) BOOST_PP_FOR_117_C(BOOST_PP_BOOL(p(118, s)), s, p, o, m)
+#define BOOST_PP_FOR_118(s,p,o,m) BOOST_PP_FOR_118_C(BOOST_PP_BOOL(p(119, s)), s, p, o, m)
+#define BOOST_PP_FOR_119(s,p,o,m) BOOST_PP_FOR_119_C(BOOST_PP_BOOL(p(120, s)), s, p, o, m)
+#define BOOST_PP_FOR_120(s,p,o,m) BOOST_PP_FOR_120_C(BOOST_PP_BOOL(p(121, s)), s, p, o, m)
+#define BOOST_PP_FOR_121(s,p,o,m) BOOST_PP_FOR_121_C(BOOST_PP_BOOL(p(122, s)), s, p, o, m)
+#define BOOST_PP_FOR_122(s,p,o,m) BOOST_PP_FOR_122_C(BOOST_PP_BOOL(p(123, s)), s, p, o, m)
+#define BOOST_PP_FOR_123(s,p,o,m) BOOST_PP_FOR_123_C(BOOST_PP_BOOL(p(124, s)), s, p, o, m)
+#define BOOST_PP_FOR_124(s,p,o,m) BOOST_PP_FOR_124_C(BOOST_PP_BOOL(p(125, s)), s, p, o, m)
+#define BOOST_PP_FOR_125(s,p,o,m) BOOST_PP_FOR_125_C(BOOST_PP_BOOL(p(126, s)), s, p, o, m)
+#define BOOST_PP_FOR_126(s,p,o,m) BOOST_PP_FOR_126_C(BOOST_PP_BOOL(p(127, s)), s, p, o, m)
+#define BOOST_PP_FOR_127(s,p,o,m) BOOST_PP_FOR_127_C(BOOST_PP_BOOL(p(128, s)), s, p, o, m)
+#define BOOST_PP_FOR_128(s,p,o,m) BOOST_PP_FOR_128_C(BOOST_PP_BOOL(p(129, s)), s, p, o, m)
+#define BOOST_PP_FOR_129(s,p,o,m) BOOST_PP_FOR_129_C(BOOST_PP_BOOL(p(130, s)), s, p, o, m)
+#define BOOST_PP_FOR_130(s,p,o,m) BOOST_PP_FOR_130_C(BOOST_PP_BOOL(p(131, s)), s, p, o, m)
+#define BOOST_PP_FOR_131(s,p,o,m) BOOST_PP_FOR_131_C(BOOST_PP_BOOL(p(132, s)), s, p, o, m)
+#define BOOST_PP_FOR_132(s,p,o,m) BOOST_PP_FOR_132_C(BOOST_PP_BOOL(p(133, s)), s, p, o, m)
+#define BOOST_PP_FOR_133(s,p,o,m) BOOST_PP_FOR_133_C(BOOST_PP_BOOL(p(134, s)), s, p, o, m)
+#define BOOST_PP_FOR_134(s,p,o,m) BOOST_PP_FOR_134_C(BOOST_PP_BOOL(p(135, s)), s, p, o, m)
+#define BOOST_PP_FOR_135(s,p,o,m) BOOST_PP_FOR_135_C(BOOST_PP_BOOL(p(136, s)), s, p, o, m)
+#define BOOST_PP_FOR_136(s,p,o,m) BOOST_PP_FOR_136_C(BOOST_PP_BOOL(p(137, s)), s, p, o, m)
+#define BOOST_PP_FOR_137(s,p,o,m) BOOST_PP_FOR_137_C(BOOST_PP_BOOL(p(138, s)), s, p, o, m)
+#define BOOST_PP_FOR_138(s,p,o,m) BOOST_PP_FOR_138_C(BOOST_PP_BOOL(p(139, s)), s, p, o, m)
+#define BOOST_PP_FOR_139(s,p,o,m) BOOST_PP_FOR_139_C(BOOST_PP_BOOL(p(140, s)), s, p, o, m)
+#define BOOST_PP_FOR_140(s,p,o,m) BOOST_PP_FOR_140_C(BOOST_PP_BOOL(p(141, s)), s, p, o, m)
+#define BOOST_PP_FOR_141(s,p,o,m) BOOST_PP_FOR_141_C(BOOST_PP_BOOL(p(142, s)), s, p, o, m)
+#define BOOST_PP_FOR_142(s,p,o,m) BOOST_PP_FOR_142_C(BOOST_PP_BOOL(p(143, s)), s, p, o, m)
+#define BOOST_PP_FOR_143(s,p,o,m) BOOST_PP_FOR_143_C(BOOST_PP_BOOL(p(144, s)), s, p, o, m)
+#define BOOST_PP_FOR_144(s,p,o,m) BOOST_PP_FOR_144_C(BOOST_PP_BOOL(p(145, s)), s, p, o, m)
+#define BOOST_PP_FOR_145(s,p,o,m) BOOST_PP_FOR_145_C(BOOST_PP_BOOL(p(146, s)), s, p, o, m)
+#define BOOST_PP_FOR_146(s,p,o,m) BOOST_PP_FOR_146_C(BOOST_PP_BOOL(p(147, s)), s, p, o, m)
+#define BOOST_PP_FOR_147(s,p,o,m) BOOST_PP_FOR_147_C(BOOST_PP_BOOL(p(148, s)), s, p, o, m)
+#define BOOST_PP_FOR_148(s,p,o,m) BOOST_PP_FOR_148_C(BOOST_PP_BOOL(p(149, s)), s, p, o, m)
+#define BOOST_PP_FOR_149(s,p,o,m) BOOST_PP_FOR_149_C(BOOST_PP_BOOL(p(150, s)), s, p, o, m)
+#define BOOST_PP_FOR_150(s,p,o,m) BOOST_PP_FOR_150_C(BOOST_PP_BOOL(p(151, s)), s, p, o, m)
+#define BOOST_PP_FOR_151(s,p,o,m) BOOST_PP_FOR_151_C(BOOST_PP_BOOL(p(152, s)), s, p, o, m)
+#define BOOST_PP_FOR_152(s,p,o,m) BOOST_PP_FOR_152_C(BOOST_PP_BOOL(p(153, s)), s, p, o, m)
+#define BOOST_PP_FOR_153(s,p,o,m) BOOST_PP_FOR_153_C(BOOST_PP_BOOL(p(154, s)), s, p, o, m)
+#define BOOST_PP_FOR_154(s,p,o,m) BOOST_PP_FOR_154_C(BOOST_PP_BOOL(p(155, s)), s, p, o, m)
+#define BOOST_PP_FOR_155(s,p,o,m) BOOST_PP_FOR_155_C(BOOST_PP_BOOL(p(156, s)), s, p, o, m)
+#define BOOST_PP_FOR_156(s,p,o,m) BOOST_PP_FOR_156_C(BOOST_PP_BOOL(p(157, s)), s, p, o, m)
+#define BOOST_PP_FOR_157(s,p,o,m) BOOST_PP_FOR_157_C(BOOST_PP_BOOL(p(158, s)), s, p, o, m)
+#define BOOST_PP_FOR_158(s,p,o,m) BOOST_PP_FOR_158_C(BOOST_PP_BOOL(p(159, s)), s, p, o, m)
+#define BOOST_PP_FOR_159(s,p,o,m) BOOST_PP_FOR_159_C(BOOST_PP_BOOL(p(160, s)), s, p, o, m)
+#define BOOST_PP_FOR_160(s,p,o,m) BOOST_PP_FOR_160_C(BOOST_PP_BOOL(p(161, s)), s, p, o, m)
+#define BOOST_PP_FOR_161(s,p,o,m) BOOST_PP_FOR_161_C(BOOST_PP_BOOL(p(162, s)), s, p, o, m)
+#define BOOST_PP_FOR_162(s,p,o,m) BOOST_PP_FOR_162_C(BOOST_PP_BOOL(p(163, s)), s, p, o, m)
+#define BOOST_PP_FOR_163(s,p,o,m) BOOST_PP_FOR_163_C(BOOST_PP_BOOL(p(164, s)), s, p, o, m)
+#define BOOST_PP_FOR_164(s,p,o,m) BOOST_PP_FOR_164_C(BOOST_PP_BOOL(p(165, s)), s, p, o, m)
+#define BOOST_PP_FOR_165(s,p,o,m) BOOST_PP_FOR_165_C(BOOST_PP_BOOL(p(166, s)), s, p, o, m)
+#define BOOST_PP_FOR_166(s,p,o,m) BOOST_PP_FOR_166_C(BOOST_PP_BOOL(p(167, s)), s, p, o, m)
+#define BOOST_PP_FOR_167(s,p,o,m) BOOST_PP_FOR_167_C(BOOST_PP_BOOL(p(168, s)), s, p, o, m)
+#define BOOST_PP_FOR_168(s,p,o,m) BOOST_PP_FOR_168_C(BOOST_PP_BOOL(p(169, s)), s, p, o, m)
+#define BOOST_PP_FOR_169(s,p,o,m) BOOST_PP_FOR_169_C(BOOST_PP_BOOL(p(170, s)), s, p, o, m)
+#define BOOST_PP_FOR_170(s,p,o,m) BOOST_PP_FOR_170_C(BOOST_PP_BOOL(p(171, s)), s, p, o, m)
+#define BOOST_PP_FOR_171(s,p,o,m) BOOST_PP_FOR_171_C(BOOST_PP_BOOL(p(172, s)), s, p, o, m)
+#define BOOST_PP_FOR_172(s,p,o,m) BOOST_PP_FOR_172_C(BOOST_PP_BOOL(p(173, s)), s, p, o, m)
+#define BOOST_PP_FOR_173(s,p,o,m) BOOST_PP_FOR_173_C(BOOST_PP_BOOL(p(174, s)), s, p, o, m)
+#define BOOST_PP_FOR_174(s,p,o,m) BOOST_PP_FOR_174_C(BOOST_PP_BOOL(p(175, s)), s, p, o, m)
+#define BOOST_PP_FOR_175(s,p,o,m) BOOST_PP_FOR_175_C(BOOST_PP_BOOL(p(176, s)), s, p, o, m)
+#define BOOST_PP_FOR_176(s,p,o,m) BOOST_PP_FOR_176_C(BOOST_PP_BOOL(p(177, s)), s, p, o, m)
+#define BOOST_PP_FOR_177(s,p,o,m) BOOST_PP_FOR_177_C(BOOST_PP_BOOL(p(178, s)), s, p, o, m)
+#define BOOST_PP_FOR_178(s,p,o,m) BOOST_PP_FOR_178_C(BOOST_PP_BOOL(p(179, s)), s, p, o, m)
+#define BOOST_PP_FOR_179(s,p,o,m) BOOST_PP_FOR_179_C(BOOST_PP_BOOL(p(180, s)), s, p, o, m)
+#define BOOST_PP_FOR_180(s,p,o,m) BOOST_PP_FOR_180_C(BOOST_PP_BOOL(p(181, s)), s, p, o, m)
+#define BOOST_PP_FOR_181(s,p,o,m) BOOST_PP_FOR_181_C(BOOST_PP_BOOL(p(182, s)), s, p, o, m)
+#define BOOST_PP_FOR_182(s,p,o,m) BOOST_PP_FOR_182_C(BOOST_PP_BOOL(p(183, s)), s, p, o, m)
+#define BOOST_PP_FOR_183(s,p,o,m) BOOST_PP_FOR_183_C(BOOST_PP_BOOL(p(184, s)), s, p, o, m)
+#define BOOST_PP_FOR_184(s,p,o,m) BOOST_PP_FOR_184_C(BOOST_PP_BOOL(p(185, s)), s, p, o, m)
+#define BOOST_PP_FOR_185(s,p,o,m) BOOST_PP_FOR_185_C(BOOST_PP_BOOL(p(186, s)), s, p, o, m)
+#define BOOST_PP_FOR_186(s,p,o,m) BOOST_PP_FOR_186_C(BOOST_PP_BOOL(p(187, s)), s, p, o, m)
+#define BOOST_PP_FOR_187(s,p,o,m) BOOST_PP_FOR_187_C(BOOST_PP_BOOL(p(188, s)), s, p, o, m)
+#define BOOST_PP_FOR_188(s,p,o,m) BOOST_PP_FOR_188_C(BOOST_PP_BOOL(p(189, s)), s, p, o, m)
+#define BOOST_PP_FOR_189(s,p,o,m) BOOST_PP_FOR_189_C(BOOST_PP_BOOL(p(190, s)), s, p, o, m)
+#define BOOST_PP_FOR_190(s,p,o,m) BOOST_PP_FOR_190_C(BOOST_PP_BOOL(p(191, s)), s, p, o, m)
+#define BOOST_PP_FOR_191(s,p,o,m) BOOST_PP_FOR_191_C(BOOST_PP_BOOL(p(192, s)), s, p, o, m)
+#define BOOST_PP_FOR_192(s,p,o,m) BOOST_PP_FOR_192_C(BOOST_PP_BOOL(p(193, s)), s, p, o, m)
+#define BOOST_PP_FOR_193(s,p,o,m) BOOST_PP_FOR_193_C(BOOST_PP_BOOL(p(194, s)), s, p, o, m)
+#define BOOST_PP_FOR_194(s,p,o,m) BOOST_PP_FOR_194_C(BOOST_PP_BOOL(p(195, s)), s, p, o, m)
+#define BOOST_PP_FOR_195(s,p,o,m) BOOST_PP_FOR_195_C(BOOST_PP_BOOL(p(196, s)), s, p, o, m)
+#define BOOST_PP_FOR_196(s,p,o,m) BOOST_PP_FOR_196_C(BOOST_PP_BOOL(p(197, s)), s, p, o, m)
+#define BOOST_PP_FOR_197(s,p,o,m) BOOST_PP_FOR_197_C(BOOST_PP_BOOL(p(198, s)), s, p, o, m)
+#define BOOST_PP_FOR_198(s,p,o,m) BOOST_PP_FOR_198_C(BOOST_PP_BOOL(p(199, s)), s, p, o, m)
+#define BOOST_PP_FOR_199(s,p,o,m) BOOST_PP_FOR_199_C(BOOST_PP_BOOL(p(200, s)), s, p, o, m)
+#define BOOST_PP_FOR_200(s,p,o,m) BOOST_PP_FOR_200_C(BOOST_PP_BOOL(p(201, s)), s, p, o, m)
+#define BOOST_PP_FOR_201(s,p,o,m) BOOST_PP_FOR_201_C(BOOST_PP_BOOL(p(202, s)), s, p, o, m)
+#define BOOST_PP_FOR_202(s,p,o,m) BOOST_PP_FOR_202_C(BOOST_PP_BOOL(p(203, s)), s, p, o, m)
+#define BOOST_PP_FOR_203(s,p,o,m) BOOST_PP_FOR_203_C(BOOST_PP_BOOL(p(204, s)), s, p, o, m)
+#define BOOST_PP_FOR_204(s,p,o,m) BOOST_PP_FOR_204_C(BOOST_PP_BOOL(p(205, s)), s, p, o, m)
+#define BOOST_PP_FOR_205(s,p,o,m) BOOST_PP_FOR_205_C(BOOST_PP_BOOL(p(206, s)), s, p, o, m)
+#define BOOST_PP_FOR_206(s,p,o,m) BOOST_PP_FOR_206_C(BOOST_PP_BOOL(p(207, s)), s, p, o, m)
+#define BOOST_PP_FOR_207(s,p,o,m) BOOST_PP_FOR_207_C(BOOST_PP_BOOL(p(208, s)), s, p, o, m)
+#define BOOST_PP_FOR_208(s,p,o,m) BOOST_PP_FOR_208_C(BOOST_PP_BOOL(p(209, s)), s, p, o, m)
+#define BOOST_PP_FOR_209(s,p,o,m) BOOST_PP_FOR_209_C(BOOST_PP_BOOL(p(210, s)), s, p, o, m)
+#define BOOST_PP_FOR_210(s,p,o,m) BOOST_PP_FOR_210_C(BOOST_PP_BOOL(p(211, s)), s, p, o, m)
+#define BOOST_PP_FOR_211(s,p,o,m) BOOST_PP_FOR_211_C(BOOST_PP_BOOL(p(212, s)), s, p, o, m)
+#define BOOST_PP_FOR_212(s,p,o,m) BOOST_PP_FOR_212_C(BOOST_PP_BOOL(p(213, s)), s, p, o, m)
+#define BOOST_PP_FOR_213(s,p,o,m) BOOST_PP_FOR_213_C(BOOST_PP_BOOL(p(214, s)), s, p, o, m)
+#define BOOST_PP_FOR_214(s,p,o,m) BOOST_PP_FOR_214_C(BOOST_PP_BOOL(p(215, s)), s, p, o, m)
+#define BOOST_PP_FOR_215(s,p,o,m) BOOST_PP_FOR_215_C(BOOST_PP_BOOL(p(216, s)), s, p, o, m)
+#define BOOST_PP_FOR_216(s,p,o,m) BOOST_PP_FOR_216_C(BOOST_PP_BOOL(p(217, s)), s, p, o, m)
+#define BOOST_PP_FOR_217(s,p,o,m) BOOST_PP_FOR_217_C(BOOST_PP_BOOL(p(218, s)), s, p, o, m)
+#define BOOST_PP_FOR_218(s,p,o,m) BOOST_PP_FOR_218_C(BOOST_PP_BOOL(p(219, s)), s, p, o, m)
+#define BOOST_PP_FOR_219(s,p,o,m) BOOST_PP_FOR_219_C(BOOST_PP_BOOL(p(220, s)), s, p, o, m)
+#define BOOST_PP_FOR_220(s,p,o,m) BOOST_PP_FOR_220_C(BOOST_PP_BOOL(p(221, s)), s, p, o, m)
+#define BOOST_PP_FOR_221(s,p,o,m) BOOST_PP_FOR_221_C(BOOST_PP_BOOL(p(222, s)), s, p, o, m)
+#define BOOST_PP_FOR_222(s,p,o,m) BOOST_PP_FOR_222_C(BOOST_PP_BOOL(p(223, s)), s, p, o, m)
+#define BOOST_PP_FOR_223(s,p,o,m) BOOST_PP_FOR_223_C(BOOST_PP_BOOL(p(224, s)), s, p, o, m)
+#define BOOST_PP_FOR_224(s,p,o,m) BOOST_PP_FOR_224_C(BOOST_PP_BOOL(p(225, s)), s, p, o, m)
+#define BOOST_PP_FOR_225(s,p,o,m) BOOST_PP_FOR_225_C(BOOST_PP_BOOL(p(226, s)), s, p, o, m)
+#define BOOST_PP_FOR_226(s,p,o,m) BOOST_PP_FOR_226_C(BOOST_PP_BOOL(p(227, s)), s, p, o, m)
+#define BOOST_PP_FOR_227(s,p,o,m) BOOST_PP_FOR_227_C(BOOST_PP_BOOL(p(228, s)), s, p, o, m)
+#define BOOST_PP_FOR_228(s,p,o,m) BOOST_PP_FOR_228_C(BOOST_PP_BOOL(p(229, s)), s, p, o, m)
+#define BOOST_PP_FOR_229(s,p,o,m) BOOST_PP_FOR_229_C(BOOST_PP_BOOL(p(230, s)), s, p, o, m)
+#define BOOST_PP_FOR_230(s,p,o,m) BOOST_PP_FOR_230_C(BOOST_PP_BOOL(p(231, s)), s, p, o, m)
+#define BOOST_PP_FOR_231(s,p,o,m) BOOST_PP_FOR_231_C(BOOST_PP_BOOL(p(232, s)), s, p, o, m)
+#define BOOST_PP_FOR_232(s,p,o,m) BOOST_PP_FOR_232_C(BOOST_PP_BOOL(p(233, s)), s, p, o, m)
+#define BOOST_PP_FOR_233(s,p,o,m) BOOST_PP_FOR_233_C(BOOST_PP_BOOL(p(234, s)), s, p, o, m)
+#define BOOST_PP_FOR_234(s,p,o,m) BOOST_PP_FOR_234_C(BOOST_PP_BOOL(p(235, s)), s, p, o, m)
+#define BOOST_PP_FOR_235(s,p,o,m) BOOST_PP_FOR_235_C(BOOST_PP_BOOL(p(236, s)), s, p, o, m)
+#define BOOST_PP_FOR_236(s,p,o,m) BOOST_PP_FOR_236_C(BOOST_PP_BOOL(p(237, s)), s, p, o, m)
+#define BOOST_PP_FOR_237(s,p,o,m) BOOST_PP_FOR_237_C(BOOST_PP_BOOL(p(238, s)), s, p, o, m)
+#define BOOST_PP_FOR_238(s,p,o,m) BOOST_PP_FOR_238_C(BOOST_PP_BOOL(p(239, s)), s, p, o, m)
+#define BOOST_PP_FOR_239(s,p,o,m) BOOST_PP_FOR_239_C(BOOST_PP_BOOL(p(240, s)), s, p, o, m)
+#define BOOST_PP_FOR_240(s,p,o,m) BOOST_PP_FOR_240_C(BOOST_PP_BOOL(p(241, s)), s, p, o, m)
+#define BOOST_PP_FOR_241(s,p,o,m) BOOST_PP_FOR_241_C(BOOST_PP_BOOL(p(242, s)), s, p, o, m)
+#define BOOST_PP_FOR_242(s,p,o,m) BOOST_PP_FOR_242_C(BOOST_PP_BOOL(p(243, s)), s, p, o, m)
+#define BOOST_PP_FOR_243(s,p,o,m) BOOST_PP_FOR_243_C(BOOST_PP_BOOL(p(244, s)), s, p, o, m)
+#define BOOST_PP_FOR_244(s,p,o,m) BOOST_PP_FOR_244_C(BOOST_PP_BOOL(p(245, s)), s, p, o, m)
+#define BOOST_PP_FOR_245(s,p,o,m) BOOST_PP_FOR_245_C(BOOST_PP_BOOL(p(246, s)), s, p, o, m)
+#define BOOST_PP_FOR_246(s,p,o,m) BOOST_PP_FOR_246_C(BOOST_PP_BOOL(p(247, s)), s, p, o, m)
+#define BOOST_PP_FOR_247(s,p,o,m) BOOST_PP_FOR_247_C(BOOST_PP_BOOL(p(248, s)), s, p, o, m)
+#define BOOST_PP_FOR_248(s,p,o,m) BOOST_PP_FOR_248_C(BOOST_PP_BOOL(p(249, s)), s, p, o, m)
+#define BOOST_PP_FOR_249(s,p,o,m) BOOST_PP_FOR_249_C(BOOST_PP_BOOL(p(250, s)), s, p, o, m)
+#define BOOST_PP_FOR_250(s,p,o,m) BOOST_PP_FOR_250_C(BOOST_PP_BOOL(p(251, s)), s, p, o, m)
+#define BOOST_PP_FOR_251(s,p,o,m) BOOST_PP_FOR_251_C(BOOST_PP_BOOL(p(252, s)), s, p, o, m)
+#define BOOST_PP_FOR_252(s,p,o,m) BOOST_PP_FOR_252_C(BOOST_PP_BOOL(p(253, s)), s, p, o, m)
+#define BOOST_PP_FOR_253(s,p,o,m) BOOST_PP_FOR_253_C(BOOST_PP_BOOL(p(254, s)), s, p, o, m)
+#define BOOST_PP_FOR_254(s,p,o,m) BOOST_PP_FOR_254_C(BOOST_PP_BOOL(p(255, s)), s, p, o, m)
+#define BOOST_PP_FOR_255(s,p,o,m) BOOST_PP_FOR_255_C(BOOST_PP_BOOL(p(256, s)), s, p, o, m)
+#define BOOST_PP_FOR_256(s,p,o,m) BOOST_PP_FOR_256_C(BOOST_PP_BOOL(p(257, s)), s, p, o, m)
+
+#define BOOST_PP_FOR_1_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(2, s) BOOST_PP_IIF(c, BOOST_PP_FOR_2, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(2, s), p, o, m)
+#define BOOST_PP_FOR_2_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(3, s) BOOST_PP_IIF(c, BOOST_PP_FOR_3, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(3, s), p, o, m)
+#define BOOST_PP_FOR_3_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(4, s) BOOST_PP_IIF(c, BOOST_PP_FOR_4, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(4, s), p, o, m)
+#define BOOST_PP_FOR_4_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(5, s) BOOST_PP_IIF(c, BOOST_PP_FOR_5, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(5, s), p, o, m)
+#define BOOST_PP_FOR_5_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(6, s) BOOST_PP_IIF(c, BOOST_PP_FOR_6, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(6, s), p, o, m)
+#define BOOST_PP_FOR_6_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(7, s) BOOST_PP_IIF(c, BOOST_PP_FOR_7, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(7, s), p, o, m)
+#define BOOST_PP_FOR_7_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(8, s) BOOST_PP_IIF(c, BOOST_PP_FOR_8, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(8, s), p, o, m)
+#define BOOST_PP_FOR_8_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(9, s) BOOST_PP_IIF(c, BOOST_PP_FOR_9, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(9, s), p, o, m)
+#define BOOST_PP_FOR_9_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(10, s) BOOST_PP_IIF(c, BOOST_PP_FOR_10, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(10, s), p, o, m)
+#define BOOST_PP_FOR_10_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(11, s) BOOST_PP_IIF(c, BOOST_PP_FOR_11, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(11, s), p, o, m)
+#define BOOST_PP_FOR_11_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(12, s) BOOST_PP_IIF(c, BOOST_PP_FOR_12, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(12, s), p, o, m)
+#define BOOST_PP_FOR_12_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(13, s) BOOST_PP_IIF(c, BOOST_PP_FOR_13, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(13, s), p, o, m)
+#define BOOST_PP_FOR_13_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(14, s) BOOST_PP_IIF(c, BOOST_PP_FOR_14, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(14, s), p, o, m)
+#define BOOST_PP_FOR_14_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(15, s) BOOST_PP_IIF(c, BOOST_PP_FOR_15, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(15, s), p, o, m)
+#define BOOST_PP_FOR_15_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(16, s) BOOST_PP_IIF(c, BOOST_PP_FOR_16, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(16, s), p, o, m)
+#define BOOST_PP_FOR_16_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(17, s) BOOST_PP_IIF(c, BOOST_PP_FOR_17, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(17, s), p, o, m)
+#define BOOST_PP_FOR_17_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(18, s) BOOST_PP_IIF(c, BOOST_PP_FOR_18, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(18, s), p, o, m)
+#define BOOST_PP_FOR_18_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(19, s) BOOST_PP_IIF(c, BOOST_PP_FOR_19, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(19, s), p, o, m)
+#define BOOST_PP_FOR_19_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(20, s) BOOST_PP_IIF(c, BOOST_PP_FOR_20, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(20, s), p, o, m)
+#define BOOST_PP_FOR_20_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(21, s) BOOST_PP_IIF(c, BOOST_PP_FOR_21, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(21, s), p, o, m)
+#define BOOST_PP_FOR_21_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(22, s) BOOST_PP_IIF(c, BOOST_PP_FOR_22, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(22, s), p, o, m)
+#define BOOST_PP_FOR_22_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(23, s) BOOST_PP_IIF(c, BOOST_PP_FOR_23, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(23, s), p, o, m)
+#define BOOST_PP_FOR_23_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(24, s) BOOST_PP_IIF(c, BOOST_PP_FOR_24, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(24, s), p, o, m)
+#define BOOST_PP_FOR_24_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(25, s) BOOST_PP_IIF(c, BOOST_PP_FOR_25, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(25, s), p, o, m)
+#define BOOST_PP_FOR_25_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(26, s) BOOST_PP_IIF(c, BOOST_PP_FOR_26, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(26, s), p, o, m)
+#define BOOST_PP_FOR_26_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(27, s) BOOST_PP_IIF(c, BOOST_PP_FOR_27, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(27, s), p, o, m)
+#define BOOST_PP_FOR_27_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(28, s) BOOST_PP_IIF(c, BOOST_PP_FOR_28, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(28, s), p, o, m)
+#define BOOST_PP_FOR_28_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(29, s) BOOST_PP_IIF(c, BOOST_PP_FOR_29, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(29, s), p, o, m)
+#define BOOST_PP_FOR_29_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(30, s) BOOST_PP_IIF(c, BOOST_PP_FOR_30, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(30, s), p, o, m)
+#define BOOST_PP_FOR_30_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(31, s) BOOST_PP_IIF(c, BOOST_PP_FOR_31, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(31, s), p, o, m)
+#define BOOST_PP_FOR_31_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(32, s) BOOST_PP_IIF(c, BOOST_PP_FOR_32, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(32, s), p, o, m)
+#define BOOST_PP_FOR_32_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(33, s) BOOST_PP_IIF(c, BOOST_PP_FOR_33, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(33, s), p, o, m)
+#define BOOST_PP_FOR_33_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(34, s) BOOST_PP_IIF(c, BOOST_PP_FOR_34, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(34, s), p, o, m)
+#define BOOST_PP_FOR_34_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(35, s) BOOST_PP_IIF(c, BOOST_PP_FOR_35, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(35, s), p, o, m)
+#define BOOST_PP_FOR_35_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(36, s) BOOST_PP_IIF(c, BOOST_PP_FOR_36, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(36, s), p, o, m)
+#define BOOST_PP_FOR_36_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(37, s) BOOST_PP_IIF(c, BOOST_PP_FOR_37, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(37, s), p, o, m)
+#define BOOST_PP_FOR_37_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(38, s) BOOST_PP_IIF(c, BOOST_PP_FOR_38, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(38, s), p, o, m)
+#define BOOST_PP_FOR_38_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(39, s) BOOST_PP_IIF(c, BOOST_PP_FOR_39, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(39, s), p, o, m)
+#define BOOST_PP_FOR_39_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(40, s) BOOST_PP_IIF(c, BOOST_PP_FOR_40, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(40, s), p, o, m)
+#define BOOST_PP_FOR_40_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(41, s) BOOST_PP_IIF(c, BOOST_PP_FOR_41, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(41, s), p, o, m)
+#define BOOST_PP_FOR_41_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(42, s) BOOST_PP_IIF(c, BOOST_PP_FOR_42, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(42, s), p, o, m)
+#define BOOST_PP_FOR_42_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(43, s) BOOST_PP_IIF(c, BOOST_PP_FOR_43, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(43, s), p, o, m)
+#define BOOST_PP_FOR_43_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(44, s) BOOST_PP_IIF(c, BOOST_PP_FOR_44, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(44, s), p, o, m)
+#define BOOST_PP_FOR_44_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(45, s) BOOST_PP_IIF(c, BOOST_PP_FOR_45, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(45, s), p, o, m)
+#define BOOST_PP_FOR_45_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(46, s) BOOST_PP_IIF(c, BOOST_PP_FOR_46, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(46, s), p, o, m)
+#define BOOST_PP_FOR_46_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(47, s) BOOST_PP_IIF(c, BOOST_PP_FOR_47, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(47, s), p, o, m)
+#define BOOST_PP_FOR_47_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(48, s) BOOST_PP_IIF(c, BOOST_PP_FOR_48, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(48, s), p, o, m)
+#define BOOST_PP_FOR_48_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(49, s) BOOST_PP_IIF(c, BOOST_PP_FOR_49, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(49, s), p, o, m)
+#define BOOST_PP_FOR_49_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(50, s) BOOST_PP_IIF(c, BOOST_PP_FOR_50, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(50, s), p, o, m)
+#define BOOST_PP_FOR_50_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(51, s) BOOST_PP_IIF(c, BOOST_PP_FOR_51, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(51, s), p, o, m)
+#define BOOST_PP_FOR_51_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(52, s) BOOST_PP_IIF(c, BOOST_PP_FOR_52, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(52, s), p, o, m)
+#define BOOST_PP_FOR_52_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(53, s) BOOST_PP_IIF(c, BOOST_PP_FOR_53, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(53, s), p, o, m)
+#define BOOST_PP_FOR_53_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(54, s) BOOST_PP_IIF(c, BOOST_PP_FOR_54, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(54, s), p, o, m)
+#define BOOST_PP_FOR_54_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(55, s) BOOST_PP_IIF(c, BOOST_PP_FOR_55, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(55, s), p, o, m)
+#define BOOST_PP_FOR_55_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(56, s) BOOST_PP_IIF(c, BOOST_PP_FOR_56, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(56, s), p, o, m)
+#define BOOST_PP_FOR_56_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(57, s) BOOST_PP_IIF(c, BOOST_PP_FOR_57, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(57, s), p, o, m)
+#define BOOST_PP_FOR_57_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(58, s) BOOST_PP_IIF(c, BOOST_PP_FOR_58, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(58, s), p, o, m)
+#define BOOST_PP_FOR_58_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(59, s) BOOST_PP_IIF(c, BOOST_PP_FOR_59, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(59, s), p, o, m)
+#define BOOST_PP_FOR_59_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(60, s) BOOST_PP_IIF(c, BOOST_PP_FOR_60, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(60, s), p, o, m)
+#define BOOST_PP_FOR_60_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(61, s) BOOST_PP_IIF(c, BOOST_PP_FOR_61, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(61, s), p, o, m)
+#define BOOST_PP_FOR_61_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(62, s) BOOST_PP_IIF(c, BOOST_PP_FOR_62, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(62, s), p, o, m)
+#define BOOST_PP_FOR_62_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(63, s) BOOST_PP_IIF(c, BOOST_PP_FOR_63, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(63, s), p, o, m)
+#define BOOST_PP_FOR_63_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(64, s) BOOST_PP_IIF(c, BOOST_PP_FOR_64, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(64, s), p, o, m)
+#define BOOST_PP_FOR_64_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(65, s) BOOST_PP_IIF(c, BOOST_PP_FOR_65, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(65, s), p, o, m)
+#define BOOST_PP_FOR_65_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(66, s) BOOST_PP_IIF(c, BOOST_PP_FOR_66, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(66, s), p, o, m)
+#define BOOST_PP_FOR_66_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(67, s) BOOST_PP_IIF(c, BOOST_PP_FOR_67, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(67, s), p, o, m)
+#define BOOST_PP_FOR_67_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(68, s) BOOST_PP_IIF(c, BOOST_PP_FOR_68, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(68, s), p, o, m)
+#define BOOST_PP_FOR_68_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(69, s) BOOST_PP_IIF(c, BOOST_PP_FOR_69, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(69, s), p, o, m)
+#define BOOST_PP_FOR_69_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(70, s) BOOST_PP_IIF(c, BOOST_PP_FOR_70, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(70, s), p, o, m)
+#define BOOST_PP_FOR_70_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(71, s) BOOST_PP_IIF(c, BOOST_PP_FOR_71, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(71, s), p, o, m)
+#define BOOST_PP_FOR_71_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(72, s) BOOST_PP_IIF(c, BOOST_PP_FOR_72, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(72, s), p, o, m)
+#define BOOST_PP_FOR_72_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(73, s) BOOST_PP_IIF(c, BOOST_PP_FOR_73, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(73, s), p, o, m)
+#define BOOST_PP_FOR_73_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(74, s) BOOST_PP_IIF(c, BOOST_PP_FOR_74, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(74, s), p, o, m)
+#define BOOST_PP_FOR_74_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(75, s) BOOST_PP_IIF(c, BOOST_PP_FOR_75, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(75, s), p, o, m)
+#define BOOST_PP_FOR_75_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(76, s) BOOST_PP_IIF(c, BOOST_PP_FOR_76, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(76, s), p, o, m)
+#define BOOST_PP_FOR_76_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(77, s) BOOST_PP_IIF(c, BOOST_PP_FOR_77, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(77, s), p, o, m)
+#define BOOST_PP_FOR_77_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(78, s) BOOST_PP_IIF(c, BOOST_PP_FOR_78, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(78, s), p, o, m)
+#define BOOST_PP_FOR_78_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(79, s) BOOST_PP_IIF(c, BOOST_PP_FOR_79, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(79, s), p, o, m)
+#define BOOST_PP_FOR_79_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(80, s) BOOST_PP_IIF(c, BOOST_PP_FOR_80, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(80, s), p, o, m)
+#define BOOST_PP_FOR_80_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(81, s) BOOST_PP_IIF(c, BOOST_PP_FOR_81, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(81, s), p, o, m)
+#define BOOST_PP_FOR_81_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(82, s) BOOST_PP_IIF(c, BOOST_PP_FOR_82, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(82, s), p, o, m)
+#define BOOST_PP_FOR_82_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(83, s) BOOST_PP_IIF(c, BOOST_PP_FOR_83, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(83, s), p, o, m)
+#define BOOST_PP_FOR_83_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(84, s) BOOST_PP_IIF(c, BOOST_PP_FOR_84, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(84, s), p, o, m)
+#define BOOST_PP_FOR_84_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(85, s) BOOST_PP_IIF(c, BOOST_PP_FOR_85, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(85, s), p, o, m)
+#define BOOST_PP_FOR_85_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(86, s) BOOST_PP_IIF(c, BOOST_PP_FOR_86, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(86, s), p, o, m)
+#define BOOST_PP_FOR_86_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(87, s) BOOST_PP_IIF(c, BOOST_PP_FOR_87, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(87, s), p, o, m)
+#define BOOST_PP_FOR_87_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(88, s) BOOST_PP_IIF(c, BOOST_PP_FOR_88, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(88, s), p, o, m)
+#define BOOST_PP_FOR_88_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(89, s) BOOST_PP_IIF(c, BOOST_PP_FOR_89, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(89, s), p, o, m)
+#define BOOST_PP_FOR_89_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(90, s) BOOST_PP_IIF(c, BOOST_PP_FOR_90, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(90, s), p, o, m)
+#define BOOST_PP_FOR_90_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(91, s) BOOST_PP_IIF(c, BOOST_PP_FOR_91, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(91, s), p, o, m)
+#define BOOST_PP_FOR_91_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(92, s) BOOST_PP_IIF(c, BOOST_PP_FOR_92, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(92, s), p, o, m)
+#define BOOST_PP_FOR_92_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(93, s) BOOST_PP_IIF(c, BOOST_PP_FOR_93, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(93, s), p, o, m)
+#define BOOST_PP_FOR_93_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(94, s) BOOST_PP_IIF(c, BOOST_PP_FOR_94, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(94, s), p, o, m)
+#define BOOST_PP_FOR_94_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(95, s) BOOST_PP_IIF(c, BOOST_PP_FOR_95, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(95, s), p, o, m)
+#define BOOST_PP_FOR_95_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(96, s) BOOST_PP_IIF(c, BOOST_PP_FOR_96, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(96, s), p, o, m)
+#define BOOST_PP_FOR_96_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(97, s) BOOST_PP_IIF(c, BOOST_PP_FOR_97, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(97, s), p, o, m)
+#define BOOST_PP_FOR_97_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(98, s) BOOST_PP_IIF(c, BOOST_PP_FOR_98, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(98, s), p, o, m)
+#define BOOST_PP_FOR_98_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(99, s) BOOST_PP_IIF(c, BOOST_PP_FOR_99, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(99, s), p, o, m)
+#define BOOST_PP_FOR_99_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(100, s) BOOST_PP_IIF(c, BOOST_PP_FOR_100, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(100, s), p, o, m)
+#define BOOST_PP_FOR_100_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(101, s) BOOST_PP_IIF(c, BOOST_PP_FOR_101, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(101, s), p, o, m)
+#define BOOST_PP_FOR_101_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(102, s) BOOST_PP_IIF(c, BOOST_PP_FOR_102, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(102, s), p, o, m)
+#define BOOST_PP_FOR_102_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(103, s) BOOST_PP_IIF(c, BOOST_PP_FOR_103, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(103, s), p, o, m)
+#define BOOST_PP_FOR_103_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(104, s) BOOST_PP_IIF(c, BOOST_PP_FOR_104, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(104, s), p, o, m)
+#define BOOST_PP_FOR_104_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(105, s) BOOST_PP_IIF(c, BOOST_PP_FOR_105, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(105, s), p, o, m)
+#define BOOST_PP_FOR_105_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(106, s) BOOST_PP_IIF(c, BOOST_PP_FOR_106, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(106, s), p, o, m)
+#define BOOST_PP_FOR_106_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(107, s) BOOST_PP_IIF(c, BOOST_PP_FOR_107, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(107, s), p, o, m)
+#define BOOST_PP_FOR_107_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(108, s) BOOST_PP_IIF(c, BOOST_PP_FOR_108, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(108, s), p, o, m)
+#define BOOST_PP_FOR_108_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(109, s) BOOST_PP_IIF(c, BOOST_PP_FOR_109, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(109, s), p, o, m)
+#define BOOST_PP_FOR_109_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(110, s) BOOST_PP_IIF(c, BOOST_PP_FOR_110, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(110, s), p, o, m)
+#define BOOST_PP_FOR_110_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(111, s) BOOST_PP_IIF(c, BOOST_PP_FOR_111, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(111, s), p, o, m)
+#define BOOST_PP_FOR_111_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(112, s) BOOST_PP_IIF(c, BOOST_PP_FOR_112, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(112, s), p, o, m)
+#define BOOST_PP_FOR_112_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(113, s) BOOST_PP_IIF(c, BOOST_PP_FOR_113, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(113, s), p, o, m)
+#define BOOST_PP_FOR_113_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(114, s) BOOST_PP_IIF(c, BOOST_PP_FOR_114, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(114, s), p, o, m)
+#define BOOST_PP_FOR_114_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(115, s) BOOST_PP_IIF(c, BOOST_PP_FOR_115, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(115, s), p, o, m)
+#define BOOST_PP_FOR_115_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(116, s) BOOST_PP_IIF(c, BOOST_PP_FOR_116, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(116, s), p, o, m)
+#define BOOST_PP_FOR_116_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(117, s) BOOST_PP_IIF(c, BOOST_PP_FOR_117, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(117, s), p, o, m)
+#define BOOST_PP_FOR_117_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(118, s) BOOST_PP_IIF(c, BOOST_PP_FOR_118, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(118, s), p, o, m)
+#define BOOST_PP_FOR_118_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(119, s) BOOST_PP_IIF(c, BOOST_PP_FOR_119, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(119, s), p, o, m)
+#define BOOST_PP_FOR_119_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(120, s) BOOST_PP_IIF(c, BOOST_PP_FOR_120, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(120, s), p, o, m)
+#define BOOST_PP_FOR_120_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(121, s) BOOST_PP_IIF(c, BOOST_PP_FOR_121, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(121, s), p, o, m)
+#define BOOST_PP_FOR_121_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(122, s) BOOST_PP_IIF(c, BOOST_PP_FOR_122, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(122, s), p, o, m)
+#define BOOST_PP_FOR_122_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(123, s) BOOST_PP_IIF(c, BOOST_PP_FOR_123, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(123, s), p, o, m)
+#define BOOST_PP_FOR_123_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(124, s) BOOST_PP_IIF(c, BOOST_PP_FOR_124, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(124, s), p, o, m)
+#define BOOST_PP_FOR_124_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(125, s) BOOST_PP_IIF(c, BOOST_PP_FOR_125, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(125, s), p, o, m)
+#define BOOST_PP_FOR_125_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(126, s) BOOST_PP_IIF(c, BOOST_PP_FOR_126, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(126, s), p, o, m)
+#define BOOST_PP_FOR_126_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(127, s) BOOST_PP_IIF(c, BOOST_PP_FOR_127, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(127, s), p, o, m)
+#define BOOST_PP_FOR_127_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(128, s) BOOST_PP_IIF(c, BOOST_PP_FOR_128, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(128, s), p, o, m)
+#define BOOST_PP_FOR_128_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(129, s) BOOST_PP_IIF(c, BOOST_PP_FOR_129, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(129, s), p, o, m)
+#define BOOST_PP_FOR_129_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(130, s) BOOST_PP_IIF(c, BOOST_PP_FOR_130, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(130, s), p, o, m)
+#define BOOST_PP_FOR_130_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(131, s) BOOST_PP_IIF(c, BOOST_PP_FOR_131, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(131, s), p, o, m)
+#define BOOST_PP_FOR_131_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(132, s) BOOST_PP_IIF(c, BOOST_PP_FOR_132, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(132, s), p, o, m)
+#define BOOST_PP_FOR_132_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(133, s) BOOST_PP_IIF(c, BOOST_PP_FOR_133, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(133, s), p, o, m)
+#define BOOST_PP_FOR_133_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(134, s) BOOST_PP_IIF(c, BOOST_PP_FOR_134, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(134, s), p, o, m)
+#define BOOST_PP_FOR_134_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(135, s) BOOST_PP_IIF(c, BOOST_PP_FOR_135, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(135, s), p, o, m)
+#define BOOST_PP_FOR_135_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(136, s) BOOST_PP_IIF(c, BOOST_PP_FOR_136, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(136, s), p, o, m)
+#define BOOST_PP_FOR_136_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(137, s) BOOST_PP_IIF(c, BOOST_PP_FOR_137, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(137, s), p, o, m)
+#define BOOST_PP_FOR_137_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(138, s) BOOST_PP_IIF(c, BOOST_PP_FOR_138, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(138, s), p, o, m)
+#define BOOST_PP_FOR_138_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(139, s) BOOST_PP_IIF(c, BOOST_PP_FOR_139, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(139, s), p, o, m)
+#define BOOST_PP_FOR_139_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(140, s) BOOST_PP_IIF(c, BOOST_PP_FOR_140, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(140, s), p, o, m)
+#define BOOST_PP_FOR_140_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(141, s) BOOST_PP_IIF(c, BOOST_PP_FOR_141, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(141, s), p, o, m)
+#define BOOST_PP_FOR_141_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(142, s) BOOST_PP_IIF(c, BOOST_PP_FOR_142, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(142, s), p, o, m)
+#define BOOST_PP_FOR_142_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(143, s) BOOST_PP_IIF(c, BOOST_PP_FOR_143, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(143, s), p, o, m)
+#define BOOST_PP_FOR_143_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(144, s) BOOST_PP_IIF(c, BOOST_PP_FOR_144, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(144, s), p, o, m)
+#define BOOST_PP_FOR_144_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(145, s) BOOST_PP_IIF(c, BOOST_PP_FOR_145, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(145, s), p, o, m)
+#define BOOST_PP_FOR_145_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(146, s) BOOST_PP_IIF(c, BOOST_PP_FOR_146, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(146, s), p, o, m)
+#define BOOST_PP_FOR_146_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(147, s) BOOST_PP_IIF(c, BOOST_PP_FOR_147, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(147, s), p, o, m)
+#define BOOST_PP_FOR_147_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(148, s) BOOST_PP_IIF(c, BOOST_PP_FOR_148, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(148, s), p, o, m)
+#define BOOST_PP_FOR_148_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(149, s) BOOST_PP_IIF(c, BOOST_PP_FOR_149, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(149, s), p, o, m)
+#define BOOST_PP_FOR_149_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(150, s) BOOST_PP_IIF(c, BOOST_PP_FOR_150, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(150, s), p, o, m)
+#define BOOST_PP_FOR_150_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(151, s) BOOST_PP_IIF(c, BOOST_PP_FOR_151, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(151, s), p, o, m)
+#define BOOST_PP_FOR_151_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(152, s) BOOST_PP_IIF(c, BOOST_PP_FOR_152, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(152, s), p, o, m)
+#define BOOST_PP_FOR_152_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(153, s) BOOST_PP_IIF(c, BOOST_PP_FOR_153, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(153, s), p, o, m)
+#define BOOST_PP_FOR_153_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(154, s) BOOST_PP_IIF(c, BOOST_PP_FOR_154, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(154, s), p, o, m)
+#define BOOST_PP_FOR_154_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(155, s) BOOST_PP_IIF(c, BOOST_PP_FOR_155, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(155, s), p, o, m)
+#define BOOST_PP_FOR_155_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(156, s) BOOST_PP_IIF(c, BOOST_PP_FOR_156, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(156, s), p, o, m)
+#define BOOST_PP_FOR_156_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(157, s) BOOST_PP_IIF(c, BOOST_PP_FOR_157, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(157, s), p, o, m)
+#define BOOST_PP_FOR_157_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(158, s) BOOST_PP_IIF(c, BOOST_PP_FOR_158, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(158, s), p, o, m)
+#define BOOST_PP_FOR_158_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(159, s) BOOST_PP_IIF(c, BOOST_PP_FOR_159, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(159, s), p, o, m)
+#define BOOST_PP_FOR_159_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(160, s) BOOST_PP_IIF(c, BOOST_PP_FOR_160, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(160, s), p, o, m)
+#define BOOST_PP_FOR_160_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(161, s) BOOST_PP_IIF(c, BOOST_PP_FOR_161, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(161, s), p, o, m)
+#define BOOST_PP_FOR_161_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(162, s) BOOST_PP_IIF(c, BOOST_PP_FOR_162, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(162, s), p, o, m)
+#define BOOST_PP_FOR_162_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(163, s) BOOST_PP_IIF(c, BOOST_PP_FOR_163, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(163, s), p, o, m)
+#define BOOST_PP_FOR_163_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(164, s) BOOST_PP_IIF(c, BOOST_PP_FOR_164, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(164, s), p, o, m)
+#define BOOST_PP_FOR_164_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(165, s) BOOST_PP_IIF(c, BOOST_PP_FOR_165, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(165, s), p, o, m)
+#define BOOST_PP_FOR_165_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(166, s) BOOST_PP_IIF(c, BOOST_PP_FOR_166, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(166, s), p, o, m)
+#define BOOST_PP_FOR_166_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(167, s) BOOST_PP_IIF(c, BOOST_PP_FOR_167, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(167, s), p, o, m)
+#define BOOST_PP_FOR_167_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(168, s) BOOST_PP_IIF(c, BOOST_PP_FOR_168, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(168, s), p, o, m)
+#define BOOST_PP_FOR_168_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(169, s) BOOST_PP_IIF(c, BOOST_PP_FOR_169, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(169, s), p, o, m)
+#define BOOST_PP_FOR_169_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(170, s) BOOST_PP_IIF(c, BOOST_PP_FOR_170, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(170, s), p, o, m)
+#define BOOST_PP_FOR_170_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(171, s) BOOST_PP_IIF(c, BOOST_PP_FOR_171, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(171, s), p, o, m)
+#define BOOST_PP_FOR_171_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(172, s) BOOST_PP_IIF(c, BOOST_PP_FOR_172, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(172, s), p, o, m)
+#define BOOST_PP_FOR_172_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(173, s) BOOST_PP_IIF(c, BOOST_PP_FOR_173, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(173, s), p, o, m)
+#define BOOST_PP_FOR_173_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(174, s) BOOST_PP_IIF(c, BOOST_PP_FOR_174, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(174, s), p, o, m)
+#define BOOST_PP_FOR_174_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(175, s) BOOST_PP_IIF(c, BOOST_PP_FOR_175, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(175, s), p, o, m)
+#define BOOST_PP_FOR_175_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(176, s) BOOST_PP_IIF(c, BOOST_PP_FOR_176, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(176, s), p, o, m)
+#define BOOST_PP_FOR_176_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(177, s) BOOST_PP_IIF(c, BOOST_PP_FOR_177, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(177, s), p, o, m)
+#define BOOST_PP_FOR_177_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(178, s) BOOST_PP_IIF(c, BOOST_PP_FOR_178, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(178, s), p, o, m)
+#define BOOST_PP_FOR_178_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(179, s) BOOST_PP_IIF(c, BOOST_PP_FOR_179, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(179, s), p, o, m)
+#define BOOST_PP_FOR_179_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(180, s) BOOST_PP_IIF(c, BOOST_PP_FOR_180, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(180, s), p, o, m)
+#define BOOST_PP_FOR_180_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(181, s) BOOST_PP_IIF(c, BOOST_PP_FOR_181, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(181, s), p, o, m)
+#define BOOST_PP_FOR_181_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(182, s) BOOST_PP_IIF(c, BOOST_PP_FOR_182, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(182, s), p, o, m)
+#define BOOST_PP_FOR_182_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(183, s) BOOST_PP_IIF(c, BOOST_PP_FOR_183, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(183, s), p, o, m)
+#define BOOST_PP_FOR_183_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(184, s) BOOST_PP_IIF(c, BOOST_PP_FOR_184, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(184, s), p, o, m)
+#define BOOST_PP_FOR_184_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(185, s) BOOST_PP_IIF(c, BOOST_PP_FOR_185, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(185, s), p, o, m)
+#define BOOST_PP_FOR_185_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(186, s) BOOST_PP_IIF(c, BOOST_PP_FOR_186, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(186, s), p, o, m)
+#define BOOST_PP_FOR_186_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(187, s) BOOST_PP_IIF(c, BOOST_PP_FOR_187, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(187, s), p, o, m)
+#define BOOST_PP_FOR_187_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(188, s) BOOST_PP_IIF(c, BOOST_PP_FOR_188, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(188, s), p, o, m)
+#define BOOST_PP_FOR_188_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(189, s) BOOST_PP_IIF(c, BOOST_PP_FOR_189, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(189, s), p, o, m)
+#define BOOST_PP_FOR_189_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(190, s) BOOST_PP_IIF(c, BOOST_PP_FOR_190, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(190, s), p, o, m)
+#define BOOST_PP_FOR_190_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(191, s) BOOST_PP_IIF(c, BOOST_PP_FOR_191, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(191, s), p, o, m)
+#define BOOST_PP_FOR_191_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(192, s) BOOST_PP_IIF(c, BOOST_PP_FOR_192, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(192, s), p, o, m)
+#define BOOST_PP_FOR_192_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(193, s) BOOST_PP_IIF(c, BOOST_PP_FOR_193, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(193, s), p, o, m)
+#define BOOST_PP_FOR_193_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(194, s) BOOST_PP_IIF(c, BOOST_PP_FOR_194, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(194, s), p, o, m)
+#define BOOST_PP_FOR_194_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(195, s) BOOST_PP_IIF(c, BOOST_PP_FOR_195, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(195, s), p, o, m)
+#define BOOST_PP_FOR_195_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(196, s) BOOST_PP_IIF(c, BOOST_PP_FOR_196, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(196, s), p, o, m)
+#define BOOST_PP_FOR_196_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(197, s) BOOST_PP_IIF(c, BOOST_PP_FOR_197, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(197, s), p, o, m)
+#define BOOST_PP_FOR_197_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(198, s) BOOST_PP_IIF(c, BOOST_PP_FOR_198, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(198, s), p, o, m)
+#define BOOST_PP_FOR_198_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(199, s) BOOST_PP_IIF(c, BOOST_PP_FOR_199, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(199, s), p, o, m)
+#define BOOST_PP_FOR_199_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(200, s) BOOST_PP_IIF(c, BOOST_PP_FOR_200, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(200, s), p, o, m)
+#define BOOST_PP_FOR_200_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(201, s) BOOST_PP_IIF(c, BOOST_PP_FOR_201, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(201, s), p, o, m)
+#define BOOST_PP_FOR_201_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(202, s) BOOST_PP_IIF(c, BOOST_PP_FOR_202, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(202, s), p, o, m)
+#define BOOST_PP_FOR_202_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(203, s) BOOST_PP_IIF(c, BOOST_PP_FOR_203, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(203, s), p, o, m)
+#define BOOST_PP_FOR_203_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(204, s) BOOST_PP_IIF(c, BOOST_PP_FOR_204, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(204, s), p, o, m)
+#define BOOST_PP_FOR_204_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(205, s) BOOST_PP_IIF(c, BOOST_PP_FOR_205, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(205, s), p, o, m)
+#define BOOST_PP_FOR_205_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(206, s) BOOST_PP_IIF(c, BOOST_PP_FOR_206, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(206, s), p, o, m)
+#define BOOST_PP_FOR_206_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(207, s) BOOST_PP_IIF(c, BOOST_PP_FOR_207, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(207, s), p, o, m)
+#define BOOST_PP_FOR_207_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(208, s) BOOST_PP_IIF(c, BOOST_PP_FOR_208, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(208, s), p, o, m)
+#define BOOST_PP_FOR_208_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(209, s) BOOST_PP_IIF(c, BOOST_PP_FOR_209, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(209, s), p, o, m)
+#define BOOST_PP_FOR_209_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(210, s) BOOST_PP_IIF(c, BOOST_PP_FOR_210, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(210, s), p, o, m)
+#define BOOST_PP_FOR_210_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(211, s) BOOST_PP_IIF(c, BOOST_PP_FOR_211, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(211, s), p, o, m)
+#define BOOST_PP_FOR_211_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(212, s) BOOST_PP_IIF(c, BOOST_PP_FOR_212, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(212, s), p, o, m)
+#define BOOST_PP_FOR_212_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(213, s) BOOST_PP_IIF(c, BOOST_PP_FOR_213, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(213, s), p, o, m)
+#define BOOST_PP_FOR_213_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(214, s) BOOST_PP_IIF(c, BOOST_PP_FOR_214, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(214, s), p, o, m)
+#define BOOST_PP_FOR_214_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(215, s) BOOST_PP_IIF(c, BOOST_PP_FOR_215, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(215, s), p, o, m)
+#define BOOST_PP_FOR_215_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(216, s) BOOST_PP_IIF(c, BOOST_PP_FOR_216, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(216, s), p, o, m)
+#define BOOST_PP_FOR_216_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(217, s) BOOST_PP_IIF(c, BOOST_PP_FOR_217, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(217, s), p, o, m)
+#define BOOST_PP_FOR_217_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(218, s) BOOST_PP_IIF(c, BOOST_PP_FOR_218, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(218, s), p, o, m)
+#define BOOST_PP_FOR_218_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(219, s) BOOST_PP_IIF(c, BOOST_PP_FOR_219, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(219, s), p, o, m)
+#define BOOST_PP_FOR_219_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(220, s) BOOST_PP_IIF(c, BOOST_PP_FOR_220, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(220, s), p, o, m)
+#define BOOST_PP_FOR_220_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(221, s) BOOST_PP_IIF(c, BOOST_PP_FOR_221, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(221, s), p, o, m)
+#define BOOST_PP_FOR_221_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(222, s) BOOST_PP_IIF(c, BOOST_PP_FOR_222, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(222, s), p, o, m)
+#define BOOST_PP_FOR_222_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(223, s) BOOST_PP_IIF(c, BOOST_PP_FOR_223, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(223, s), p, o, m)
+#define BOOST_PP_FOR_223_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(224, s) BOOST_PP_IIF(c, BOOST_PP_FOR_224, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(224, s), p, o, m)
+#define BOOST_PP_FOR_224_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(225, s) BOOST_PP_IIF(c, BOOST_PP_FOR_225, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(225, s), p, o, m)
+#define BOOST_PP_FOR_225_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(226, s) BOOST_PP_IIF(c, BOOST_PP_FOR_226, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(226, s), p, o, m)
+#define BOOST_PP_FOR_226_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(227, s) BOOST_PP_IIF(c, BOOST_PP_FOR_227, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(227, s), p, o, m)
+#define BOOST_PP_FOR_227_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(228, s) BOOST_PP_IIF(c, BOOST_PP_FOR_228, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(228, s), p, o, m)
+#define BOOST_PP_FOR_228_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(229, s) BOOST_PP_IIF(c, BOOST_PP_FOR_229, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(229, s), p, o, m)
+#define BOOST_PP_FOR_229_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(230, s) BOOST_PP_IIF(c, BOOST_PP_FOR_230, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(230, s), p, o, m)
+#define BOOST_PP_FOR_230_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(231, s) BOOST_PP_IIF(c, BOOST_PP_FOR_231, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(231, s), p, o, m)
+#define BOOST_PP_FOR_231_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(232, s) BOOST_PP_IIF(c, BOOST_PP_FOR_232, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(232, s), p, o, m)
+#define BOOST_PP_FOR_232_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(233, s) BOOST_PP_IIF(c, BOOST_PP_FOR_233, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(233, s), p, o, m)
+#define BOOST_PP_FOR_233_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(234, s) BOOST_PP_IIF(c, BOOST_PP_FOR_234, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(234, s), p, o, m)
+#define BOOST_PP_FOR_234_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(235, s) BOOST_PP_IIF(c, BOOST_PP_FOR_235, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(235, s), p, o, m)
+#define BOOST_PP_FOR_235_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(236, s) BOOST_PP_IIF(c, BOOST_PP_FOR_236, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(236, s), p, o, m)
+#define BOOST_PP_FOR_236_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(237, s) BOOST_PP_IIF(c, BOOST_PP_FOR_237, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(237, s), p, o, m)
+#define BOOST_PP_FOR_237_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(238, s) BOOST_PP_IIF(c, BOOST_PP_FOR_238, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(238, s), p, o, m)
+#define BOOST_PP_FOR_238_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(239, s) BOOST_PP_IIF(c, BOOST_PP_FOR_239, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(239, s), p, o, m)
+#define BOOST_PP_FOR_239_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(240, s) BOOST_PP_IIF(c, BOOST_PP_FOR_240, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(240, s), p, o, m)
+#define BOOST_PP_FOR_240_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(241, s) BOOST_PP_IIF(c, BOOST_PP_FOR_241, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(241, s), p, o, m)
+#define BOOST_PP_FOR_241_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(242, s) BOOST_PP_IIF(c, BOOST_PP_FOR_242, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(242, s), p, o, m)
+#define BOOST_PP_FOR_242_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(243, s) BOOST_PP_IIF(c, BOOST_PP_FOR_243, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(243, s), p, o, m)
+#define BOOST_PP_FOR_243_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(244, s) BOOST_PP_IIF(c, BOOST_PP_FOR_244, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(244, s), p, o, m)
+#define BOOST_PP_FOR_244_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(245, s) BOOST_PP_IIF(c, BOOST_PP_FOR_245, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(245, s), p, o, m)
+#define BOOST_PP_FOR_245_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(246, s) BOOST_PP_IIF(c, BOOST_PP_FOR_246, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(246, s), p, o, m)
+#define BOOST_PP_FOR_246_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(247, s) BOOST_PP_IIF(c, BOOST_PP_FOR_247, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(247, s), p, o, m)
+#define BOOST_PP_FOR_247_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(248, s) BOOST_PP_IIF(c, BOOST_PP_FOR_248, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(248, s), p, o, m)
+#define BOOST_PP_FOR_248_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(249, s) BOOST_PP_IIF(c, BOOST_PP_FOR_249, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(249, s), p, o, m)
+#define BOOST_PP_FOR_249_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(250, s) BOOST_PP_IIF(c, BOOST_PP_FOR_250, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(250, s), p, o, m)
+#define BOOST_PP_FOR_250_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(251, s) BOOST_PP_IIF(c, BOOST_PP_FOR_251, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(251, s), p, o, m)
+#define BOOST_PP_FOR_251_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(252, s) BOOST_PP_IIF(c, BOOST_PP_FOR_252, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(252, s), p, o, m)
+#define BOOST_PP_FOR_252_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(253, s) BOOST_PP_IIF(c, BOOST_PP_FOR_253, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(253, s), p, o, m)
+#define BOOST_PP_FOR_253_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(254, s) BOOST_PP_IIF(c, BOOST_PP_FOR_254, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(254, s), p, o, m)
+#define BOOST_PP_FOR_254_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(255, s) BOOST_PP_IIF(c, BOOST_PP_FOR_255, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(255, s), p, o, m)
+#define BOOST_PP_FOR_255_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(256, s) BOOST_PP_IIF(c, BOOST_PP_FOR_256, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(256, s), p, o, m)
+#define BOOST_PP_FOR_256_C(c,s,p,o,m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(257, s) BOOST_PP_IIF(c, BOOST_PP_FOR_257, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(257, s), p, o, m)
+# 45 "/usr/include/boost/preprocessor/repetition/for.hpp" 2 3 4
+
+
+
+
+
+#define BOOST_PP_FOR_257_PR(s,p) BOOST_PP_BOOL(p(257, s))
+
+
+#define BOOST_PP_FOR_257_ERROR() BOOST_PP_ERROR(0x0002)
+#define BOOST_PP_FOR_257(s,p,o,m) BOOST_PP_IIF ( BOOST_PP_FOR_257_PR(s,p), BOOST_PP_FOR_257_ERROR, BOOST_PP_EMPTY ) ()
+# 65 "/usr/include/boost/preprocessor/repetition/for.hpp" 3 4
+#define BOOST_PP_FOR_CHECK_BOOST_PP_NIL 1
+
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_1(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_2(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_3(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_4(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_5(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_6(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_7(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_8(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_9(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_10(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_11(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_12(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_13(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_14(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_15(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_16(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_17(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_18(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_19(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_20(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_21(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_22(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_23(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_24(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_25(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_26(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_27(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_28(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_29(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_30(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_31(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_32(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_33(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_34(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_35(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_36(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_37(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_38(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_39(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_40(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_41(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_42(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_43(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_44(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_45(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_46(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_47(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_48(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_49(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_50(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_51(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_52(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_53(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_54(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_55(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_56(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_57(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_58(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_59(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_60(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_61(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_62(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_63(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_64(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_65(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_66(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_67(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_68(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_69(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_70(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_71(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_72(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_73(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_74(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_75(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_76(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_77(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_78(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_79(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_80(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_81(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_82(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_83(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_84(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_85(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_86(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_87(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_88(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_89(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_90(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_91(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_92(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_93(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_94(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_95(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_96(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_97(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_98(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_99(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_100(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_101(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_102(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_103(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_104(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_105(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_106(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_107(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_108(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_109(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_110(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_111(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_112(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_113(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_114(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_115(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_116(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_117(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_118(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_119(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_120(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_121(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_122(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_123(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_124(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_125(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_126(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_127(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_128(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_129(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_130(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_131(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_132(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_133(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_134(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_135(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_136(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_137(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_138(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_139(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_140(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_141(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_142(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_143(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_144(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_145(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_146(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_147(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_148(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_149(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_150(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_151(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_152(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_153(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_154(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_155(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_156(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_157(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_158(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_159(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_160(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_161(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_162(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_163(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_164(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_165(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_166(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_167(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_168(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_169(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_170(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_171(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_172(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_173(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_174(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_175(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_176(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_177(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_178(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_179(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_180(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_181(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_182(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_183(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_184(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_185(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_186(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_187(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_188(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_189(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_190(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_191(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_192(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_193(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_194(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_195(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_196(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_197(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_198(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_199(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_200(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_201(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_202(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_203(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_204(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_205(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_206(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_207(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_208(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_209(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_210(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_211(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_212(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_213(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_214(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_215(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_216(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_217(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_218(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_219(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_220(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_221(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_222(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_223(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_224(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_225(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_226(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_227(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_228(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_229(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_230(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_231(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_232(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_233(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_234(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_235(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_236(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_237(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_238(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_239(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_240(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_241(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_242(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_243(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_244(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_245(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_246(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_247(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_248(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_249(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_250(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_251(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_252(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_253(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_254(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_255(s,p,o,m) 0
+#define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_256(s,p,o,m) 0
+# 20 "/usr/include/boost/preprocessor/seq/for_each.hpp" 2 3 4
+# 1 "/usr/include/boost/preprocessor/seq/seq.hpp" 1 3 4
+# 13 "/usr/include/boost/preprocessor/seq/seq.hpp" 3 4
+#define BOOST_PREPROCESSOR_SEQ_SEQ_HPP 
+
+
+# 1 "/usr/include/boost/preprocessor/seq/elem.hpp" 1 3 4
+# 13 "/usr/include/boost/preprocessor/seq/elem.hpp" 3 4
+#define BOOST_PREPROCESSOR_SEQ_ELEM_HPP 
+# 22 "/usr/include/boost/preprocessor/seq/elem.hpp" 3 4
+#define BOOST_PP_SEQ_ELEM(i,seq) BOOST_PP_SEQ_ELEM_I(i, seq)
+# 41 "/usr/include/boost/preprocessor/seq/elem.hpp" 3 4
+#define BOOST_PP_SEQ_ELEM_I(i,seq) BOOST_PP_SEQ_ELEM_II(BOOST_PP_SEQ_ELEM_ ## i seq)
+
+#define BOOST_PP_SEQ_ELEM_II(im) BOOST_PP_SEQ_ELEM_III(im)
+#define BOOST_PP_SEQ_ELEM_III(x,_) x
+
+
+#define BOOST_PP_SEQ_ELEM_0(x) x, BOOST_PP_NIL
+#define BOOST_PP_SEQ_ELEM_1(_) BOOST_PP_SEQ_ELEM_0
+#define BOOST_PP_SEQ_ELEM_2(_) BOOST_PP_SEQ_ELEM_1
+#define BOOST_PP_SEQ_ELEM_3(_) BOOST_PP_SEQ_ELEM_2
+#define BOOST_PP_SEQ_ELEM_4(_) BOOST_PP_SEQ_ELEM_3
+#define BOOST_PP_SEQ_ELEM_5(_) BOOST_PP_SEQ_ELEM_4
+#define BOOST_PP_SEQ_ELEM_6(_) BOOST_PP_SEQ_ELEM_5
+#define BOOST_PP_SEQ_ELEM_7(_) BOOST_PP_SEQ_ELEM_6
+#define BOOST_PP_SEQ_ELEM_8(_) BOOST_PP_SEQ_ELEM_7
+#define BOOST_PP_SEQ_ELEM_9(_) BOOST_PP_SEQ_ELEM_8
+#define BOOST_PP_SEQ_ELEM_10(_) BOOST_PP_SEQ_ELEM_9
+#define BOOST_PP_SEQ_ELEM_11(_) BOOST_PP_SEQ_ELEM_10
+#define BOOST_PP_SEQ_ELEM_12(_) BOOST_PP_SEQ_ELEM_11
+#define BOOST_PP_SEQ_ELEM_13(_) BOOST_PP_SEQ_ELEM_12
+#define BOOST_PP_SEQ_ELEM_14(_) BOOST_PP_SEQ_ELEM_13
+#define BOOST_PP_SEQ_ELEM_15(_) BOOST_PP_SEQ_ELEM_14
+#define BOOST_PP_SEQ_ELEM_16(_) BOOST_PP_SEQ_ELEM_15
+#define BOOST_PP_SEQ_ELEM_17(_) BOOST_PP_SEQ_ELEM_16
+#define BOOST_PP_SEQ_ELEM_18(_) BOOST_PP_SEQ_ELEM_17
+#define BOOST_PP_SEQ_ELEM_19(_) BOOST_PP_SEQ_ELEM_18
+#define BOOST_PP_SEQ_ELEM_20(_) BOOST_PP_SEQ_ELEM_19
+#define BOOST_PP_SEQ_ELEM_21(_) BOOST_PP_SEQ_ELEM_20
+#define BOOST_PP_SEQ_ELEM_22(_) BOOST_PP_SEQ_ELEM_21
+#define BOOST_PP_SEQ_ELEM_23(_) BOOST_PP_SEQ_ELEM_22
+#define BOOST_PP_SEQ_ELEM_24(_) BOOST_PP_SEQ_ELEM_23
+#define BOOST_PP_SEQ_ELEM_25(_) BOOST_PP_SEQ_ELEM_24
+#define BOOST_PP_SEQ_ELEM_26(_) BOOST_PP_SEQ_ELEM_25
+#define BOOST_PP_SEQ_ELEM_27(_) BOOST_PP_SEQ_ELEM_26
+#define BOOST_PP_SEQ_ELEM_28(_) BOOST_PP_SEQ_ELEM_27
+#define BOOST_PP_SEQ_ELEM_29(_) BOOST_PP_SEQ_ELEM_28
+#define BOOST_PP_SEQ_ELEM_30(_) BOOST_PP_SEQ_ELEM_29
+#define BOOST_PP_SEQ_ELEM_31(_) BOOST_PP_SEQ_ELEM_30
+#define BOOST_PP_SEQ_ELEM_32(_) BOOST_PP_SEQ_ELEM_31
+#define BOOST_PP_SEQ_ELEM_33(_) BOOST_PP_SEQ_ELEM_32
+#define BOOST_PP_SEQ_ELEM_34(_) BOOST_PP_SEQ_ELEM_33
+#define BOOST_PP_SEQ_ELEM_35(_) BOOST_PP_SEQ_ELEM_34
+#define BOOST_PP_SEQ_ELEM_36(_) BOOST_PP_SEQ_ELEM_35
+#define BOOST_PP_SEQ_ELEM_37(_) BOOST_PP_SEQ_ELEM_36
+#define BOOST_PP_SEQ_ELEM_38(_) BOOST_PP_SEQ_ELEM_37
+#define BOOST_PP_SEQ_ELEM_39(_) BOOST_PP_SEQ_ELEM_38
+#define BOOST_PP_SEQ_ELEM_40(_) BOOST_PP_SEQ_ELEM_39
+#define BOOST_PP_SEQ_ELEM_41(_) BOOST_PP_SEQ_ELEM_40
+#define BOOST_PP_SEQ_ELEM_42(_) BOOST_PP_SEQ_ELEM_41
+#define BOOST_PP_SEQ_ELEM_43(_) BOOST_PP_SEQ_ELEM_42
+#define BOOST_PP_SEQ_ELEM_44(_) BOOST_PP_SEQ_ELEM_43
+#define BOOST_PP_SEQ_ELEM_45(_) BOOST_PP_SEQ_ELEM_44
+#define BOOST_PP_SEQ_ELEM_46(_) BOOST_PP_SEQ_ELEM_45
+#define BOOST_PP_SEQ_ELEM_47(_) BOOST_PP_SEQ_ELEM_46
+#define BOOST_PP_SEQ_ELEM_48(_) BOOST_PP_SEQ_ELEM_47
+#define BOOST_PP_SEQ_ELEM_49(_) BOOST_PP_SEQ_ELEM_48
+#define BOOST_PP_SEQ_ELEM_50(_) BOOST_PP_SEQ_ELEM_49
+#define BOOST_PP_SEQ_ELEM_51(_) BOOST_PP_SEQ_ELEM_50
+#define BOOST_PP_SEQ_ELEM_52(_) BOOST_PP_SEQ_ELEM_51
+#define BOOST_PP_SEQ_ELEM_53(_) BOOST_PP_SEQ_ELEM_52
+#define BOOST_PP_SEQ_ELEM_54(_) BOOST_PP_SEQ_ELEM_53
+#define BOOST_PP_SEQ_ELEM_55(_) BOOST_PP_SEQ_ELEM_54
+#define BOOST_PP_SEQ_ELEM_56(_) BOOST_PP_SEQ_ELEM_55
+#define BOOST_PP_SEQ_ELEM_57(_) BOOST_PP_SEQ_ELEM_56
+#define BOOST_PP_SEQ_ELEM_58(_) BOOST_PP_SEQ_ELEM_57
+#define BOOST_PP_SEQ_ELEM_59(_) BOOST_PP_SEQ_ELEM_58
+#define BOOST_PP_SEQ_ELEM_60(_) BOOST_PP_SEQ_ELEM_59
+#define BOOST_PP_SEQ_ELEM_61(_) BOOST_PP_SEQ_ELEM_60
+#define BOOST_PP_SEQ_ELEM_62(_) BOOST_PP_SEQ_ELEM_61
+#define BOOST_PP_SEQ_ELEM_63(_) BOOST_PP_SEQ_ELEM_62
+#define BOOST_PP_SEQ_ELEM_64(_) BOOST_PP_SEQ_ELEM_63
+#define BOOST_PP_SEQ_ELEM_65(_) BOOST_PP_SEQ_ELEM_64
+#define BOOST_PP_SEQ_ELEM_66(_) BOOST_PP_SEQ_ELEM_65
+#define BOOST_PP_SEQ_ELEM_67(_) BOOST_PP_SEQ_ELEM_66
+#define BOOST_PP_SEQ_ELEM_68(_) BOOST_PP_SEQ_ELEM_67
+#define BOOST_PP_SEQ_ELEM_69(_) BOOST_PP_SEQ_ELEM_68
+#define BOOST_PP_SEQ_ELEM_70(_) BOOST_PP_SEQ_ELEM_69
+#define BOOST_PP_SEQ_ELEM_71(_) BOOST_PP_SEQ_ELEM_70
+#define BOOST_PP_SEQ_ELEM_72(_) BOOST_PP_SEQ_ELEM_71
+#define BOOST_PP_SEQ_ELEM_73(_) BOOST_PP_SEQ_ELEM_72
+#define BOOST_PP_SEQ_ELEM_74(_) BOOST_PP_SEQ_ELEM_73
+#define BOOST_PP_SEQ_ELEM_75(_) BOOST_PP_SEQ_ELEM_74
+#define BOOST_PP_SEQ_ELEM_76(_) BOOST_PP_SEQ_ELEM_75
+#define BOOST_PP_SEQ_ELEM_77(_) BOOST_PP_SEQ_ELEM_76
+#define BOOST_PP_SEQ_ELEM_78(_) BOOST_PP_SEQ_ELEM_77
+#define BOOST_PP_SEQ_ELEM_79(_) BOOST_PP_SEQ_ELEM_78
+#define BOOST_PP_SEQ_ELEM_80(_) BOOST_PP_SEQ_ELEM_79
+#define BOOST_PP_SEQ_ELEM_81(_) BOOST_PP_SEQ_ELEM_80
+#define BOOST_PP_SEQ_ELEM_82(_) BOOST_PP_SEQ_ELEM_81
+#define BOOST_PP_SEQ_ELEM_83(_) BOOST_PP_SEQ_ELEM_82
+#define BOOST_PP_SEQ_ELEM_84(_) BOOST_PP_SEQ_ELEM_83
+#define BOOST_PP_SEQ_ELEM_85(_) BOOST_PP_SEQ_ELEM_84
+#define BOOST_PP_SEQ_ELEM_86(_) BOOST_PP_SEQ_ELEM_85
+#define BOOST_PP_SEQ_ELEM_87(_) BOOST_PP_SEQ_ELEM_86
+#define BOOST_PP_SEQ_ELEM_88(_) BOOST_PP_SEQ_ELEM_87
+#define BOOST_PP_SEQ_ELEM_89(_) BOOST_PP_SEQ_ELEM_88
+#define BOOST_PP_SEQ_ELEM_90(_) BOOST_PP_SEQ_ELEM_89
+#define BOOST_PP_SEQ_ELEM_91(_) BOOST_PP_SEQ_ELEM_90
+#define BOOST_PP_SEQ_ELEM_92(_) BOOST_PP_SEQ_ELEM_91
+#define BOOST_PP_SEQ_ELEM_93(_) BOOST_PP_SEQ_ELEM_92
+#define BOOST_PP_SEQ_ELEM_94(_) BOOST_PP_SEQ_ELEM_93
+#define BOOST_PP_SEQ_ELEM_95(_) BOOST_PP_SEQ_ELEM_94
+#define BOOST_PP_SEQ_ELEM_96(_) BOOST_PP_SEQ_ELEM_95
+#define BOOST_PP_SEQ_ELEM_97(_) BOOST_PP_SEQ_ELEM_96
+#define BOOST_PP_SEQ_ELEM_98(_) BOOST_PP_SEQ_ELEM_97
+#define BOOST_PP_SEQ_ELEM_99(_) BOOST_PP_SEQ_ELEM_98
+#define BOOST_PP_SEQ_ELEM_100(_) BOOST_PP_SEQ_ELEM_99
+#define BOOST_PP_SEQ_ELEM_101(_) BOOST_PP_SEQ_ELEM_100
+#define BOOST_PP_SEQ_ELEM_102(_) BOOST_PP_SEQ_ELEM_101
+#define BOOST_PP_SEQ_ELEM_103(_) BOOST_PP_SEQ_ELEM_102
+#define BOOST_PP_SEQ_ELEM_104(_) BOOST_PP_SEQ_ELEM_103
+#define BOOST_PP_SEQ_ELEM_105(_) BOOST_PP_SEQ_ELEM_104
+#define BOOST_PP_SEQ_ELEM_106(_) BOOST_PP_SEQ_ELEM_105
+#define BOOST_PP_SEQ_ELEM_107(_) BOOST_PP_SEQ_ELEM_106
+#define BOOST_PP_SEQ_ELEM_108(_) BOOST_PP_SEQ_ELEM_107
+#define BOOST_PP_SEQ_ELEM_109(_) BOOST_PP_SEQ_ELEM_108
+#define BOOST_PP_SEQ_ELEM_110(_) BOOST_PP_SEQ_ELEM_109
+#define BOOST_PP_SEQ_ELEM_111(_) BOOST_PP_SEQ_ELEM_110
+#define BOOST_PP_SEQ_ELEM_112(_) BOOST_PP_SEQ_ELEM_111
+#define BOOST_PP_SEQ_ELEM_113(_) BOOST_PP_SEQ_ELEM_112
+#define BOOST_PP_SEQ_ELEM_114(_) BOOST_PP_SEQ_ELEM_113
+#define BOOST_PP_SEQ_ELEM_115(_) BOOST_PP_SEQ_ELEM_114
+#define BOOST_PP_SEQ_ELEM_116(_) BOOST_PP_SEQ_ELEM_115
+#define BOOST_PP_SEQ_ELEM_117(_) BOOST_PP_SEQ_ELEM_116
+#define BOOST_PP_SEQ_ELEM_118(_) BOOST_PP_SEQ_ELEM_117
+#define BOOST_PP_SEQ_ELEM_119(_) BOOST_PP_SEQ_ELEM_118
+#define BOOST_PP_SEQ_ELEM_120(_) BOOST_PP_SEQ_ELEM_119
+#define BOOST_PP_SEQ_ELEM_121(_) BOOST_PP_SEQ_ELEM_120
+#define BOOST_PP_SEQ_ELEM_122(_) BOOST_PP_SEQ_ELEM_121
+#define BOOST_PP_SEQ_ELEM_123(_) BOOST_PP_SEQ_ELEM_122
+#define BOOST_PP_SEQ_ELEM_124(_) BOOST_PP_SEQ_ELEM_123
+#define BOOST_PP_SEQ_ELEM_125(_) BOOST_PP_SEQ_ELEM_124
+#define BOOST_PP_SEQ_ELEM_126(_) BOOST_PP_SEQ_ELEM_125
+#define BOOST_PP_SEQ_ELEM_127(_) BOOST_PP_SEQ_ELEM_126
+#define BOOST_PP_SEQ_ELEM_128(_) BOOST_PP_SEQ_ELEM_127
+#define BOOST_PP_SEQ_ELEM_129(_) BOOST_PP_SEQ_ELEM_128
+#define BOOST_PP_SEQ_ELEM_130(_) BOOST_PP_SEQ_ELEM_129
+#define BOOST_PP_SEQ_ELEM_131(_) BOOST_PP_SEQ_ELEM_130
+#define BOOST_PP_SEQ_ELEM_132(_) BOOST_PP_SEQ_ELEM_131
+#define BOOST_PP_SEQ_ELEM_133(_) BOOST_PP_SEQ_ELEM_132
+#define BOOST_PP_SEQ_ELEM_134(_) BOOST_PP_SEQ_ELEM_133
+#define BOOST_PP_SEQ_ELEM_135(_) BOOST_PP_SEQ_ELEM_134
+#define BOOST_PP_SEQ_ELEM_136(_) BOOST_PP_SEQ_ELEM_135
+#define BOOST_PP_SEQ_ELEM_137(_) BOOST_PP_SEQ_ELEM_136
+#define BOOST_PP_SEQ_ELEM_138(_) BOOST_PP_SEQ_ELEM_137
+#define BOOST_PP_SEQ_ELEM_139(_) BOOST_PP_SEQ_ELEM_138
+#define BOOST_PP_SEQ_ELEM_140(_) BOOST_PP_SEQ_ELEM_139
+#define BOOST_PP_SEQ_ELEM_141(_) BOOST_PP_SEQ_ELEM_140
+#define BOOST_PP_SEQ_ELEM_142(_) BOOST_PP_SEQ_ELEM_141
+#define BOOST_PP_SEQ_ELEM_143(_) BOOST_PP_SEQ_ELEM_142
+#define BOOST_PP_SEQ_ELEM_144(_) BOOST_PP_SEQ_ELEM_143
+#define BOOST_PP_SEQ_ELEM_145(_) BOOST_PP_SEQ_ELEM_144
+#define BOOST_PP_SEQ_ELEM_146(_) BOOST_PP_SEQ_ELEM_145
+#define BOOST_PP_SEQ_ELEM_147(_) BOOST_PP_SEQ_ELEM_146
+#define BOOST_PP_SEQ_ELEM_148(_) BOOST_PP_SEQ_ELEM_147
+#define BOOST_PP_SEQ_ELEM_149(_) BOOST_PP_SEQ_ELEM_148
+#define BOOST_PP_SEQ_ELEM_150(_) BOOST_PP_SEQ_ELEM_149
+#define BOOST_PP_SEQ_ELEM_151(_) BOOST_PP_SEQ_ELEM_150
+#define BOOST_PP_SEQ_ELEM_152(_) BOOST_PP_SEQ_ELEM_151
+#define BOOST_PP_SEQ_ELEM_153(_) BOOST_PP_SEQ_ELEM_152
+#define BOOST_PP_SEQ_ELEM_154(_) BOOST_PP_SEQ_ELEM_153
+#define BOOST_PP_SEQ_ELEM_155(_) BOOST_PP_SEQ_ELEM_154
+#define BOOST_PP_SEQ_ELEM_156(_) BOOST_PP_SEQ_ELEM_155
+#define BOOST_PP_SEQ_ELEM_157(_) BOOST_PP_SEQ_ELEM_156
+#define BOOST_PP_SEQ_ELEM_158(_) BOOST_PP_SEQ_ELEM_157
+#define BOOST_PP_SEQ_ELEM_159(_) BOOST_PP_SEQ_ELEM_158
+#define BOOST_PP_SEQ_ELEM_160(_) BOOST_PP_SEQ_ELEM_159
+#define BOOST_PP_SEQ_ELEM_161(_) BOOST_PP_SEQ_ELEM_160
+#define BOOST_PP_SEQ_ELEM_162(_) BOOST_PP_SEQ_ELEM_161
+#define BOOST_PP_SEQ_ELEM_163(_) BOOST_PP_SEQ_ELEM_162
+#define BOOST_PP_SEQ_ELEM_164(_) BOOST_PP_SEQ_ELEM_163
+#define BOOST_PP_SEQ_ELEM_165(_) BOOST_PP_SEQ_ELEM_164
+#define BOOST_PP_SEQ_ELEM_166(_) BOOST_PP_SEQ_ELEM_165
+#define BOOST_PP_SEQ_ELEM_167(_) BOOST_PP_SEQ_ELEM_166
+#define BOOST_PP_SEQ_ELEM_168(_) BOOST_PP_SEQ_ELEM_167
+#define BOOST_PP_SEQ_ELEM_169(_) BOOST_PP_SEQ_ELEM_168
+#define BOOST_PP_SEQ_ELEM_170(_) BOOST_PP_SEQ_ELEM_169
+#define BOOST_PP_SEQ_ELEM_171(_) BOOST_PP_SEQ_ELEM_170
+#define BOOST_PP_SEQ_ELEM_172(_) BOOST_PP_SEQ_ELEM_171
+#define BOOST_PP_SEQ_ELEM_173(_) BOOST_PP_SEQ_ELEM_172
+#define BOOST_PP_SEQ_ELEM_174(_) BOOST_PP_SEQ_ELEM_173
+#define BOOST_PP_SEQ_ELEM_175(_) BOOST_PP_SEQ_ELEM_174
+#define BOOST_PP_SEQ_ELEM_176(_) BOOST_PP_SEQ_ELEM_175
+#define BOOST_PP_SEQ_ELEM_177(_) BOOST_PP_SEQ_ELEM_176
+#define BOOST_PP_SEQ_ELEM_178(_) BOOST_PP_SEQ_ELEM_177
+#define BOOST_PP_SEQ_ELEM_179(_) BOOST_PP_SEQ_ELEM_178
+#define BOOST_PP_SEQ_ELEM_180(_) BOOST_PP_SEQ_ELEM_179
+#define BOOST_PP_SEQ_ELEM_181(_) BOOST_PP_SEQ_ELEM_180
+#define BOOST_PP_SEQ_ELEM_182(_) BOOST_PP_SEQ_ELEM_181
+#define BOOST_PP_SEQ_ELEM_183(_) BOOST_PP_SEQ_ELEM_182
+#define BOOST_PP_SEQ_ELEM_184(_) BOOST_PP_SEQ_ELEM_183
+#define BOOST_PP_SEQ_ELEM_185(_) BOOST_PP_SEQ_ELEM_184
+#define BOOST_PP_SEQ_ELEM_186(_) BOOST_PP_SEQ_ELEM_185
+#define BOOST_PP_SEQ_ELEM_187(_) BOOST_PP_SEQ_ELEM_186
+#define BOOST_PP_SEQ_ELEM_188(_) BOOST_PP_SEQ_ELEM_187
+#define BOOST_PP_SEQ_ELEM_189(_) BOOST_PP_SEQ_ELEM_188
+#define BOOST_PP_SEQ_ELEM_190(_) BOOST_PP_SEQ_ELEM_189
+#define BOOST_PP_SEQ_ELEM_191(_) BOOST_PP_SEQ_ELEM_190
+#define BOOST_PP_SEQ_ELEM_192(_) BOOST_PP_SEQ_ELEM_191
+#define BOOST_PP_SEQ_ELEM_193(_) BOOST_PP_SEQ_ELEM_192
+#define BOOST_PP_SEQ_ELEM_194(_) BOOST_PP_SEQ_ELEM_193
+#define BOOST_PP_SEQ_ELEM_195(_) BOOST_PP_SEQ_ELEM_194
+#define BOOST_PP_SEQ_ELEM_196(_) BOOST_PP_SEQ_ELEM_195
+#define BOOST_PP_SEQ_ELEM_197(_) BOOST_PP_SEQ_ELEM_196
+#define BOOST_PP_SEQ_ELEM_198(_) BOOST_PP_SEQ_ELEM_197
+#define BOOST_PP_SEQ_ELEM_199(_) BOOST_PP_SEQ_ELEM_198
+#define BOOST_PP_SEQ_ELEM_200(_) BOOST_PP_SEQ_ELEM_199
+#define BOOST_PP_SEQ_ELEM_201(_) BOOST_PP_SEQ_ELEM_200
+#define BOOST_PP_SEQ_ELEM_202(_) BOOST_PP_SEQ_ELEM_201
+#define BOOST_PP_SEQ_ELEM_203(_) BOOST_PP_SEQ_ELEM_202
+#define BOOST_PP_SEQ_ELEM_204(_) BOOST_PP_SEQ_ELEM_203
+#define BOOST_PP_SEQ_ELEM_205(_) BOOST_PP_SEQ_ELEM_204
+#define BOOST_PP_SEQ_ELEM_206(_) BOOST_PP_SEQ_ELEM_205
+#define BOOST_PP_SEQ_ELEM_207(_) BOOST_PP_SEQ_ELEM_206
+#define BOOST_PP_SEQ_ELEM_208(_) BOOST_PP_SEQ_ELEM_207
+#define BOOST_PP_SEQ_ELEM_209(_) BOOST_PP_SEQ_ELEM_208
+#define BOOST_PP_SEQ_ELEM_210(_) BOOST_PP_SEQ_ELEM_209
+#define BOOST_PP_SEQ_ELEM_211(_) BOOST_PP_SEQ_ELEM_210
+#define BOOST_PP_SEQ_ELEM_212(_) BOOST_PP_SEQ_ELEM_211
+#define BOOST_PP_SEQ_ELEM_213(_) BOOST_PP_SEQ_ELEM_212
+#define BOOST_PP_SEQ_ELEM_214(_) BOOST_PP_SEQ_ELEM_213
+#define BOOST_PP_SEQ_ELEM_215(_) BOOST_PP_SEQ_ELEM_214
+#define BOOST_PP_SEQ_ELEM_216(_) BOOST_PP_SEQ_ELEM_215
+#define BOOST_PP_SEQ_ELEM_217(_) BOOST_PP_SEQ_ELEM_216
+#define BOOST_PP_SEQ_ELEM_218(_) BOOST_PP_SEQ_ELEM_217
+#define BOOST_PP_SEQ_ELEM_219(_) BOOST_PP_SEQ_ELEM_218
+#define BOOST_PP_SEQ_ELEM_220(_) BOOST_PP_SEQ_ELEM_219
+#define BOOST_PP_SEQ_ELEM_221(_) BOOST_PP_SEQ_ELEM_220
+#define BOOST_PP_SEQ_ELEM_222(_) BOOST_PP_SEQ_ELEM_221
+#define BOOST_PP_SEQ_ELEM_223(_) BOOST_PP_SEQ_ELEM_222
+#define BOOST_PP_SEQ_ELEM_224(_) BOOST_PP_SEQ_ELEM_223
+#define BOOST_PP_SEQ_ELEM_225(_) BOOST_PP_SEQ_ELEM_224
+#define BOOST_PP_SEQ_ELEM_226(_) BOOST_PP_SEQ_ELEM_225
+#define BOOST_PP_SEQ_ELEM_227(_) BOOST_PP_SEQ_ELEM_226
+#define BOOST_PP_SEQ_ELEM_228(_) BOOST_PP_SEQ_ELEM_227
+#define BOOST_PP_SEQ_ELEM_229(_) BOOST_PP_SEQ_ELEM_228
+#define BOOST_PP_SEQ_ELEM_230(_) BOOST_PP_SEQ_ELEM_229
+#define BOOST_PP_SEQ_ELEM_231(_) BOOST_PP_SEQ_ELEM_230
+#define BOOST_PP_SEQ_ELEM_232(_) BOOST_PP_SEQ_ELEM_231
+#define BOOST_PP_SEQ_ELEM_233(_) BOOST_PP_SEQ_ELEM_232
+#define BOOST_PP_SEQ_ELEM_234(_) BOOST_PP_SEQ_ELEM_233
+#define BOOST_PP_SEQ_ELEM_235(_) BOOST_PP_SEQ_ELEM_234
+#define BOOST_PP_SEQ_ELEM_236(_) BOOST_PP_SEQ_ELEM_235
+#define BOOST_PP_SEQ_ELEM_237(_) BOOST_PP_SEQ_ELEM_236
+#define BOOST_PP_SEQ_ELEM_238(_) BOOST_PP_SEQ_ELEM_237
+#define BOOST_PP_SEQ_ELEM_239(_) BOOST_PP_SEQ_ELEM_238
+#define BOOST_PP_SEQ_ELEM_240(_) BOOST_PP_SEQ_ELEM_239
+#define BOOST_PP_SEQ_ELEM_241(_) BOOST_PP_SEQ_ELEM_240
+#define BOOST_PP_SEQ_ELEM_242(_) BOOST_PP_SEQ_ELEM_241
+#define BOOST_PP_SEQ_ELEM_243(_) BOOST_PP_SEQ_ELEM_242
+#define BOOST_PP_SEQ_ELEM_244(_) BOOST_PP_SEQ_ELEM_243
+#define BOOST_PP_SEQ_ELEM_245(_) BOOST_PP_SEQ_ELEM_244
+#define BOOST_PP_SEQ_ELEM_246(_) BOOST_PP_SEQ_ELEM_245
+#define BOOST_PP_SEQ_ELEM_247(_) BOOST_PP_SEQ_ELEM_246
+#define BOOST_PP_SEQ_ELEM_248(_) BOOST_PP_SEQ_ELEM_247
+#define BOOST_PP_SEQ_ELEM_249(_) BOOST_PP_SEQ_ELEM_248
+#define BOOST_PP_SEQ_ELEM_250(_) BOOST_PP_SEQ_ELEM_249
+#define BOOST_PP_SEQ_ELEM_251(_) BOOST_PP_SEQ_ELEM_250
+#define BOOST_PP_SEQ_ELEM_252(_) BOOST_PP_SEQ_ELEM_251
+#define BOOST_PP_SEQ_ELEM_253(_) BOOST_PP_SEQ_ELEM_252
+#define BOOST_PP_SEQ_ELEM_254(_) BOOST_PP_SEQ_ELEM_253
+#define BOOST_PP_SEQ_ELEM_255(_) BOOST_PP_SEQ_ELEM_254
+# 17 "/usr/include/boost/preprocessor/seq/seq.hpp" 2 3 4
+
+
+
+#define BOOST_PP_SEQ_HEAD(seq) BOOST_PP_SEQ_ELEM(0, seq)
+# 35 "/usr/include/boost/preprocessor/seq/seq.hpp" 3 4
+#define BOOST_PP_SEQ_TAIL(seq) BOOST_PP_SEQ_TAIL_I seq
+
+
+#define BOOST_PP_SEQ_TAIL_I(x) 
+
+
+
+#define BOOST_PP_SEQ_NIL(x) (x)
+# 21 "/usr/include/boost/preprocessor/seq/for_each.hpp" 2 3 4
+# 1 "/usr/include/boost/preprocessor/seq/size.hpp" 1 3 4
+# 13 "/usr/include/boost/preprocessor/seq/size.hpp" 3 4
+#define BOOST_PREPROCESSOR_SEQ_SIZE_HPP 
+# 28 "/usr/include/boost/preprocessor/seq/size.hpp" 3 4
+#define BOOST_PP_SEQ_SIZE(seq) BOOST_PP_CAT(BOOST_PP_SEQ_SIZE_, BOOST_PP_SEQ_SIZE_0 seq)
+
+
+#define BOOST_PP_SEQ_SIZE_0(_) BOOST_PP_SEQ_SIZE_1
+#define BOOST_PP_SEQ_SIZE_1(_) BOOST_PP_SEQ_SIZE_2
+#define BOOST_PP_SEQ_SIZE_2(_) BOOST_PP_SEQ_SIZE_3
+#define BOOST_PP_SEQ_SIZE_3(_) BOOST_PP_SEQ_SIZE_4
+#define BOOST_PP_SEQ_SIZE_4(_) BOOST_PP_SEQ_SIZE_5
+#define BOOST_PP_SEQ_SIZE_5(_) BOOST_PP_SEQ_SIZE_6
+#define BOOST_PP_SEQ_SIZE_6(_) BOOST_PP_SEQ_SIZE_7
+#define BOOST_PP_SEQ_SIZE_7(_) BOOST_PP_SEQ_SIZE_8
+#define BOOST_PP_SEQ_SIZE_8(_) BOOST_PP_SEQ_SIZE_9
+#define BOOST_PP_SEQ_SIZE_9(_) BOOST_PP_SEQ_SIZE_10
+#define BOOST_PP_SEQ_SIZE_10(_) BOOST_PP_SEQ_SIZE_11
+#define BOOST_PP_SEQ_SIZE_11(_) BOOST_PP_SEQ_SIZE_12
+#define BOOST_PP_SEQ_SIZE_12(_) BOOST_PP_SEQ_SIZE_13
+#define BOOST_PP_SEQ_SIZE_13(_) BOOST_PP_SEQ_SIZE_14
+#define BOOST_PP_SEQ_SIZE_14(_) BOOST_PP_SEQ_SIZE_15
+#define BOOST_PP_SEQ_SIZE_15(_) BOOST_PP_SEQ_SIZE_16
+#define BOOST_PP_SEQ_SIZE_16(_) BOOST_PP_SEQ_SIZE_17
+#define BOOST_PP_SEQ_SIZE_17(_) BOOST_PP_SEQ_SIZE_18
+#define BOOST_PP_SEQ_SIZE_18(_) BOOST_PP_SEQ_SIZE_19
+#define BOOST_PP_SEQ_SIZE_19(_) BOOST_PP_SEQ_SIZE_20
+#define BOOST_PP_SEQ_SIZE_20(_) BOOST_PP_SEQ_SIZE_21
+#define BOOST_PP_SEQ_SIZE_21(_) BOOST_PP_SEQ_SIZE_22
+#define BOOST_PP_SEQ_SIZE_22(_) BOOST_PP_SEQ_SIZE_23
+#define BOOST_PP_SEQ_SIZE_23(_) BOOST_PP_SEQ_SIZE_24
+#define BOOST_PP_SEQ_SIZE_24(_) BOOST_PP_SEQ_SIZE_25
+#define BOOST_PP_SEQ_SIZE_25(_) BOOST_PP_SEQ_SIZE_26
+#define BOOST_PP_SEQ_SIZE_26(_) BOOST_PP_SEQ_SIZE_27
+#define BOOST_PP_SEQ_SIZE_27(_) BOOST_PP_SEQ_SIZE_28
+#define BOOST_PP_SEQ_SIZE_28(_) BOOST_PP_SEQ_SIZE_29
+#define BOOST_PP_SEQ_SIZE_29(_) BOOST_PP_SEQ_SIZE_30
+#define BOOST_PP_SEQ_SIZE_30(_) BOOST_PP_SEQ_SIZE_31
+#define BOOST_PP_SEQ_SIZE_31(_) BOOST_PP_SEQ_SIZE_32
+#define BOOST_PP_SEQ_SIZE_32(_) BOOST_PP_SEQ_SIZE_33
+#define BOOST_PP_SEQ_SIZE_33(_) BOOST_PP_SEQ_SIZE_34
+#define BOOST_PP_SEQ_SIZE_34(_) BOOST_PP_SEQ_SIZE_35
+#define BOOST_PP_SEQ_SIZE_35(_) BOOST_PP_SEQ_SIZE_36
+#define BOOST_PP_SEQ_SIZE_36(_) BOOST_PP_SEQ_SIZE_37
+#define BOOST_PP_SEQ_SIZE_37(_) BOOST_PP_SEQ_SIZE_38
+#define BOOST_PP_SEQ_SIZE_38(_) BOOST_PP_SEQ_SIZE_39
+#define BOOST_PP_SEQ_SIZE_39(_) BOOST_PP_SEQ_SIZE_40
+#define BOOST_PP_SEQ_SIZE_40(_) BOOST_PP_SEQ_SIZE_41
+#define BOOST_PP_SEQ_SIZE_41(_) BOOST_PP_SEQ_SIZE_42
+#define BOOST_PP_SEQ_SIZE_42(_) BOOST_PP_SEQ_SIZE_43
+#define BOOST_PP_SEQ_SIZE_43(_) BOOST_PP_SEQ_SIZE_44
+#define BOOST_PP_SEQ_SIZE_44(_) BOOST_PP_SEQ_SIZE_45
+#define BOOST_PP_SEQ_SIZE_45(_) BOOST_PP_SEQ_SIZE_46
+#define BOOST_PP_SEQ_SIZE_46(_) BOOST_PP_SEQ_SIZE_47
+#define BOOST_PP_SEQ_SIZE_47(_) BOOST_PP_SEQ_SIZE_48
+#define BOOST_PP_SEQ_SIZE_48(_) BOOST_PP_SEQ_SIZE_49
+#define BOOST_PP_SEQ_SIZE_49(_) BOOST_PP_SEQ_SIZE_50
+#define BOOST_PP_SEQ_SIZE_50(_) BOOST_PP_SEQ_SIZE_51
+#define BOOST_PP_SEQ_SIZE_51(_) BOOST_PP_SEQ_SIZE_52
+#define BOOST_PP_SEQ_SIZE_52(_) BOOST_PP_SEQ_SIZE_53
+#define BOOST_PP_SEQ_SIZE_53(_) BOOST_PP_SEQ_SIZE_54
+#define BOOST_PP_SEQ_SIZE_54(_) BOOST_PP_SEQ_SIZE_55
+#define BOOST_PP_SEQ_SIZE_55(_) BOOST_PP_SEQ_SIZE_56
+#define BOOST_PP_SEQ_SIZE_56(_) BOOST_PP_SEQ_SIZE_57
+#define BOOST_PP_SEQ_SIZE_57(_) BOOST_PP_SEQ_SIZE_58
+#define BOOST_PP_SEQ_SIZE_58(_) BOOST_PP_SEQ_SIZE_59
+#define BOOST_PP_SEQ_SIZE_59(_) BOOST_PP_SEQ_SIZE_60
+#define BOOST_PP_SEQ_SIZE_60(_) BOOST_PP_SEQ_SIZE_61
+#define BOOST_PP_SEQ_SIZE_61(_) BOOST_PP_SEQ_SIZE_62
+#define BOOST_PP_SEQ_SIZE_62(_) BOOST_PP_SEQ_SIZE_63
+#define BOOST_PP_SEQ_SIZE_63(_) BOOST_PP_SEQ_SIZE_64
+#define BOOST_PP_SEQ_SIZE_64(_) BOOST_PP_SEQ_SIZE_65
+#define BOOST_PP_SEQ_SIZE_65(_) BOOST_PP_SEQ_SIZE_66
+#define BOOST_PP_SEQ_SIZE_66(_) BOOST_PP_SEQ_SIZE_67
+#define BOOST_PP_SEQ_SIZE_67(_) BOOST_PP_SEQ_SIZE_68
+#define BOOST_PP_SEQ_SIZE_68(_) BOOST_PP_SEQ_SIZE_69
+#define BOOST_PP_SEQ_SIZE_69(_) BOOST_PP_SEQ_SIZE_70
+#define BOOST_PP_SEQ_SIZE_70(_) BOOST_PP_SEQ_SIZE_71
+#define BOOST_PP_SEQ_SIZE_71(_) BOOST_PP_SEQ_SIZE_72
+#define BOOST_PP_SEQ_SIZE_72(_) BOOST_PP_SEQ_SIZE_73
+#define BOOST_PP_SEQ_SIZE_73(_) BOOST_PP_SEQ_SIZE_74
+#define BOOST_PP_SEQ_SIZE_74(_) BOOST_PP_SEQ_SIZE_75
+#define BOOST_PP_SEQ_SIZE_75(_) BOOST_PP_SEQ_SIZE_76
+#define BOOST_PP_SEQ_SIZE_76(_) BOOST_PP_SEQ_SIZE_77
+#define BOOST_PP_SEQ_SIZE_77(_) BOOST_PP_SEQ_SIZE_78
+#define BOOST_PP_SEQ_SIZE_78(_) BOOST_PP_SEQ_SIZE_79
+#define BOOST_PP_SEQ_SIZE_79(_) BOOST_PP_SEQ_SIZE_80
+#define BOOST_PP_SEQ_SIZE_80(_) BOOST_PP_SEQ_SIZE_81
+#define BOOST_PP_SEQ_SIZE_81(_) BOOST_PP_SEQ_SIZE_82
+#define BOOST_PP_SEQ_SIZE_82(_) BOOST_PP_SEQ_SIZE_83
+#define BOOST_PP_SEQ_SIZE_83(_) BOOST_PP_SEQ_SIZE_84
+#define BOOST_PP_SEQ_SIZE_84(_) BOOST_PP_SEQ_SIZE_85
+#define BOOST_PP_SEQ_SIZE_85(_) BOOST_PP_SEQ_SIZE_86
+#define BOOST_PP_SEQ_SIZE_86(_) BOOST_PP_SEQ_SIZE_87
+#define BOOST_PP_SEQ_SIZE_87(_) BOOST_PP_SEQ_SIZE_88
+#define BOOST_PP_SEQ_SIZE_88(_) BOOST_PP_SEQ_SIZE_89
+#define BOOST_PP_SEQ_SIZE_89(_) BOOST_PP_SEQ_SIZE_90
+#define BOOST_PP_SEQ_SIZE_90(_) BOOST_PP_SEQ_SIZE_91
+#define BOOST_PP_SEQ_SIZE_91(_) BOOST_PP_SEQ_SIZE_92
+#define BOOST_PP_SEQ_SIZE_92(_) BOOST_PP_SEQ_SIZE_93
+#define BOOST_PP_SEQ_SIZE_93(_) BOOST_PP_SEQ_SIZE_94
+#define BOOST_PP_SEQ_SIZE_94(_) BOOST_PP_SEQ_SIZE_95
+#define BOOST_PP_SEQ_SIZE_95(_) BOOST_PP_SEQ_SIZE_96
+#define BOOST_PP_SEQ_SIZE_96(_) BOOST_PP_SEQ_SIZE_97
+#define BOOST_PP_SEQ_SIZE_97(_) BOOST_PP_SEQ_SIZE_98
+#define BOOST_PP_SEQ_SIZE_98(_) BOOST_PP_SEQ_SIZE_99
+#define BOOST_PP_SEQ_SIZE_99(_) BOOST_PP_SEQ_SIZE_100
+#define BOOST_PP_SEQ_SIZE_100(_) BOOST_PP_SEQ_SIZE_101
+#define BOOST_PP_SEQ_SIZE_101(_) BOOST_PP_SEQ_SIZE_102
+#define BOOST_PP_SEQ_SIZE_102(_) BOOST_PP_SEQ_SIZE_103
+#define BOOST_PP_SEQ_SIZE_103(_) BOOST_PP_SEQ_SIZE_104
+#define BOOST_PP_SEQ_SIZE_104(_) BOOST_PP_SEQ_SIZE_105
+#define BOOST_PP_SEQ_SIZE_105(_) BOOST_PP_SEQ_SIZE_106
+#define BOOST_PP_SEQ_SIZE_106(_) BOOST_PP_SEQ_SIZE_107
+#define BOOST_PP_SEQ_SIZE_107(_) BOOST_PP_SEQ_SIZE_108
+#define BOOST_PP_SEQ_SIZE_108(_) BOOST_PP_SEQ_SIZE_109
+#define BOOST_PP_SEQ_SIZE_109(_) BOOST_PP_SEQ_SIZE_110
+#define BOOST_PP_SEQ_SIZE_110(_) BOOST_PP_SEQ_SIZE_111
+#define BOOST_PP_SEQ_SIZE_111(_) BOOST_PP_SEQ_SIZE_112
+#define BOOST_PP_SEQ_SIZE_112(_) BOOST_PP_SEQ_SIZE_113
+#define BOOST_PP_SEQ_SIZE_113(_) BOOST_PP_SEQ_SIZE_114
+#define BOOST_PP_SEQ_SIZE_114(_) BOOST_PP_SEQ_SIZE_115
+#define BOOST_PP_SEQ_SIZE_115(_) BOOST_PP_SEQ_SIZE_116
+#define BOOST_PP_SEQ_SIZE_116(_) BOOST_PP_SEQ_SIZE_117
+#define BOOST_PP_SEQ_SIZE_117(_) BOOST_PP_SEQ_SIZE_118
+#define BOOST_PP_SEQ_SIZE_118(_) BOOST_PP_SEQ_SIZE_119
+#define BOOST_PP_SEQ_SIZE_119(_) BOOST_PP_SEQ_SIZE_120
+#define BOOST_PP_SEQ_SIZE_120(_) BOOST_PP_SEQ_SIZE_121
+#define BOOST_PP_SEQ_SIZE_121(_) BOOST_PP_SEQ_SIZE_122
+#define BOOST_PP_SEQ_SIZE_122(_) BOOST_PP_SEQ_SIZE_123
+#define BOOST_PP_SEQ_SIZE_123(_) BOOST_PP_SEQ_SIZE_124
+#define BOOST_PP_SEQ_SIZE_124(_) BOOST_PP_SEQ_SIZE_125
+#define BOOST_PP_SEQ_SIZE_125(_) BOOST_PP_SEQ_SIZE_126
+#define BOOST_PP_SEQ_SIZE_126(_) BOOST_PP_SEQ_SIZE_127
+#define BOOST_PP_SEQ_SIZE_127(_) BOOST_PP_SEQ_SIZE_128
+#define BOOST_PP_SEQ_SIZE_128(_) BOOST_PP_SEQ_SIZE_129
+#define BOOST_PP_SEQ_SIZE_129(_) BOOST_PP_SEQ_SIZE_130
+#define BOOST_PP_SEQ_SIZE_130(_) BOOST_PP_SEQ_SIZE_131
+#define BOOST_PP_SEQ_SIZE_131(_) BOOST_PP_SEQ_SIZE_132
+#define BOOST_PP_SEQ_SIZE_132(_) BOOST_PP_SEQ_SIZE_133
+#define BOOST_PP_SEQ_SIZE_133(_) BOOST_PP_SEQ_SIZE_134
+#define BOOST_PP_SEQ_SIZE_134(_) BOOST_PP_SEQ_SIZE_135
+#define BOOST_PP_SEQ_SIZE_135(_) BOOST_PP_SEQ_SIZE_136
+#define BOOST_PP_SEQ_SIZE_136(_) BOOST_PP_SEQ_SIZE_137
+#define BOOST_PP_SEQ_SIZE_137(_) BOOST_PP_SEQ_SIZE_138
+#define BOOST_PP_SEQ_SIZE_138(_) BOOST_PP_SEQ_SIZE_139
+#define BOOST_PP_SEQ_SIZE_139(_) BOOST_PP_SEQ_SIZE_140
+#define BOOST_PP_SEQ_SIZE_140(_) BOOST_PP_SEQ_SIZE_141
+#define BOOST_PP_SEQ_SIZE_141(_) BOOST_PP_SEQ_SIZE_142
+#define BOOST_PP_SEQ_SIZE_142(_) BOOST_PP_SEQ_SIZE_143
+#define BOOST_PP_SEQ_SIZE_143(_) BOOST_PP_SEQ_SIZE_144
+#define BOOST_PP_SEQ_SIZE_144(_) BOOST_PP_SEQ_SIZE_145
+#define BOOST_PP_SEQ_SIZE_145(_) BOOST_PP_SEQ_SIZE_146
+#define BOOST_PP_SEQ_SIZE_146(_) BOOST_PP_SEQ_SIZE_147
+#define BOOST_PP_SEQ_SIZE_147(_) BOOST_PP_SEQ_SIZE_148
+#define BOOST_PP_SEQ_SIZE_148(_) BOOST_PP_SEQ_SIZE_149
+#define BOOST_PP_SEQ_SIZE_149(_) BOOST_PP_SEQ_SIZE_150
+#define BOOST_PP_SEQ_SIZE_150(_) BOOST_PP_SEQ_SIZE_151
+#define BOOST_PP_SEQ_SIZE_151(_) BOOST_PP_SEQ_SIZE_152
+#define BOOST_PP_SEQ_SIZE_152(_) BOOST_PP_SEQ_SIZE_153
+#define BOOST_PP_SEQ_SIZE_153(_) BOOST_PP_SEQ_SIZE_154
+#define BOOST_PP_SEQ_SIZE_154(_) BOOST_PP_SEQ_SIZE_155
+#define BOOST_PP_SEQ_SIZE_155(_) BOOST_PP_SEQ_SIZE_156
+#define BOOST_PP_SEQ_SIZE_156(_) BOOST_PP_SEQ_SIZE_157
+#define BOOST_PP_SEQ_SIZE_157(_) BOOST_PP_SEQ_SIZE_158
+#define BOOST_PP_SEQ_SIZE_158(_) BOOST_PP_SEQ_SIZE_159
+#define BOOST_PP_SEQ_SIZE_159(_) BOOST_PP_SEQ_SIZE_160
+#define BOOST_PP_SEQ_SIZE_160(_) BOOST_PP_SEQ_SIZE_161
+#define BOOST_PP_SEQ_SIZE_161(_) BOOST_PP_SEQ_SIZE_162
+#define BOOST_PP_SEQ_SIZE_162(_) BOOST_PP_SEQ_SIZE_163
+#define BOOST_PP_SEQ_SIZE_163(_) BOOST_PP_SEQ_SIZE_164
+#define BOOST_PP_SEQ_SIZE_164(_) BOOST_PP_SEQ_SIZE_165
+#define BOOST_PP_SEQ_SIZE_165(_) BOOST_PP_SEQ_SIZE_166
+#define BOOST_PP_SEQ_SIZE_166(_) BOOST_PP_SEQ_SIZE_167
+#define BOOST_PP_SEQ_SIZE_167(_) BOOST_PP_SEQ_SIZE_168
+#define BOOST_PP_SEQ_SIZE_168(_) BOOST_PP_SEQ_SIZE_169
+#define BOOST_PP_SEQ_SIZE_169(_) BOOST_PP_SEQ_SIZE_170
+#define BOOST_PP_SEQ_SIZE_170(_) BOOST_PP_SEQ_SIZE_171
+#define BOOST_PP_SEQ_SIZE_171(_) BOOST_PP_SEQ_SIZE_172
+#define BOOST_PP_SEQ_SIZE_172(_) BOOST_PP_SEQ_SIZE_173
+#define BOOST_PP_SEQ_SIZE_173(_) BOOST_PP_SEQ_SIZE_174
+#define BOOST_PP_SEQ_SIZE_174(_) BOOST_PP_SEQ_SIZE_175
+#define BOOST_PP_SEQ_SIZE_175(_) BOOST_PP_SEQ_SIZE_176
+#define BOOST_PP_SEQ_SIZE_176(_) BOOST_PP_SEQ_SIZE_177
+#define BOOST_PP_SEQ_SIZE_177(_) BOOST_PP_SEQ_SIZE_178
+#define BOOST_PP_SEQ_SIZE_178(_) BOOST_PP_SEQ_SIZE_179
+#define BOOST_PP_SEQ_SIZE_179(_) BOOST_PP_SEQ_SIZE_180
+#define BOOST_PP_SEQ_SIZE_180(_) BOOST_PP_SEQ_SIZE_181
+#define BOOST_PP_SEQ_SIZE_181(_) BOOST_PP_SEQ_SIZE_182
+#define BOOST_PP_SEQ_SIZE_182(_) BOOST_PP_SEQ_SIZE_183
+#define BOOST_PP_SEQ_SIZE_183(_) BOOST_PP_SEQ_SIZE_184
+#define BOOST_PP_SEQ_SIZE_184(_) BOOST_PP_SEQ_SIZE_185
+#define BOOST_PP_SEQ_SIZE_185(_) BOOST_PP_SEQ_SIZE_186
+#define BOOST_PP_SEQ_SIZE_186(_) BOOST_PP_SEQ_SIZE_187
+#define BOOST_PP_SEQ_SIZE_187(_) BOOST_PP_SEQ_SIZE_188
+#define BOOST_PP_SEQ_SIZE_188(_) BOOST_PP_SEQ_SIZE_189
+#define BOOST_PP_SEQ_SIZE_189(_) BOOST_PP_SEQ_SIZE_190
+#define BOOST_PP_SEQ_SIZE_190(_) BOOST_PP_SEQ_SIZE_191
+#define BOOST_PP_SEQ_SIZE_191(_) BOOST_PP_SEQ_SIZE_192
+#define BOOST_PP_SEQ_SIZE_192(_) BOOST_PP_SEQ_SIZE_193
+#define BOOST_PP_SEQ_SIZE_193(_) BOOST_PP_SEQ_SIZE_194
+#define BOOST_PP_SEQ_SIZE_194(_) BOOST_PP_SEQ_SIZE_195
+#define BOOST_PP_SEQ_SIZE_195(_) BOOST_PP_SEQ_SIZE_196
+#define BOOST_PP_SEQ_SIZE_196(_) BOOST_PP_SEQ_SIZE_197
+#define BOOST_PP_SEQ_SIZE_197(_) BOOST_PP_SEQ_SIZE_198
+#define BOOST_PP_SEQ_SIZE_198(_) BOOST_PP_SEQ_SIZE_199
+#define BOOST_PP_SEQ_SIZE_199(_) BOOST_PP_SEQ_SIZE_200
+#define BOOST_PP_SEQ_SIZE_200(_) BOOST_PP_SEQ_SIZE_201
+#define BOOST_PP_SEQ_SIZE_201(_) BOOST_PP_SEQ_SIZE_202
+#define BOOST_PP_SEQ_SIZE_202(_) BOOST_PP_SEQ_SIZE_203
+#define BOOST_PP_SEQ_SIZE_203(_) BOOST_PP_SEQ_SIZE_204
+#define BOOST_PP_SEQ_SIZE_204(_) BOOST_PP_SEQ_SIZE_205
+#define BOOST_PP_SEQ_SIZE_205(_) BOOST_PP_SEQ_SIZE_206
+#define BOOST_PP_SEQ_SIZE_206(_) BOOST_PP_SEQ_SIZE_207
+#define BOOST_PP_SEQ_SIZE_207(_) BOOST_PP_SEQ_SIZE_208
+#define BOOST_PP_SEQ_SIZE_208(_) BOOST_PP_SEQ_SIZE_209
+#define BOOST_PP_SEQ_SIZE_209(_) BOOST_PP_SEQ_SIZE_210
+#define BOOST_PP_SEQ_SIZE_210(_) BOOST_PP_SEQ_SIZE_211
+#define BOOST_PP_SEQ_SIZE_211(_) BOOST_PP_SEQ_SIZE_212
+#define BOOST_PP_SEQ_SIZE_212(_) BOOST_PP_SEQ_SIZE_213
+#define BOOST_PP_SEQ_SIZE_213(_) BOOST_PP_SEQ_SIZE_214
+#define BOOST_PP_SEQ_SIZE_214(_) BOOST_PP_SEQ_SIZE_215
+#define BOOST_PP_SEQ_SIZE_215(_) BOOST_PP_SEQ_SIZE_216
+#define BOOST_PP_SEQ_SIZE_216(_) BOOST_PP_SEQ_SIZE_217
+#define BOOST_PP_SEQ_SIZE_217(_) BOOST_PP_SEQ_SIZE_218
+#define BOOST_PP_SEQ_SIZE_218(_) BOOST_PP_SEQ_SIZE_219
+#define BOOST_PP_SEQ_SIZE_219(_) BOOST_PP_SEQ_SIZE_220
+#define BOOST_PP_SEQ_SIZE_220(_) BOOST_PP_SEQ_SIZE_221
+#define BOOST_PP_SEQ_SIZE_221(_) BOOST_PP_SEQ_SIZE_222
+#define BOOST_PP_SEQ_SIZE_222(_) BOOST_PP_SEQ_SIZE_223
+#define BOOST_PP_SEQ_SIZE_223(_) BOOST_PP_SEQ_SIZE_224
+#define BOOST_PP_SEQ_SIZE_224(_) BOOST_PP_SEQ_SIZE_225
+#define BOOST_PP_SEQ_SIZE_225(_) BOOST_PP_SEQ_SIZE_226
+#define BOOST_PP_SEQ_SIZE_226(_) BOOST_PP_SEQ_SIZE_227
+#define BOOST_PP_SEQ_SIZE_227(_) BOOST_PP_SEQ_SIZE_228
+#define BOOST_PP_SEQ_SIZE_228(_) BOOST_PP_SEQ_SIZE_229
+#define BOOST_PP_SEQ_SIZE_229(_) BOOST_PP_SEQ_SIZE_230
+#define BOOST_PP_SEQ_SIZE_230(_) BOOST_PP_SEQ_SIZE_231
+#define BOOST_PP_SEQ_SIZE_231(_) BOOST_PP_SEQ_SIZE_232
+#define BOOST_PP_SEQ_SIZE_232(_) BOOST_PP_SEQ_SIZE_233
+#define BOOST_PP_SEQ_SIZE_233(_) BOOST_PP_SEQ_SIZE_234
+#define BOOST_PP_SEQ_SIZE_234(_) BOOST_PP_SEQ_SIZE_235
+#define BOOST_PP_SEQ_SIZE_235(_) BOOST_PP_SEQ_SIZE_236
+#define BOOST_PP_SEQ_SIZE_236(_) BOOST_PP_SEQ_SIZE_237
+#define BOOST_PP_SEQ_SIZE_237(_) BOOST_PP_SEQ_SIZE_238
+#define BOOST_PP_SEQ_SIZE_238(_) BOOST_PP_SEQ_SIZE_239
+#define BOOST_PP_SEQ_SIZE_239(_) BOOST_PP_SEQ_SIZE_240
+#define BOOST_PP_SEQ_SIZE_240(_) BOOST_PP_SEQ_SIZE_241
+#define BOOST_PP_SEQ_SIZE_241(_) BOOST_PP_SEQ_SIZE_242
+#define BOOST_PP_SEQ_SIZE_242(_) BOOST_PP_SEQ_SIZE_243
+#define BOOST_PP_SEQ_SIZE_243(_) BOOST_PP_SEQ_SIZE_244
+#define BOOST_PP_SEQ_SIZE_244(_) BOOST_PP_SEQ_SIZE_245
+#define BOOST_PP_SEQ_SIZE_245(_) BOOST_PP_SEQ_SIZE_246
+#define BOOST_PP_SEQ_SIZE_246(_) BOOST_PP_SEQ_SIZE_247
+#define BOOST_PP_SEQ_SIZE_247(_) BOOST_PP_SEQ_SIZE_248
+#define BOOST_PP_SEQ_SIZE_248(_) BOOST_PP_SEQ_SIZE_249
+#define BOOST_PP_SEQ_SIZE_249(_) BOOST_PP_SEQ_SIZE_250
+#define BOOST_PP_SEQ_SIZE_250(_) BOOST_PP_SEQ_SIZE_251
+#define BOOST_PP_SEQ_SIZE_251(_) BOOST_PP_SEQ_SIZE_252
+#define BOOST_PP_SEQ_SIZE_252(_) BOOST_PP_SEQ_SIZE_253
+#define BOOST_PP_SEQ_SIZE_253(_) BOOST_PP_SEQ_SIZE_254
+#define BOOST_PP_SEQ_SIZE_254(_) BOOST_PP_SEQ_SIZE_255
+#define BOOST_PP_SEQ_SIZE_255(_) BOOST_PP_SEQ_SIZE_256
+#define BOOST_PP_SEQ_SIZE_256(_) BOOST_PP_SEQ_SIZE_257
+
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_0 0
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_1 1
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_2 2
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_3 3
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_4 4
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_5 5
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_6 6
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_7 7
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_8 8
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_9 9
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_10 10
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_11 11
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_12 12
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_13 13
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_14 14
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_15 15
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_16 16
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_17 17
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_18 18
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_19 19
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_20 20
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_21 21
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_22 22
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_23 23
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_24 24
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_25 25
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_26 26
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_27 27
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_28 28
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_29 29
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_30 30
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_31 31
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_32 32
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_33 33
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_34 34
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_35 35
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_36 36
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_37 37
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_38 38
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_39 39
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_40 40
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_41 41
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_42 42
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_43 43
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_44 44
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_45 45
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_46 46
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_47 47
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_48 48
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_49 49
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_50 50
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_51 51
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_52 52
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_53 53
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_54 54
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_55 55
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_56 56
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_57 57
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_58 58
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_59 59
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_60 60
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_61 61
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_62 62
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_63 63
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_64 64
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_65 65
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_66 66
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_67 67
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_68 68
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_69 69
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_70 70
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_71 71
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_72 72
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_73 73
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_74 74
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_75 75
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_76 76
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_77 77
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_78 78
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_79 79
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_80 80
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_81 81
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_82 82
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_83 83
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_84 84
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_85 85
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_86 86
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_87 87
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_88 88
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_89 89
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_90 90
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_91 91
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_92 92
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_93 93
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_94 94
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_95 95
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_96 96
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_97 97
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_98 98
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_99 99
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_100 100
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_101 101
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_102 102
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_103 103
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_104 104
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_105 105
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_106 106
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_107 107
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_108 108
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_109 109
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_110 110
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_111 111
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_112 112
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_113 113
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_114 114
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_115 115
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_116 116
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_117 117
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_118 118
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_119 119
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_120 120
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_121 121
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_122 122
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_123 123
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_124 124
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_125 125
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_126 126
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_127 127
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_128 128
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_129 129
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_130 130
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_131 131
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_132 132
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_133 133
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_134 134
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_135 135
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_136 136
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_137 137
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_138 138
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_139 139
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_140 140
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_141 141
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_142 142
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_143 143
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_144 144
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_145 145
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_146 146
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_147 147
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_148 148
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_149 149
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_150 150
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_151 151
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_152 152
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_153 153
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_154 154
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_155 155
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_156 156
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_157 157
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_158 158
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_159 159
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_160 160
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_161 161
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_162 162
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_163 163
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_164 164
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_165 165
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_166 166
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_167 167
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_168 168
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_169 169
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_170 170
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_171 171
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_172 172
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_173 173
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_174 174
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_175 175
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_176 176
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_177 177
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_178 178
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_179 179
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_180 180
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_181 181
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_182 182
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_183 183
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_184 184
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_185 185
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_186 186
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_187 187
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_188 188
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_189 189
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_190 190
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_191 191
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_192 192
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_193 193
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_194 194
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_195 195
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_196 196
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_197 197
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_198 198
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_199 199
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_200 200
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_201 201
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_202 202
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_203 203
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_204 204
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_205 205
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_206 206
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_207 207
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_208 208
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_209 209
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_210 210
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_211 211
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_212 212
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_213 213
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_214 214
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_215 215
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_216 216
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_217 217
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_218 218
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_219 219
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_220 220
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_221 221
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_222 222
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_223 223
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_224 224
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_225 225
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_226 226
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_227 227
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_228 228
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_229 229
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_230 230
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_231 231
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_232 232
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_233 233
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_234 234
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_235 235
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_236 236
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_237 237
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_238 238
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_239 239
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_240 240
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_241 241
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_242 242
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_243 243
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_244 244
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_245 245
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_246 246
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_247 247
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_248 248
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_249 249
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_250 250
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_251 251
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_252 252
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_253 253
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_254 254
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_255 255
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_256 256
+#define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_257 257
+# 22 "/usr/include/boost/preprocessor/seq/for_each.hpp" 2 3 4
+# 1 "/usr/include/boost/preprocessor/seq/detail/is_empty.hpp" 1 3 4
+# 13 "/usr/include/boost/preprocessor/seq/detail/is_empty.hpp" 3 4
+#define BOOST_PREPROCESSOR_SEQ_DETAIL_IS_EMPTY_HPP 
+
+
+
+
+# 1 "/usr/include/boost/preprocessor/logical/compl.hpp" 1 3 4
+# 13 "/usr/include/boost/preprocessor/logical/compl.hpp" 3 4
+#define BOOST_PREPROCESSOR_LOGICAL_COMPL_HPP 
+
+
+
+
+
+
+#define BOOST_PP_COMPL(x) BOOST_PP_COMPL_I(x)
+
+
+
+
+
+
+#define BOOST_PP_COMPL_I(x) BOOST_PP_COMPL_ ## x
+
+
+
+
+
+#define BOOST_PP_COMPL_0 1
+#define BOOST_PP_COMPL_1 0
+# 19 "/usr/include/boost/preprocessor/seq/detail/is_empty.hpp" 2 3 4
+
+
+
+
+#define BOOST_PP_SEQ_DETAIL_IS_EMPTY(seq) BOOST_PP_COMPL ( BOOST_PP_SEQ_DETAIL_IS_NOT_EMPTY(seq) )
+
+
+
+
+
+
+#define BOOST_PP_SEQ_DETAIL_IS_EMPTY_SIZE(size) BOOST_PP_COMPL ( BOOST_PP_SEQ_DETAIL_IS_NOT_EMPTY_SIZE(size) )
+
+
+
+
+
+
+#define BOOST_PP_SEQ_DETAIL_IS_NOT_EMPTY(seq) BOOST_PP_SEQ_DETAIL_IS_NOT_EMPTY_SIZE(BOOST_PP_SEQ_DETAIL_EMPTY_SIZE(seq))
+
+
+
+#define BOOST_PP_SEQ_DETAIL_IS_NOT_EMPTY_SIZE(size) BOOST_PP_BOOL(size)
+
+
+
+#define BOOST_PP_SEQ_DETAIL_EMPTY_SIZE(seq) BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(seq (nil)))
+# 23 "/usr/include/boost/preprocessor/seq/for_each.hpp" 2 3 4
+# 1 "/usr/include/boost/preprocessor/tuple/elem.hpp" 1 3 4
+# 16 "/usr/include/boost/preprocessor/tuple/elem.hpp" 3 4
+#define BOOST_PREPROCESSOR_TUPLE_ELEM_HPP 
+
+
+
+# 1 "/usr/include/boost/preprocessor/facilities/expand.hpp" 1 3 4
+# 15 "/usr/include/boost/preprocessor/facilities/expand.hpp" 3 4
+#define BOOST_PREPROCESSOR_FACILITIES_EXPAND_HPP 
+
+
+
+
+#define BOOST_PP_EXPAND(x) BOOST_PP_EXPAND_I(x)
+
+
+
+
+
+#define BOOST_PP_EXPAND_I(x) x
+# 21 "/usr/include/boost/preprocessor/tuple/elem.hpp" 2 3 4
+# 1 "/usr/include/boost/preprocessor/facilities/overload.hpp" 1 3 4
+# 14 "/usr/include/boost/preprocessor/facilities/overload.hpp" 3 4
+#define BOOST_PREPROCESSOR_FACILITIES_OVERLOAD_HPP 
+
+
+# 1 "/usr/include/boost/preprocessor/variadic/size.hpp" 1 3 4
+# 14 "/usr/include/boost/preprocessor/variadic/size.hpp" 3 4
+#define BOOST_PREPROCESSOR_VARIADIC_SIZE_HPP 
+# 25 "/usr/include/boost/preprocessor/variadic/size.hpp" 3 4
+#define BOOST_PP_VARIADIC_SIZE(...) BOOST_PP_VARIADIC_SIZE_I(__VA_ARGS__, 64, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1,)
+
+#define BOOST_PP_VARIADIC_SIZE_I(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59,e60,e61,e62,e63,size,...) size
+# 18 "/usr/include/boost/preprocessor/facilities/overload.hpp" 2 3 4
+
+
+
+
+#define BOOST_PP_OVERLOAD(prefix,...) BOOST_PP_CAT(prefix, BOOST_PP_VARIADIC_SIZE(__VA_ARGS__))
+# 22 "/usr/include/boost/preprocessor/tuple/elem.hpp" 2 3 4
+# 1 "/usr/include/boost/preprocessor/tuple/rem.hpp" 1 3 4
+# 14 "/usr/include/boost/preprocessor/tuple/rem.hpp" 3 4
+#define BOOST_PREPROCESSOR_TUPLE_REM_HPP 
+
+
+
+
+
+# 1 "/usr/include/boost/preprocessor/tuple/detail/is_single_return.hpp" 1 3 4
+# 13 "/usr/include/boost/preprocessor/tuple/detail/is_single_return.hpp" 3 4
+#define BOOST_PREPROCESSOR_TUPLE_DETAIL_IS_SINGLE_RETURN_HPP 
+# 21 "/usr/include/boost/preprocessor/tuple/rem.hpp" 2 3 4
+# 29 "/usr/include/boost/preprocessor/tuple/rem.hpp" 3 4
+#define BOOST_PP_REM(...) __VA_ARGS__
+# 44 "/usr/include/boost/preprocessor/tuple/rem.hpp" 3 4
+#define BOOST_PP_TUPLE_REM(size) BOOST_PP_REM
+# 54 "/usr/include/boost/preprocessor/tuple/rem.hpp" 3 4
+#define BOOST_PP_TUPLE_REM_0() 
+#define BOOST_PP_TUPLE_REM_1(e0) e0
+#define BOOST_PP_TUPLE_REM_2(e0,e1) e0, e1
+#define BOOST_PP_TUPLE_REM_3(e0,e1,e2) e0, e1, e2
+#define BOOST_PP_TUPLE_REM_4(e0,e1,e2,e3) e0, e1, e2, e3
+#define BOOST_PP_TUPLE_REM_5(e0,e1,e2,e3,e4) e0, e1, e2, e3, e4
+#define BOOST_PP_TUPLE_REM_6(e0,e1,e2,e3,e4,e5) e0, e1, e2, e3, e4, e5
+#define BOOST_PP_TUPLE_REM_7(e0,e1,e2,e3,e4,e5,e6) e0, e1, e2, e3, e4, e5, e6
+#define BOOST_PP_TUPLE_REM_8(e0,e1,e2,e3,e4,e5,e6,e7) e0, e1, e2, e3, e4, e5, e6, e7
+#define BOOST_PP_TUPLE_REM_9(e0,e1,e2,e3,e4,e5,e6,e7,e8) e0, e1, e2, e3, e4, e5, e6, e7, e8
+#define BOOST_PP_TUPLE_REM_10(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9
+#define BOOST_PP_TUPLE_REM_11(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10
+#define BOOST_PP_TUPLE_REM_12(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11
+#define BOOST_PP_TUPLE_REM_13(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12
+#define BOOST_PP_TUPLE_REM_14(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13
+#define BOOST_PP_TUPLE_REM_15(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14
+#define BOOST_PP_TUPLE_REM_16(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15
+#define BOOST_PP_TUPLE_REM_17(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16
+#define BOOST_PP_TUPLE_REM_18(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17
+#define BOOST_PP_TUPLE_REM_19(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18
+#define BOOST_PP_TUPLE_REM_20(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19
+#define BOOST_PP_TUPLE_REM_21(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20
+#define BOOST_PP_TUPLE_REM_22(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21
+#define BOOST_PP_TUPLE_REM_23(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22
+#define BOOST_PP_TUPLE_REM_24(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23
+#define BOOST_PP_TUPLE_REM_25(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24
+#define BOOST_PP_TUPLE_REM_26(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25
+#define BOOST_PP_TUPLE_REM_27(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26
+#define BOOST_PP_TUPLE_REM_28(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27
+#define BOOST_PP_TUPLE_REM_29(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28
+#define BOOST_PP_TUPLE_REM_30(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29
+#define BOOST_PP_TUPLE_REM_31(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30
+#define BOOST_PP_TUPLE_REM_32(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31
+#define BOOST_PP_TUPLE_REM_33(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32
+#define BOOST_PP_TUPLE_REM_34(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33
+#define BOOST_PP_TUPLE_REM_35(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34
+#define BOOST_PP_TUPLE_REM_36(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35
+#define BOOST_PP_TUPLE_REM_37(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36
+#define BOOST_PP_TUPLE_REM_38(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37
+#define BOOST_PP_TUPLE_REM_39(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38
+#define BOOST_PP_TUPLE_REM_40(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39
+#define BOOST_PP_TUPLE_REM_41(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40
+#define BOOST_PP_TUPLE_REM_42(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41
+#define BOOST_PP_TUPLE_REM_43(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42
+#define BOOST_PP_TUPLE_REM_44(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43
+#define BOOST_PP_TUPLE_REM_45(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44
+#define BOOST_PP_TUPLE_REM_46(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45
+#define BOOST_PP_TUPLE_REM_47(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46
+#define BOOST_PP_TUPLE_REM_48(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47
+#define BOOST_PP_TUPLE_REM_49(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48
+#define BOOST_PP_TUPLE_REM_50(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49
+#define BOOST_PP_TUPLE_REM_51(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50
+#define BOOST_PP_TUPLE_REM_52(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51
+#define BOOST_PP_TUPLE_REM_53(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52
+#define BOOST_PP_TUPLE_REM_54(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53
+#define BOOST_PP_TUPLE_REM_55(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54
+#define BOOST_PP_TUPLE_REM_56(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55
+#define BOOST_PP_TUPLE_REM_57(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56
+#define BOOST_PP_TUPLE_REM_58(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57
+#define BOOST_PP_TUPLE_REM_59(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58
+#define BOOST_PP_TUPLE_REM_60(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59
+#define BOOST_PP_TUPLE_REM_61(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59,e60) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60
+#define BOOST_PP_TUPLE_REM_62(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59,e60,e61) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61
+#define BOOST_PP_TUPLE_REM_63(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59,e60,e61,e62) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62
+#define BOOST_PP_TUPLE_REM_64(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59,e60,e61,e62,e63) e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63
+# 129 "/usr/include/boost/preprocessor/tuple/rem.hpp" 3 4
+#define BOOST_PP_TUPLE_REM_CTOR(...) BOOST_PP_OVERLOAD(BOOST_PP_TUPLE_REM_CTOR_O_, __VA_ARGS__)(__VA_ARGS__)
+#define BOOST_PP_TUPLE_REM_CTOR_O_1(tuple) BOOST_PP_REM tuple
+
+#define BOOST_PP_TUPLE_REM_CTOR_O_2(size,tuple) BOOST_PP_TUPLE_REM_CTOR_O_1(tuple)
+# 23 "/usr/include/boost/preprocessor/tuple/elem.hpp" 2 3 4
+# 1 "/usr/include/boost/preprocessor/variadic/elem.hpp" 1 3 4
+# 14 "/usr/include/boost/preprocessor/variadic/elem.hpp" 3 4
+#define BOOST_PREPROCESSOR_VARIADIC_ELEM_HPP 
+# 26 "/usr/include/boost/preprocessor/variadic/elem.hpp" 3 4
+#define BOOST_PP_VARIADIC_ELEM(n,...) BOOST_PP_CAT(BOOST_PP_VARIADIC_ELEM_, n)(__VA_ARGS__,)
+
+#define BOOST_PP_VARIADIC_ELEM_0(e0,...) e0
+#define BOOST_PP_VARIADIC_ELEM_1(e0,e1,...) e1
+#define BOOST_PP_VARIADIC_ELEM_2(e0,e1,e2,...) e2
+#define BOOST_PP_VARIADIC_ELEM_3(e0,e1,e2,e3,...) e3
+#define BOOST_PP_VARIADIC_ELEM_4(e0,e1,e2,e3,e4,...) e4
+#define BOOST_PP_VARIADIC_ELEM_5(e0,e1,e2,e3,e4,e5,...) e5
+#define BOOST_PP_VARIADIC_ELEM_6(e0,e1,e2,e3,e4,e5,e6,...) e6
+#define BOOST_PP_VARIADIC_ELEM_7(e0,e1,e2,e3,e4,e5,e6,e7,...) e7
+#define BOOST_PP_VARIADIC_ELEM_8(e0,e1,e2,e3,e4,e5,e6,e7,e8,...) e8
+#define BOOST_PP_VARIADIC_ELEM_9(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,...) e9
+#define BOOST_PP_VARIADIC_ELEM_10(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,...) e10
+#define BOOST_PP_VARIADIC_ELEM_11(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,...) e11
+#define BOOST_PP_VARIADIC_ELEM_12(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,...) e12
+#define BOOST_PP_VARIADIC_ELEM_13(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,...) e13
+#define BOOST_PP_VARIADIC_ELEM_14(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,...) e14
+#define BOOST_PP_VARIADIC_ELEM_15(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,...) e15
+#define BOOST_PP_VARIADIC_ELEM_16(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,...) e16
+#define BOOST_PP_VARIADIC_ELEM_17(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,...) e17
+#define BOOST_PP_VARIADIC_ELEM_18(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,...) e18
+#define BOOST_PP_VARIADIC_ELEM_19(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,...) e19
+#define BOOST_PP_VARIADIC_ELEM_20(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,...) e20
+#define BOOST_PP_VARIADIC_ELEM_21(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,...) e21
+#define BOOST_PP_VARIADIC_ELEM_22(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,...) e22
+#define BOOST_PP_VARIADIC_ELEM_23(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,...) e23
+#define BOOST_PP_VARIADIC_ELEM_24(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,...) e24
+#define BOOST_PP_VARIADIC_ELEM_25(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,...) e25
+#define BOOST_PP_VARIADIC_ELEM_26(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,...) e26
+#define BOOST_PP_VARIADIC_ELEM_27(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,...) e27
+#define BOOST_PP_VARIADIC_ELEM_28(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,...) e28
+#define BOOST_PP_VARIADIC_ELEM_29(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,...) e29
+#define BOOST_PP_VARIADIC_ELEM_30(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,...) e30
+#define BOOST_PP_VARIADIC_ELEM_31(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,...) e31
+#define BOOST_PP_VARIADIC_ELEM_32(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,...) e32
+#define BOOST_PP_VARIADIC_ELEM_33(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,...) e33
+#define BOOST_PP_VARIADIC_ELEM_34(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,...) e34
+#define BOOST_PP_VARIADIC_ELEM_35(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,...) e35
+#define BOOST_PP_VARIADIC_ELEM_36(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,...) e36
+#define BOOST_PP_VARIADIC_ELEM_37(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,...) e37
+#define BOOST_PP_VARIADIC_ELEM_38(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,...) e38
+#define BOOST_PP_VARIADIC_ELEM_39(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,...) e39
+#define BOOST_PP_VARIADIC_ELEM_40(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,...) e40
+#define BOOST_PP_VARIADIC_ELEM_41(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,...) e41
+#define BOOST_PP_VARIADIC_ELEM_42(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,...) e42
+#define BOOST_PP_VARIADIC_ELEM_43(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,...) e43
+#define BOOST_PP_VARIADIC_ELEM_44(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,...) e44
+#define BOOST_PP_VARIADIC_ELEM_45(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,...) e45
+#define BOOST_PP_VARIADIC_ELEM_46(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,...) e46
+#define BOOST_PP_VARIADIC_ELEM_47(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,...) e47
+#define BOOST_PP_VARIADIC_ELEM_48(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,...) e48
+#define BOOST_PP_VARIADIC_ELEM_49(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,...) e49
+#define BOOST_PP_VARIADIC_ELEM_50(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,...) e50
+#define BOOST_PP_VARIADIC_ELEM_51(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,...) e51
+#define BOOST_PP_VARIADIC_ELEM_52(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,...) e52
+#define BOOST_PP_VARIADIC_ELEM_53(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,...) e53
+#define BOOST_PP_VARIADIC_ELEM_54(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,...) e54
+#define BOOST_PP_VARIADIC_ELEM_55(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,...) e55
+#define BOOST_PP_VARIADIC_ELEM_56(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,...) e56
+#define BOOST_PP_VARIADIC_ELEM_57(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,...) e57
+#define BOOST_PP_VARIADIC_ELEM_58(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,...) e58
+#define BOOST_PP_VARIADIC_ELEM_59(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59,...) e59
+#define BOOST_PP_VARIADIC_ELEM_60(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59,e60,...) e60
+#define BOOST_PP_VARIADIC_ELEM_61(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59,e60,e61,...) e61
+#define BOOST_PP_VARIADIC_ELEM_62(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59,e60,e61,e62,...) e62
+#define BOOST_PP_VARIADIC_ELEM_63(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59,e60,e61,e62,e63,...) e63
+# 24 "/usr/include/boost/preprocessor/tuple/elem.hpp" 2 3 4
+# 40 "/usr/include/boost/preprocessor/tuple/elem.hpp" 3 4
+#define BOOST_PP_TUPLE_ELEM(...) BOOST_PP_OVERLOAD(BOOST_PP_TUPLE_ELEM_O_, __VA_ARGS__)(__VA_ARGS__)
+#define BOOST_PP_TUPLE_ELEM_O_2(n,tuple) BOOST_PP_VARIADIC_ELEM(n, BOOST_PP_REM tuple)
+
+#define BOOST_PP_TUPLE_ELEM_O_3(size,n,tuple) BOOST_PP_TUPLE_ELEM_O_2(n, tuple)
+# 192 "/usr/include/boost/preprocessor/tuple/elem.hpp" 3 4
+#define BOOST_PP_TUPLE_ELEM_1_0(a) a
+
+#define BOOST_PP_TUPLE_ELEM_2_0(a,b) a
+#define BOOST_PP_TUPLE_ELEM_2_1(a,b) b
+
+#define BOOST_PP_TUPLE_ELEM_3_0(a,b,c) a
+#define BOOST_PP_TUPLE_ELEM_3_1(a,b,c) b
+#define BOOST_PP_TUPLE_ELEM_3_2(a,b,c) c
+# 24 "/usr/include/boost/preprocessor/seq/for_each.hpp" 2 3 4
+
+
+
+
+
+#define BOOST_PP_SEQ_FOR_EACH(macro,data,seq) BOOST_PP_SEQ_FOR_EACH_DETAIL_CHECK(macro, data, seq)
+
+
+
+
+
+#define BOOST_PP_SEQ_FOR_EACH_DETAIL_CHECK_EXEC(macro,data,seq) BOOST_PP_FOR((macro, data, seq, BOOST_PP_SEQ_SIZE(seq)), BOOST_PP_SEQ_FOR_EACH_P, BOOST_PP_SEQ_FOR_EACH_O, BOOST_PP_SEQ_FOR_EACH_M)
+#define BOOST_PP_SEQ_FOR_EACH_DETAIL_CHECK_EMPTY(macro,data,seq) 
+
+#define BOOST_PP_SEQ_FOR_EACH_DETAIL_CHECK(macro,data,seq) BOOST_PP_IIF ( BOOST_PP_SEQ_DETAIL_IS_NOT_EMPTY(seq), BOOST_PP_SEQ_FOR_EACH_DETAIL_CHECK_EXEC, BOOST_PP_SEQ_FOR_EACH_DETAIL_CHECK_EMPTY ) (macro, data, seq)
+# 48 "/usr/include/boost/preprocessor/seq/for_each.hpp" 3 4
+#define BOOST_PP_SEQ_FOR_EACH_P(r,x) BOOST_PP_TUPLE_ELEM(4, 3, x)
+
+
+#define BOOST_PP_SEQ_FOR_EACH_O(r,x) BOOST_PP_SEQ_FOR_EACH_O_I x
+
+
+
+
+#define BOOST_PP_SEQ_FOR_EACH_O_I(macro,data,seq,sz) BOOST_PP_SEQ_FOR_EACH_O_I_DEC(macro, data, seq, BOOST_PP_DEC(sz))
+
+
+#define BOOST_PP_SEQ_FOR_EACH_O_I_DEC(macro,data,seq,sz) ( macro, data, BOOST_PP_IF ( sz, BOOST_PP_SEQ_FOR_EACH_O_I_TAIL, BOOST_PP_SEQ_FOR_EACH_O_I_NIL ) (seq), sz )
+# 73 "/usr/include/boost/preprocessor/seq/for_each.hpp" 3 4
+#define BOOST_PP_SEQ_FOR_EACH_O_I_TAIL(seq) BOOST_PP_SEQ_TAIL(seq)
+#define BOOST_PP_SEQ_FOR_EACH_O_I_NIL(seq) BOOST_PP_NIL
+
+
+#define BOOST_PP_SEQ_FOR_EACH_M(r,x) BOOST_PP_SEQ_FOR_EACH_M_IM(r, BOOST_PP_TUPLE_REM_4 x)
+#define BOOST_PP_SEQ_FOR_EACH_M_IM(r,im) BOOST_PP_SEQ_FOR_EACH_M_I(r, im)
+
+
+
+
+#define BOOST_PP_SEQ_FOR_EACH_M_I(r,macro,data,seq,sz) macro(r, data, BOOST_PP_SEQ_HEAD(seq))
+
+
+
+
+#define BOOST_PP_SEQ_FOR_EACH_R(r,macro,data,seq) BOOST_PP_SEQ_FOR_EACH_DETAIL_CHECK_R(r, macro, data, seq)
+
+
+
+
+
+#define BOOST_PP_SEQ_FOR_EACH_DETAIL_CHECK_EXEC_R(r,macro,data,seq) BOOST_PP_FOR_ ## r((macro, data, seq, BOOST_PP_SEQ_SIZE(seq)), BOOST_PP_SEQ_FOR_EACH_P, BOOST_PP_SEQ_FOR_EACH_O, BOOST_PP_SEQ_FOR_EACH_M)
+#define BOOST_PP_SEQ_FOR_EACH_DETAIL_CHECK_EMPTY_R(r,macro,data,seq) 
+
+#define BOOST_PP_SEQ_FOR_EACH_DETAIL_CHECK_R(r,macro,data,seq) BOOST_PP_IIF ( BOOST_PP_SEQ_DETAIL_IS_NOT_EMPTY(seq), BOOST_PP_SEQ_FOR_EACH_DETAIL_CHECK_EXEC_R, BOOST_PP_SEQ_FOR_EACH_DETAIL_CHECK_EMPTY_R ) (r, macro, data, seq)
+# 25 "/usr/include/boost/test/utils/class_properties.hpp" 2 3 4
+
+# 1 "/usr/include/boost/call_traits.hpp" 1 3 4
+# 12 "/usr/include/boost/call_traits.hpp" 3 4
+#define BOOST_CALL_TRAITS_HPP 
+
+
+
+
+
+# 1 "/usr/include/boost/detail/call_traits.hpp" 1 3 4
+# 19 "/usr/include/boost/detail/call_traits.hpp" 3 4
+#define BOOST_DETAIL_CALL_TRAITS_HPP 
+
+
+
+
+
+
+# 1 "/usr/include/boost/type_traits/is_arithmetic.hpp" 1 3 4
+# 10 "/usr/include/boost/type_traits/is_arithmetic.hpp" 3 4
+#define BOOST_TT_IS_ARITHMETIC_HPP_INCLUDED 
+
+# 1 "/usr/include/boost/type_traits/is_integral.hpp" 1 3 4
+# 10 "/usr/include/boost/type_traits/is_integral.hpp" 3 4
+#define BOOST_TT_IS_INTEGRAL_HPP_INCLUDED 
+
+
+# 1 "/usr/include/boost/type_traits/integral_constant.hpp" 1 3 4
+
+
+
+
+
+
+#define BOOST_TYPE_TRAITS_INTEGRAL_CONSTANT_HPP 
+# 31 "/usr/include/boost/type_traits/integral_constant.hpp" 3 4
+namespace mpl_{
+
+   template <bool B> struct bool_;
+   template <class I, I val> struct integral_c;
+   struct integral_c_tag;
+}
+
+namespace boost
+{
+   namespace mpl
+   {
+      using ::mpl_::bool_;
+      using ::mpl_::integral_c;
+      using ::mpl_::integral_c_tag;
+   }
+}
+
+
+
+namespace boost{
+
+   template <class T, T val>
+   struct integral_constant
+   {
+      typedef mpl::integral_c_tag tag;
+      typedef T value_type;
+      typedef integral_constant<T, val> type;
+      static const T value = val;
+
+      operator const mpl::integral_c<T, val>& ()const
+      {
+         static const char data[sizeof(long)] = { 0 };
+         static const void* pdata = data;
+         return *(reinterpret_cast<const mpl::integral_c<T, val>*>(pdata));
+      }
+      constexpr operator T()const { return val; }
+   };
+
+   template <class T, T val>
+   T const integral_constant<T, val>::value;
+
+   template <bool val>
+   struct integral_constant<bool, val>
+   {
+      typedef mpl::integral_c_tag tag;
+      typedef bool value_type;
+      typedef integral_constant<bool, val> type;
+      static const bool value = val;
+
+      operator const mpl::bool_<val>& ()const
+      {
+         static const char data[sizeof(long)] = { 0 };
+         static const void* pdata = data;
+         return *(reinterpret_cast<const mpl::bool_<val>*>(pdata));
+      }
+      constexpr operator bool()const { return val; }
+   };
+
+   template <bool val>
+   bool const integral_constant<bool, val>::value;
+
+   typedef integral_constant<bool, true> true_type;
+   typedef integral_constant<bool, false> false_type;
+
+}
+# 14 "/usr/include/boost/type_traits/is_integral.hpp" 2 3 4
+
+namespace boost {
+
+
+
+
+
+
+template <class T> struct is_integral : public false_type {};
+template <class T> struct is_integral<const T> : public is_integral<T> {};
+template <class T> struct is_integral<volatile const T> : public is_integral<T>{};
+template <class T> struct is_integral<volatile T> : public is_integral<T>{};
+
+
+
+
+template<> struct is_integral<unsigned char> : public true_type {};
+template<> struct is_integral<unsigned short> : public true_type{};
+template<> struct is_integral<unsigned int> : public true_type{};
+template<> struct is_integral<unsigned long> : public true_type{};
+
+template<> struct is_integral<signed char> : public true_type{};
+template<> struct is_integral<short> : public true_type{};
+template<> struct is_integral<int> : public true_type{};
+template<> struct is_integral<long> : public true_type{};
+
+template<> struct is_integral<char> : public true_type{};
+template<> struct is_integral<bool> : public true_type{};
+
+
+
+
+
+template<> struct is_integral<wchar_t> : public true_type{};
+# 67 "/usr/include/boost/type_traits/is_integral.hpp" 3 4
+template<> struct is_integral< ::boost::ulong_long_type> : public true_type{};
+template<> struct is_integral< ::boost::long_long_type> : public true_type{};
+
+
+
+
+
+
+template<> struct is_integral<boost::int128_type> : public true_type{};
+template<> struct is_integral<boost::uint128_type> : public true_type{};
+
+
+template<> struct is_integral<char16_t> : public true_type{};
+
+
+template<> struct is_integral<char32_t> : public true_type{};
+
+
+
+
+}
+# 13 "/usr/include/boost/type_traits/is_arithmetic.hpp" 2 3 4
+# 1 "/usr/include/boost/type_traits/is_floating_point.hpp" 1 3 4
+# 9 "/usr/include/boost/type_traits/is_floating_point.hpp" 3 4
+#define BOOST_TYPE_TRAITS_IS_FLOATING_HPP_INCLUDED 
+
+
+
+namespace boost {
+
+
+   template <class T> struct is_floating_point : public false_type{};
+   template <class T> struct is_floating_point<const T> : public is_floating_point<T>{};
+   template <class T> struct is_floating_point<volatile const T> : public is_floating_point<T>{};
+   template <class T> struct is_floating_point<volatile T> : public is_floating_point<T>{};
+   template<> struct is_floating_point<float> : public true_type{};
+   template<> struct is_floating_point<double> : public true_type{};
+   template<> struct is_floating_point<long double> : public true_type{};
+
+
+
+
+
+}
+# 14 "/usr/include/boost/type_traits/is_arithmetic.hpp" 2 3 4
+
+namespace boost {
+
+template <class T>
+struct is_arithmetic : public integral_constant<bool, is_integral<T>::value || is_floating_point<T>::value> {};
+
+}
+# 27 "/usr/include/boost/detail/call_traits.hpp" 2 3 4
+# 1 "/usr/include/boost/type_traits/is_enum.hpp" 1 3 4
+# 12 "/usr/include/boost/type_traits/is_enum.hpp" 3 4
+#define BOOST_TT_IS_ENUM_HPP_INCLUDED 
+
+# 1 "/usr/include/boost/type_traits/intrinsics.hpp" 1 3 4
+# 9 "/usr/include/boost/type_traits/intrinsics.hpp" 3 4
+#define BOOST_TT_INTRINSICS_HPP_INCLUDED 
+# 259 "/usr/include/boost/type_traits/intrinsics.hpp" 3 4
+#define BOOST_INTEL_TT_OPTS 
+
+
+#define BOOST_IS_UNION(T) __is_union(T)
+#define BOOST_IS_POD(T) __is_pod(T)
+#define BOOST_IS_EMPTY(T) __is_empty(T)
+#define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) ((__has_trivial_constructor(T) BOOST_INTEL_TT_OPTS) && ! ::boost::is_volatile<T>::value)
+#define BOOST_HAS_TRIVIAL_COPY(T) ((__has_trivial_copy(T) BOOST_INTEL_TT_OPTS) && !is_reference<T>::value)
+
+#define BOOST_HAS_TRIVIAL_ASSIGN(T) ((__has_trivial_assign(T) BOOST_INTEL_TT_OPTS) && ! ::boost::is_volatile<T>::value && ! ::boost::is_const<T>::value && is_assignable<T&, const T&>::value)
+#define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) (__has_trivial_destructor(T) BOOST_INTEL_TT_OPTS && is_destructible<T>::value)
+#define BOOST_HAS_NOTHROW_CONSTRUCTOR(T) (__has_nothrow_constructor(T) && is_default_constructible<T>::value BOOST_INTEL_TT_OPTS)
+#define BOOST_HAS_NOTHROW_COPY(T) ((__has_nothrow_copy(T) BOOST_INTEL_TT_OPTS) && !is_volatile<T>::value && !is_reference<T>::value && is_copy_constructible<T>::value)
+#define BOOST_HAS_NOTHROW_ASSIGN(T) ((__has_nothrow_assign(T) BOOST_INTEL_TT_OPTS) && !is_volatile<T>::value && !is_const<T>::value && is_assignable<T&, const T&>::value)
+# 282 "/usr/include/boost/type_traits/intrinsics.hpp" 3 4
+#define BOOST_HAS_VIRTUAL_DESTRUCTOR(T) __has_virtual_destructor(T)
+
+#define BOOST_IS_ABSTRACT(T) __is_abstract(T)
+#define BOOST_IS_BASE_OF(T,U) (__is_base_of(T,U) && !is_same<T,U>::value)
+#define BOOST_IS_CLASS(T) __is_class(T)
+#define BOOST_IS_ENUM(T) __is_enum(T)
+#define BOOST_IS_POLYMORPHIC(T) __is_polymorphic(T)
+
+
+
+
+
+#define BOOST_ALIGNMENT_OF(T) __alignof__(T)
+
+
+#define BOOST_IS_FINAL(T) __is_final(T)
+
+
+
+#define BOOST_HAS_TRIVIAL_MOVE_ASSIGN(T) (__is_trivially_assignable(T&, T&&) && is_assignable<T&, T&&>::value && !::boost::is_volatile<T>::value)
+#define BOOST_HAS_TRIVIAL_MOVE_CONSTRUCTOR(T) (__is_trivially_constructible(T, T&&) && is_constructible<T, T&&>::value && !::boost::is_volatile<T>::value)
+
+
+#define BOOST_HAS_TYPE_TRAITS_INTRINSICS 
+# 15 "/usr/include/boost/type_traits/is_enum.hpp" 2 3 4
+# 32 "/usr/include/boost/type_traits/is_enum.hpp" 3 4
+namespace boost {
+# 160 "/usr/include/boost/type_traits/is_enum.hpp" 3 4
+template <class T> struct is_enum : public integral_constant<bool, __is_enum(T)> {};
+
+
+
+}
+# 28 "/usr/include/boost/detail/call_traits.hpp" 2 3 4
+# 1 "/usr/include/boost/type_traits/is_pointer.hpp" 1 3 4
+# 22 "/usr/include/boost/type_traits/is_pointer.hpp" 3 4
+#define BOOST_TT_IS_POINTER_HPP_INCLUDED 
+
+
+
+namespace boost {
+
+
+
+
+template <class T> struct is_pointer : public false_type{};
+template <class T> struct is_pointer<T*> : public true_type{};
+template <class T> struct is_pointer<T*const> : public true_type{};
+template <class T> struct is_pointer<T*const volatile> : public true_type{};
+template <class T> struct is_pointer<T*volatile> : public true_type{};
+# 45 "/usr/include/boost/type_traits/is_pointer.hpp" 3 4
+}
+# 29 "/usr/include/boost/detail/call_traits.hpp" 2 3 4
+
+
+namespace boost{
+
+namespace detail{
+
+template <typename T, bool small_>
+struct ct_imp2
+{
+   typedef const T& param_type;
+};
+
+template <typename T>
+struct ct_imp2<T, true>
+{
+   typedef const T param_type;
+};
+
+template <typename T, bool isp, bool b1, bool b2>
+struct ct_imp
+{
+   typedef const T& param_type;
+};
+
+template <typename T, bool isp, bool b2>
+struct ct_imp<T, isp, true, b2>
+{
+   typedef typename ct_imp2<T, sizeof(T) <= sizeof(void*)>::param_type param_type;
+};
+
+template <typename T, bool isp, bool b1>
+struct ct_imp<T, isp, b1, true>
+{
+   typedef typename ct_imp2<T, sizeof(T) <= sizeof(void*)>::param_type param_type;
+};
+
+template <typename T, bool b1, bool b2>
+struct ct_imp<T, true, b1, b2>
+{
+   typedef const T param_type;
+};
+
+}
+
+template <typename T>
+struct call_traits
+{
+public:
+   typedef T value_type;
+   typedef T& reference;
+   typedef const T& const_reference;
+
+
+
+
+
+
+   typedef typename boost::detail::ct_imp<
+      T,
+      ::boost::is_pointer<T>::value,
+      ::boost::is_arithmetic<T>::value,
+      ::boost::is_enum<T>::value
+   >::param_type param_type;
+};
+
+template <typename T>
+struct call_traits<T&>
+{
+   typedef T& value_type;
+   typedef T& reference;
+   typedef const T& const_reference;
+   typedef T& param_type;
+};
+# 143 "/usr/include/boost/detail/call_traits.hpp" 3 4
+template <typename T, std::size_t N>
+struct call_traits<T [N]>
+{
+private:
+   typedef T array_type[N];
+public:
+
+   typedef const T* value_type;
+   typedef array_type& reference;
+   typedef const array_type& const_reference;
+   typedef const T* const param_type;
+};
+
+template <typename T, std::size_t N>
+struct call_traits<const T [N]>
+{
+private:
+   typedef const T array_type[N];
+public:
+
+   typedef const T* value_type;
+   typedef array_type& reference;
+   typedef const array_type& const_reference;
+   typedef const T* const param_type;
+};
+
+
+}
+# 19 "/usr/include/boost/call_traits.hpp" 2 3 4
+# 27 "/usr/include/boost/test/utils/class_properties.hpp" 2 3 4
+# 1 "/usr/include/boost/type_traits/add_pointer.hpp" 1 3 4
+# 10 "/usr/include/boost/type_traits/add_pointer.hpp" 3 4
+#define BOOST_TT_ADD_POINTER_HPP_INCLUDED 
+
+# 1 "/usr/include/boost/type_traits/remove_reference.hpp" 1 3 4
+# 10 "/usr/include/boost/type_traits/remove_reference.hpp" 3 4
+#define BOOST_TT_REMOVE_REFERENCE_HPP_INCLUDED 
+
+
+
+
+namespace boost {
+
+
+namespace detail{
+
+
+
+
+template <class T>
+struct remove_rvalue_ref
+{
+   typedef T type;
+};
+
+template <class T>
+struct remove_rvalue_ref<T&&>
+{
+   typedef T type;
+};
+
+
+}
+
+template <class T> struct remove_reference{ typedef typename boost::detail::remove_rvalue_ref<T>::type type; };
+template <class T> struct remove_reference<T&>{ typedef T type; };
+# 53 "/usr/include/boost/type_traits/remove_reference.hpp" 3 4
+   template <class T> using remove_reference_t = typename remove_reference<T>::type;
+
+
+
+}
+# 13 "/usr/include/boost/type_traits/add_pointer.hpp" 2 3 4
+
+namespace boost {
+# 50 "/usr/include/boost/type_traits/add_pointer.hpp" 3 4
+template <typename T>
+struct add_pointer
+{
+    typedef typename remove_reference<T>::type no_ref_type;
+    typedef no_ref_type* type;
+};
+
+
+
+
+
+   template <class T> using add_pointer_t = typename add_pointer<T>::type;
+
+
+
+}
+# 28 "/usr/include/boost/test/utils/class_properties.hpp" 2 3 4
+
+# 1 "/usr/include/boost/utility/addressof.hpp" 1 3 4
+# 10 "/usr/include/boost/utility/addressof.hpp" 3 4
+#define BOOST_UTILITY_ADDRESSOF_HPP 
+
+
+
+
+# 1 "/usr/include/boost/core/addressof.hpp" 1 3 4
+# 15 "/usr/include/boost/core/addressof.hpp" 3 4
+#define BOOST_CORE_ADDRESSOF_HPP 
+
+
+
+
+
+
+#define BOOST_CORE_HAS_BUILTIN_ADDRESSOF 
+# 34 "/usr/include/boost/core/addressof.hpp" 3 4
+namespace boost {
+
+template<class T>
+constexpr inline T*
+addressof(T& o) noexcept
+{
+    return __builtin_addressof(o);
+}
+
+}
+# 266 "/usr/include/boost/core/addressof.hpp" 3 4
+namespace boost {
+
+template<class T>
+const T* addressof(const T&&) = delete;
+
+}
+# 16 "/usr/include/boost/utility/addressof.hpp" 2 3 4
+# 30 "/usr/include/boost/test/utils/class_properties.hpp" 2 3 4
+
+
+
+
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 35 "/usr/include/boost/test/utils/class_properties.hpp" 2 3 4
+
+
+
+namespace boost {
+namespace unit_test {
+
+
+
+
+
+template<class PropertyType>
+class class_property {
+protected:
+    typedef typename call_traits<PropertyType>::const_reference read_access_t;
+    typedef typename call_traits<PropertyType>::param_type write_param_t;
+    typedef typename add_pointer<typename add_const<PropertyType>::type>::type address_res_t;
+public:
+
+                    class_property() : value( PropertyType() ) {}
+    explicit class_property( write_param_t init_value )
+    : value( init_value ) {}
+
+
+    operator read_access_t() const { return value; }
+    read_access_t get() const { return value; }
+    bool operator!() const { return !value; }
+    address_res_t operator&() const { return &value; }
+
+
+
+protected:
+
+    PropertyType value;
+};
+# 80 "/usr/include/boost/test/utils/class_properties.hpp" 3 4
+template<typename CharT1, typename Tr,class PropertyType>
+inline std::basic_ostream<CharT1,Tr>&
+operator<<( std::basic_ostream<CharT1,Tr>& os, class_property<PropertyType> const& p )
+
+
+{
+    return os << p.get();
+}
+
+
+
+#define DEFINE_PROPERTY_FREE_BINARY_OPERATOR(op) template<class PropertyType> inline bool operator op( PropertyType const& lhs, class_property<PropertyType> const& rhs ) { return lhs op rhs.get(); } template<class PropertyType> inline bool operator op( class_property<PropertyType> const& lhs, PropertyType const& rhs ) { return lhs.get() op rhs; } template<class PropertyType> inline bool operator op( class_property<PropertyType> const& lhs, class_property<PropertyType> const& rhs ) { return lhs.get() op rhs.get(); }
+# 113 "/usr/include/boost/test/utils/class_properties.hpp" 3 4
+template<class PropertyType> inline bool operator ==( PropertyType const& lhs, class_property<PropertyType> const& rhs ) { return lhs == rhs.get(); } template<class PropertyType> inline bool operator ==( class_property<PropertyType> const& lhs, PropertyType const& rhs ) { return lhs.get() == rhs; } template<class PropertyType> inline bool operator ==( class_property<PropertyType> const& lhs, class_property<PropertyType> const& rhs ) { return lhs.get() == rhs.get(); }
+template<class PropertyType> inline bool operator !=( PropertyType const& lhs, class_property<PropertyType> const& rhs ) { return lhs != rhs.get(); } template<class PropertyType> inline bool operator !=( class_property<PropertyType> const& lhs, PropertyType const& rhs ) { return lhs.get() != rhs; } template<class PropertyType> inline bool operator !=( class_property<PropertyType> const& lhs, class_property<PropertyType> const& rhs ) { return lhs.get() != rhs.get(); }
+
+#undef DEFINE_PROPERTY_FREE_BINARY_OPERATOR
+
+
+
+
+
+template<class PropertyType>
+class readonly_property : public class_property<PropertyType> {
+    typedef class_property<PropertyType> base_prop;
+    typedef typename base_prop::address_res_t arrow_res_t;
+protected:
+    typedef typename base_prop::write_param_t write_param_t;
+public:
+
+                    readonly_property() {}
+    explicit readonly_property( write_param_t init_value ) : base_prop( init_value ) {}
+
+
+    arrow_res_t operator->() const { return boost::addressof( base_prop::value ); }
+};
+# 145 "/usr/include/boost/test/utils/class_properties.hpp" 3 4
+#define BOOST_READONLY_PROPERTY_DECLARE_FRIEND(r,data,elem) friend class elem;
+
+#define BOOST_READONLY_PROPERTY(property_type,friends) class BOOST_JOIN( readonly_property, __LINE__ ) : public boost::unit_test::readonly_property<property_type > { typedef boost::unit_test::readonly_property<property_type > base_prop; BOOST_PP_SEQ_FOR_EACH( BOOST_READONLY_PROPERTY_DECLARE_FRIEND, ' ', friends ) typedef base_prop::write_param_t write_param_t; public: BOOST_JOIN( readonly_property, __LINE__ )() {} explicit BOOST_JOIN( readonly_property, __LINE__ )( write_param_t init_v ) : base_prop( init_v ) {} }
+# 166 "/usr/include/boost/test/utils/class_properties.hpp" 3 4
+template<class PropertyType>
+class readwrite_property : public class_property<PropertyType> {
+    typedef class_property<PropertyType> base_prop;
+    typedef typename add_pointer<PropertyType>::type arrow_res_t;
+    typedef typename base_prop::address_res_t const_arrow_res_t;
+    typedef typename base_prop::write_param_t write_param_t;
+public:
+                    readwrite_property() : base_prop() {}
+    explicit readwrite_property( write_param_t init_value ) : base_prop( init_value ) {}
+
+
+    void set( write_param_t v ) { base_prop::value = v; }
+    arrow_res_t operator->() { return boost::addressof( base_prop::value ); }
+    const_arrow_res_t operator->() const { return boost::addressof( base_prop::value ); }
+
+
+    using base_prop::value;
+
+};
+
+
+
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 192 "/usr/include/boost/test/utils/class_properties.hpp" 2 3 4
+
+#undef BOOST_TEST_NO_PROTECTED_USING
+# 22 "/usr/include/boost/test/execution_monitor.hpp" 2 3 4
+
+
+# 1 "/usr/include/boost/shared_ptr.hpp" 1 3 4
+
+#define BOOST_SHARED_PTR_HPP_INCLUDED 
+# 17 "/usr/include/boost/shared_ptr.hpp" 3 4
+# 1 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 1 3 4
+
+#define BOOST_SMART_PTR_SHARED_PTR_HPP_INCLUDED 
+# 23 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 3 4
+# 1 "/usr/include/boost/config/no_tr1/memory.hpp" 1 3 4
+# 14 "/usr/include/boost/config/no_tr1/memory.hpp" 3 4
+#define BOOST_CONFIG_MEMORY 
+
+
+#define BOOST_TR1_NO_RECURSION 
+#define BOOST_CONFIG_NO_MEMORY_RECURSION 
+
+
+# 1 "/usr/include/c++/10.2.0/memory" 1 3 4
+# 45 "/usr/include/c++/10.2.0/memory" 3 4
+#define _GLIBCXX_MEMORY 1
+
+       
+# 48 "/usr/include/c++/10.2.0/memory" 3
+# 66 "/usr/include/c++/10.2.0/memory" 3
+# 1 "/usr/include/c++/10.2.0/bits/stl_uninitialized.h" 1 3
+# 57 "/usr/include/c++/10.2.0/bits/stl_uninitialized.h" 3
+#define _STL_UNINITIALIZED_H 1
+# 69 "/usr/include/c++/10.2.0/bits/stl_uninitialized.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+
+
+
+  template<bool _TrivialValueTypes>
+    struct __uninitialized_copy
+    {
+      template<typename _InputIterator, typename _ForwardIterator>
+        static _ForwardIterator
+        __uninit_copy(_InputIterator __first, _InputIterator __last,
+        _ForwardIterator __result)
+        {
+   _ForwardIterator __cur = __result;
+   try
+     {
+       for (; __first != __last; ++__first, (void)++__cur)
+  std::_Construct(std::__addressof(*__cur), *__first);
+       return __cur;
+     }
+   catch(...)
+     {
+       std::_Destroy(__result, __cur);
+       throw;
+     }
+ }
+    };
+
+  template<>
+    struct __uninitialized_copy<true>
+    {
+      template<typename _InputIterator, typename _ForwardIterator>
+        static _ForwardIterator
+        __uninit_copy(_InputIterator __first, _InputIterator __last,
+        _ForwardIterator __result)
+        { return std::copy(__first, __last, __result); }
+    };
+# 123 "/usr/include/c++/10.2.0/bits/stl_uninitialized.h" 3
+  template<typename _InputIterator, typename _ForwardIterator>
+    inline _ForwardIterator
+    uninitialized_copy(_InputIterator __first, _InputIterator __last,
+         _ForwardIterator __result)
+    {
+      typedef typename iterator_traits<_InputIterator>::value_type
+ _ValueType1;
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+ _ValueType2;
+
+
+
+
+
+      static_assert(is_constructible<_ValueType2, decltype(*__first)>::value,
+   "result type must be constructible from value type of input range");
+
+      typedef typename iterator_traits<_InputIterator>::reference _RefType1;
+      typedef typename iterator_traits<_ForwardIterator>::reference _RefType2;
+
+
+      const bool __assignable = is_assignable<_RefType2, _RefType1>::value;
+
+
+      return std::__uninitialized_copy<__is_trivial(_ValueType1)
+           && __is_trivial(_ValueType2)
+           && __assignable>::
+ __uninit_copy(__first, __last, __result);
+    }
+
+
+
+  template<bool _TrivialValueType>
+    struct __uninitialized_fill
+    {
+      template<typename _ForwardIterator, typename _Tp>
+        static void
+        __uninit_fill(_ForwardIterator __first, _ForwardIterator __last,
+        const _Tp& __x)
+        {
+   _ForwardIterator __cur = __first;
+   try
+     {
+       for (; __cur != __last; ++__cur)
+  std::_Construct(std::__addressof(*__cur), __x);
+     }
+   catch(...)
+     {
+       std::_Destroy(__first, __cur);
+       throw;
+     }
+ }
+    };
+
+  template<>
+    struct __uninitialized_fill<true>
+    {
+      template<typename _ForwardIterator, typename _Tp>
+        static void
+        __uninit_fill(_ForwardIterator __first, _ForwardIterator __last,
+        const _Tp& __x)
+        { std::fill(__first, __last, __x); }
+    };
+# 198 "/usr/include/c++/10.2.0/bits/stl_uninitialized.h" 3
+  template<typename _ForwardIterator, typename _Tp>
+    inline void
+    uninitialized_fill(_ForwardIterator __first, _ForwardIterator __last,
+         const _Tp& __x)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+ _ValueType;
+
+
+
+
+
+      static_assert(is_constructible<_ValueType, const _Tp&>::value,
+   "result type must be constructible from input type");
+
+
+
+      const bool __assignable = is_copy_assignable<_ValueType>::value;
+
+
+      std::__uninitialized_fill<__is_trivial(_ValueType) && __assignable>::
+ __uninit_fill(__first, __last, __x);
+    }
+
+
+
+  template<bool _TrivialValueType>
+    struct __uninitialized_fill_n
+    {
+      template<typename _ForwardIterator, typename _Size, typename _Tp>
+        static _ForwardIterator
+        __uninit_fill_n(_ForwardIterator __first, _Size __n,
+   const _Tp& __x)
+        {
+   _ForwardIterator __cur = __first;
+   try
+     {
+       for (; __n > 0; --__n, (void) ++__cur)
+  std::_Construct(std::__addressof(*__cur), __x);
+       return __cur;
+     }
+   catch(...)
+     {
+       std::_Destroy(__first, __cur);
+       throw;
+     }
+ }
+    };
+
+  template<>
+    struct __uninitialized_fill_n<true>
+    {
+      template<typename _ForwardIterator, typename _Size, typename _Tp>
+        static _ForwardIterator
+        __uninit_fill_n(_ForwardIterator __first, _Size __n,
+   const _Tp& __x)
+        { return std::fill_n(__first, __n, __x); }
+    };
+# 270 "/usr/include/c++/10.2.0/bits/stl_uninitialized.h" 3
+  template<typename _ForwardIterator, typename _Size, typename _Tp>
+    inline _ForwardIterator
+    uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+ _ValueType;
+
+
+
+
+
+      static_assert(is_constructible<_ValueType, const _Tp&>::value,
+   "result type must be constructible from input type");
+
+
+
+      const bool __assignable = is_copy_assignable<_ValueType>::value;
+
+      return __uninitialized_fill_n<__is_trivial(_ValueType) && __assignable>::
+ __uninit_fill_n(__first, __n, __x);
+    }
+# 300 "/usr/include/c++/10.2.0/bits/stl_uninitialized.h" 3
+  template<typename _InputIterator, typename _ForwardIterator,
+    typename _Allocator>
+    _ForwardIterator
+    __uninitialized_copy_a(_InputIterator __first, _InputIterator __last,
+      _ForwardIterator __result, _Allocator& __alloc)
+    {
+      _ForwardIterator __cur = __result;
+      try
+ {
+   typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
+   for (; __first != __last; ++__first, (void)++__cur)
+     __traits::construct(__alloc, std::__addressof(*__cur), *__first);
+   return __cur;
+ }
+      catch(...)
+ {
+   std::_Destroy(__result, __cur, __alloc);
+   throw;
+ }
+    }
+
+  template<typename _InputIterator, typename _ForwardIterator, typename _Tp>
+    inline _ForwardIterator
+    __uninitialized_copy_a(_InputIterator __first, _InputIterator __last,
+      _ForwardIterator __result, allocator<_Tp>&)
+    { return std::uninitialized_copy(__first, __last, __result); }
+
+  template<typename _InputIterator, typename _ForwardIterator,
+    typename _Allocator>
+    inline _ForwardIterator
+    __uninitialized_move_a(_InputIterator __first, _InputIterator __last,
+      _ForwardIterator __result, _Allocator& __alloc)
+    {
+      return std::__uninitialized_copy_a(std::make_move_iterator(__first),
+      std::make_move_iterator(__last),
+      __result, __alloc);
+    }
+
+  template<typename _InputIterator, typename _ForwardIterator,
+    typename _Allocator>
+    inline _ForwardIterator
+    __uninitialized_move_if_noexcept_a(_InputIterator __first,
+           _InputIterator __last,
+           _ForwardIterator __result,
+           _Allocator& __alloc)
+    {
+      return std::__uninitialized_copy_a
+ (std::__make_move_if_noexcept_iterator(__first),
+  std::__make_move_if_noexcept_iterator(__last), __result, __alloc);
+    }
+
+  template<typename _ForwardIterator, typename _Tp, typename _Allocator>
+    void
+    __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last,
+      const _Tp& __x, _Allocator& __alloc)
+    {
+      _ForwardIterator __cur = __first;
+      try
+ {
+   typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
+   for (; __cur != __last; ++__cur)
+     __traits::construct(__alloc, std::__addressof(*__cur), __x);
+ }
+      catch(...)
+ {
+   std::_Destroy(__first, __cur, __alloc);
+   throw;
+ }
+    }
+
+  template<typename _ForwardIterator, typename _Tp, typename _Tp2>
+    inline void
+    __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last,
+      const _Tp& __x, allocator<_Tp2>&)
+    { std::uninitialized_fill(__first, __last, __x); }
+
+  template<typename _ForwardIterator, typename _Size, typename _Tp,
+    typename _Allocator>
+    _ForwardIterator
+    __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n,
+        const _Tp& __x, _Allocator& __alloc)
+    {
+      _ForwardIterator __cur = __first;
+      try
+ {
+   typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
+   for (; __n > 0; --__n, (void) ++__cur)
+     __traits::construct(__alloc, std::__addressof(*__cur), __x);
+   return __cur;
+ }
+      catch(...)
+ {
+   std::_Destroy(__first, __cur, __alloc);
+   throw;
+ }
+    }
+
+  template<typename _ForwardIterator, typename _Size, typename _Tp,
+    typename _Tp2>
+    inline _ForwardIterator
+    __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n,
+        const _Tp& __x, allocator<_Tp2>&)
+    { return std::uninitialized_fill_n(__first, __n, __x); }
+# 414 "/usr/include/c++/10.2.0/bits/stl_uninitialized.h" 3
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _ForwardIterator, typename _Allocator>
+    inline _ForwardIterator
+    __uninitialized_copy_move(_InputIterator1 __first1,
+         _InputIterator1 __last1,
+         _InputIterator2 __first2,
+         _InputIterator2 __last2,
+         _ForwardIterator __result,
+         _Allocator& __alloc)
+    {
+      _ForwardIterator __mid = std::__uninitialized_copy_a(__first1, __last1,
+          __result,
+          __alloc);
+      try
+ {
+   return std::__uninitialized_move_a(__first2, __last2, __mid, __alloc);
+ }
+      catch(...)
+ {
+   std::_Destroy(__result, __mid, __alloc);
+   throw;
+ }
+    }
+
+
+
+
+
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _ForwardIterator, typename _Allocator>
+    inline _ForwardIterator
+    __uninitialized_move_copy(_InputIterator1 __first1,
+         _InputIterator1 __last1,
+         _InputIterator2 __first2,
+         _InputIterator2 __last2,
+         _ForwardIterator __result,
+         _Allocator& __alloc)
+    {
+      _ForwardIterator __mid = std::__uninitialized_move_a(__first1, __last1,
+          __result,
+          __alloc);
+      try
+ {
+   return std::__uninitialized_copy_a(__first2, __last2, __mid, __alloc);
+ }
+      catch(...)
+ {
+   std::_Destroy(__result, __mid, __alloc);
+   throw;
+ }
+    }
+
+
+
+
+  template<typename _ForwardIterator, typename _Tp, typename _InputIterator,
+    typename _Allocator>
+    inline _ForwardIterator
+    __uninitialized_fill_move(_ForwardIterator __result, _ForwardIterator __mid,
+         const _Tp& __x, _InputIterator __first,
+         _InputIterator __last, _Allocator& __alloc)
+    {
+      std::__uninitialized_fill_a(__result, __mid, __x, __alloc);
+      try
+ {
+   return std::__uninitialized_move_a(__first, __last, __mid, __alloc);
+ }
+      catch(...)
+ {
+   std::_Destroy(__result, __mid, __alloc);
+   throw;
+ }
+    }
+
+
+
+
+  template<typename _InputIterator, typename _ForwardIterator, typename _Tp,
+    typename _Allocator>
+    inline void
+    __uninitialized_move_fill(_InputIterator __first1, _InputIterator __last1,
+         _ForwardIterator __first2,
+         _ForwardIterator __last2, const _Tp& __x,
+         _Allocator& __alloc)
+    {
+      _ForwardIterator __mid2 = std::__uninitialized_move_a(__first1, __last1,
+           __first2,
+           __alloc);
+      try
+ {
+   std::__uninitialized_fill_a(__mid2, __last2, __x, __alloc);
+ }
+      catch(...)
+ {
+   std::_Destroy(__first2, __mid2, __alloc);
+   throw;
+ }
+    }
+# 521 "/usr/include/c++/10.2.0/bits/stl_uninitialized.h" 3
+  template<bool _TrivialValueType>
+    struct __uninitialized_default_1
+    {
+      template<typename _ForwardIterator>
+        static void
+        __uninit_default(_ForwardIterator __first, _ForwardIterator __last)
+        {
+   _ForwardIterator __cur = __first;
+   try
+     {
+       for (; __cur != __last; ++__cur)
+  std::_Construct(std::__addressof(*__cur));
+     }
+   catch(...)
+     {
+       std::_Destroy(__first, __cur);
+       throw;
+     }
+ }
+    };
+
+  template<>
+    struct __uninitialized_default_1<true>
+    {
+      template<typename _ForwardIterator>
+        static void
+        __uninit_default(_ForwardIterator __first, _ForwardIterator __last)
+        {
+   typedef typename iterator_traits<_ForwardIterator>::value_type
+     _ValueType;
+
+   std::fill(__first, __last, _ValueType());
+ }
+    };
+
+  template<bool _TrivialValueType>
+    struct __uninitialized_default_n_1
+    {
+      template<typename _ForwardIterator, typename _Size>
+        static _ForwardIterator
+        __uninit_default_n(_ForwardIterator __first, _Size __n)
+        {
+   _ForwardIterator __cur = __first;
+   try
+     {
+       for (; __n > 0; --__n, (void) ++__cur)
+  std::_Construct(std::__addressof(*__cur));
+       return __cur;
+     }
+   catch(...)
+     {
+       std::_Destroy(__first, __cur);
+       throw;
+     }
+ }
+    };
+
+  template<>
+    struct __uninitialized_default_n_1<true>
+    {
+      template<typename _ForwardIterator, typename _Size>
+        static _ForwardIterator
+        __uninit_default_n(_ForwardIterator __first, _Size __n)
+        {
+   typedef typename iterator_traits<_ForwardIterator>::value_type
+     _ValueType;
+
+   return std::fill_n(__first, __n, _ValueType());
+ }
+    };
+
+
+
+
+  template<typename _ForwardIterator>
+    inline void
+    __uninitialized_default(_ForwardIterator __first,
+       _ForwardIterator __last)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+ _ValueType;
+
+      const bool __assignable = is_copy_assignable<_ValueType>::value;
+
+      std::__uninitialized_default_1<__is_trivial(_ValueType)
+         && __assignable>::
+ __uninit_default(__first, __last);
+    }
+
+
+
+  template<typename _ForwardIterator, typename _Size>
+    inline _ForwardIterator
+    __uninitialized_default_n(_ForwardIterator __first, _Size __n)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+ _ValueType;
+
+      const bool __assignable = is_copy_assignable<_ValueType>::value;
+
+      return __uninitialized_default_n_1<__is_trivial(_ValueType)
+           && __assignable>::
+ __uninit_default_n(__first, __n);
+    }
+
+
+
+
+
+  template<typename _ForwardIterator, typename _Allocator>
+    void
+    __uninitialized_default_a(_ForwardIterator __first,
+         _ForwardIterator __last,
+         _Allocator& __alloc)
+    {
+      _ForwardIterator __cur = __first;
+      try
+ {
+   typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
+   for (; __cur != __last; ++__cur)
+     __traits::construct(__alloc, std::__addressof(*__cur));
+ }
+      catch(...)
+ {
+   std::_Destroy(__first, __cur, __alloc);
+   throw;
+ }
+    }
+
+  template<typename _ForwardIterator, typename _Tp>
+    inline void
+    __uninitialized_default_a(_ForwardIterator __first,
+         _ForwardIterator __last,
+         allocator<_Tp>&)
+    { std::__uninitialized_default(__first, __last); }
+
+
+
+
+
+  template<typename _ForwardIterator, typename _Size, typename _Allocator>
+    _ForwardIterator
+    __uninitialized_default_n_a(_ForwardIterator __first, _Size __n,
+    _Allocator& __alloc)
+    {
+      _ForwardIterator __cur = __first;
+      try
+ {
+   typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
+   for (; __n > 0; --__n, (void) ++__cur)
+     __traits::construct(__alloc, std::__addressof(*__cur));
+   return __cur;
+ }
+      catch(...)
+ {
+   std::_Destroy(__first, __cur, __alloc);
+   throw;
+ }
+    }
+
+  template<typename _ForwardIterator, typename _Size, typename _Tp>
+    inline _ForwardIterator
+    __uninitialized_default_n_a(_ForwardIterator __first, _Size __n,
+    allocator<_Tp>&)
+    { return std::__uninitialized_default_n(__first, __n); }
+
+  template<bool _TrivialValueType>
+    struct __uninitialized_default_novalue_1
+    {
+      template<typename _ForwardIterator>
+ static void
+ __uninit_default_novalue(_ForwardIterator __first,
+     _ForwardIterator __last)
+ {
+   _ForwardIterator __cur = __first;
+   try
+     {
+       for (; __cur != __last; ++__cur)
+  std::_Construct_novalue(std::__addressof(*__cur));
+     }
+   catch(...)
+     {
+       std::_Destroy(__first, __cur);
+       throw;
+     }
+ }
+    };
+
+  template<>
+    struct __uninitialized_default_novalue_1<true>
+    {
+      template<typename _ForwardIterator>
+        static void
+        __uninit_default_novalue(_ForwardIterator __first,
+     _ForwardIterator __last)
+ {
+ }
+    };
+
+  template<bool _TrivialValueType>
+    struct __uninitialized_default_novalue_n_1
+    {
+      template<typename _ForwardIterator, typename _Size>
+ static _ForwardIterator
+ __uninit_default_novalue_n(_ForwardIterator __first, _Size __n)
+ {
+   _ForwardIterator __cur = __first;
+   try
+     {
+       for (; __n > 0; --__n, (void) ++__cur)
+  std::_Construct_novalue(std::__addressof(*__cur));
+       return __cur;
+     }
+   catch(...)
+     {
+       std::_Destroy(__first, __cur);
+       throw;
+     }
+ }
+    };
+
+  template<>
+    struct __uninitialized_default_novalue_n_1<true>
+    {
+      template<typename _ForwardIterator, typename _Size>
+ static _ForwardIterator
+ __uninit_default_novalue_n(_ForwardIterator __first, _Size __n)
+ { return std::next(__first, __n); }
+    };
+
+
+
+
+  template<typename _ForwardIterator>
+    inline void
+    __uninitialized_default_novalue(_ForwardIterator __first,
+        _ForwardIterator __last)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+ _ValueType;
+
+      std::__uninitialized_default_novalue_1<
+ is_trivially_default_constructible<_ValueType>::value>::
+ __uninit_default_novalue(__first, __last);
+    }
+
+
+
+  template<typename _ForwardIterator, typename _Size>
+    inline _ForwardIterator
+    __uninitialized_default_novalue_n(_ForwardIterator __first, _Size __n)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+ _ValueType;
+
+      return __uninitialized_default_novalue_n_1<
+ is_trivially_default_constructible<_ValueType>::value>::
+ __uninit_default_novalue_n(__first, __n);
+    }
+
+  template<typename _InputIterator, typename _Size,
+    typename _ForwardIterator>
+    _ForwardIterator
+    __uninitialized_copy_n(_InputIterator __first, _Size __n,
+      _ForwardIterator __result, input_iterator_tag)
+    {
+      _ForwardIterator __cur = __result;
+      try
+ {
+   for (; __n > 0; --__n, (void) ++__first, ++__cur)
+     std::_Construct(std::__addressof(*__cur), *__first);
+   return __cur;
+ }
+      catch(...)
+ {
+   std::_Destroy(__result, __cur);
+   throw;
+ }
+    }
+
+  template<typename _RandomAccessIterator, typename _Size,
+    typename _ForwardIterator>
+    inline _ForwardIterator
+    __uninitialized_copy_n(_RandomAccessIterator __first, _Size __n,
+      _ForwardIterator __result,
+      random_access_iterator_tag)
+    { return std::uninitialized_copy(__first, __first + __n, __result); }
+
+  template<typename _InputIterator, typename _Size,
+    typename _ForwardIterator>
+    pair<_InputIterator, _ForwardIterator>
+    __uninitialized_copy_n_pair(_InputIterator __first, _Size __n,
+      _ForwardIterator __result, input_iterator_tag)
+    {
+      _ForwardIterator __cur = __result;
+      try
+ {
+   for (; __n > 0; --__n, (void) ++__first, ++__cur)
+     std::_Construct(std::__addressof(*__cur), *__first);
+   return {__first, __cur};
+ }
+      catch(...)
+ {
+   std::_Destroy(__result, __cur);
+   throw;
+ }
+    }
+
+  template<typename _RandomAccessIterator, typename _Size,
+    typename _ForwardIterator>
+    inline pair<_RandomAccessIterator, _ForwardIterator>
+    __uninitialized_copy_n_pair(_RandomAccessIterator __first, _Size __n,
+      _ForwardIterator __result,
+      random_access_iterator_tag)
+    {
+      auto __second_res = uninitialized_copy(__first, __first + __n, __result);
+      auto __first_res = std::next(__first, __n);
+      return {__first_res, __second_res};
+    }
+# 852 "/usr/include/c++/10.2.0/bits/stl_uninitialized.h" 3
+  template<typename _InputIterator, typename _Size, typename _ForwardIterator>
+    inline _ForwardIterator
+    uninitialized_copy_n(_InputIterator __first, _Size __n,
+    _ForwardIterator __result)
+    { return std::__uninitialized_copy_n(__first, __n, __result,
+      std::__iterator_category(__first)); }
+
+
+  template<typename _InputIterator, typename _Size, typename _ForwardIterator>
+    inline pair<_InputIterator, _ForwardIterator>
+    __uninitialized_copy_n_pair(_InputIterator __first, _Size __n,
+         _ForwardIterator __result)
+    {
+      return
+ std::__uninitialized_copy_n_pair(__first, __n, __result,
+      std::__iterator_category(__first));
+    }
+
+
+
+
+#define __cpp_lib_raw_memory_algorithms 201606L
+
+
+
+
+
+
+  template <typename _ForwardIterator>
+    inline void
+    uninitialized_default_construct(_ForwardIterator __first,
+        _ForwardIterator __last)
+    {
+      __uninitialized_default_novalue(__first, __last);
+    }
+
+
+
+
+
+
+
+  template <typename _ForwardIterator, typename _Size>
+    inline _ForwardIterator
+    uninitialized_default_construct_n(_ForwardIterator __first, _Size __count)
+    {
+      return __uninitialized_default_novalue_n(__first, __count);
+    }
+
+
+
+
+
+
+  template <typename _ForwardIterator>
+    inline void
+    uninitialized_value_construct(_ForwardIterator __first,
+      _ForwardIterator __last)
+    {
+      return __uninitialized_default(__first, __last);
+    }
+
+
+
+
+
+
+
+  template <typename _ForwardIterator, typename _Size>
+    inline _ForwardIterator
+    uninitialized_value_construct_n(_ForwardIterator __first, _Size __count)
+    {
+      return __uninitialized_default_n(__first, __count);
+    }
+# 934 "/usr/include/c++/10.2.0/bits/stl_uninitialized.h" 3
+  template <typename _InputIterator, typename _ForwardIterator>
+    inline _ForwardIterator
+    uninitialized_move(_InputIterator __first, _InputIterator __last,
+         _ForwardIterator __result)
+    {
+      return std::uninitialized_copy
+ (std::make_move_iterator(__first),
+  std::make_move_iterator(__last), __result);
+    }
+# 951 "/usr/include/c++/10.2.0/bits/stl_uninitialized.h" 3
+  template <typename _InputIterator, typename _Size, typename _ForwardIterator>
+    inline pair<_InputIterator, _ForwardIterator>
+    uninitialized_move_n(_InputIterator __first, _Size __count,
+    _ForwardIterator __result)
+    {
+      auto __res = std::__uninitialized_copy_n_pair
+ (std::make_move_iterator(__first),
+  __count, __result);
+      return {__res.first.base(), __res.second};
+    }
+
+
+
+
+
+  template<typename _Tp, typename _Up, typename _Allocator>
+    inline void
+    __relocate_object_a(_Tp* __restrict __dest, _Up* __restrict __orig,
+   _Allocator& __alloc)
+    noexcept(noexcept(std::allocator_traits<_Allocator>::construct(__alloc,
+    __dest, std::move(*__orig)))
+      && noexcept(std::allocator_traits<_Allocator>::destroy(
+       __alloc, std::__addressof(*__orig))))
+    {
+      typedef std::allocator_traits<_Allocator> __traits;
+      __traits::construct(__alloc, __dest, std::move(*__orig));
+      __traits::destroy(__alloc, std::__addressof(*__orig));
+    }
+
+
+
+  template<typename _Tp, typename = void>
+    struct __is_bitwise_relocatable
+    : is_trivial<_Tp> { };
+
+  template <typename _Tp, typename _Up>
+    inline __enable_if_t<std::__is_bitwise_relocatable<_Tp>::value, _Tp*>
+    __relocate_a_1(_Tp* __first, _Tp* __last,
+     _Tp* __result, allocator<_Up>&) noexcept
+    {
+      ptrdiff_t __count = __last - __first;
+      if (__count > 0)
+ __builtin_memmove(__result, __first, __count * sizeof(_Tp));
+      return __result + __count;
+    }
+
+  template <typename _InputIterator, typename _ForwardIterator,
+     typename _Allocator>
+    inline _ForwardIterator
+    __relocate_a_1(_InputIterator __first, _InputIterator __last,
+     _ForwardIterator __result, _Allocator& __alloc)
+    noexcept(noexcept(std::__relocate_object_a(std::addressof(*__result),
+            std::addressof(*__first),
+            __alloc)))
+    {
+      typedef typename iterator_traits<_InputIterator>::value_type
+ _ValueType;
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+ _ValueType2;
+      static_assert(std::is_same<_ValueType, _ValueType2>::value,
+   "relocation is only possible for values of the same type");
+      _ForwardIterator __cur = __result;
+      for (; __first != __last; ++__first, (void)++__cur)
+ std::__relocate_object_a(std::__addressof(*__cur),
+     std::__addressof(*__first), __alloc);
+      return __cur;
+    }
+
+  template <typename _InputIterator, typename _ForwardIterator,
+     typename _Allocator>
+    inline _ForwardIterator
+    __relocate_a(_InputIterator __first, _InputIterator __last,
+   _ForwardIterator __result, _Allocator& __alloc)
+    noexcept(noexcept(__relocate_a_1(std::__niter_base(__first),
+         std::__niter_base(__last),
+         std::__niter_base(__result), __alloc)))
+    {
+      return __relocate_a_1(std::__niter_base(__first),
+       std::__niter_base(__last),
+       std::__niter_base(__result), __alloc);
+    }
+
+
+
+
+
+
+
+}
+# 67 "/usr/include/c++/10.2.0/memory" 2 3
+# 1 "/usr/include/c++/10.2.0/bits/stl_tempbuf.h" 1 3
+# 57 "/usr/include/c++/10.2.0/bits/stl_tempbuf.h" 3
+#define _STL_TEMPBUF_H 1
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  namespace __detail
+  {
+    template<typename _Tp>
+      inline void
+      __return_temporary_buffer(_Tp* __p,
+    size_t __len __attribute__((__unused__)))
+      {
+
+ ::operator delete(__p, __len * sizeof(_Tp));
+
+
+
+      }
+  }
+# 98 "/usr/include/c++/10.2.0/bits/stl_tempbuf.h" 3
+  template<typename _Tp>
+    pair<_Tp*, ptrdiff_t>
+    get_temporary_buffer(ptrdiff_t __len) noexcept
+    {
+      const ptrdiff_t __max =
+ __gnu_cxx::__numeric_traits<ptrdiff_t>::__max / sizeof(_Tp);
+      if (__len > __max)
+ __len = __max;
+
+      while (__len > 0)
+ {
+   _Tp* __tmp = static_cast<_Tp*>(::operator new(__len * sizeof(_Tp),
+       std::nothrow));
+   if (__tmp != 0)
+     return std::pair<_Tp*, ptrdiff_t>(__tmp, __len);
+   __len /= 2;
+ }
+      return std::pair<_Tp*, ptrdiff_t>(static_cast<_Tp*>(0), 0);
+    }
+# 125 "/usr/include/c++/10.2.0/bits/stl_tempbuf.h" 3
+  template<typename _Tp>
+    inline void
+    return_temporary_buffer(_Tp* __p)
+    { ::operator delete(__p); }
+
+
+
+
+
+
+  template<typename _ForwardIterator, typename _Tp>
+    class _Temporary_buffer
+    {
+
+     
+
+    public:
+      typedef _Tp value_type;
+      typedef value_type* pointer;
+      typedef pointer iterator;
+      typedef ptrdiff_t size_type;
+
+    protected:
+      size_type _M_original_len;
+      size_type _M_len;
+      pointer _M_buffer;
+
+    public:
+
+      size_type
+      size() const
+      { return _M_len; }
+
+
+      size_type
+      requested_size() const
+      { return _M_original_len; }
+
+
+      iterator
+      begin()
+      { return _M_buffer; }
+
+
+      iterator
+      end()
+      { return _M_buffer + _M_len; }
+
+
+
+
+
+      _Temporary_buffer(_ForwardIterator __seed, size_type __original_len);
+
+      ~_Temporary_buffer()
+      {
+ std::_Destroy(_M_buffer, _M_buffer + _M_len);
+ std::__detail::__return_temporary_buffer(_M_buffer, _M_len);
+      }
+
+    private:
+
+      _Temporary_buffer(const _Temporary_buffer&);
+
+      void
+      operator=(const _Temporary_buffer&);
+    };
+
+
+  template<bool>
+    struct __uninitialized_construct_buf_dispatch
+    {
+      template<typename _Pointer, typename _ForwardIterator>
+        static void
+        __ucr(_Pointer __first, _Pointer __last,
+       _ForwardIterator __seed)
+        {
+   if (__first == __last)
+     return;
+
+   _Pointer __cur = __first;
+   try
+     {
+       std::_Construct(std::__addressof(*__first),
+         std::move(*__seed));
+       _Pointer __prev = __cur;
+       ++__cur;
+       for(; __cur != __last; ++__cur, ++__prev)
+  std::_Construct(std::__addressof(*__cur),
+    std::move(*__prev));
+       *__seed = std::move(*__prev);
+     }
+   catch(...)
+     {
+       std::_Destroy(__first, __cur);
+       throw;
+     }
+ }
+    };
+
+  template<>
+    struct __uninitialized_construct_buf_dispatch<true>
+    {
+      template<typename _Pointer, typename _ForwardIterator>
+        static void
+        __ucr(_Pointer, _Pointer, _ForwardIterator) { }
+    };
+# 243 "/usr/include/c++/10.2.0/bits/stl_tempbuf.h" 3
+  template<typename _Pointer, typename _ForwardIterator>
+    inline void
+    __uninitialized_construct_buf(_Pointer __first, _Pointer __last,
+      _ForwardIterator __seed)
+    {
+      typedef typename std::iterator_traits<_Pointer>::value_type
+ _ValueType;
+
+      std::__uninitialized_construct_buf_dispatch<
+        __has_trivial_constructor(_ValueType)>::
+   __ucr(__first, __last, __seed);
+    }
+
+  template<typename _ForwardIterator, typename _Tp>
+    _Temporary_buffer<_ForwardIterator, _Tp>::
+    _Temporary_buffer(_ForwardIterator __seed, size_type __original_len)
+    : _M_original_len(__original_len), _M_len(0), _M_buffer(0)
+    {
+      std::pair<pointer, size_type> __p(
+  std::get_temporary_buffer<value_type>(_M_original_len));
+
+      if (__p.first)
+ {
+   try
+     {
+       std::__uninitialized_construct_buf(__p.first, __p.first + __p.second,
+       __seed);
+       _M_buffer = __p.first;
+       _M_len = __p.second;
+     }
+   catch(...)
+     {
+       std::__detail::__return_temporary_buffer(__p.first, __p.second);
+       throw;
+     }
+ }
+    }
+
+
+}
+# 68 "/usr/include/c++/10.2.0/memory" 2 3
+# 1 "/usr/include/c++/10.2.0/bits/stl_raw_storage_iter.h" 1 3
+# 57 "/usr/include/c++/10.2.0/bits/stl_raw_storage_iter.h" 3
+#define _STL_RAW_STORAGE_ITERATOR_H 1
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+
+  template <class _OutputIterator, class _Tp>
+    class raw_storage_iterator
+    : public iterator<output_iterator_tag, void, void, void, void>
+    {
+    protected:
+      _OutputIterator _M_iter;
+
+    public:
+      explicit
+      raw_storage_iterator(_OutputIterator __x)
+      : _M_iter(__x) {}
+
+      raw_storage_iterator&
+      operator*() { return *this; }
+
+      raw_storage_iterator&
+      operator=(const _Tp& __element)
+      {
+ std::_Construct(std::__addressof(*_M_iter), __element);
+ return *this;
+      }
+
+
+
+
+      raw_storage_iterator&
+      operator=(_Tp&& __element)
+      {
+ std::_Construct(std::__addressof(*_M_iter), std::move(__element));
+ return *this;
+      }
+
+
+      raw_storage_iterator&
+      operator++()
+      {
+ ++_M_iter;
+ return *this;
+      }
+
+      raw_storage_iterator
+      operator++(int)
+      {
+ raw_storage_iterator __tmp = *this;
+ ++_M_iter;
+ return __tmp;
+      }
+
+
+
+      _OutputIterator base() const { return _M_iter; }
+    };
+
+
+}
+# 69 "/usr/include/c++/10.2.0/memory" 2 3
+# 1 "/usr/include/c++/10.2.0/bits/ranges_uninitialized.h" 1 3
+# 31 "/usr/include/c++/10.2.0/bits/ranges_uninitialized.h" 3
+#define _RANGES_UNINITIALIZED_H 1
+# 70 "/usr/include/c++/10.2.0/memory" 2 3
+
+
+
+
+
+
+# 1 "/usr/include/c++/10.2.0/ext/concurrence.h" 1 3
+# 30 "/usr/include/c++/10.2.0/ext/concurrence.h" 3
+#define _CONCURRENCE_H 1
+
+       
+# 33 "/usr/include/c++/10.2.0/ext/concurrence.h" 3
+
+
+
+
+
+
+
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+
+
+  enum _Lock_policy { _S_single, _S_mutex, _S_atomic };
+
+
+
+  static const _Lock_policy __default_lock_policy =
+
+
+
+  _S_atomic;
+
+
+
+
+
+
+  class __concurrence_lock_error : public std::exception
+  {
+  public:
+    virtual char const*
+    what() const throw()
+    { return "__gnu_cxx::__concurrence_lock_error"; }
+  };
+
+  class __concurrence_unlock_error : public std::exception
+  {
+  public:
+    virtual char const*
+    what() const throw()
+    { return "__gnu_cxx::__concurrence_unlock_error"; }
+  };
+
+  class __concurrence_broadcast_error : public std::exception
+  {
+  public:
+    virtual char const*
+    what() const throw()
+    { return "__gnu_cxx::__concurrence_broadcast_error"; }
+  };
+
+  class __concurrence_wait_error : public std::exception
+  {
+  public:
+    virtual char const*
+    what() const throw()
+    { return "__gnu_cxx::__concurrence_wait_error"; }
+  };
+
+
+  inline void
+  __throw_concurrence_lock_error()
+  { (throw (__concurrence_lock_error())); }
+
+  inline void
+  __throw_concurrence_unlock_error()
+  { (throw (__concurrence_unlock_error())); }
+
+
+  inline void
+  __throw_concurrence_broadcast_error()
+  { (throw (__concurrence_broadcast_error())); }
+
+  inline void
+  __throw_concurrence_wait_error()
+  { (throw (__concurrence_wait_error())); }
+
+
+  class __mutex
+  {
+  private:
+
+    __gthread_mutex_t _M_mutex = { { 0, 0, 0, 0, PTHREAD_MUTEX_TIMED_NP, 0, 0, { 0, 0 } } };
+
+
+
+
+    __mutex(const __mutex&);
+    __mutex& operator=(const __mutex&);
+
+  public:
+    __mutex()
+    {
+
+
+
+
+    }
+# 144 "/usr/include/c++/10.2.0/ext/concurrence.h" 3
+    void lock()
+    {
+
+      if (__gthread_active_p())
+ {
+   if (__gthread_mutex_lock(&_M_mutex) != 0)
+     __throw_concurrence_lock_error();
+ }
+
+    }
+
+    void unlock()
+    {
+
+      if (__gthread_active_p())
+ {
+   if (__gthread_mutex_unlock(&_M_mutex) != 0)
+     __throw_concurrence_unlock_error();
+ }
+
+    }
+
+    __gthread_mutex_t* gthread_mutex(void)
+      { return &_M_mutex; }
+  };
+
+  class __recursive_mutex
+  {
+  private:
+
+    __gthread_recursive_mutex_t _M_mutex = { { 0, 0, 0, 0, PTHREAD_MUTEX_RECURSIVE_NP, 0, 0, { 0, 0 } } };
+
+
+
+
+    __recursive_mutex(const __recursive_mutex&);
+    __recursive_mutex& operator=(const __recursive_mutex&);
+
+  public:
+    __recursive_mutex()
+    {
+
+
+
+
+    }
+# 199 "/usr/include/c++/10.2.0/ext/concurrence.h" 3
+    void lock()
+    {
+
+      if (__gthread_active_p())
+ {
+   if (__gthread_recursive_mutex_lock(&_M_mutex) != 0)
+     __throw_concurrence_lock_error();
+ }
+
+    }
+
+    void unlock()
+    {
+
+      if (__gthread_active_p())
+ {
+   if (__gthread_recursive_mutex_unlock(&_M_mutex) != 0)
+     __throw_concurrence_unlock_error();
+ }
+
+    }
+
+    __gthread_recursive_mutex_t* gthread_recursive_mutex(void)
+    { return &_M_mutex; }
+  };
+
+
+
+
+  class __scoped_lock
+  {
+  public:
+    typedef __mutex __mutex_type;
+
+  private:
+    __mutex_type& _M_device;
+
+    __scoped_lock(const __scoped_lock&);
+    __scoped_lock& operator=(const __scoped_lock&);
+
+  public:
+    explicit __scoped_lock(__mutex_type& __name) : _M_device(__name)
+    { _M_device.lock(); }
+
+    ~__scoped_lock() throw()
+    { _M_device.unlock(); }
+  };
+
+
+  class __cond
+  {
+  private:
+
+    __gthread_cond_t _M_cond = { { {0}, {0}, {0, 0}, {0, 0}, 0, 0, {0, 0} } };
+
+
+
+
+    __cond(const __cond&);
+    __cond& operator=(const __cond&);
+
+  public:
+    __cond()
+    {
+
+
+
+
+    }
+# 277 "/usr/include/c++/10.2.0/ext/concurrence.h" 3
+    void broadcast()
+    {
+
+      if (__gthread_active_p())
+ {
+   if (__gthread_cond_broadcast(&_M_cond) != 0)
+     __throw_concurrence_broadcast_error();
+ }
+
+    }
+
+    void wait(__mutex *mutex)
+    {
+
+      {
+   if (__gthread_cond_wait(&_M_cond, mutex->gthread_mutex()) != 0)
+     __throw_concurrence_wait_error();
+      }
+
+    }
+
+    void wait_recursive(__recursive_mutex *mutex)
+    {
+
+      {
+   if (__gthread_cond_wait_recursive(&_M_cond,
+         mutex->gthread_recursive_mutex())
+       != 0)
+     __throw_concurrence_wait_error();
+      }
+
+    }
+  };
+
+
+
+}
+# 77 "/usr/include/c++/10.2.0/memory" 2 3
+
+
+# 1 "/usr/include/c++/10.2.0/bits/uses_allocator.h" 1 3
+# 26 "/usr/include/c++/10.2.0/bits/uses_allocator.h" 3
+#define _USES_ALLOCATOR_H 1
+# 35 "/usr/include/c++/10.2.0/bits/uses_allocator.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+  struct __erased_type { };
+
+
+
+
+  template<typename _Alloc, typename _Tp>
+    using __is_erased_or_convertible
+      = __or_<is_convertible<_Alloc, _Tp>, is_same<_Tp, __erased_type>>;
+
+
+  struct allocator_arg_t { explicit allocator_arg_t() = default; };
+
+  inline constexpr allocator_arg_t allocator_arg =
+    allocator_arg_t();
+
+  template<typename _Tp, typename _Alloc, typename = __void_t<>>
+    struct __uses_allocator_helper
+    : false_type { };
+
+  template<typename _Tp, typename _Alloc>
+    struct __uses_allocator_helper<_Tp, _Alloc,
+       __void_t<typename _Tp::allocator_type>>
+    : __is_erased_or_convertible<_Alloc, typename _Tp::allocator_type>::type
+    { };
+
+
+  template<typename _Tp, typename _Alloc>
+    struct uses_allocator
+    : __uses_allocator_helper<_Tp, _Alloc>::type
+    { };
+
+  struct __uses_alloc_base { };
+
+  struct __uses_alloc0 : __uses_alloc_base
+  {
+    struct _Sink { void operator=(const void*) { } } _M_a;
+  };
+
+  template<typename _Alloc>
+    struct __uses_alloc1 : __uses_alloc_base { const _Alloc* _M_a; };
+
+  template<typename _Alloc>
+    struct __uses_alloc2 : __uses_alloc_base { const _Alloc* _M_a; };
+
+  template<bool, typename _Tp, typename _Alloc, typename... _Args>
+    struct __uses_alloc;
+
+  template<typename _Tp, typename _Alloc, typename... _Args>
+    struct __uses_alloc<true, _Tp, _Alloc, _Args...>
+    : conditional<
+        is_constructible<_Tp, allocator_arg_t, const _Alloc&, _Args...>::value,
+        __uses_alloc1<_Alloc>,
+        __uses_alloc2<_Alloc>>::type
+    {
+
+
+      static_assert(__or_<
+   is_constructible<_Tp, allocator_arg_t, const _Alloc&, _Args...>,
+   is_constructible<_Tp, _Args..., const _Alloc&>>::value,
+   "construction with an allocator must be possible"
+   " if uses_allocator is true");
+    };
+
+  template<typename _Tp, typename _Alloc, typename... _Args>
+    struct __uses_alloc<false, _Tp, _Alloc, _Args...>
+    : __uses_alloc0 { };
+
+  template<typename _Tp, typename _Alloc, typename... _Args>
+    using __uses_alloc_t =
+      __uses_alloc<uses_allocator<_Tp, _Alloc>::value, _Tp, _Alloc, _Args...>;
+
+  template<typename _Tp, typename _Alloc, typename... _Args>
+   
+    inline __uses_alloc_t<_Tp, _Alloc, _Args...>
+    __use_alloc(const _Alloc& __a)
+    {
+      __uses_alloc_t<_Tp, _Alloc, _Args...> __ret;
+      __ret._M_a = std::__addressof(__a);
+      return __ret;
+    }
+
+  template<typename _Tp, typename _Alloc, typename... _Args>
+    void
+    __use_alloc(const _Alloc&&) = delete;
+
+
+  template <typename _Tp, typename _Alloc>
+    inline constexpr bool uses_allocator_v =
+      uses_allocator<_Tp, _Alloc>::value;
+
+
+  template<template<typename...> class _Predicate,
+    typename _Tp, typename _Alloc, typename... _Args>
+    struct __is_uses_allocator_predicate
+    : conditional<uses_allocator<_Tp, _Alloc>::value,
+      __or_<_Predicate<_Tp, allocator_arg_t, _Alloc, _Args...>,
+     _Predicate<_Tp, _Args..., _Alloc>>,
+      _Predicate<_Tp, _Args...>>::type { };
+
+  template<typename _Tp, typename _Alloc, typename... _Args>
+    struct __is_uses_allocator_constructible
+    : __is_uses_allocator_predicate<is_constructible, _Tp, _Alloc, _Args...>
+    { };
+
+
+  template<typename _Tp, typename _Alloc, typename... _Args>
+    inline constexpr bool __is_uses_allocator_constructible_v =
+      __is_uses_allocator_constructible<_Tp, _Alloc, _Args...>::value;
+
+
+  template<typename _Tp, typename _Alloc, typename... _Args>
+    struct __is_nothrow_uses_allocator_constructible
+    : __is_uses_allocator_predicate<is_nothrow_constructible,
+        _Tp, _Alloc, _Args...>
+    { };
+
+
+
+  template<typename _Tp, typename _Alloc, typename... _Args>
+    inline constexpr bool
+    __is_nothrow_uses_allocator_constructible_v =
+      __is_nothrow_uses_allocator_constructible<_Tp, _Alloc, _Args...>::value;
+
+
+  template<typename _Tp, typename... _Args>
+    void __uses_allocator_construct_impl(__uses_alloc0 __a, _Tp* __ptr,
+      _Args&&... __args)
+    { ::new ((void*)__ptr) _Tp(std::forward<_Args>(__args)...); }
+
+  template<typename _Tp, typename _Alloc, typename... _Args>
+    void __uses_allocator_construct_impl(__uses_alloc1<_Alloc> __a, _Tp* __ptr,
+      _Args&&... __args)
+    {
+      ::new ((void*)__ptr) _Tp(allocator_arg, *__a._M_a,
+          std::forward<_Args>(__args)...);
+    }
+
+  template<typename _Tp, typename _Alloc, typename... _Args>
+    void __uses_allocator_construct_impl(__uses_alloc2<_Alloc> __a, _Tp* __ptr,
+      _Args&&... __args)
+    { ::new ((void*)__ptr) _Tp(std::forward<_Args>(__args)..., *__a._M_a); }
+
+  template<typename _Tp, typename _Alloc, typename... _Args>
+    void __uses_allocator_construct(const _Alloc& __a, _Tp* __ptr,
+        _Args&&... __args)
+    {
+      std::__uses_allocator_construct_impl(
+   std::__use_alloc<_Tp, _Alloc, _Args...>(__a), __ptr,
+   std::forward<_Args>(__args)...);
+    }
+
+
+}
+# 80 "/usr/include/c++/10.2.0/memory" 2 3
+
+
+
+# 1 "/usr/include/c++/10.2.0/bits/unique_ptr.h" 1 3
+# 31 "/usr/include/c++/10.2.0/bits/unique_ptr.h" 3
+#define _UNIQUE_PTR_H 1
+
+
+
+
+# 1 "/usr/include/c++/10.2.0/utility" 1 3
+# 56 "/usr/include/c++/10.2.0/utility" 3
+#define _GLIBCXX_UTILITY 1
+
+       
+# 59 "/usr/include/c++/10.2.0/utility" 3
+# 69 "/usr/include/c++/10.2.0/utility" 3
+# 1 "/usr/include/c++/10.2.0/bits/stl_relops.h" 1 3
+# 65 "/usr/include/c++/10.2.0/bits/stl_relops.h" 3
+#define _STL_RELOPS_H 1
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  namespace rel_ops
+  {
+# 85 "/usr/include/c++/10.2.0/bits/stl_relops.h" 3
+    template <class _Tp>
+      inline bool
+      operator!=(const _Tp& __x, const _Tp& __y)
+      { return !(__x == __y); }
+# 98 "/usr/include/c++/10.2.0/bits/stl_relops.h" 3
+    template <class _Tp>
+      inline bool
+      operator>(const _Tp& __x, const _Tp& __y)
+      { return __y < __x; }
+# 111 "/usr/include/c++/10.2.0/bits/stl_relops.h" 3
+    template <class _Tp>
+      inline bool
+      operator<=(const _Tp& __x, const _Tp& __y)
+      { return !(__y < __x); }
+# 124 "/usr/include/c++/10.2.0/bits/stl_relops.h" 3
+    template <class _Tp>
+      inline bool
+      operator>=(const _Tp& __x, const _Tp& __y)
+      { return !(__x < __y); }
+  }
+
+
+}
+# 70 "/usr/include/c++/10.2.0/utility" 2 3
+# 82 "/usr/include/c++/10.2.0/utility" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+  template<typename _Tp>
+    struct tuple_size;
+
+
+
+
+
+  template<typename _Tp,
+    typename _Up = typename remove_cv<_Tp>::type,
+    typename = typename enable_if<is_same<_Tp, _Up>::value>::type,
+    size_t = tuple_size<_Tp>::value>
+    using __enable_if_has_tuple_size = _Tp;
+
+  template<typename _Tp>
+    struct tuple_size<const __enable_if_has_tuple_size<_Tp>>
+    : public tuple_size<_Tp> { };
+
+  template<typename _Tp>
+    struct tuple_size<volatile __enable_if_has_tuple_size<_Tp>>
+    : public tuple_size<_Tp> { };
+
+  template<typename _Tp>
+    struct tuple_size<const volatile __enable_if_has_tuple_size<_Tp>>
+    : public tuple_size<_Tp> { };
+
+
+  template<std::size_t __i, typename _Tp>
+    struct tuple_element;
+
+
+  template<std::size_t __i, typename _Tp>
+    using __tuple_element_t = typename tuple_element<__i, _Tp>::type;
+
+  template<std::size_t __i, typename _Tp>
+    struct tuple_element<__i, const _Tp>
+    {
+      typedef typename add_const<__tuple_element_t<__i, _Tp>>::type type;
+    };
+
+  template<std::size_t __i, typename _Tp>
+    struct tuple_element<__i, volatile _Tp>
+    {
+      typedef typename add_volatile<__tuple_element_t<__i, _Tp>>::type type;
+    };
+
+  template<std::size_t __i, typename _Tp>
+    struct tuple_element<__i, const volatile _Tp>
+    {
+      typedef typename add_cv<__tuple_element_t<__i, _Tp>>::type type;
+    };
+
+
+
+
+
+#define __cpp_lib_tuple_element_t 201402L
+
+  template<std::size_t __i, typename _Tp>
+    using tuple_element_t = typename tuple_element<__i, _Tp>::type;
+
+
+
+
+
+  template<typename _T1, typename _T2>
+    struct __is_tuple_like_impl<std::pair<_T1, _T2>> : true_type
+    { };
+
+
+  template<class _Tp1, class _Tp2>
+    struct tuple_size<std::pair<_Tp1, _Tp2>>
+    : public integral_constant<std::size_t, 2> { };
+
+
+  template<class _Tp1, class _Tp2>
+    struct tuple_element<0, std::pair<_Tp1, _Tp2>>
+    { typedef _Tp1 type; };
+
+
+  template<class _Tp1, class _Tp2>
+    struct tuple_element<1, std::pair<_Tp1, _Tp2>>
+    { typedef _Tp2 type; };
+
+  template<std::size_t _Int>
+    struct __pair_get;
+
+  template<>
+    struct __pair_get<0>
+    {
+      template<typename _Tp1, typename _Tp2>
+        static constexpr _Tp1&
+        __get(std::pair<_Tp1, _Tp2>& __pair) noexcept
+        { return __pair.first; }
+
+      template<typename _Tp1, typename _Tp2>
+        static constexpr _Tp1&&
+        __move_get(std::pair<_Tp1, _Tp2>&& __pair) noexcept
+        { return std::forward<_Tp1>(__pair.first); }
+
+      template<typename _Tp1, typename _Tp2>
+        static constexpr const _Tp1&
+        __const_get(const std::pair<_Tp1, _Tp2>& __pair) noexcept
+        { return __pair.first; }
+
+      template<typename _Tp1, typename _Tp2>
+        static constexpr const _Tp1&&
+        __const_move_get(const std::pair<_Tp1, _Tp2>&& __pair) noexcept
+        { return std::forward<const _Tp1>(__pair.first); }
+    };
+
+  template<>
+    struct __pair_get<1>
+    {
+      template<typename _Tp1, typename _Tp2>
+        static constexpr _Tp2&
+        __get(std::pair<_Tp1, _Tp2>& __pair) noexcept
+        { return __pair.second; }
+
+      template<typename _Tp1, typename _Tp2>
+        static constexpr _Tp2&&
+        __move_get(std::pair<_Tp1, _Tp2>&& __pair) noexcept
+        { return std::forward<_Tp2>(__pair.second); }
+
+      template<typename _Tp1, typename _Tp2>
+        static constexpr const _Tp2&
+        __const_get(const std::pair<_Tp1, _Tp2>& __pair) noexcept
+        { return __pair.second; }
+
+      template<typename _Tp1, typename _Tp2>
+        static constexpr const _Tp2&&
+        __const_move_get(const std::pair<_Tp1, _Tp2>&& __pair) noexcept
+        { return std::forward<const _Tp2>(__pair.second); }
+    };
+
+  template<std::size_t _Int, class _Tp1, class _Tp2>
+    constexpr typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&
+    get(std::pair<_Tp1, _Tp2>& __in) noexcept
+    { return __pair_get<_Int>::__get(__in); }
+
+  template<std::size_t _Int, class _Tp1, class _Tp2>
+    constexpr typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&&
+    get(std::pair<_Tp1, _Tp2>&& __in) noexcept
+    { return __pair_get<_Int>::__move_get(std::move(__in)); }
+
+  template<std::size_t _Int, class _Tp1, class _Tp2>
+    constexpr const typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&
+    get(const std::pair<_Tp1, _Tp2>& __in) noexcept
+    { return __pair_get<_Int>::__const_get(__in); }
+
+  template<std::size_t _Int, class _Tp1, class _Tp2>
+    constexpr const typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&&
+    get(const std::pair<_Tp1, _Tp2>&& __in) noexcept
+    { return __pair_get<_Int>::__const_move_get(std::move(__in)); }
+
+
+
+#define __cpp_lib_tuples_by_type 201304
+
+  template <typename _Tp, typename _Up>
+    constexpr _Tp&
+    get(pair<_Tp, _Up>& __p) noexcept
+    { return __p.first; }
+
+  template <typename _Tp, typename _Up>
+    constexpr const _Tp&
+    get(const pair<_Tp, _Up>& __p) noexcept
+    { return __p.first; }
+
+  template <typename _Tp, typename _Up>
+    constexpr _Tp&&
+    get(pair<_Tp, _Up>&& __p) noexcept
+    { return std::move(__p.first); }
+
+  template <typename _Tp, typename _Up>
+    constexpr const _Tp&&
+    get(const pair<_Tp, _Up>&& __p) noexcept
+    { return std::move(__p.first); }
+
+  template <typename _Tp, typename _Up>
+    constexpr _Tp&
+    get(pair<_Up, _Tp>& __p) noexcept
+    { return __p.second; }
+
+  template <typename _Tp, typename _Up>
+    constexpr const _Tp&
+    get(const pair<_Up, _Tp>& __p) noexcept
+    { return __p.second; }
+
+  template <typename _Tp, typename _Up>
+    constexpr _Tp&&
+    get(pair<_Up, _Tp>&& __p) noexcept
+    { return std::move(__p.second); }
+
+  template <typename _Tp, typename _Up>
+    constexpr const _Tp&&
+    get(const pair<_Up, _Tp>&& __p) noexcept
+    { return std::move(__p.second); }
+
+#define __cpp_lib_exchange_function 201304
+
+
+  template <typename _Tp, typename _Up = _Tp>
+   
+    inline _Tp
+    exchange(_Tp& __obj, _Up&& __new_val)
+    { return std::__exchange(__obj, std::forward<_Up>(__new_val)); }
+
+
+
+
+
+  template<size_t... _Indexes> struct _Index_tuple { };
+# 307 "/usr/include/c++/10.2.0/utility" 3
+  template<size_t _Num>
+    struct _Build_index_tuple
+    {
+
+
+
+
+
+
+      using __type = _Index_tuple<__integer_pack(_Num)...>;
+
+    };
+
+
+
+#define __cpp_lib_integer_sequence 201304
+
+
+  template<typename _Tp, _Tp... _Idx>
+    struct integer_sequence
+    {
+      typedef _Tp value_type;
+      static constexpr size_t size() noexcept { return sizeof...(_Idx); }
+    };
+
+
+  template<typename _Tp, _Tp _Num>
+    using make_integer_sequence
+
+
+
+      = integer_sequence<_Tp, __integer_pack(_Num)...>;
+
+
+#undef _GLIBCXX_USE_MAKE_INTEGER_SEQ
+
+
+  template<size_t... _Idx>
+    using index_sequence = integer_sequence<size_t, _Idx...>;
+
+
+  template<size_t _Num>
+    using make_index_sequence = make_integer_sequence<size_t, _Num>;
+
+
+  template<typename... _Types>
+    using index_sequence_for = make_index_sequence<sizeof...(_Types)>;
+
+
+
+
+  struct in_place_t {
+    explicit in_place_t() = default;
+  };
+
+  inline constexpr in_place_t in_place{};
+
+  template<typename _Tp> struct in_place_type_t
+  {
+    explicit in_place_type_t() = default;
+  };
+
+  template<typename _Tp>
+    inline constexpr in_place_type_t<_Tp> in_place_type{};
+
+  template<size_t _Idx> struct in_place_index_t
+  {
+    explicit in_place_index_t() = default;
+  };
+
+  template<size_t _Idx>
+    inline constexpr in_place_index_t<_Idx> in_place_index{};
+
+  template<typename>
+    struct __is_in_place_type_impl : false_type
+    { };
+
+  template<typename _Tp>
+    struct __is_in_place_type_impl<in_place_type_t<_Tp>> : true_type
+    { };
+
+  template<typename _Tp>
+    struct __is_in_place_type
+      : public __is_in_place_type_impl<_Tp>
+    { };
+
+#define __cpp_lib_as_const 201510
+  template<typename _Tp>
+    constexpr add_const_t<_Tp>& as_const(_Tp& __t) noexcept { return __t; }
+
+  template<typename _Tp>
+    void as_const(const _Tp&&) = delete;
+# 473 "/usr/include/c++/10.2.0/utility" 3
+
+}
+# 37 "/usr/include/c++/10.2.0/bits/unique_ptr.h" 2 3
+# 1 "/usr/include/c++/10.2.0/tuple" 1 3
+# 30 "/usr/include/c++/10.2.0/tuple" 3
+#define _GLIBCXX_TUPLE 1
+
+       
+# 33 "/usr/include/c++/10.2.0/tuple" 3
+
+
+
+
+
+
+# 1 "/usr/include/c++/10.2.0/array" 1 3
+# 30 "/usr/include/c++/10.2.0/array" 3
+#define _GLIBCXX_ARRAY 1
+
+       
+# 33 "/usr/include/c++/10.2.0/array" 3
+# 43 "/usr/include/c++/10.2.0/array" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  template<typename _Tp, std::size_t _Nm>
+    struct __array_traits
+    {
+      typedef _Tp _Type[_Nm];
+      typedef __is_swappable<_Tp> _Is_swappable;
+      typedef __is_nothrow_swappable<_Tp> _Is_nothrow_swappable;
+
+      static constexpr _Tp&
+      _S_ref(const _Type& __t, std::size_t __n) noexcept
+      { return const_cast<_Tp&>(__t[__n]); }
+
+      static constexpr _Tp*
+      _S_ptr(const _Type& __t) noexcept
+      { return const_cast<_Tp*>(__t); }
+    };
+
+ template<typename _Tp>
+   struct __array_traits<_Tp, 0>
+   {
+     struct _Type { };
+     typedef true_type _Is_swappable;
+     typedef true_type _Is_nothrow_swappable;
+
+     static constexpr _Tp&
+     _S_ref(const _Type&, std::size_t) noexcept
+     { return *static_cast<_Tp*>(nullptr); }
+
+     static constexpr _Tp*
+     _S_ptr(const _Type&) noexcept
+     { return nullptr; }
+   };
+# 93 "/usr/include/c++/10.2.0/array" 3
+  template<typename _Tp, std::size_t _Nm>
+    struct array
+    {
+      typedef _Tp value_type;
+      typedef value_type* pointer;
+      typedef const value_type* const_pointer;
+      typedef value_type& reference;
+      typedef const value_type& const_reference;
+      typedef value_type* iterator;
+      typedef const value_type* const_iterator;
+      typedef std::size_t size_type;
+      typedef std::ptrdiff_t difference_type;
+      typedef std::reverse_iterator<iterator> reverse_iterator;
+      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+
+
+      typedef std::__array_traits<_Tp, _Nm> _AT_Type;
+      typename _AT_Type::_Type _M_elems;
+
+
+
+
+      void
+      fill(const value_type& __u)
+      { std::fill_n(begin(), size(), __u); }
+
+      void
+      swap(array& __other)
+      noexcept(_AT_Type::_Is_nothrow_swappable::value)
+      { std::swap_ranges(begin(), end(), __other.begin()); }
+
+
+      constexpr iterator
+      begin() noexcept
+      { return iterator(data()); }
+
+      constexpr const_iterator
+      begin() const noexcept
+      { return const_iterator(data()); }
+
+      constexpr iterator
+      end() noexcept
+      { return iterator(data() + _Nm); }
+
+      constexpr const_iterator
+      end() const noexcept
+      { return const_iterator(data() + _Nm); }
+
+      constexpr reverse_iterator
+      rbegin() noexcept
+      { return reverse_iterator(end()); }
+
+      constexpr const_reverse_iterator
+      rbegin() const noexcept
+      { return const_reverse_iterator(end()); }
+
+      constexpr reverse_iterator
+      rend() noexcept
+      { return reverse_iterator(begin()); }
+
+      constexpr const_reverse_iterator
+      rend() const noexcept
+      { return const_reverse_iterator(begin()); }
+
+      constexpr const_iterator
+      cbegin() const noexcept
+      { return const_iterator(data()); }
+
+      constexpr const_iterator
+      cend() const noexcept
+      { return const_iterator(data() + _Nm); }
+
+      constexpr const_reverse_iterator
+      crbegin() const noexcept
+      { return const_reverse_iterator(end()); }
+
+      constexpr const_reverse_iterator
+      crend() const noexcept
+      { return const_reverse_iterator(begin()); }
+
+
+      constexpr size_type
+      size() const noexcept { return _Nm; }
+
+      constexpr size_type
+      max_size() const noexcept { return _Nm; }
+
+      [[__nodiscard__]] constexpr bool
+      empty() const noexcept { return size() == 0; }
+
+
+      constexpr reference
+      operator[](size_type __n) noexcept
+      { return _AT_Type::_S_ref(_M_elems, __n); }
+
+      constexpr const_reference
+      operator[](size_type __n) const noexcept
+      { return _AT_Type::_S_ref(_M_elems, __n); }
+
+      constexpr reference
+      at(size_type __n)
+      {
+ if (__n >= _Nm)
+   std::__throw_out_of_range_fmt(("array::at: __n (which is %zu) " ">= _Nm (which is %zu)")
+                                 ,
+     __n, _Nm);
+ return _AT_Type::_S_ref(_M_elems, __n);
+      }
+
+      constexpr const_reference
+      at(size_type __n) const
+      {
+
+
+ return __n < _Nm ? _AT_Type::_S_ref(_M_elems, __n)
+   : (std::__throw_out_of_range_fmt(("array::at: __n (which is %zu) " ">= _Nm (which is %zu)")
+                                    ,
+        __n, _Nm),
+      _AT_Type::_S_ref(_M_elems, 0));
+      }
+
+      constexpr reference
+      front() noexcept
+      { return *begin(); }
+
+      constexpr const_reference
+      front() const noexcept
+      { return _AT_Type::_S_ref(_M_elems, 0); }
+
+      constexpr reference
+      back() noexcept
+      { return _Nm ? *(end() - 1) : *end(); }
+
+      constexpr const_reference
+      back() const noexcept
+      {
+ return _Nm ? _AT_Type::_S_ref(_M_elems, _Nm - 1)
+             : _AT_Type::_S_ref(_M_elems, 0);
+      }
+
+      constexpr pointer
+      data() noexcept
+      { return _AT_Type::_S_ptr(_M_elems); }
+
+      constexpr const_pointer
+      data() const noexcept
+      { return _AT_Type::_S_ptr(_M_elems); }
+    };
+
+
+  template<typename _Tp, typename... _Up>
+    array(_Tp, _Up...)
+      -> array<enable_if_t<(is_same_v<_Tp, _Up> && ...), _Tp>,
+        1 + sizeof...(_Up)>;
+
+
+
+  template<typename _Tp, std::size_t _Nm>
+   
+    inline bool
+    operator==(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
+    { return std::equal(__one.begin(), __one.end(), __two.begin()); }
+# 275 "/usr/include/c++/10.2.0/array" 3
+  template<typename _Tp, std::size_t _Nm>
+   
+    inline bool
+    operator!=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
+    { return !(__one == __two); }
+
+  template<typename _Tp, std::size_t _Nm>
+   
+    inline bool
+    operator<(const array<_Tp, _Nm>& __a, const array<_Tp, _Nm>& __b)
+    {
+      return std::lexicographical_compare(__a.begin(), __a.end(),
+       __b.begin(), __b.end());
+    }
+
+  template<typename _Tp, std::size_t _Nm>
+   
+    inline bool
+    operator>(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
+    { return __two < __one; }
+
+  template<typename _Tp, std::size_t _Nm>
+   
+    inline bool
+    operator<=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
+    { return !(__one > __two); }
+
+  template<typename _Tp, std::size_t _Nm>
+   
+    inline bool
+    operator>=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
+    { return !(__one < __two); }
+
+
+
+  template<typename _Tp, std::size_t _Nm>
+   
+    inline
+
+
+    typename enable_if<
+      std::__array_traits<_Tp, _Nm>::_Is_swappable::value
+    >::type
+
+
+
+    swap(array<_Tp, _Nm>& __one, array<_Tp, _Nm>& __two)
+    noexcept(noexcept(__one.swap(__two)))
+    { __one.swap(__two); }
+
+
+  template<typename _Tp, std::size_t _Nm>
+    typename enable_if<
+      !std::__array_traits<_Tp, _Nm>::_Is_swappable::value>::type
+    swap(array<_Tp, _Nm>&, array<_Tp, _Nm>&) = delete;
+
+
+  template<std::size_t _Int, typename _Tp, std::size_t _Nm>
+    constexpr _Tp&
+    get(array<_Tp, _Nm>& __arr) noexcept
+    {
+      static_assert(_Int < _Nm, "array index is within bounds");
+      return std::__array_traits<_Tp, _Nm>::
+ _S_ref(__arr._M_elems, _Int);
+    }
+
+  template<std::size_t _Int, typename _Tp, std::size_t _Nm>
+    constexpr _Tp&&
+    get(array<_Tp, _Nm>&& __arr) noexcept
+    {
+      static_assert(_Int < _Nm, "array index is within bounds");
+      return std::move(std::get<_Int>(__arr));
+    }
+
+  template<std::size_t _Int, typename _Tp, std::size_t _Nm>
+    constexpr const _Tp&
+    get(const array<_Tp, _Nm>& __arr) noexcept
+    {
+      static_assert(_Int < _Nm, "array index is within bounds");
+      return std::__array_traits<_Tp, _Nm>::
+ _S_ref(__arr._M_elems, _Int);
+    }
+
+  template<std::size_t _Int, typename _Tp, std::size_t _Nm>
+    constexpr const _Tp&&
+    get(const array<_Tp, _Nm>&& __arr) noexcept
+    {
+      static_assert(_Int < _Nm, "array index is within bounds");
+      return std::move(std::get<_Int>(__arr));
+    }
+# 404 "/usr/include/c++/10.2.0/array" 3
+
+}
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+  template<typename _Tp>
+    struct tuple_size;
+
+
+  template<typename _Tp, std::size_t _Nm>
+    struct tuple_size<std::array<_Tp, _Nm>>
+    : public integral_constant<std::size_t, _Nm> { };
+
+
+  template<std::size_t _Int, typename _Tp>
+    struct tuple_element;
+
+
+  template<std::size_t _Int, typename _Tp, std::size_t _Nm>
+    struct tuple_element<_Int, std::array<_Tp, _Nm>>
+    {
+      static_assert(_Int < _Nm, "index is out of bounds");
+      typedef _Tp type;
+    };
+
+  template<typename _Tp, std::size_t _Nm>
+    struct __is_tuple_like_impl<std::array<_Tp, _Nm>> : true_type
+    { };
+
+
+}
+# 40 "/usr/include/c++/10.2.0/tuple" 2 3
+
+# 1 "/usr/include/c++/10.2.0/bits/invoke.h" 1 3
+# 31 "/usr/include/c++/10.2.0/bits/invoke.h" 3
+#define _GLIBCXX_INVOKE_H 1
+
+       
+# 34 "/usr/include/c++/10.2.0/bits/invoke.h" 3
+
+
+
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 52 "/usr/include/c++/10.2.0/bits/invoke.h" 3
+  template<typename _Tp, typename _Up = typename __inv_unwrap<_Tp>::type>
+    constexpr _Up&&
+    __invfwd(typename remove_reference<_Tp>::type& __t) noexcept
+    { return static_cast<_Up&&>(__t); }
+
+  template<typename _Res, typename _Fn, typename... _Args>
+    constexpr _Res
+    __invoke_impl(__invoke_other, _Fn&& __f, _Args&&... __args)
+    { return std::forward<_Fn>(__f)(std::forward<_Args>(__args)...); }
+
+  template<typename _Res, typename _MemFun, typename _Tp, typename... _Args>
+    constexpr _Res
+    __invoke_impl(__invoke_memfun_ref, _MemFun&& __f, _Tp&& __t,
+    _Args&&... __args)
+    { return (__invfwd<_Tp>(__t).*__f)(std::forward<_Args>(__args)...); }
+
+  template<typename _Res, typename _MemFun, typename _Tp, typename... _Args>
+    constexpr _Res
+    __invoke_impl(__invoke_memfun_deref, _MemFun&& __f, _Tp&& __t,
+    _Args&&... __args)
+    {
+      return ((*std::forward<_Tp>(__t)).*__f)(std::forward<_Args>(__args)...);
+    }
+
+  template<typename _Res, typename _MemPtr, typename _Tp>
+    constexpr _Res
+    __invoke_impl(__invoke_memobj_ref, _MemPtr&& __f, _Tp&& __t)
+    { return __invfwd<_Tp>(__t).*__f; }
+
+  template<typename _Res, typename _MemPtr, typename _Tp>
+    constexpr _Res
+    __invoke_impl(__invoke_memobj_deref, _MemPtr&& __f, _Tp&& __t)
+    { return (*std::forward<_Tp>(__t)).*__f; }
+
+
+  template<typename _Callable, typename... _Args>
+    constexpr typename __invoke_result<_Callable, _Args...>::type
+    __invoke(_Callable&& __fn, _Args&&... __args)
+    noexcept(__is_nothrow_invocable<_Callable, _Args...>::value)
+    {
+      using __result = __invoke_result<_Callable, _Args...>;
+      using __type = typename __result::type;
+      using __tag = typename __result::__invoke_type;
+      return std::__invoke_impl<__type>(__tag{}, std::forward<_Callable>(__fn),
+     std::forward<_Args>(__args)...);
+    }
+
+
+
+  template<typename _Res, typename _Callable, typename... _Args>
+    constexpr enable_if_t<is_invocable_r_v<_Res, _Callable, _Args...>, _Res>
+    __invoke_r(_Callable&& __fn, _Args&&... __args)
+    noexcept(is_nothrow_invocable_r_v<_Res, _Callable, _Args...>)
+    {
+      using __result = __invoke_result<_Callable, _Args...>;
+      using __type = typename __result::type;
+      using __tag = typename __result::__invoke_type;
+      if constexpr (is_void_v<_Res>)
+ std::__invoke_impl<__type>(__tag{}, std::forward<_Callable>(__fn),
+     std::forward<_Args>(__args)...);
+      else
+ return std::__invoke_impl<__type>(__tag{},
+       std::forward<_Callable>(__fn),
+       std::forward<_Args>(__args)...);
+    }
+# 158 "/usr/include/c++/10.2.0/bits/invoke.h" 3
+
+}
+# 42 "/usr/include/c++/10.2.0/tuple" 2 3
+
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+
+
+  template<typename... _Elements>
+    class tuple;
+
+  template<typename _Tp>
+    struct __is_empty_non_tuple : is_empty<_Tp> { };
+
+
+  template<typename _El0, typename... _El>
+    struct __is_empty_non_tuple<tuple<_El0, _El...>> : false_type { };
+
+
+  template<typename _Tp>
+    using __empty_not_final
+    = typename conditional<__is_final(_Tp), false_type,
+      __is_empty_non_tuple<_Tp>>::type;
+
+  template<std::size_t _Idx, typename _Head,
+    bool = __empty_not_final<_Head>::value>
+    struct _Head_base;
+
+  template<std::size_t _Idx, typename _Head>
+    struct _Head_base<_Idx, _Head, true>
+    : public _Head
+    {
+      constexpr _Head_base()
+      : _Head() { }
+
+      constexpr _Head_base(const _Head& __h)
+      : _Head(__h) { }
+
+      constexpr _Head_base(const _Head_base&) = default;
+      constexpr _Head_base(_Head_base&&) = default;
+
+      template<typename _UHead>
+        constexpr _Head_base(_UHead&& __h)
+ : _Head(std::forward<_UHead>(__h)) { }
+
+      _Head_base(allocator_arg_t, __uses_alloc0)
+      : _Head() { }
+
+      template<typename _Alloc>
+ _Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a)
+ : _Head(allocator_arg, *__a._M_a) { }
+
+      template<typename _Alloc>
+ _Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a)
+ : _Head(*__a._M_a) { }
+
+      template<typename _UHead>
+ _Head_base(__uses_alloc0, _UHead&& __uhead)
+ : _Head(std::forward<_UHead>(__uhead)) { }
+
+      template<typename _Alloc, typename _UHead>
+ _Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead)
+ : _Head(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead)) { }
+
+      template<typename _Alloc, typename _UHead>
+ _Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead)
+ : _Head(std::forward<_UHead>(__uhead), *__a._M_a) { }
+
+      static constexpr _Head&
+      _M_head(_Head_base& __b) noexcept { return __b; }
+
+      static constexpr const _Head&
+      _M_head(const _Head_base& __b) noexcept { return __b; }
+    };
+
+  template<std::size_t _Idx, typename _Head>
+    struct _Head_base<_Idx, _Head, false>
+    {
+      constexpr _Head_base()
+      : _M_head_impl() { }
+
+      constexpr _Head_base(const _Head& __h)
+      : _M_head_impl(__h) { }
+
+      constexpr _Head_base(const _Head_base&) = default;
+      constexpr _Head_base(_Head_base&&) = default;
+
+      template<typename _UHead>
+        constexpr _Head_base(_UHead&& __h)
+ : _M_head_impl(std::forward<_UHead>(__h)) { }
+
+     
+      _Head_base(allocator_arg_t, __uses_alloc0)
+      : _M_head_impl() { }
+
+      template<typename _Alloc>
+ _Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a)
+ : _M_head_impl(allocator_arg, *__a._M_a) { }
+
+      template<typename _Alloc>
+ _Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a)
+ : _M_head_impl(*__a._M_a) { }
+
+      template<typename _UHead>
+
+ _Head_base(__uses_alloc0, _UHead&& __uhead)
+ : _M_head_impl(std::forward<_UHead>(__uhead)) { }
+
+      template<typename _Alloc, typename _UHead>
+ _Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead)
+ : _M_head_impl(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead))
+ { }
+
+      template<typename _Alloc, typename _UHead>
+ _Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead)
+ : _M_head_impl(std::forward<_UHead>(__uhead), *__a._M_a) { }
+
+      static constexpr _Head&
+      _M_head(_Head_base& __b) noexcept { return __b._M_head_impl; }
+
+      static constexpr const _Head&
+      _M_head(const _Head_base& __b) noexcept { return __b._M_head_impl; }
+
+      _Head _M_head_impl;
+    };
+# 182 "/usr/include/c++/10.2.0/tuple" 3
+  template<std::size_t _Idx, typename... _Elements>
+    struct _Tuple_impl;
+
+
+
+
+
+
+  template<std::size_t _Idx, typename _Head, typename... _Tail>
+    struct _Tuple_impl<_Idx, _Head, _Tail...>
+    : public _Tuple_impl<_Idx + 1, _Tail...>,
+      private _Head_base<_Idx, _Head>
+    {
+      template<std::size_t, typename...> friend class _Tuple_impl;
+
+      typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited;
+      typedef _Head_base<_Idx, _Head> _Base;
+
+      static constexpr _Head&
+      _M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }
+
+      static constexpr const _Head&
+      _M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }
+
+      static constexpr _Inherited&
+      _M_tail(_Tuple_impl& __t) noexcept { return __t; }
+
+      static constexpr const _Inherited&
+      _M_tail(const _Tuple_impl& __t) noexcept { return __t; }
+
+      constexpr _Tuple_impl()
+      : _Inherited(), _Base() { }
+
+      explicit
+      constexpr _Tuple_impl(const _Head& __head, const _Tail&... __tail)
+      : _Inherited(__tail...), _Base(__head) { }
+
+      template<typename _UHead, typename... _UTail, typename = typename
+               enable_if<sizeof...(_Tail) == sizeof...(_UTail)>::type>
+        explicit
+        constexpr _Tuple_impl(_UHead&& __head, _UTail&&... __tail)
+ : _Inherited(std::forward<_UTail>(__tail)...),
+   _Base(std::forward<_UHead>(__head)) { }
+
+      constexpr _Tuple_impl(const _Tuple_impl&) = default;
+
+
+
+      _Tuple_impl& operator=(const _Tuple_impl&) = delete;
+
+      constexpr
+      _Tuple_impl(_Tuple_impl&& __in)
+      noexcept(__and_<is_nothrow_move_constructible<_Head>,
+               is_nothrow_move_constructible<_Inherited>>::value)
+      : _Inherited(std::move(_M_tail(__in))),
+ _Base(std::forward<_Head>(_M_head(__in))) { }
+
+      template<typename... _UElements>
+        constexpr _Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in)
+ : _Inherited(_Tuple_impl<_Idx, _UElements...>::_M_tail(__in)),
+   _Base(_Tuple_impl<_Idx, _UElements...>::_M_head(__in)) { }
+
+      template<typename _UHead, typename... _UTails>
+        constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
+ : _Inherited(std::move
+       (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),
+   _Base(std::forward<_UHead>
+  (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) { }
+
+      template<typename _Alloc>
+
+ _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a)
+ : _Inherited(__tag, __a),
+          _Base(__tag, __use_alloc<_Head>(__a)) { }
+
+      template<typename _Alloc>
+ _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
+      const _Head& __head, const _Tail&... __tail)
+ : _Inherited(__tag, __a, __tail...),
+          _Base(__use_alloc<_Head, _Alloc, _Head>(__a), __head) { }
+
+      template<typename _Alloc, typename _UHead, typename... _UTail,
+               typename = typename enable_if<sizeof...(_Tail)
+          == sizeof...(_UTail)>::type>
+
+ _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
+             _UHead&& __head, _UTail&&... __tail)
+ : _Inherited(__tag, __a, std::forward<_UTail>(__tail)...),
+          _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
+         std::forward<_UHead>(__head)) { }
+
+      template<typename _Alloc>
+
+        _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
+             const _Tuple_impl& __in)
+ : _Inherited(__tag, __a, _M_tail(__in)),
+          _Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(__in)) { }
+
+      template<typename _Alloc>
+
+ _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
+             _Tuple_impl&& __in)
+ : _Inherited(__tag, __a, std::move(_M_tail(__in))),
+   _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
+         std::forward<_Head>(_M_head(__in))) { }
+
+      template<typename _Alloc, typename... _UElements>
+
+ _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
+             const _Tuple_impl<_Idx, _UElements...>& __in)
+ : _Inherited(__tag, __a,
+       _Tuple_impl<_Idx, _UElements...>::_M_tail(__in)),
+   _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
+  _Tuple_impl<_Idx, _UElements...>::_M_head(__in)) { }
+
+      template<typename _Alloc, typename _UHead, typename... _UTails>
+
+ _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
+             _Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
+ : _Inherited(__tag, __a, std::move
+       (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),
+   _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
+                std::forward<_UHead>
+  (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) { }
+
+      template<typename... _UElements>
+
+        void
+        _M_assign(const _Tuple_impl<_Idx, _UElements...>& __in)
+        {
+   _M_head(*this) = _Tuple_impl<_Idx, _UElements...>::_M_head(__in);
+   _M_tail(*this)._M_assign(
+       _Tuple_impl<_Idx, _UElements...>::_M_tail(__in));
+ }
+
+      template<typename _UHead, typename... _UTails>
+
+        void
+        _M_assign(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
+        {
+   _M_head(*this) = std::forward<_UHead>
+     (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in));
+   _M_tail(*this)._M_assign(
+       std::move(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in)));
+ }
+
+    protected:
+     
+      void
+      _M_swap(_Tuple_impl& __in)
+      {
+ using std::swap;
+ swap(_M_head(*this), _M_head(__in));
+ _Inherited::_M_swap(_M_tail(__in));
+      }
+    };
+
+
+  template<std::size_t _Idx, typename _Head>
+    struct _Tuple_impl<_Idx, _Head>
+    : private _Head_base<_Idx, _Head>
+    {
+      template<std::size_t, typename...> friend class _Tuple_impl;
+
+      typedef _Head_base<_Idx, _Head> _Base;
+
+      static constexpr _Head&
+      _M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }
+
+      static constexpr const _Head&
+      _M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }
+
+      constexpr _Tuple_impl()
+      : _Base() { }
+
+      explicit
+      constexpr _Tuple_impl(const _Head& __head)
+      : _Base(__head) { }
+
+      template<typename _UHead>
+        explicit
+        constexpr _Tuple_impl(_UHead&& __head)
+ : _Base(std::forward<_UHead>(__head)) { }
+
+      constexpr _Tuple_impl(const _Tuple_impl&) = default;
+
+
+
+      _Tuple_impl& operator=(const _Tuple_impl&) = delete;
+
+      constexpr
+      _Tuple_impl(_Tuple_impl&& __in)
+      noexcept(is_nothrow_move_constructible<_Head>::value)
+      : _Base(std::forward<_Head>(_M_head(__in))) { }
+
+      template<typename _UHead>
+        constexpr _Tuple_impl(const _Tuple_impl<_Idx, _UHead>& __in)
+ : _Base(_Tuple_impl<_Idx, _UHead>::_M_head(__in)) { }
+
+      template<typename _UHead>
+        constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead>&& __in)
+ : _Base(std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)))
+ { }
+
+      template<typename _Alloc>
+
+ _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a)
+ : _Base(__tag, __use_alloc<_Head>(__a)) { }
+
+      template<typename _Alloc>
+ _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
+      const _Head& __head)
+ : _Base(__use_alloc<_Head, _Alloc, _Head>(__a), __head) { }
+
+      template<typename _Alloc, typename _UHead>
+
+ _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
+             _UHead&& __head)
+ : _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
+         std::forward<_UHead>(__head)) { }
+
+      template<typename _Alloc>
+
+        _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
+             const _Tuple_impl& __in)
+ : _Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(__in)) { }
+
+      template<typename _Alloc>
+
+ _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
+             _Tuple_impl&& __in)
+ : _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
+         std::forward<_Head>(_M_head(__in))) { }
+
+      template<typename _Alloc, typename _UHead>
+
+ _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
+             const _Tuple_impl<_Idx, _UHead>& __in)
+ : _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
+  _Tuple_impl<_Idx, _UHead>::_M_head(__in)) { }
+
+      template<typename _Alloc, typename _UHead>
+
+ _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
+             _Tuple_impl<_Idx, _UHead>&& __in)
+ : _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
+                std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)))
+ { }
+
+      template<typename _UHead>
+
+        void
+        _M_assign(const _Tuple_impl<_Idx, _UHead>& __in)
+        {
+   _M_head(*this) = _Tuple_impl<_Idx, _UHead>::_M_head(__in);
+ }
+
+      template<typename _UHead>
+
+        void
+        _M_assign(_Tuple_impl<_Idx, _UHead>&& __in)
+        {
+   _M_head(*this)
+     = std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in));
+ }
+
+    protected:
+     
+      void
+      _M_swap(_Tuple_impl& __in)
+      {
+ using std::swap;
+ swap(_M_head(*this), _M_head(__in));
+      }
+    };
+
+
+
+  template<bool, typename... _Types>
+    struct _TupleConstraints
+    {
+
+
+
+      template<typename... _UTypes>
+ static constexpr bool __is_implicitly_constructible()
+ {
+   return __and_<is_constructible<_Types, _UTypes>...,
+   is_convertible<_UTypes, _Types>...
+   >::value;
+ }
+
+
+
+
+      template<typename... _UTypes>
+ static constexpr bool __is_explicitly_constructible()
+ {
+   return __and_<is_constructible<_Types, _UTypes>...,
+   __not_<__and_<is_convertible<_UTypes, _Types>...>>
+   >::value;
+ }
+
+      static constexpr bool __is_implicitly_default_constructible()
+      {
+ return __and_<std::__is_implicitly_default_constructible<_Types>...
+        >::value;
+      }
+
+      static constexpr bool __is_explicitly_default_constructible()
+      {
+ return __and_<is_default_constructible<_Types>...,
+        __not_<__and_<
+   std::__is_implicitly_default_constructible<_Types>...>
+        >>::value;
+      }
+    };
+
+
+
+  template<typename... _Types>
+    struct _TupleConstraints<false, _Types...>
+    {
+      template<typename... _UTypes>
+ static constexpr bool __is_implicitly_constructible()
+ { return false; }
+
+      template<typename... _UTypes>
+ static constexpr bool __is_explicitly_constructible()
+ { return false; }
+    };
+
+
+  template<typename... _Elements>
+    class tuple : public _Tuple_impl<0, _Elements...>
+    {
+      typedef _Tuple_impl<0, _Elements...> _Inherited;
+
+      template<bool _Cond>
+ using _TCC = _TupleConstraints<_Cond, _Elements...>;
+
+
+      template<bool _Dummy>
+ using _ImplicitDefaultCtor = __enable_if_t<
+   _TCC<_Dummy>::__is_implicitly_default_constructible(),
+   bool>;
+
+
+      template<bool _Dummy>
+ using _ExplicitDefaultCtor = __enable_if_t<
+   _TCC<_Dummy>::__is_explicitly_default_constructible(),
+   bool>;
+
+
+      template<bool _Cond, typename... _Args>
+ using _ImplicitCtor = __enable_if_t<
+   _TCC<_Cond>::template __is_implicitly_constructible<_Args...>(),
+   bool>;
+
+
+      template<bool _Cond, typename... _Args>
+ using _ExplicitCtor = __enable_if_t<
+   _TCC<_Cond>::template __is_explicitly_constructible<_Args...>(),
+   bool>;
+
+      template<typename... _UElements>
+ static constexpr
+ __enable_if_t<sizeof...(_UElements) == sizeof...(_Elements), bool>
+ __assignable()
+ { return __and_<is_assignable<_Elements&, _UElements>...>::value; }
+
+
+      template<typename... _UElements>
+ static constexpr bool __nothrow_assignable()
+ {
+   return
+     __and_<is_nothrow_assignable<_Elements&, _UElements>...>::value;
+ }
+
+
+      template<typename... _UElements>
+ static constexpr bool __nothrow_constructible()
+ {
+   return
+     __and_<is_nothrow_constructible<_Elements, _UElements>...>::value;
+ }
+
+
+      template<typename _Up>
+ static constexpr bool __valid_args()
+ {
+   return sizeof...(_Elements) == 1
+     && !is_same<tuple, __remove_cvref_t<_Up>>::value;
+ }
+
+
+      template<typename, typename, typename... _Tail>
+ static constexpr bool __valid_args()
+ { return (sizeof...(_Tail) + 2) == sizeof...(_Elements); }
+# 591 "/usr/include/c++/10.2.0/tuple" 3
+      template<typename _Tuple, typename = tuple,
+        typename = __remove_cvref_t<_Tuple>>
+ struct _UseOtherCtor
+ : false_type
+ { };
+
+
+      template<typename _Tuple, typename _Tp, typename _Up>
+ struct _UseOtherCtor<_Tuple, tuple<_Tp>, tuple<_Up>>
+ : __or_<is_convertible<_Tuple, _Tp>, is_constructible<_Tp, _Tuple>>
+ { };
+
+
+      template<typename _Tuple, typename _Tp>
+ struct _UseOtherCtor<_Tuple, tuple<_Tp>, tuple<_Tp>>
+ : true_type
+ { };
+
+
+
+
+      template<typename _Tuple>
+ static constexpr bool __use_other_ctor()
+ { return _UseOtherCtor<_Tuple>::value; }
+
+    public:
+      template<typename _Dummy = void,
+        _ImplicitDefaultCtor<is_void<_Dummy>::value> = true>
+ constexpr
+ tuple()
+ noexcept(__and_<is_nothrow_default_constructible<_Elements>...>::value)
+ : _Inherited() { }
+
+      template<typename _Dummy = void,
+        _ExplicitDefaultCtor<is_void<_Dummy>::value> = false>
+ explicit constexpr
+ tuple()
+ noexcept(__and_<is_nothrow_default_constructible<_Elements>...>::value)
+ : _Inherited() { }
+
+      template<bool _NotEmpty = (sizeof...(_Elements) >= 1),
+        _ImplicitCtor<_NotEmpty, const _Elements&...> = true>
+ constexpr
+ tuple(const _Elements&... __elements)
+ noexcept(__nothrow_constructible<const _Elements&...>())
+ : _Inherited(__elements...) { }
+
+      template<bool _NotEmpty = (sizeof...(_Elements) >= 1),
+        _ExplicitCtor<_NotEmpty, const _Elements&...> = false>
+ explicit constexpr
+ tuple(const _Elements&... __elements)
+ noexcept(__nothrow_constructible<const _Elements&...>())
+ : _Inherited(__elements...) { }
+
+      template<typename... _UElements,
+        bool _Valid = __valid_args<_UElements...>(),
+        _ImplicitCtor<_Valid, _UElements...> = true>
+ constexpr
+ tuple(_UElements&&... __elements)
+ noexcept(__nothrow_constructible<_UElements...>())
+ : _Inherited(std::forward<_UElements>(__elements)...) { }
+
+      template<typename... _UElements,
+        bool _Valid = __valid_args<_UElements...>(),
+        _ExplicitCtor<_Valid, _UElements...> = false>
+ explicit constexpr
+ tuple(_UElements&&... __elements)
+ noexcept(__nothrow_constructible<_UElements...>())
+ : _Inherited(std::forward<_UElements>(__elements)...) { }
+
+      constexpr tuple(const tuple&) = default;
+
+      constexpr tuple(tuple&&) = default;
+
+      template<typename... _UElements,
+        bool _Valid = (sizeof...(_Elements) == sizeof...(_UElements))
+      && !__use_other_ctor<const tuple<_UElements...>&>(),
+        _ImplicitCtor<_Valid, const _UElements&...> = true>
+ constexpr
+ tuple(const tuple<_UElements...>& __in)
+ noexcept(__nothrow_constructible<const _UElements&...>())
+ : _Inherited(static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
+ { }
+
+      template<typename... _UElements,
+        bool _Valid = (sizeof...(_Elements) == sizeof...(_UElements))
+      && !__use_other_ctor<const tuple<_UElements...>&>(),
+        _ExplicitCtor<_Valid, const _UElements&...> = false>
+ explicit constexpr
+ tuple(const tuple<_UElements...>& __in)
+ noexcept(__nothrow_constructible<const _UElements&...>())
+ : _Inherited(static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
+ { }
+
+      template<typename... _UElements,
+        bool _Valid = (sizeof...(_Elements) == sizeof...(_UElements))
+        && !__use_other_ctor<tuple<_UElements...>&&>(),
+        _ImplicitCtor<_Valid, _UElements...> = true>
+ constexpr
+ tuple(tuple<_UElements...>&& __in)
+ noexcept(__nothrow_constructible<_UElements...>())
+ : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { }
+
+      template<typename... _UElements,
+        bool _Valid = (sizeof...(_Elements) == sizeof...(_UElements))
+        && !__use_other_ctor<tuple<_UElements...>&&>(),
+        _ExplicitCtor<_Valid, _UElements...> = false>
+ explicit constexpr
+ tuple(tuple<_UElements...>&& __in)
+ noexcept(__nothrow_constructible<_UElements...>())
+ : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { }
+
+
+
+      template<typename _Alloc,
+        _ImplicitDefaultCtor<is_object<_Alloc>::value> = true>
+
+ tuple(allocator_arg_t __tag, const _Alloc& __a)
+ : _Inherited(__tag, __a) { }
+
+      template<typename _Alloc, bool _NotEmpty = (sizeof...(_Elements) >= 1),
+        _ImplicitCtor<_NotEmpty, const _Elements&...> = true>
+
+ tuple(allocator_arg_t __tag, const _Alloc& __a,
+       const _Elements&... __elements)
+ : _Inherited(__tag, __a, __elements...) { }
+
+      template<typename _Alloc, bool _NotEmpty = (sizeof...(_Elements) >= 1),
+        _ExplicitCtor<_NotEmpty, const _Elements&...> = false>
+
+ explicit
+ tuple(allocator_arg_t __tag, const _Alloc& __a,
+       const _Elements&... __elements)
+ : _Inherited(__tag, __a, __elements...) { }
+
+      template<typename _Alloc, typename... _UElements,
+        bool _Valid = __valid_args<_UElements...>(),
+        _ImplicitCtor<_Valid, _UElements...> = true>
+
+ tuple(allocator_arg_t __tag, const _Alloc& __a,
+       _UElements&&... __elements)
+ : _Inherited(__tag, __a, std::forward<_UElements>(__elements)...)
+ { }
+
+      template<typename _Alloc, typename... _UElements,
+   bool _Valid = __valid_args<_UElements...>(),
+        _ExplicitCtor<_Valid, _UElements...> = false>
+
+ explicit
+ tuple(allocator_arg_t __tag, const _Alloc& __a,
+       _UElements&&... __elements)
+ : _Inherited(__tag, __a, std::forward<_UElements>(__elements)...)
+ { }
+
+      template<typename _Alloc>
+
+ tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in)
+ : _Inherited(__tag, __a, static_cast<const _Inherited&>(__in)) { }
+
+      template<typename _Alloc>
+
+ tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in)
+ : _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { }
+
+      template<typename _Alloc, typename... _UElements,
+        bool _Valid = (sizeof...(_Elements) == sizeof...(_UElements))
+        && !__use_other_ctor<const tuple<_UElements...>&>(),
+        _ImplicitCtor<_Valid, const _UElements&...> = true>
+
+ tuple(allocator_arg_t __tag, const _Alloc& __a,
+       const tuple<_UElements...>& __in)
+ : _Inherited(__tag, __a,
+              static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
+ { }
+
+      template<typename _Alloc, typename... _UElements,
+        bool _Valid = (sizeof...(_Elements) == sizeof...(_UElements))
+        && !__use_other_ctor<const tuple<_UElements...>&>(),
+        _ExplicitCtor<_Valid, const _UElements&...> = false>
+
+ explicit
+ tuple(allocator_arg_t __tag, const _Alloc& __a,
+       const tuple<_UElements...>& __in)
+ : _Inherited(__tag, __a,
+              static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
+ { }
+
+      template<typename _Alloc, typename... _UElements,
+        bool _Valid = (sizeof...(_Elements) == sizeof...(_UElements))
+        && !__use_other_ctor<tuple<_UElements...>&&>(),
+        _ImplicitCtor<_Valid, _UElements...> = true>
+
+ tuple(allocator_arg_t __tag, const _Alloc& __a,
+       tuple<_UElements...>&& __in)
+ : _Inherited(__tag, __a,
+              static_cast<_Tuple_impl<0, _UElements...>&&>(__in))
+ { }
+
+      template<typename _Alloc, typename... _UElements,
+        bool _Valid = (sizeof...(_Elements) == sizeof...(_UElements))
+        && !__use_other_ctor<tuple<_UElements...>&&>(),
+        _ExplicitCtor<_Valid, _UElements...> = false>
+
+ explicit
+ tuple(allocator_arg_t __tag, const _Alloc& __a,
+       tuple<_UElements...>&& __in)
+ : _Inherited(__tag, __a,
+              static_cast<_Tuple_impl<0, _UElements...>&&>(__in))
+ { }
+
+
+
+     
+      tuple&
+      operator=(typename conditional<__assignable<const _Elements&...>(),
+         const tuple&,
+         const __nonesuch&>::type __in)
+      noexcept(__nothrow_assignable<const _Elements&...>())
+      {
+ this->_M_assign(__in);
+ return *this;
+      }
+
+     
+      tuple&
+      operator=(typename conditional<__assignable<_Elements...>(),
+         tuple&&,
+         __nonesuch&&>::type __in)
+      noexcept(__nothrow_assignable<_Elements...>())
+      {
+ this->_M_assign(std::move(__in));
+ return *this;
+      }
+
+      template<typename... _UElements>
+
+ __enable_if_t<__assignable<const _UElements&...>(), tuple&>
+ operator=(const tuple<_UElements...>& __in)
+ noexcept(__nothrow_assignable<const _UElements&...>())
+ {
+   this->_M_assign(__in);
+   return *this;
+ }
+
+      template<typename... _UElements>
+
+ __enable_if_t<__assignable<_UElements...>(), tuple&>
+ operator=(tuple<_UElements...>&& __in)
+ noexcept(__nothrow_assignable<_UElements...>())
+ {
+   this->_M_assign(std::move(__in));
+   return *this;
+ }
+
+
+     
+      void
+      swap(tuple& __in)
+      noexcept(__and_<__is_nothrow_swappable<_Elements>...>::value)
+      { _Inherited::_M_swap(__in); }
+    };
+
+
+  template<typename... _UTypes>
+    tuple(_UTypes...) -> tuple<_UTypes...>;
+  template<typename _T1, typename _T2>
+    tuple(pair<_T1, _T2>) -> tuple<_T1, _T2>;
+  template<typename _Alloc, typename... _UTypes>
+    tuple(allocator_arg_t, _Alloc, _UTypes...) -> tuple<_UTypes...>;
+  template<typename _Alloc, typename _T1, typename _T2>
+    tuple(allocator_arg_t, _Alloc, pair<_T1, _T2>) -> tuple<_T1, _T2>;
+  template<typename _Alloc, typename... _UTypes>
+    tuple(allocator_arg_t, _Alloc, tuple<_UTypes...>) -> tuple<_UTypes...>;
+
+
+
+  template<>
+    class tuple<>
+    {
+    public:
+      void swap(tuple&) noexcept { }
+
+
+      tuple() = default;
+
+      template<typename _Alloc>
+
+ tuple(allocator_arg_t, const _Alloc&) noexcept { }
+      template<typename _Alloc>
+
+ tuple(allocator_arg_t, const _Alloc&, const tuple&) noexcept { }
+    };
+
+
+
+  template<typename _T1, typename _T2>
+    class tuple<_T1, _T2> : public _Tuple_impl<0, _T1, _T2>
+    {
+      typedef _Tuple_impl<0, _T1, _T2> _Inherited;
+
+
+      template<bool _Dummy, typename _U1, typename _U2>
+ using _ImplicitDefaultCtor = __enable_if_t<
+   _TupleConstraints<_Dummy, _U1, _U2>::
+     __is_implicitly_default_constructible(),
+   bool>;
+
+
+      template<bool _Dummy, typename _U1, typename _U2>
+ using _ExplicitDefaultCtor = __enable_if_t<
+   _TupleConstraints<_Dummy, _U1, _U2>::
+     __is_explicitly_default_constructible(),
+   bool>;
+
+      template<bool _Dummy>
+ using _TCC = _TupleConstraints<_Dummy, _T1, _T2>;
+
+
+      template<bool _Cond, typename _U1, typename _U2>
+ using _ImplicitCtor = __enable_if_t<
+   _TCC<_Cond>::template __is_implicitly_constructible<_U1, _U2>(),
+   bool>;
+
+
+      template<bool _Cond, typename _U1, typename _U2>
+ using _ExplicitCtor = __enable_if_t<
+   _TCC<_Cond>::template __is_explicitly_constructible<_U1, _U2>(),
+   bool>;
+
+      template<typename _U1, typename _U2>
+ static constexpr bool __assignable()
+ {
+   return __and_<is_assignable<_T1&, _U1>,
+   is_assignable<_T2&, _U2>>::value;
+ }
+
+      template<typename _U1, typename _U2>
+ static constexpr bool __nothrow_assignable()
+ {
+   return __and_<is_nothrow_assignable<_T1&, _U1>,
+   is_nothrow_assignable<_T2&, _U2>>::value;
+ }
+
+      template<typename _U1, typename _U2>
+ static constexpr bool __nothrow_constructible()
+ {
+   return __and_<is_nothrow_constructible<_T1, _U1>,
+       is_nothrow_constructible<_T2, _U2>>::value;
+ }
+
+      static constexpr bool __nothrow_default_constructible()
+      {
+ return __and_<is_nothrow_default_constructible<_T1>,
+        is_nothrow_default_constructible<_T2>>::value;
+      }
+
+      template<typename _U1>
+ static constexpr bool __is_alloc_arg()
+ { return is_same<__remove_cvref_t<_U1>, allocator_arg_t>::value; }
+
+    public:
+      template<bool _Dummy = true,
+        _ImplicitDefaultCtor<_Dummy, _T1, _T2> = true>
+ constexpr
+ tuple()
+ noexcept(__nothrow_default_constructible())
+ : _Inherited() { }
+
+      template<bool _Dummy = true,
+        _ExplicitDefaultCtor<_Dummy, _T1, _T2> = false>
+ explicit constexpr
+ tuple()
+ noexcept(__nothrow_default_constructible())
+ : _Inherited() { }
+
+      template<bool _Dummy = true,
+        _ImplicitCtor<_Dummy, const _T1&, const _T2&> = true>
+ constexpr
+ tuple(const _T1& __a1, const _T2& __a2)
+ noexcept(__nothrow_constructible<const _T1&, const _T2&>())
+ : _Inherited(__a1, __a2) { }
+
+      template<bool _Dummy = true,
+        _ExplicitCtor<_Dummy, const _T1&, const _T2&> = false>
+ explicit constexpr
+ tuple(const _T1& __a1, const _T2& __a2)
+ noexcept(__nothrow_constructible<const _T1&, const _T2&>())
+ : _Inherited(__a1, __a2) { }
+
+      template<typename _U1, typename _U2,
+        _ImplicitCtor<!__is_alloc_arg<_U1>(), _U1, _U2> = true>
+ constexpr
+ tuple(_U1&& __a1, _U2&& __a2)
+ noexcept(__nothrow_constructible<_U1, _U2>())
+ : _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { }
+
+      template<typename _U1, typename _U2,
+        _ExplicitCtor<!__is_alloc_arg<_U1>(), _U1, _U2> = false>
+ explicit constexpr
+ tuple(_U1&& __a1, _U2&& __a2)
+ noexcept(__nothrow_constructible<_U1, _U2>())
+ : _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { }
+
+      constexpr tuple(const tuple&) = default;
+
+      constexpr tuple(tuple&&) = default;
+
+      template<typename _U1, typename _U2,
+        _ImplicitCtor<true, const _U1&, const _U2&> = true>
+ constexpr
+ tuple(const tuple<_U1, _U2>& __in)
+ noexcept(__nothrow_constructible<const _U1&, const _U2&>())
+ : _Inherited(static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in)) { }
+
+      template<typename _U1, typename _U2,
+        _ExplicitCtor<true, const _U1&, const _U2&> = false>
+ explicit constexpr
+ tuple(const tuple<_U1, _U2>& __in)
+ noexcept(__nothrow_constructible<const _U1&, const _U2&>())
+ : _Inherited(static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in)) { }
+
+      template<typename _U1, typename _U2,
+        _ImplicitCtor<true, _U1, _U2> = true>
+ constexpr
+ tuple(tuple<_U1, _U2>&& __in)
+ noexcept(__nothrow_constructible<_U1, _U2>())
+ : _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { }
+
+      template<typename _U1, typename _U2,
+        _ExplicitCtor<true, _U1, _U2> = false>
+ explicit constexpr
+ tuple(tuple<_U1, _U2>&& __in)
+ noexcept(__nothrow_constructible<_U1, _U2>())
+ : _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { }
+
+      template<typename _U1, typename _U2,
+        _ImplicitCtor<true, const _U1&, const _U2&> = true>
+ constexpr
+ tuple(const pair<_U1, _U2>& __in)
+ noexcept(__nothrow_constructible<const _U1&, const _U2&>())
+ : _Inherited(__in.first, __in.second) { }
+
+      template<typename _U1, typename _U2,
+        _ExplicitCtor<true, const _U1&, const _U2&> = false>
+ explicit constexpr
+ tuple(const pair<_U1, _U2>& __in)
+ noexcept(__nothrow_constructible<const _U1&, const _U2&>())
+ : _Inherited(__in.first, __in.second) { }
+
+      template<typename _U1, typename _U2,
+        _ImplicitCtor<true, _U1, _U2> = true>
+ constexpr
+ tuple(pair<_U1, _U2>&& __in)
+ noexcept(__nothrow_constructible<_U1, _U2>())
+ : _Inherited(std::forward<_U1>(__in.first),
+       std::forward<_U2>(__in.second)) { }
+
+      template<typename _U1, typename _U2,
+        _ExplicitCtor<true, _U1, _U2> = false>
+ explicit constexpr
+ tuple(pair<_U1, _U2>&& __in)
+ noexcept(__nothrow_constructible<_U1, _U2>())
+ : _Inherited(std::forward<_U1>(__in.first),
+       std::forward<_U2>(__in.second)) { }
+
+
+
+      template<typename _Alloc,
+        _ImplicitDefaultCtor<is_object<_Alloc>::value, _T1, _T2> = true>
+
+ tuple(allocator_arg_t __tag, const _Alloc& __a)
+ : _Inherited(__tag, __a) { }
+
+      template<typename _Alloc, bool _Dummy = true,
+        _ImplicitCtor<_Dummy, const _T1&, const _T2&> = true>
+
+ tuple(allocator_arg_t __tag, const _Alloc& __a,
+       const _T1& __a1, const _T2& __a2)
+ : _Inherited(__tag, __a, __a1, __a2) { }
+
+      template<typename _Alloc, bool _Dummy = true,
+        _ExplicitCtor<_Dummy, const _T1&, const _T2&> = false>
+ explicit
+
+ tuple(allocator_arg_t __tag, const _Alloc& __a,
+       const _T1& __a1, const _T2& __a2)
+ : _Inherited(__tag, __a, __a1, __a2) { }
+
+      template<typename _Alloc, typename _U1, typename _U2,
+        _ImplicitCtor<true, _U1, _U2> = true>
+
+ tuple(allocator_arg_t __tag, const _Alloc& __a, _U1&& __a1, _U2&& __a2)
+ : _Inherited(__tag, __a, std::forward<_U1>(__a1),
+              std::forward<_U2>(__a2)) { }
+
+      template<typename _Alloc, typename _U1, typename _U2,
+        _ExplicitCtor<true, _U1, _U2> = false>
+ explicit
+
+ tuple(allocator_arg_t __tag, const _Alloc& __a,
+       _U1&& __a1, _U2&& __a2)
+ : _Inherited(__tag, __a, std::forward<_U1>(__a1),
+              std::forward<_U2>(__a2)) { }
+
+      template<typename _Alloc>
+
+ tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in)
+ : _Inherited(__tag, __a, static_cast<const _Inherited&>(__in)) { }
+
+      template<typename _Alloc>
+
+ tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in)
+ : _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { }
+
+      template<typename _Alloc, typename _U1, typename _U2,
+        _ImplicitCtor<true, const _U1&, const _U2&> = true>
+
+ tuple(allocator_arg_t __tag, const _Alloc& __a,
+       const tuple<_U1, _U2>& __in)
+ : _Inherited(__tag, __a,
+              static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in))
+ { }
+
+      template<typename _Alloc, typename _U1, typename _U2,
+        _ExplicitCtor<true, const _U1&, const _U2&> = false>
+ explicit
+
+ tuple(allocator_arg_t __tag, const _Alloc& __a,
+       const tuple<_U1, _U2>& __in)
+ : _Inherited(__tag, __a,
+              static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in))
+ { }
+
+      template<typename _Alloc, typename _U1, typename _U2,
+        _ImplicitCtor<true, _U1, _U2> = true>
+
+ tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_U1, _U2>&& __in)
+ : _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in))
+ { }
+
+      template<typename _Alloc, typename _U1, typename _U2,
+        _ExplicitCtor<true, _U1, _U2> = false>
+ explicit
+
+ tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_U1, _U2>&& __in)
+ : _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in))
+ { }
+
+      template<typename _Alloc, typename _U1, typename _U2,
+        _ImplicitCtor<true, const _U1&, const _U2&> = true>
+
+ tuple(allocator_arg_t __tag, const _Alloc& __a,
+       const pair<_U1, _U2>& __in)
+ : _Inherited(__tag, __a, __in.first, __in.second) { }
+
+      template<typename _Alloc, typename _U1, typename _U2,
+        _ExplicitCtor<true, const _U1&, const _U2&> = false>
+ explicit
+
+ tuple(allocator_arg_t __tag, const _Alloc& __a,
+       const pair<_U1, _U2>& __in)
+ : _Inherited(__tag, __a, __in.first, __in.second) { }
+
+      template<typename _Alloc, typename _U1, typename _U2,
+        _ImplicitCtor<true, _U1, _U2> = true>
+
+ tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>&& __in)
+ : _Inherited(__tag, __a, std::forward<_U1>(__in.first),
+       std::forward<_U2>(__in.second)) { }
+
+      template<typename _Alloc, typename _U1, typename _U2,
+        _ExplicitCtor<true, _U1, _U2> = false>
+ explicit
+
+ tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>&& __in)
+ : _Inherited(__tag, __a, std::forward<_U1>(__in.first),
+       std::forward<_U2>(__in.second)) { }
+
+
+
+     
+      tuple&
+      operator=(typename conditional<__assignable<const _T1&, const _T2&>(),
+         const tuple&,
+         const __nonesuch&>::type __in)
+      noexcept(__nothrow_assignable<const _T1&, const _T2&>())
+      {
+ this->_M_assign(__in);
+ return *this;
+      }
+
+     
+      tuple&
+      operator=(typename conditional<__assignable<_T1, _T2>(),
+         tuple&&,
+         __nonesuch&&>::type __in)
+      noexcept(__nothrow_assignable<_T1, _T2>())
+      {
+ this->_M_assign(std::move(__in));
+ return *this;
+      }
+
+      template<typename _U1, typename _U2>
+
+ __enable_if_t<__assignable<const _U1&, const _U2&>(), tuple&>
+ operator=(const tuple<_U1, _U2>& __in)
+ noexcept(__nothrow_assignable<const _U1&, const _U2&>())
+ {
+   this->_M_assign(__in);
+   return *this;
+ }
+
+      template<typename _U1, typename _U2>
+
+ __enable_if_t<__assignable<_U1, _U2>(), tuple&>
+ operator=(tuple<_U1, _U2>&& __in)
+ noexcept(__nothrow_assignable<_U1, _U2>())
+ {
+   this->_M_assign(std::move(__in));
+   return *this;
+ }
+
+      template<typename _U1, typename _U2>
+
+ __enable_if_t<__assignable<const _U1&, const _U2&>(), tuple&>
+ operator=(const pair<_U1, _U2>& __in)
+ noexcept(__nothrow_assignable<const _U1&, const _U2&>())
+ {
+   this->_M_head(*this) = __in.first;
+   this->_M_tail(*this)._M_head(*this) = __in.second;
+   return *this;
+ }
+
+      template<typename _U1, typename _U2>
+
+ __enable_if_t<__assignable<_U1, _U2>(), tuple&>
+ operator=(pair<_U1, _U2>&& __in)
+ noexcept(__nothrow_assignable<_U1, _U2>())
+ {
+   this->_M_head(*this) = std::forward<_U1>(__in.first);
+   this->_M_tail(*this)._M_head(*this) = std::forward<_U2>(__in.second);
+   return *this;
+ }
+
+     
+      void
+      swap(tuple& __in)
+      noexcept(__and_<__is_nothrow_swappable<_T1>,
+        __is_nothrow_swappable<_T2>>::value)
+      { _Inherited::_M_swap(__in); }
+    };
+
+
+
+  template<typename... _Elements>
+    struct tuple_size<tuple<_Elements...>>
+    : public integral_constant<std::size_t, sizeof...(_Elements)> { };
+
+
+  template <typename _Tp>
+    inline constexpr size_t tuple_size_v = tuple_size<_Tp>::value;
+
+
+
+
+
+
+  template<std::size_t __i, typename _Head, typename... _Tail>
+    struct tuple_element<__i, tuple<_Head, _Tail...> >
+    : tuple_element<__i - 1, tuple<_Tail...> > { };
+
+
+
+
+  template<typename _Head, typename... _Tail>
+    struct tuple_element<0, tuple<_Head, _Tail...> >
+    {
+      typedef _Head type;
+    };
+
+
+
+
+  template<size_t __i>
+    struct tuple_element<__i, tuple<>>
+    {
+      static_assert(__i < tuple_size<tuple<>>::value,
+   "tuple index is in range");
+    };
+
+  template<std::size_t __i, typename _Head, typename... _Tail>
+    constexpr _Head&
+    __get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
+    { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
+
+  template<std::size_t __i, typename _Head, typename... _Tail>
+    constexpr const _Head&
+    __get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
+    { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
+
+
+  template<std::size_t __i, typename... _Elements>
+    constexpr __tuple_element_t<__i, tuple<_Elements...>>&
+    get(tuple<_Elements...>& __t) noexcept
+    { return std::__get_helper<__i>(__t); }
+
+
+  template<std::size_t __i, typename... _Elements>
+    constexpr const __tuple_element_t<__i, tuple<_Elements...>>&
+    get(const tuple<_Elements...>& __t) noexcept
+    { return std::__get_helper<__i>(__t); }
+
+
+  template<std::size_t __i, typename... _Elements>
+    constexpr __tuple_element_t<__i, tuple<_Elements...>>&&
+    get(tuple<_Elements...>&& __t) noexcept
+    {
+      typedef __tuple_element_t<__i, tuple<_Elements...>> __element_type;
+      return std::forward<__element_type&&>(std::get<__i>(__t));
+    }
+
+
+  template<std::size_t __i, typename... _Elements>
+    constexpr const __tuple_element_t<__i, tuple<_Elements...>>&&
+    get(const tuple<_Elements...>&& __t) noexcept
+    {
+      typedef __tuple_element_t<__i, tuple<_Elements...>> __element_type;
+      return std::forward<const __element_type&&>(std::get<__i>(__t));
+    }
+
+
+
+#define __cpp_lib_tuples_by_type 201304
+
+  template<typename _Head, size_t __i, typename... _Tail>
+    constexpr _Head&
+    __get_helper2(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
+    { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
+
+  template<typename _Head, size_t __i, typename... _Tail>
+    constexpr const _Head&
+    __get_helper2(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
+    { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
+
+
+  template <typename _Tp, typename... _Types>
+    constexpr _Tp&
+    get(tuple<_Types...>& __t) noexcept
+    { return std::__get_helper2<_Tp>(__t); }
+
+
+  template <typename _Tp, typename... _Types>
+    constexpr _Tp&&
+    get(tuple<_Types...>&& __t) noexcept
+    { return std::forward<_Tp&&>(std::__get_helper2<_Tp>(__t)); }
+
+
+  template <typename _Tp, typename... _Types>
+    constexpr const _Tp&
+    get(const tuple<_Types...>& __t) noexcept
+    { return std::__get_helper2<_Tp>(__t); }
+
+
+
+  template <typename _Tp, typename... _Types>
+    constexpr const _Tp&&
+    get(const tuple<_Types...>&& __t) noexcept
+    { return std::forward<const _Tp&&>(std::__get_helper2<_Tp>(__t)); }
+
+
+
+  template<typename _Tp, typename _Up, size_t __i, size_t __size>
+    struct __tuple_compare
+    {
+      static constexpr bool
+      __eq(const _Tp& __t, const _Up& __u)
+      {
+ return bool(std::get<__i>(__t) == std::get<__i>(__u))
+   && __tuple_compare<_Tp, _Up, __i + 1, __size>::__eq(__t, __u);
+      }
+
+      static constexpr bool
+      __less(const _Tp& __t, const _Up& __u)
+      {
+ return bool(std::get<__i>(__t) < std::get<__i>(__u))
+   || (!bool(std::get<__i>(__u) < std::get<__i>(__t))
+       && __tuple_compare<_Tp, _Up, __i + 1, __size>::__less(__t, __u));
+      }
+    };
+
+  template<typename _Tp, typename _Up, size_t __size>
+    struct __tuple_compare<_Tp, _Up, __size, __size>
+    {
+      static constexpr bool
+      __eq(const _Tp&, const _Up&) { return true; }
+
+      static constexpr bool
+      __less(const _Tp&, const _Up&) { return false; }
+    };
+
+  template<typename... _TElements, typename... _UElements>
+    constexpr bool
+    operator==(const tuple<_TElements...>& __t,
+        const tuple<_UElements...>& __u)
+    {
+      static_assert(sizeof...(_TElements) == sizeof...(_UElements),
+   "tuple objects can only be compared if they have equal sizes.");
+      using __compare = __tuple_compare<tuple<_TElements...>,
+     tuple<_UElements...>,
+     0, sizeof...(_TElements)>;
+      return __compare::__eq(__t, __u);
+    }
+# 1433 "/usr/include/c++/10.2.0/tuple" 3
+  template<typename... _TElements, typename... _UElements>
+    constexpr bool
+    operator<(const tuple<_TElements...>& __t,
+       const tuple<_UElements...>& __u)
+    {
+      static_assert(sizeof...(_TElements) == sizeof...(_UElements),
+   "tuple objects can only be compared if they have equal sizes.");
+      using __compare = __tuple_compare<tuple<_TElements...>,
+     tuple<_UElements...>,
+     0, sizeof...(_TElements)>;
+      return __compare::__less(__t, __u);
+    }
+
+  template<typename... _TElements, typename... _UElements>
+    constexpr bool
+    operator!=(const tuple<_TElements...>& __t,
+        const tuple<_UElements...>& __u)
+    { return !(__t == __u); }
+
+  template<typename... _TElements, typename... _UElements>
+    constexpr bool
+    operator>(const tuple<_TElements...>& __t,
+       const tuple<_UElements...>& __u)
+    { return __u < __t; }
+
+  template<typename... _TElements, typename... _UElements>
+    constexpr bool
+    operator<=(const tuple<_TElements...>& __t,
+        const tuple<_UElements...>& __u)
+    { return !(__u < __t); }
+
+  template<typename... _TElements, typename... _UElements>
+    constexpr bool
+    operator>=(const tuple<_TElements...>& __t,
+        const tuple<_UElements...>& __u)
+    { return !(__t < __u); }
+
+
+
+  template<typename... _Elements>
+    constexpr tuple<typename __decay_and_strip<_Elements>::__type...>
+    make_tuple(_Elements&&... __args)
+    {
+      typedef tuple<typename __decay_and_strip<_Elements>::__type...>
+ __result_type;
+      return __result_type(std::forward<_Elements>(__args)...);
+    }
+
+
+
+
+  template<typename... _Elements>
+    constexpr tuple<_Elements&&...>
+    forward_as_tuple(_Elements&&... __args) noexcept
+    { return tuple<_Elements&&...>(std::forward<_Elements>(__args)...); }
+
+  template<size_t, typename, typename, size_t>
+    struct __make_tuple_impl;
+
+  template<size_t _Idx, typename _Tuple, typename... _Tp, size_t _Nm>
+    struct __make_tuple_impl<_Idx, tuple<_Tp...>, _Tuple, _Nm>
+    : __make_tuple_impl<_Idx + 1,
+   tuple<_Tp..., __tuple_element_t<_Idx, _Tuple>>,
+   _Tuple, _Nm>
+    { };
+
+  template<std::size_t _Nm, typename _Tuple, typename... _Tp>
+    struct __make_tuple_impl<_Nm, tuple<_Tp...>, _Tuple, _Nm>
+    {
+      typedef tuple<_Tp...> __type;
+    };
+
+  template<typename _Tuple>
+    struct __do_make_tuple
+    : __make_tuple_impl<0, tuple<>, _Tuple, std::tuple_size<_Tuple>::value>
+    { };
+
+
+  template<typename _Tuple>
+    struct __make_tuple
+    : public __do_make_tuple<__remove_cvref_t<_Tuple>>
+    { };
+
+
+  template<typename...>
+    struct __combine_tuples;
+
+  template<>
+    struct __combine_tuples<>
+    {
+      typedef tuple<> __type;
+    };
+
+  template<typename... _Ts>
+    struct __combine_tuples<tuple<_Ts...>>
+    {
+      typedef tuple<_Ts...> __type;
+    };
+
+  template<typename... _T1s, typename... _T2s, typename... _Rem>
+    struct __combine_tuples<tuple<_T1s...>, tuple<_T2s...>, _Rem...>
+    {
+      typedef typename __combine_tuples<tuple<_T1s..., _T2s...>,
+     _Rem...>::__type __type;
+    };
+
+
+  template<typename... _Tpls>
+    struct __tuple_cat_result
+    {
+      typedef typename __combine_tuples
+        <typename __make_tuple<_Tpls>::__type...>::__type __type;
+    };
+
+
+
+  template<typename...>
+    struct __make_1st_indices;
+
+  template<>
+    struct __make_1st_indices<>
+    {
+      typedef std::_Index_tuple<> __type;
+    };
+
+  template<typename _Tp, typename... _Tpls>
+    struct __make_1st_indices<_Tp, _Tpls...>
+    {
+      typedef typename std::_Build_index_tuple<std::tuple_size<
+ typename std::remove_reference<_Tp>::type>::value>::__type __type;
+    };
+
+
+
+
+  template<typename _Ret, typename _Indices, typename... _Tpls>
+    struct __tuple_concater;
+
+  template<typename _Ret, std::size_t... _Is, typename _Tp, typename... _Tpls>
+    struct __tuple_concater<_Ret, std::_Index_tuple<_Is...>, _Tp, _Tpls...>
+    {
+      template<typename... _Us>
+        static constexpr _Ret
+        _S_do(_Tp&& __tp, _Tpls&&... __tps, _Us&&... __us)
+        {
+   typedef typename __make_1st_indices<_Tpls...>::__type __idx;
+   typedef __tuple_concater<_Ret, __idx, _Tpls...> __next;
+   return __next::_S_do(std::forward<_Tpls>(__tps)...,
+          std::forward<_Us>(__us)...,
+          std::get<_Is>(std::forward<_Tp>(__tp))...);
+ }
+    };
+
+  template<typename _Ret>
+    struct __tuple_concater<_Ret, std::_Index_tuple<>>
+    {
+      template<typename... _Us>
+ static constexpr _Ret
+ _S_do(_Us&&... __us)
+        {
+   return _Ret(std::forward<_Us>(__us)...);
+ }
+    };
+
+
+  template<typename... _Tpls, typename = typename
+           enable_if<__and_<__is_tuple_like<_Tpls>...>::value>::type>
+    constexpr auto
+    tuple_cat(_Tpls&&... __tpls)
+    -> typename __tuple_cat_result<_Tpls...>::__type
+    {
+      typedef typename __tuple_cat_result<_Tpls...>::__type __ret;
+      typedef typename __make_1st_indices<_Tpls...>::__type __idx;
+      typedef __tuple_concater<__ret, __idx, _Tpls...> __concater;
+      return __concater::_S_do(std::forward<_Tpls>(__tpls)...);
+    }
+
+
+
+
+  template<typename... _Elements>
+    constexpr tuple<_Elements&...>
+    tie(_Elements&... __args) noexcept
+    { return tuple<_Elements&...>(__args...); }
+
+
+  template<typename... _Elements>
+   
+    inline
+
+
+    typename enable_if<__and_<__is_swappable<_Elements>...>::value
+      >::type
+
+
+
+    swap(tuple<_Elements...>& __x, tuple<_Elements...>& __y)
+    noexcept(noexcept(__x.swap(__y)))
+    { __x.swap(__y); }
+
+
+  template<typename... _Elements>
+   
+    typename enable_if<!__and_<__is_swappable<_Elements>...>::value>::type
+    swap(tuple<_Elements...>&, tuple<_Elements...>&) = delete;
+
+
+
+
+
+
+  struct _Swallow_assign
+  {
+    template<class _Tp>
+      constexpr const _Swallow_assign&
+      operator=(const _Tp&) const
+      { return *this; }
+  };
+
+
+
+  inline constexpr _Swallow_assign ignore{};
+
+
+  template<typename... _Types, typename _Alloc>
+    struct uses_allocator<tuple<_Types...>, _Alloc> : true_type { };
+# 1669 "/usr/include/c++/10.2.0/tuple" 3
+  template<class _T1, class _T2>
+    template<typename... _Args1, typename... _Args2>
+     
+      inline
+      pair<_T1, _T2>::
+      pair(piecewise_construct_t,
+    tuple<_Args1...> __first, tuple<_Args2...> __second)
+      : pair(__first, __second,
+      typename _Build_index_tuple<sizeof...(_Args1)>::__type(),
+      typename _Build_index_tuple<sizeof...(_Args2)>::__type())
+      { }
+
+  template<class _T1, class _T2>
+    template<typename... _Args1, std::size_t... _Indexes1,
+             typename... _Args2, std::size_t... _Indexes2>
+      inline
+      pair<_T1, _T2>::
+      pair(tuple<_Args1...>& __tuple1, tuple<_Args2...>& __tuple2,
+    _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>)
+      : first(std::forward<_Args1>(std::get<_Indexes1>(__tuple1))...),
+        second(std::forward<_Args2>(std::get<_Indexes2>(__tuple2))...)
+      { }
+
+
+
+
+
+
+
+  template<template<typename...> class _Trait, typename _Tp, typename _Tuple>
+    inline constexpr bool __unpack_std_tuple = false;
+
+  template<template<typename...> class _Trait, typename _Tp, typename... _Up>
+    inline constexpr bool __unpack_std_tuple<_Trait, _Tp, tuple<_Up...>>
+      = _Trait<_Tp, _Up...>::value;
+
+  template<template<typename...> class _Trait, typename _Tp, typename... _Up>
+    inline constexpr bool __unpack_std_tuple<_Trait, _Tp, tuple<_Up...>&>
+      = _Trait<_Tp, _Up&...>::value;
+
+  template<template<typename...> class _Trait, typename _Tp, typename... _Up>
+    inline constexpr bool __unpack_std_tuple<_Trait, _Tp, const tuple<_Up...>>
+      = _Trait<_Tp, const _Up...>::value;
+
+  template<template<typename...> class _Trait, typename _Tp, typename... _Up>
+    inline constexpr bool __unpack_std_tuple<_Trait, _Tp, const tuple<_Up...>&>
+      = _Trait<_Tp, const _Up&...>::value;
+
+#define __cpp_lib_apply 201603
+
+  template <typename _Fn, typename _Tuple, size_t... _Idx>
+    constexpr decltype(auto)
+    __apply_impl(_Fn&& __f, _Tuple&& __t, index_sequence<_Idx...>)
+    {
+      return std::__invoke(std::forward<_Fn>(__f),
+      std::get<_Idx>(std::forward<_Tuple>(__t))...);
+    }
+
+  template <typename _Fn, typename _Tuple>
+    constexpr decltype(auto)
+    apply(_Fn&& __f, _Tuple&& __t)
+    noexcept(__unpack_std_tuple<is_nothrow_invocable, _Fn, _Tuple>)
+    {
+      using _Indices
+ = make_index_sequence<tuple_size_v<remove_reference_t<_Tuple>>>;
+      return std::__apply_impl(std::forward<_Fn>(__f),
+          std::forward<_Tuple>(__t),
+          _Indices{});
+    }
+
+#define __cpp_lib_make_from_tuple 201606
+
+  template <typename _Tp, typename _Tuple, size_t... _Idx>
+    constexpr _Tp
+    __make_from_tuple_impl(_Tuple&& __t, index_sequence<_Idx...>)
+    { return _Tp(std::get<_Idx>(std::forward<_Tuple>(__t))...); }
+
+  template <typename _Tp, typename _Tuple>
+    constexpr _Tp
+    make_from_tuple(_Tuple&& __t)
+    noexcept(__unpack_std_tuple<is_nothrow_constructible, _Tp, _Tuple>)
+    {
+      return __make_from_tuple_impl<_Tp>(
+        std::forward<_Tuple>(__t),
+ make_index_sequence<tuple_size_v<remove_reference_t<_Tuple>>>{});
+    }
+
+
+
+
+
+}
+# 38 "/usr/include/c++/10.2.0/bits/unique_ptr.h" 2 3
+
+
+
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+
+
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+  template<typename> class auto_ptr;
+#pragma GCC diagnostic pop
+
+
+
+  template<typename _Tp>
+    struct default_delete
+    {
+
+      constexpr default_delete() noexcept = default;
+
+
+
+
+
+
+      template<typename _Up,
+        typename = _Require<is_convertible<_Up*, _Tp*>>>
+        default_delete(const default_delete<_Up>&) noexcept { }
+
+
+      void
+      operator()(_Tp* __ptr) const
+      {
+ static_assert(!is_void<_Tp>::value,
+        "can't delete pointer to incomplete type");
+ static_assert(sizeof(_Tp)>0,
+        "can't delete pointer to incomplete type");
+ delete __ptr;
+      }
+    };
+
+
+
+
+
+  template<typename _Tp>
+    struct default_delete<_Tp[]>
+    {
+    public:
+
+      constexpr default_delete() noexcept = default;
+# 109 "/usr/include/c++/10.2.0/bits/unique_ptr.h" 3
+      template<typename _Up,
+        typename = _Require<is_convertible<_Up(*)[], _Tp(*)[]>>>
+        default_delete(const default_delete<_Up[]>&) noexcept { }
+
+
+      template<typename _Up>
+ typename enable_if<is_convertible<_Up(*)[], _Tp(*)[]>::value>::type
+ operator()(_Up* __ptr) const
+ {
+   static_assert(sizeof(_Tp)>0,
+   "can't delete pointer to incomplete type");
+   delete [] __ptr;
+ }
+    };
+
+
+
+
+  template <typename _Tp, typename _Dp>
+    class __uniq_ptr_impl
+    {
+      template <typename _Up, typename _Ep, typename = void>
+ struct _Ptr
+ {
+   using type = _Up*;
+ };
+
+      template <typename _Up, typename _Ep>
+ struct
+ _Ptr<_Up, _Ep, __void_t<typename remove_reference<_Ep>::type::pointer>>
+ {
+   using type = typename remove_reference<_Ep>::type::pointer;
+ };
+
+    public:
+      using _DeleterConstraint = enable_if<
+        __and_<__not_<is_pointer<_Dp>>,
+        is_default_constructible<_Dp>>::value>;
+
+      using pointer = typename _Ptr<_Tp, _Dp>::type;
+
+      static_assert( !is_rvalue_reference<_Dp>::value,
+       "unique_ptr's deleter type must be a function object type"
+       " or an lvalue reference type" );
+
+      __uniq_ptr_impl() = default;
+      __uniq_ptr_impl(pointer __p) : _M_t() { _M_ptr() = __p; }
+
+      template<typename _Del>
+      __uniq_ptr_impl(pointer __p, _Del&& __d)
+ : _M_t(__p, std::forward<_Del>(__d)) { }
+
+      __uniq_ptr_impl(__uniq_ptr_impl&& __u) noexcept
+      : _M_t(std::move(__u._M_t))
+      { __u._M_ptr() = nullptr; }
+
+      __uniq_ptr_impl& operator=(__uniq_ptr_impl&& __u) noexcept
+      {
+ reset(__u.release());
+ _M_deleter() = std::forward<_Dp>(__u._M_deleter());
+ return *this;
+      }
+
+      pointer& _M_ptr() { return std::get<0>(_M_t); }
+      pointer _M_ptr() const { return std::get<0>(_M_t); }
+      _Dp& _M_deleter() { return std::get<1>(_M_t); }
+      const _Dp& _M_deleter() const { return std::get<1>(_M_t); }
+
+      void reset(pointer __p) noexcept
+      {
+ const pointer __old_p = _M_ptr();
+ _M_ptr() = __p;
+ if (__old_p)
+   _M_deleter()(__old_p);
+      }
+
+      pointer release() noexcept
+      {
+ pointer __p = _M_ptr();
+ _M_ptr() = nullptr;
+ return __p;
+      }
+
+      void
+      swap(__uniq_ptr_impl& __rhs) noexcept
+      {
+ using std::swap;
+ swap(this->_M_ptr(), __rhs._M_ptr());
+ swap(this->_M_deleter(), __rhs._M_deleter());
+      }
+
+    private:
+      tuple<pointer, _Dp> _M_t;
+    };
+
+
+  template <typename _Tp, typename _Dp,
+     bool = is_move_constructible<_Dp>::value,
+     bool = is_move_assignable<_Dp>::value>
+    struct __uniq_ptr_data : __uniq_ptr_impl<_Tp, _Dp>
+    {
+      using __uniq_ptr_impl<_Tp, _Dp>::__uniq_ptr_impl;
+      __uniq_ptr_data(__uniq_ptr_data&&) = default;
+      __uniq_ptr_data& operator=(__uniq_ptr_data&&) = default;
+    };
+
+  template <typename _Tp, typename _Dp>
+    struct __uniq_ptr_data<_Tp, _Dp, true, false> : __uniq_ptr_impl<_Tp, _Dp>
+    {
+      using __uniq_ptr_impl<_Tp, _Dp>::__uniq_ptr_impl;
+      __uniq_ptr_data(__uniq_ptr_data&&) = default;
+      __uniq_ptr_data& operator=(__uniq_ptr_data&&) = delete;
+    };
+
+  template <typename _Tp, typename _Dp>
+    struct __uniq_ptr_data<_Tp, _Dp, false, true> : __uniq_ptr_impl<_Tp, _Dp>
+    {
+      using __uniq_ptr_impl<_Tp, _Dp>::__uniq_ptr_impl;
+      __uniq_ptr_data(__uniq_ptr_data&&) = delete;
+      __uniq_ptr_data& operator=(__uniq_ptr_data&&) = default;
+    };
+
+  template <typename _Tp, typename _Dp>
+    struct __uniq_ptr_data<_Tp, _Dp, false, false> : __uniq_ptr_impl<_Tp, _Dp>
+    {
+      using __uniq_ptr_impl<_Tp, _Dp>::__uniq_ptr_impl;
+      __uniq_ptr_data(__uniq_ptr_data&&) = delete;
+      __uniq_ptr_data& operator=(__uniq_ptr_data&&) = delete;
+    };
+
+
+
+  template <typename _Tp, typename _Dp = default_delete<_Tp>>
+    class unique_ptr
+    {
+      template <typename _Up>
+ using _DeleterConstraint =
+   typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type;
+
+      __uniq_ptr_data<_Tp, _Dp> _M_t;
+
+    public:
+      using pointer = typename __uniq_ptr_impl<_Tp, _Dp>::pointer;
+      using element_type = _Tp;
+      using deleter_type = _Dp;
+
+    private:
+
+
+      template<typename _Up, typename _Ep>
+ using __safe_conversion_up = __and_<
+   is_convertible<typename unique_ptr<_Up, _Ep>::pointer, pointer>,
+   __not_<is_array<_Up>>
+        >;
+
+    public:
+
+
+
+      template<typename _Del = _Dp, typename = _DeleterConstraint<_Del>>
+ constexpr unique_ptr() noexcept
+ : _M_t()
+ { }
+
+
+
+
+
+
+
+      template<typename _Del = _Dp, typename = _DeleterConstraint<_Del>>
+ explicit
+ unique_ptr(pointer __p) noexcept
+ : _M_t(__p)
+        { }
+# 292 "/usr/include/c++/10.2.0/bits/unique_ptr.h" 3
+      template<typename _Del = deleter_type,
+        typename = _Require<is_copy_constructible<_Del>>>
+ unique_ptr(pointer __p, const deleter_type& __d) noexcept
+ : _M_t(__p, __d) { }
+# 304 "/usr/include/c++/10.2.0/bits/unique_ptr.h" 3
+      template<typename _Del = deleter_type,
+        typename = _Require<is_move_constructible<_Del>>>
+ unique_ptr(pointer __p,
+     __enable_if_t<!is_lvalue_reference<_Del>::value,
+     _Del&&> __d) noexcept
+ : _M_t(__p, std::move(__d))
+ { }
+
+      template<typename _Del = deleter_type,
+        typename _DelUnref = typename remove_reference<_Del>::type>
+ unique_ptr(pointer,
+     __enable_if_t<is_lvalue_reference<_Del>::value,
+     _DelUnref&&>) = delete;
+
+
+      template<typename _Del = _Dp, typename = _DeleterConstraint<_Del>>
+ constexpr unique_ptr(nullptr_t) noexcept
+ : _M_t()
+ { }
+
+
+
+
+      unique_ptr(unique_ptr&&) = default;
+
+
+
+
+
+
+
+      template<typename _Up, typename _Ep, typename = _Require<
+               __safe_conversion_up<_Up, _Ep>,
+        typename conditional<is_reference<_Dp>::value,
+        is_same<_Ep, _Dp>,
+        is_convertible<_Ep, _Dp>>::type>>
+ unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
+ : _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter()))
+ { }
+
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+      template<typename _Up, typename = _Require<
+        is_convertible<_Up*, _Tp*>, is_same<_Dp, default_delete<_Tp>>>>
+ unique_ptr(auto_ptr<_Up>&& __u) noexcept;
+#pragma GCC diagnostic pop
+
+
+
+      ~unique_ptr() noexcept
+      {
+ static_assert(__is_invocable<deleter_type&, pointer>::value,
+        "unique_ptr's deleter must be invocable with a pointer");
+ auto& __ptr = _M_t._M_ptr();
+ if (__ptr != nullptr)
+   get_deleter()(std::move(__ptr));
+ __ptr = pointer();
+      }
+
+
+
+
+
+
+
+      unique_ptr& operator=(unique_ptr&&) = default;
+# 380 "/usr/include/c++/10.2.0/bits/unique_ptr.h" 3
+      template<typename _Up, typename _Ep>
+        typename enable_if< __and_<
+          __safe_conversion_up<_Up, _Ep>,
+          is_assignable<deleter_type&, _Ep&&>
+          >::value,
+          unique_ptr&>::type
+ operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
+ {
+   reset(__u.release());
+   get_deleter() = std::forward<_Ep>(__u.get_deleter());
+   return *this;
+ }
+
+
+      unique_ptr&
+      operator=(nullptr_t) noexcept
+      {
+ reset();
+ return *this;
+      }
+
+
+
+
+      typename add_lvalue_reference<element_type>::type
+      operator*() const
+      {
+ ;
+ return *get();
+      }
+
+
+      pointer
+      operator->() const noexcept
+      {
+ ;
+ return get();
+      }
+
+
+      pointer
+      get() const noexcept
+      { return _M_t._M_ptr(); }
+
+
+      deleter_type&
+      get_deleter() noexcept
+      { return _M_t._M_deleter(); }
+
+
+      const deleter_type&
+      get_deleter() const noexcept
+      { return _M_t._M_deleter(); }
+
+
+      explicit operator bool() const noexcept
+      { return get() == pointer() ? false : true; }
+
+
+
+
+      pointer
+      release() noexcept
+      { return _M_t.release(); }
+
+
+
+
+
+
+
+      void
+      reset(pointer __p = pointer()) noexcept
+      {
+ static_assert(__is_invocable<deleter_type&, pointer>::value,
+        "unique_ptr's deleter must be invocable with a pointer");
+ _M_t.reset(std::move(__p));
+      }
+
+
+      void
+      swap(unique_ptr& __u) noexcept
+      {
+ static_assert(__is_swappable<_Dp>::value, "deleter must be swappable");
+ _M_t.swap(__u._M_t);
+      }
+
+
+      unique_ptr(const unique_ptr&) = delete;
+      unique_ptr& operator=(const unique_ptr&) = delete;
+  };
+
+
+
+
+
+  template<typename _Tp, typename _Dp>
+    class unique_ptr<_Tp[], _Dp>
+    {
+      template <typename _Up>
+      using _DeleterConstraint =
+ typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type;
+
+      __uniq_ptr_data<_Tp, _Dp> _M_t;
+
+      template<typename _Up>
+ using __remove_cv = typename remove_cv<_Up>::type;
+
+
+      template<typename _Up>
+ using __is_derived_Tp
+   = __and_< is_base_of<_Tp, _Up>,
+      __not_<is_same<__remove_cv<_Tp>, __remove_cv<_Up>>> >;
+
+    public:
+      using pointer = typename __uniq_ptr_impl<_Tp, _Dp>::pointer;
+      using element_type = _Tp;
+      using deleter_type = _Dp;
+
+
+
+      template<typename _Up, typename _Ep,
+               typename _UPtr = unique_ptr<_Up, _Ep>,
+        typename _UP_pointer = typename _UPtr::pointer,
+        typename _UP_element_type = typename _UPtr::element_type>
+ using __safe_conversion_up = __and_<
+          is_array<_Up>,
+          is_same<pointer, element_type*>,
+          is_same<_UP_pointer, _UP_element_type*>,
+          is_convertible<_UP_element_type(*)[], element_type(*)[]>
+        >;
+
+
+      template<typename _Up>
+        using __safe_conversion_raw = __and_<
+          __or_<__or_<is_same<_Up, pointer>,
+                      is_same<_Up, nullptr_t>>,
+                __and_<is_pointer<_Up>,
+                       is_same<pointer, element_type*>,
+                       is_convertible<
+                         typename remove_pointer<_Up>::type(*)[],
+                         element_type(*)[]>
+                >
+          >
+        >;
+
+
+
+
+      template<typename _Del = _Dp, typename = _DeleterConstraint<_Del>>
+ constexpr unique_ptr() noexcept
+ : _M_t()
+ { }
+# 541 "/usr/include/c++/10.2.0/bits/unique_ptr.h" 3
+      template<typename _Up,
+        typename _Vp = _Dp,
+        typename = _DeleterConstraint<_Vp>,
+        typename = typename enable_if<
+                 __safe_conversion_raw<_Up>::value, bool>::type>
+ explicit
+ unique_ptr(_Up __p) noexcept
+ : _M_t(__p)
+        { }
+# 559 "/usr/include/c++/10.2.0/bits/unique_ptr.h" 3
+      template<typename _Up, typename _Del = deleter_type,
+        typename = _Require<__safe_conversion_raw<_Up>,
+       is_copy_constructible<_Del>>>
+      unique_ptr(_Up __p, const deleter_type& __d) noexcept
+      : _M_t(__p, __d) { }
+# 573 "/usr/include/c++/10.2.0/bits/unique_ptr.h" 3
+      template<typename _Up, typename _Del = deleter_type,
+        typename = _Require<__safe_conversion_raw<_Up>,
+       is_move_constructible<_Del>>>
+ unique_ptr(_Up __p,
+     __enable_if_t<!is_lvalue_reference<_Del>::value,
+     _Del&&> __d) noexcept
+ : _M_t(std::move(__p), std::move(__d))
+ { }
+
+      template<typename _Up, typename _Del = deleter_type,
+        typename _DelUnref = typename remove_reference<_Del>::type,
+        typename = _Require<__safe_conversion_raw<_Up>>>
+ unique_ptr(_Up,
+     __enable_if_t<is_lvalue_reference<_Del>::value,
+     _DelUnref&&>) = delete;
+
+
+      unique_ptr(unique_ptr&&) = default;
+
+
+      template<typename _Del = _Dp, typename = _DeleterConstraint<_Del>>
+ constexpr unique_ptr(nullptr_t) noexcept
+ : _M_t()
+        { }
+
+      template<typename _Up, typename _Ep, typename = _Require<
+        __safe_conversion_up<_Up, _Ep>,
+        typename conditional<is_reference<_Dp>::value,
+        is_same<_Ep, _Dp>,
+        is_convertible<_Ep, _Dp>>::type>>
+ unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
+ : _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter()))
+ { }
+
+
+      ~unique_ptr()
+      {
+ auto& __ptr = _M_t._M_ptr();
+ if (__ptr != nullptr)
+   get_deleter()(__ptr);
+ __ptr = pointer();
+      }
+
+
+
+
+
+
+
+      unique_ptr&
+      operator=(unique_ptr&&) = default;
+# 632 "/usr/include/c++/10.2.0/bits/unique_ptr.h" 3
+      template<typename _Up, typename _Ep>
+ typename
+ enable_if<__and_<__safe_conversion_up<_Up, _Ep>,
+                         is_assignable<deleter_type&, _Ep&&>
+                  >::value,
+                  unique_ptr&>::type
+ operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
+ {
+   reset(__u.release());
+   get_deleter() = std::forward<_Ep>(__u.get_deleter());
+   return *this;
+ }
+
+
+      unique_ptr&
+      operator=(nullptr_t) noexcept
+      {
+ reset();
+ return *this;
+      }
+
+
+
+
+      typename std::add_lvalue_reference<element_type>::type
+      operator[](size_t __i) const
+      {
+ ;
+ return get()[__i];
+      }
+
+
+      pointer
+      get() const noexcept
+      { return _M_t._M_ptr(); }
+
+
+      deleter_type&
+      get_deleter() noexcept
+      { return _M_t._M_deleter(); }
+
+
+      const deleter_type&
+      get_deleter() const noexcept
+      { return _M_t._M_deleter(); }
+
+
+      explicit operator bool() const noexcept
+      { return get() == pointer() ? false : true; }
+
+
+
+
+      pointer
+      release() noexcept
+      { return _M_t.release(); }
+
+
+
+
+
+
+
+      template <typename _Up,
+                typename = _Require<
+                  __or_<is_same<_Up, pointer>,
+                        __and_<is_same<pointer, element_type*>,
+                               is_pointer<_Up>,
+                               is_convertible<
+                                 typename remove_pointer<_Up>::type(*)[],
+                                 element_type(*)[]
+                               >
+                        >
+                  >
+               >>
+      void
+      reset(_Up __p) noexcept
+      { _M_t.reset(std::move(__p)); }
+
+      void reset(nullptr_t = nullptr) noexcept
+      { reset(pointer()); }
+
+
+      void
+      swap(unique_ptr& __u) noexcept
+      {
+ static_assert(__is_swappable<_Dp>::value, "deleter must be swappable");
+ _M_t.swap(__u._M_t);
+      }
+
+
+      unique_ptr(const unique_ptr&) = delete;
+      unique_ptr& operator=(const unique_ptr&) = delete;
+    };
+
+
+
+
+  template<typename _Tp, typename _Dp>
+    inline
+
+
+    typename enable_if<__is_swappable<_Dp>::value>::type
+
+
+
+    swap(unique_ptr<_Tp, _Dp>& __x,
+  unique_ptr<_Tp, _Dp>& __y) noexcept
+    { __x.swap(__y); }
+
+
+  template<typename _Tp, typename _Dp>
+    typename enable_if<!__is_swappable<_Dp>::value>::type
+    swap(unique_ptr<_Tp, _Dp>&,
+  unique_ptr<_Tp, _Dp>&) = delete;
+
+
+
+  template<typename _Tp, typename _Dp,
+    typename _Up, typename _Ep>
+    [[__nodiscard__]] inline bool
+    operator==(const unique_ptr<_Tp, _Dp>& __x,
+        const unique_ptr<_Up, _Ep>& __y)
+    { return __x.get() == __y.get(); }
+
+
+  template<typename _Tp, typename _Dp>
+    [[__nodiscard__]] inline bool
+    operator==(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept
+    { return !__x; }
+
+
+
+  template<typename _Tp, typename _Dp>
+    [[__nodiscard__]] inline bool
+    operator==(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept
+    { return !__x; }
+
+
+  template<typename _Tp, typename _Dp,
+    typename _Up, typename _Ep>
+    [[__nodiscard__]] inline bool
+    operator!=(const unique_ptr<_Tp, _Dp>& __x,
+        const unique_ptr<_Up, _Ep>& __y)
+    { return __x.get() != __y.get(); }
+
+
+  template<typename _Tp, typename _Dp>
+    [[__nodiscard__]] inline bool
+    operator!=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept
+    { return (bool)__x; }
+
+
+  template<typename _Tp, typename _Dp>
+    [[__nodiscard__]] inline bool
+    operator!=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept
+    { return (bool)__x; }
+
+
+
+  template<typename _Tp, typename _Dp,
+    typename _Up, typename _Ep>
+    [[__nodiscard__]] inline bool
+    operator<(const unique_ptr<_Tp, _Dp>& __x,
+       const unique_ptr<_Up, _Ep>& __y)
+    {
+      typedef typename
+ std::common_type<typename unique_ptr<_Tp, _Dp>::pointer,
+                  typename unique_ptr<_Up, _Ep>::pointer>::type _CT;
+      return std::less<_CT>()(__x.get(), __y.get());
+    }
+
+
+  template<typename _Tp, typename _Dp>
+    [[__nodiscard__]] inline bool
+    operator<(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
+    {
+      return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(__x.get(),
+         nullptr);
+    }
+
+
+  template<typename _Tp, typename _Dp>
+    [[__nodiscard__]] inline bool
+    operator<(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
+    {
+      return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(nullptr,
+         __x.get());
+    }
+
+
+  template<typename _Tp, typename _Dp,
+    typename _Up, typename _Ep>
+    [[__nodiscard__]] inline bool
+    operator<=(const unique_ptr<_Tp, _Dp>& __x,
+        const unique_ptr<_Up, _Ep>& __y)
+    { return !(__y < __x); }
+
+
+  template<typename _Tp, typename _Dp>
+    [[__nodiscard__]] inline bool
+    operator<=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
+    { return !(nullptr < __x); }
+
+
+  template<typename _Tp, typename _Dp>
+    [[__nodiscard__]] inline bool
+    operator<=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
+    { return !(__x < nullptr); }
+
+
+  template<typename _Tp, typename _Dp,
+    typename _Up, typename _Ep>
+    [[__nodiscard__]] inline bool
+    operator>(const unique_ptr<_Tp, _Dp>& __x,
+       const unique_ptr<_Up, _Ep>& __y)
+    { return (__y < __x); }
+
+
+  template<typename _Tp, typename _Dp>
+    [[__nodiscard__]] inline bool
+    operator>(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
+    {
+      return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(nullptr,
+         __x.get());
+    }
+
+
+  template<typename _Tp, typename _Dp>
+    [[__nodiscard__]] inline bool
+    operator>(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
+    {
+      return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(__x.get(),
+         nullptr);
+    }
+
+
+  template<typename _Tp, typename _Dp,
+    typename _Up, typename _Ep>
+    [[__nodiscard__]] inline bool
+    operator>=(const unique_ptr<_Tp, _Dp>& __x,
+        const unique_ptr<_Up, _Ep>& __y)
+    { return !(__x < __y); }
+
+
+  template<typename _Tp, typename _Dp>
+    [[__nodiscard__]] inline bool
+    operator>=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
+    { return !(__x < nullptr); }
+
+
+  template<typename _Tp, typename _Dp>
+    [[__nodiscard__]] inline bool
+    operator>=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
+    { return !(nullptr < __x); }
+# 912 "/usr/include/c++/10.2.0/bits/unique_ptr.h" 3
+  template<typename _Up, typename _Ptr = typename _Up::pointer,
+    bool = __poison_hash<_Ptr>::__enable_hash_call>
+    struct __uniq_ptr_hash
+
+    : private __poison_hash<_Ptr>
+
+    {
+      size_t
+      operator()(const _Up& __u) const
+      noexcept(noexcept(std::declval<hash<_Ptr>>()(std::declval<_Ptr>())))
+      { return hash<_Ptr>()(__u.get()); }
+    };
+
+  template<typename _Up, typename _Ptr>
+    struct __uniq_ptr_hash<_Up, _Ptr, false>
+    : private __poison_hash<_Ptr>
+    { };
+
+
+
+  template<typename _Tp, typename _Dp>
+    struct hash<unique_ptr<_Tp, _Dp>>
+    : public __hash_base<size_t, unique_ptr<_Tp, _Dp>>,
+      public __uniq_ptr_hash<unique_ptr<_Tp, _Dp>>
+    { };
+
+
+
+#define __cpp_lib_make_unique 201304
+
+
+
+  template<typename _Tp>
+    struct _MakeUniq
+    { typedef unique_ptr<_Tp> __single_object; };
+
+  template<typename _Tp>
+    struct _MakeUniq<_Tp[]>
+    { typedef unique_ptr<_Tp[]> __array; };
+
+  template<typename _Tp, size_t _Bound>
+    struct _MakeUniq<_Tp[_Bound]>
+    { struct __invalid_type { }; };
+
+
+
+
+  template<typename _Tp, typename... _Args>
+    inline typename _MakeUniq<_Tp>::__single_object
+    make_unique(_Args&&... __args)
+    { return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...)); }
+
+
+  template<typename _Tp>
+    inline typename _MakeUniq<_Tp>::__array
+    make_unique(size_t __num)
+    { return unique_ptr<_Tp>(new remove_extent_t<_Tp>[__num]()); }
+
+
+  template<typename _Tp, typename... _Args>
+    inline typename _MakeUniq<_Tp>::__invalid_type
+    make_unique(_Args&&...) = delete;
+# 995 "/usr/include/c++/10.2.0/bits/unique_ptr.h" 3
+  namespace __detail::__variant
+  {
+    template<typename> struct _Never_valueless_alt;
+
+
+
+    template<typename _Tp, typename _Del>
+      struct _Never_valueless_alt<std::unique_ptr<_Tp, _Del>>
+      : std::true_type
+      { };
+  }
+
+
+
+}
+# 84 "/usr/include/c++/10.2.0/memory" 2 3
+# 1 "/usr/include/c++/10.2.0/bits/shared_ptr.h" 1 3
+# 50 "/usr/include/c++/10.2.0/bits/shared_ptr.h" 3
+#define _SHARED_PTR_H 1
+
+# 1 "/usr/include/c++/10.2.0/bits/shared_ptr_base.h" 1 3
+# 50 "/usr/include/c++/10.2.0/bits/shared_ptr_base.h" 3
+#define _SHARED_PTR_BASE_H 1
+
+
+# 1 "/usr/include/c++/10.2.0/bits/allocated_ptr.h" 1 3
+# 31 "/usr/include/c++/10.2.0/bits/allocated_ptr.h" 3
+#define _ALLOCATED_PTR_H 1
+# 40 "/usr/include/c++/10.2.0/bits/allocated_ptr.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+  template<typename _Alloc>
+    struct __allocated_ptr
+    {
+      using pointer = typename allocator_traits<_Alloc>::pointer;
+      using value_type = typename allocator_traits<_Alloc>::value_type;
+
+
+      __allocated_ptr(_Alloc& __a, pointer __ptr) noexcept
+      : _M_alloc(std::__addressof(__a)), _M_ptr(__ptr)
+      { }
+
+
+      template<typename _Ptr,
+        typename _Req = _Require<is_same<_Ptr, value_type*>>>
+      __allocated_ptr(_Alloc& __a, _Ptr __ptr)
+      : _M_alloc(std::__addressof(__a)),
+ _M_ptr(pointer_traits<pointer>::pointer_to(*__ptr))
+      { }
+
+
+      __allocated_ptr(__allocated_ptr&& __gd) noexcept
+      : _M_alloc(__gd._M_alloc), _M_ptr(__gd._M_ptr)
+      { __gd._M_ptr = nullptr; }
+
+
+      ~__allocated_ptr()
+      {
+ if (_M_ptr != nullptr)
+   std::allocator_traits<_Alloc>::deallocate(*_M_alloc, _M_ptr, 1);
+      }
+
+
+      __allocated_ptr&
+      operator=(std::nullptr_t) noexcept
+      {
+ _M_ptr = nullptr;
+ return *this;
+      }
+
+
+      value_type* get() { return std::__to_address(_M_ptr); }
+
+    private:
+      _Alloc* _M_alloc;
+      pointer _M_ptr;
+    };
+
+
+  template<typename _Alloc>
+    __allocated_ptr<_Alloc>
+    __allocate_guarded(_Alloc& __a)
+    {
+      return { __a, std::allocator_traits<_Alloc>::allocate(__a, 1) };
+    }
+
+
+}
+# 54 "/usr/include/c++/10.2.0/bits/shared_ptr_base.h" 2 3
+# 1 "/usr/include/c++/10.2.0/bits/refwrap.h" 1 3
+# 31 "/usr/include/c++/10.2.0/bits/refwrap.h" 3
+#define _GLIBCXX_REFWRAP_H 1
+
+       
+# 34 "/usr/include/c++/10.2.0/bits/refwrap.h" 3
+# 43 "/usr/include/c++/10.2.0/bits/refwrap.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 54 "/usr/include/c++/10.2.0/bits/refwrap.h" 3
+  template<typename _Res, typename... _ArgTypes>
+    struct _Maybe_unary_or_binary_function { };
+
+
+  template<typename _Res, typename _T1>
+    struct _Maybe_unary_or_binary_function<_Res, _T1>
+    : std::unary_function<_T1, _Res> { };
+
+
+  template<typename _Res, typename _T1, typename _T2>
+    struct _Maybe_unary_or_binary_function<_Res, _T1, _T2>
+    : std::binary_function<_T1, _T2, _Res> { };
+
+  template<typename _Signature>
+    struct _Mem_fn_traits;
+
+  template<typename _Res, typename _Class, typename... _ArgTypes>
+    struct _Mem_fn_traits_base
+    {
+      using __result_type = _Res;
+      using __maybe_type
+ = _Maybe_unary_or_binary_function<_Res, _Class*, _ArgTypes...>;
+      using __arity = integral_constant<size_t, sizeof...(_ArgTypes)>;
+    };
+
+#define _GLIBCXX_MEM_FN_TRAITS2(_CV,_REF,_LVAL,_RVAL) template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) _CV _REF> : _Mem_fn_traits_base<_Res, _CV _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) _CV _REF> : _Mem_fn_traits_base<_Res, _CV _Class, _ArgTypes...> { using __vararg = true_type; };
+# 93 "/usr/include/c++/10.2.0/bits/refwrap.h" 3
+#define _GLIBCXX_MEM_FN_TRAITS(_REF,_LVAL,_RVAL) _GLIBCXX_MEM_FN_TRAITS2( , _REF, _LVAL, _RVAL) _GLIBCXX_MEM_FN_TRAITS2(const , _REF, _LVAL, _RVAL) _GLIBCXX_MEM_FN_TRAITS2(volatile , _REF, _LVAL, _RVAL) _GLIBCXX_MEM_FN_TRAITS2(const volatile, _REF, _LVAL, _RVAL)
+
+
+
+
+
+template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) > : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) > : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const > : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const > : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile > : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile > : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile > : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile > : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; };
+template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) &> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) &> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const &> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const &> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile &> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile &> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile &> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile &> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; };
+template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) &&> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) &&> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const &&> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const &&> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile &&> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile &&> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile &&> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile &&> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; };
+
+
+template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; };
+template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) & noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) & noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const & noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const & noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile & noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile & noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile & noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile & noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; };
+template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) && noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) && noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const && noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const && noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile && noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile && noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile && noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile && noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; };
+
+
+#undef _GLIBCXX_MEM_FN_TRAITS
+#undef _GLIBCXX_MEM_FN_TRAITS2
+
+
+  template<typename _Functor, typename = __void_t<>>
+    struct _Maybe_get_result_type
+    { };
+
+  template<typename _Functor>
+    struct _Maybe_get_result_type<_Functor,
+      __void_t<typename _Functor::result_type>>
+    { typedef typename _Functor::result_type result_type; };
+
+
+
+
+
+  template<typename _Functor>
+    struct _Weak_result_type_impl
+    : _Maybe_get_result_type<_Functor>
+    { };
+
+
+  template<typename _Res, typename... _ArgTypes , bool _NE>
+    struct _Weak_result_type_impl<_Res(_ArgTypes...) noexcept (_NE)>
+    { typedef _Res result_type; };
+
+
+  template<typename _Res, typename... _ArgTypes , bool _NE>
+    struct _Weak_result_type_impl<_Res(_ArgTypes......) noexcept (_NE)>
+    { typedef _Res result_type; };
+
+
+  template<typename _Res, typename... _ArgTypes , bool _NE>
+    struct _Weak_result_type_impl<_Res(*)(_ArgTypes...) noexcept (_NE)>
+    { typedef _Res result_type; };
+
+
+  template<typename _Res, typename... _ArgTypes , bool _NE>
+    struct
+    _Weak_result_type_impl<_Res(*)(_ArgTypes......) noexcept (_NE)>
+    { typedef _Res result_type; };
+
+
+  template<typename _Functor,
+    bool = is_member_function_pointer<_Functor>::value>
+    struct _Weak_result_type_memfun
+    : _Weak_result_type_impl<_Functor>
+    { };
+
+
+  template<typename _MemFunPtr>
+    struct _Weak_result_type_memfun<_MemFunPtr, true>
+    {
+      using result_type = typename _Mem_fn_traits<_MemFunPtr>::__result_type;
+    };
+
+
+  template<typename _Func, typename _Class>
+    struct _Weak_result_type_memfun<_Func _Class::*, false>
+    { };
+
+
+
+
+
+  template<typename _Functor>
+    struct _Weak_result_type
+    : _Weak_result_type_memfun<typename remove_cv<_Functor>::type>
+    { };
+
+
+
+  template<typename _Tp, typename = __void_t<>>
+    struct _Refwrap_base_arg1
+    { };
+
+
+  template<typename _Tp>
+    struct _Refwrap_base_arg1<_Tp,
+         __void_t<typename _Tp::argument_type>>
+    {
+      typedef typename _Tp::argument_type argument_type;
+    };
+
+
+  template<typename _Tp, typename = __void_t<>>
+    struct _Refwrap_base_arg2
+    { };
+
+
+  template<typename _Tp>
+    struct _Refwrap_base_arg2<_Tp,
+         __void_t<typename _Tp::first_argument_type,
+           typename _Tp::second_argument_type>>
+    {
+      typedef typename _Tp::first_argument_type first_argument_type;
+      typedef typename _Tp::second_argument_type second_argument_type;
+    };
+
+
+
+
+
+
+
+  template<typename _Tp>
+    struct _Reference_wrapper_base
+    : _Weak_result_type<_Tp>, _Refwrap_base_arg1<_Tp>, _Refwrap_base_arg2<_Tp>
+    { };
+
+
+  template<typename _Res, typename _T1 , bool _NE>
+    struct _Reference_wrapper_base<_Res(_T1) noexcept (_NE)>
+    : unary_function<_T1, _Res>
+    { };
+
+  template<typename _Res, typename _T1>
+    struct _Reference_wrapper_base<_Res(_T1) const>
+    : unary_function<_T1, _Res>
+    { };
+
+  template<typename _Res, typename _T1>
+    struct _Reference_wrapper_base<_Res(_T1) volatile>
+    : unary_function<_T1, _Res>
+    { };
+
+  template<typename _Res, typename _T1>
+    struct _Reference_wrapper_base<_Res(_T1) const volatile>
+    : unary_function<_T1, _Res>
+    { };
+
+
+  template<typename _Res, typename _T1, typename _T2 , bool _NE>
+    struct _Reference_wrapper_base<_Res(_T1, _T2) noexcept (_NE)>
+    : binary_function<_T1, _T2, _Res>
+    { };
+
+  template<typename _Res, typename _T1, typename _T2>
+    struct _Reference_wrapper_base<_Res(_T1, _T2) const>
+    : binary_function<_T1, _T2, _Res>
+    { };
+
+  template<typename _Res, typename _T1, typename _T2>
+    struct _Reference_wrapper_base<_Res(_T1, _T2) volatile>
+    : binary_function<_T1, _T2, _Res>
+    { };
+
+  template<typename _Res, typename _T1, typename _T2>
+    struct _Reference_wrapper_base<_Res(_T1, _T2) const volatile>
+    : binary_function<_T1, _T2, _Res>
+    { };
+
+
+  template<typename _Res, typename _T1 , bool _NE>
+    struct _Reference_wrapper_base<_Res(*)(_T1) noexcept (_NE)>
+    : unary_function<_T1, _Res>
+    { };
+
+
+  template<typename _Res, typename _T1, typename _T2 , bool _NE>
+    struct _Reference_wrapper_base<_Res(*)(_T1, _T2) noexcept (_NE)>
+    : binary_function<_T1, _T2, _Res>
+    { };
+
+  template<typename _Tp, bool = is_member_function_pointer<_Tp>::value>
+    struct _Reference_wrapper_base_memfun
+    : _Reference_wrapper_base<_Tp>
+    { };
+
+  template<typename _MemFunPtr>
+    struct _Reference_wrapper_base_memfun<_MemFunPtr, true>
+    : _Mem_fn_traits<_MemFunPtr>::__maybe_type
+    {
+      using result_type = typename _Mem_fn_traits<_MemFunPtr>::__result_type;
+    };
+# 293 "/usr/include/c++/10.2.0/bits/refwrap.h" 3
+  template<typename _Tp>
+    class reference_wrapper
+
+
+
+    : public _Reference_wrapper_base_memfun<typename remove_cv<_Tp>::type>
+
+    {
+      _Tp* _M_data;
+
+     
+      static _Tp* _S_fun(_Tp& __r) noexcept { return std::__addressof(__r); }
+
+      static void _S_fun(_Tp&&) = delete;
+
+      template<typename _Up, typename _Up2 = __remove_cvref_t<_Up>>
+ using __not_same
+   = typename enable_if<!is_same<reference_wrapper, _Up2>::value>::type;
+
+    public:
+      typedef _Tp type;
+
+
+
+
+      template<typename _Up, typename = __not_same<_Up>, typename
+  = decltype(reference_wrapper::_S_fun(std::declval<_Up>()))>
+
+ reference_wrapper(_Up&& __uref)
+ noexcept(noexcept(reference_wrapper::_S_fun(std::declval<_Up>())))
+ : _M_data(reference_wrapper::_S_fun(std::forward<_Up>(__uref)))
+ { }
+
+      reference_wrapper(const reference_wrapper&) = default;
+
+      reference_wrapper&
+      operator=(const reference_wrapper&) = default;
+
+     
+      operator _Tp&() const noexcept
+      { return this->get(); }
+
+     
+      _Tp&
+      get() const noexcept
+      { return *_M_data; }
+
+      template<typename... _Args>
+
+ typename result_of<_Tp&(_Args&&...)>::type
+ operator()(_Args&&... __args) const
+ {
+
+
+
+
+   return std::__invoke(get(), std::forward<_Args>(__args)...);
+ }
+    };
+
+
+  template<typename _Tp>
+    reference_wrapper(_Tp&) -> reference_wrapper<_Tp>;
+
+
+
+
+
+  template<typename _Tp>
+   
+    inline reference_wrapper<_Tp>
+    ref(_Tp& __t) noexcept
+    { return reference_wrapper<_Tp>(__t); }
+
+
+  template<typename _Tp>
+   
+    inline reference_wrapper<const _Tp>
+    cref(const _Tp& __t) noexcept
+    { return reference_wrapper<const _Tp>(__t); }
+
+  template<typename _Tp>
+    void ref(const _Tp&&) = delete;
+
+  template<typename _Tp>
+    void cref(const _Tp&&) = delete;
+
+
+  template<typename _Tp>
+   
+    inline reference_wrapper<_Tp>
+    ref(reference_wrapper<_Tp> __t) noexcept
+    { return __t; }
+
+
+  template<typename _Tp>
+   
+    inline reference_wrapper<const _Tp>
+    cref(reference_wrapper<_Tp> __t) noexcept
+    { return { __t.get() }; }
+
+
+
+
+}
+# 55 "/usr/include/c++/10.2.0/bits/shared_ptr_base.h" 2 3
+
+# 1 "/usr/include/c++/10.2.0/ext/aligned_buffer.h" 1 3
+# 30 "/usr/include/c++/10.2.0/ext/aligned_buffer.h" 3
+#define _ALIGNED_BUFFER_H 1
+
+       
+# 33 "/usr/include/c++/10.2.0/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()); }
+    };
+# 89 "/usr/include/c++/10.2.0/ext/aligned_buffer.h" 3
+  template<typename _Tp>
+    struct __aligned_buffer
+    : std::aligned_storage<sizeof(_Tp), __alignof__(_Tp)>
+    {
+      typename
+ std::aligned_storage<sizeof(_Tp), __alignof__(_Tp)>::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()); }
+    };
+
+
+}
+# 57 "/usr/include/c++/10.2.0/bits/shared_ptr_base.h" 2 3
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+  template<typename> class auto_ptr;
+#pragma GCC diagnostic pop
+
+
+
+
+
+
+  class bad_weak_ptr : public std::exception
+  {
+  public:
+    virtual char const* what() const noexcept;
+
+    virtual ~bad_weak_ptr() noexcept;
+  };
+
+
+  inline void
+  __throw_bad_weak_ptr()
+  { (throw (bad_weak_ptr())); }
+
+  using __gnu_cxx::_Lock_policy;
+  using __gnu_cxx::__default_lock_policy;
+  using __gnu_cxx::_S_single;
+  using __gnu_cxx::_S_mutex;
+  using __gnu_cxx::_S_atomic;
+
+
+  template<_Lock_policy _Lp>
+    class _Mutex_base
+    {
+    protected:
+
+      enum { _S_need_barriers = 0 };
+    };
+
+  template<>
+    class _Mutex_base<_S_mutex>
+    : public __gnu_cxx::__mutex
+    {
+    protected:
+
+
+
+      enum { _S_need_barriers = 1 };
+    };
+
+  template<_Lock_policy _Lp = __default_lock_policy>
+    class _Sp_counted_base
+    : public _Mutex_base<_Lp>
+    {
+    public:
+      _Sp_counted_base() noexcept
+      : _M_use_count(1), _M_weak_count(1) { }
+
+      virtual
+      ~_Sp_counted_base() noexcept
+      { }
+
+
+
+      virtual void
+      _M_dispose() noexcept = 0;
+
+
+      virtual void
+      _M_destroy() noexcept
+      { delete this; }
+
+      virtual void*
+      _M_get_deleter(const std::type_info&) noexcept = 0;
+
+      void
+      _M_add_ref_copy()
+      { __gnu_cxx::__atomic_add_dispatch(&_M_use_count, 1); }
+
+      void
+      _M_add_ref_lock();
+
+      bool
+      _M_add_ref_lock_nothrow();
+
+      void
+      _M_release() noexcept
+      {
+
+        ;
+ if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) == 1)
+   {
+            ;
+     _M_dispose();
+
+
+
+
+     if (_Mutex_base<_Lp>::_S_need_barriers)
+       {
+  __atomic_thread_fence (4);
+       }
+
+
+            ;
+     if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count,
+             -1) == 1)
+              {
+                ;
+         _M_destroy();
+              }
+   }
+      }
+
+      void
+      _M_weak_add_ref() noexcept
+      { __gnu_cxx::__atomic_add_dispatch(&_M_weak_count, 1); }
+
+      void
+      _M_weak_release() noexcept
+      {
+
+        ;
+ if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count, -1) == 1)
+   {
+            ;
+     if (_Mutex_base<_Lp>::_S_need_barriers)
+       {
+
+
+  __atomic_thread_fence (4);
+       }
+     _M_destroy();
+   }
+      }
+
+      long
+      _M_get_use_count() const noexcept
+      {
+
+
+        return __atomic_load_n(&_M_use_count, 0);
+      }
+
+    private:
+      _Sp_counted_base(_Sp_counted_base const&) = delete;
+      _Sp_counted_base& operator=(_Sp_counted_base const&) = delete;
+
+      _Atomic_word _M_use_count;
+      _Atomic_word _M_weak_count;
+    };
+
+  template<>
+    inline void
+    _Sp_counted_base<_S_single>::
+    _M_add_ref_lock()
+    {
+      if (_M_use_count == 0)
+ __throw_bad_weak_ptr();
+      ++_M_use_count;
+    }
+
+  template<>
+    inline void
+    _Sp_counted_base<_S_mutex>::
+    _M_add_ref_lock()
+    {
+      __gnu_cxx::__scoped_lock sentry(*this);
+      if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, 1) == 0)
+ {
+   _M_use_count = 0;
+   __throw_bad_weak_ptr();
+ }
+    }
+
+  template<>
+    inline void
+    _Sp_counted_base<_S_atomic>::
+    _M_add_ref_lock()
+    {
+
+      _Atomic_word __count = _M_get_use_count();
+      do
+ {
+   if (__count == 0)
+     __throw_bad_weak_ptr();
+
+
+ }
+      while (!__atomic_compare_exchange_n(&_M_use_count, &__count, __count + 1,
+       true, 4,
+       0));
+    }
+
+  template<>
+    inline bool
+    _Sp_counted_base<_S_single>::
+    _M_add_ref_lock_nothrow()
+    {
+      if (_M_use_count == 0)
+ return false;
+      ++_M_use_count;
+      return true;
+    }
+
+  template<>
+    inline bool
+    _Sp_counted_base<_S_mutex>::
+    _M_add_ref_lock_nothrow()
+    {
+      __gnu_cxx::__scoped_lock sentry(*this);
+      if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, 1) == 0)
+ {
+   _M_use_count = 0;
+   return false;
+ }
+      return true;
+    }
+
+  template<>
+    inline bool
+    _Sp_counted_base<_S_atomic>::
+    _M_add_ref_lock_nothrow()
+    {
+
+      _Atomic_word __count = _M_get_use_count();
+      do
+ {
+   if (__count == 0)
+     return false;
+
+
+ }
+      while (!__atomic_compare_exchange_n(&_M_use_count, &__count, __count + 1,
+       true, 4,
+       0));
+      return true;
+    }
+
+  template<>
+    inline void
+    _Sp_counted_base<_S_single>::_M_add_ref_copy()
+    { ++_M_use_count; }
+
+  template<>
+    inline void
+    _Sp_counted_base<_S_single>::_M_release() noexcept
+    {
+      if (--_M_use_count == 0)
+        {
+          _M_dispose();
+          if (--_M_weak_count == 0)
+            _M_destroy();
+        }
+    }
+
+  template<>
+    inline void
+    _Sp_counted_base<_S_single>::_M_weak_add_ref() noexcept
+    { ++_M_weak_count; }
+
+  template<>
+    inline void
+    _Sp_counted_base<_S_single>::_M_weak_release() noexcept
+    {
+      if (--_M_weak_count == 0)
+        _M_destroy();
+    }
+
+  template<>
+    inline long
+    _Sp_counted_base<_S_single>::_M_get_use_count() const noexcept
+    { return _M_use_count; }
+
+
+
+  template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
+    class __shared_ptr;
+
+  template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
+    class __weak_ptr;
+
+  template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
+    class __enable_shared_from_this;
+
+  template<typename _Tp>
+    class shared_ptr;
+
+  template<typename _Tp>
+    class weak_ptr;
+
+  template<typename _Tp>
+    struct owner_less;
+
+  template<typename _Tp>
+    class enable_shared_from_this;
+
+  template<_Lock_policy _Lp = __default_lock_policy>
+    class __weak_count;
+
+  template<_Lock_policy _Lp = __default_lock_policy>
+    class __shared_count;
+
+
+
+  template<typename _Ptr, _Lock_policy _Lp>
+    class _Sp_counted_ptr final : public _Sp_counted_base<_Lp>
+    {
+    public:
+      explicit
+      _Sp_counted_ptr(_Ptr __p) noexcept
+      : _M_ptr(__p) { }
+
+      virtual void
+      _M_dispose() noexcept
+      { delete _M_ptr; }
+
+      virtual void
+      _M_destroy() noexcept
+      { delete this; }
+
+      virtual void*
+      _M_get_deleter(const std::type_info&) noexcept
+      { return nullptr; }
+
+      _Sp_counted_ptr(const _Sp_counted_ptr&) = delete;
+      _Sp_counted_ptr& operator=(const _Sp_counted_ptr&) = delete;
+
+    private:
+      _Ptr _M_ptr;
+    };
+
+  template<>
+    inline void
+    _Sp_counted_ptr<nullptr_t, _S_single>::_M_dispose() noexcept { }
+
+  template<>
+    inline void
+    _Sp_counted_ptr<nullptr_t, _S_mutex>::_M_dispose() noexcept { }
+
+  template<>
+    inline void
+    _Sp_counted_ptr<nullptr_t, _S_atomic>::_M_dispose() noexcept { }
+
+  template<int _Nm, typename _Tp,
+    bool __use_ebo = !__is_final(_Tp) && __is_empty(_Tp)>
+    struct _Sp_ebo_helper;
+
+
+  template<int _Nm, typename _Tp>
+    struct _Sp_ebo_helper<_Nm, _Tp, true> : private _Tp
+    {
+      explicit _Sp_ebo_helper(const _Tp& __tp) : _Tp(__tp) { }
+      explicit _Sp_ebo_helper(_Tp&& __tp) : _Tp(std::move(__tp)) { }
+
+      static _Tp&
+      _S_get(_Sp_ebo_helper& __eboh) { return static_cast<_Tp&>(__eboh); }
+    };
+
+
+  template<int _Nm, typename _Tp>
+    struct _Sp_ebo_helper<_Nm, _Tp, false>
+    {
+      explicit _Sp_ebo_helper(const _Tp& __tp) : _M_tp(__tp) { }
+      explicit _Sp_ebo_helper(_Tp&& __tp) : _M_tp(std::move(__tp)) { }
+
+      static _Tp&
+      _S_get(_Sp_ebo_helper& __eboh)
+      { return __eboh._M_tp; }
+
+    private:
+      _Tp _M_tp;
+    };
+
+
+  template<typename _Ptr, typename _Deleter, typename _Alloc, _Lock_policy _Lp>
+    class _Sp_counted_deleter final : public _Sp_counted_base<_Lp>
+    {
+      class _Impl : _Sp_ebo_helper<0, _Deleter>, _Sp_ebo_helper<1, _Alloc>
+      {
+ typedef _Sp_ebo_helper<0, _Deleter> _Del_base;
+ typedef _Sp_ebo_helper<1, _Alloc> _Alloc_base;
+
+      public:
+ _Impl(_Ptr __p, _Deleter __d, const _Alloc& __a) noexcept
+ : _M_ptr(__p), _Del_base(std::move(__d)), _Alloc_base(__a)
+ { }
+
+ _Deleter& _M_del() noexcept { return _Del_base::_S_get(*this); }
+ _Alloc& _M_alloc() noexcept { return _Alloc_base::_S_get(*this); }
+
+ _Ptr _M_ptr;
+      };
+
+    public:
+      using __allocator_type = __alloc_rebind<_Alloc, _Sp_counted_deleter>;
+
+
+      _Sp_counted_deleter(_Ptr __p, _Deleter __d) noexcept
+      : _M_impl(__p, std::move(__d), _Alloc()) { }
+
+
+      _Sp_counted_deleter(_Ptr __p, _Deleter __d, const _Alloc& __a) noexcept
+      : _M_impl(__p, std::move(__d), __a) { }
+
+      ~_Sp_counted_deleter() noexcept { }
+
+      virtual void
+      _M_dispose() noexcept
+      { _M_impl._M_del()(_M_impl._M_ptr); }
+
+      virtual void
+      _M_destroy() noexcept
+      {
+ __allocator_type __a(_M_impl._M_alloc());
+ __allocated_ptr<__allocator_type> __guard_ptr{ __a, this };
+ this->~_Sp_counted_deleter();
+      }
+
+      virtual void*
+      _M_get_deleter(const std::type_info& __ti) noexcept
+      {
+
+
+
+        return __ti == typeid(_Deleter)
+   ? std::__addressof(_M_impl._M_del())
+   : nullptr;
+
+
+
+      }
+
+    private:
+      _Impl _M_impl;
+    };
+
+
+
+  struct _Sp_make_shared_tag
+  {
+  private:
+    template<typename _Tp, typename _Alloc, _Lock_policy _Lp>
+      friend class _Sp_counted_ptr_inplace;
+
+    static const type_info&
+    _S_ti() noexcept __attribute__ ((__visibility__ ("default")))
+    {
+      alignas(type_info) static constexpr char __tag[sizeof(type_info)] = { };
+      return reinterpret_cast<const type_info&>(__tag);
+    }
+
+    static bool _S_eq(const type_info&) noexcept;
+  };
+
+  template<typename _Alloc>
+    struct _Sp_alloc_shared_tag
+    {
+      const _Alloc& _M_a;
+    };
+
+  template<typename _Tp, typename _Alloc, _Lock_policy _Lp>
+    class _Sp_counted_ptr_inplace final : public _Sp_counted_base<_Lp>
+    {
+      class _Impl : _Sp_ebo_helper<0, _Alloc>
+      {
+ typedef _Sp_ebo_helper<0, _Alloc> _A_base;
+
+      public:
+ explicit _Impl(_Alloc __a) noexcept : _A_base(__a) { }
+
+ _Alloc& _M_alloc() noexcept { return _A_base::_S_get(*this); }
+
+ __gnu_cxx::__aligned_buffer<_Tp> _M_storage;
+      };
+
+    public:
+      using __allocator_type = __alloc_rebind<_Alloc, _Sp_counted_ptr_inplace>;
+
+
+      template<typename... _Args>
+ _Sp_counted_ptr_inplace(_Alloc __a, _Args&&... __args)
+ : _M_impl(__a)
+ {
+
+
+   allocator_traits<_Alloc>::construct(__a, _M_ptr(),
+       std::forward<_Args>(__args)...);
+ }
+
+      ~_Sp_counted_ptr_inplace() noexcept { }
+
+      virtual void
+      _M_dispose() noexcept
+      {
+ allocator_traits<_Alloc>::destroy(_M_impl._M_alloc(), _M_ptr());
+      }
+
+
+      virtual void
+      _M_destroy() noexcept
+      {
+ __allocator_type __a(_M_impl._M_alloc());
+ __allocated_ptr<__allocator_type> __guard_ptr{ __a, this };
+ this->~_Sp_counted_ptr_inplace();
+      }
+
+    private:
+      friend class __shared_count<_Lp>;
+
+
+
+      virtual void*
+      _M_get_deleter(const std::type_info& __ti) noexcept override
+      {
+ auto __ptr = const_cast<typename remove_cv<_Tp>::type*>(_M_ptr());
+
+
+
+
+ if (&__ti == &_Sp_make_shared_tag::_S_ti()
+     ||
+
+     __ti == typeid(_Sp_make_shared_tag)
+
+
+
+    )
+   return __ptr;
+ return nullptr;
+      }
+
+      _Tp* _M_ptr() noexcept { return _M_impl._M_storage._M_ptr(); }
+
+      _Impl _M_impl;
+    };
+
+
+  struct __sp_array_delete
+  {
+    template<typename _Yp>
+      void operator()(_Yp* __p) const { delete[] __p; }
+  };
+
+  template<_Lock_policy _Lp>
+    class __shared_count
+    {
+      template<typename _Tp>
+ struct __not_alloc_shared_tag { using type = void; };
+
+      template<typename _Tp>
+ struct __not_alloc_shared_tag<_Sp_alloc_shared_tag<_Tp>> { };
+
+    public:
+      constexpr __shared_count() noexcept : _M_pi(0)
+      { }
+
+      template<typename _Ptr>
+        explicit
+ __shared_count(_Ptr __p) : _M_pi(0)
+ {
+   try
+     {
+       _M_pi = new _Sp_counted_ptr<_Ptr, _Lp>(__p);
+     }
+   catch(...)
+     {
+       delete __p;
+       throw;
+     }
+ }
+
+      template<typename _Ptr>
+ __shared_count(_Ptr __p, false_type)
+ : __shared_count(__p)
+ { }
+
+      template<typename _Ptr>
+ __shared_count(_Ptr __p, true_type)
+ : __shared_count(__p, __sp_array_delete{}, allocator<void>())
+ { }
+
+      template<typename _Ptr, typename _Deleter,
+        typename = typename __not_alloc_shared_tag<_Deleter>::type>
+ __shared_count(_Ptr __p, _Deleter __d)
+ : __shared_count(__p, std::move(__d), allocator<void>())
+ { }
+
+      template<typename _Ptr, typename _Deleter, typename _Alloc,
+        typename = typename __not_alloc_shared_tag<_Deleter>::type>
+ __shared_count(_Ptr __p, _Deleter __d, _Alloc __a) : _M_pi(0)
+ {
+   typedef _Sp_counted_deleter<_Ptr, _Deleter, _Alloc, _Lp> _Sp_cd_type;
+   try
+     {
+       typename _Sp_cd_type::__allocator_type __a2(__a);
+       auto __guard = std::__allocate_guarded(__a2);
+       _Sp_cd_type* __mem = __guard.get();
+       ::new (__mem) _Sp_cd_type(__p, std::move(__d), std::move(__a));
+       _M_pi = __mem;
+       __guard = nullptr;
+     }
+   catch(...)
+     {
+       __d(__p);
+       throw;
+     }
+ }
+
+      template<typename _Tp, typename _Alloc, typename... _Args>
+ __shared_count(_Tp*& __p, _Sp_alloc_shared_tag<_Alloc> __a,
+         _Args&&... __args)
+ {
+   typedef _Sp_counted_ptr_inplace<_Tp, _Alloc, _Lp> _Sp_cp_type;
+   typename _Sp_cp_type::__allocator_type __a2(__a._M_a);
+   auto __guard = std::__allocate_guarded(__a2);
+   _Sp_cp_type* __mem = __guard.get();
+   auto __pi = ::new (__mem)
+     _Sp_cp_type(__a._M_a, std::forward<_Args>(__args)...);
+   __guard = nullptr;
+   _M_pi = __pi;
+   __p = __pi->_M_ptr();
+ }
+
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+      template<typename _Tp>
+        explicit
+ __shared_count(std::auto_ptr<_Tp>&& __r);
+#pragma GCC diagnostic pop
+
+
+
+      template<typename _Tp, typename _Del>
+        explicit
+ __shared_count(std::unique_ptr<_Tp, _Del>&& __r) : _M_pi(0)
+ {
+
+
+   if (__r.get() == nullptr)
+     return;
+
+   using _Ptr = typename unique_ptr<_Tp, _Del>::pointer;
+   using _Del2 = typename conditional<is_reference<_Del>::value,
+       reference_wrapper<typename remove_reference<_Del>::type>,
+       _Del>::type;
+   using _Sp_cd_type
+     = _Sp_counted_deleter<_Ptr, _Del2, allocator<void>, _Lp>;
+   using _Alloc = allocator<_Sp_cd_type>;
+   using _Alloc_traits = allocator_traits<_Alloc>;
+   _Alloc __a;
+   _Sp_cd_type* __mem = _Alloc_traits::allocate(__a, 1);
+   _Alloc_traits::construct(__a, __mem, __r.release(),
+       __r.get_deleter());
+   _M_pi = __mem;
+ }
+
+
+      explicit __shared_count(const __weak_count<_Lp>& __r);
+
+
+      explicit __shared_count(const __weak_count<_Lp>& __r, std::nothrow_t);
+
+      ~__shared_count() noexcept
+      {
+ if (_M_pi != nullptr)
+   _M_pi->_M_release();
+      }
+
+      __shared_count(const __shared_count& __r) noexcept
+      : _M_pi(__r._M_pi)
+      {
+ if (_M_pi != 0)
+   _M_pi->_M_add_ref_copy();
+      }
+
+      __shared_count&
+      operator=(const __shared_count& __r) noexcept
+      {
+ _Sp_counted_base<_Lp>* __tmp = __r._M_pi;
+ if (__tmp != _M_pi)
+   {
+     if (__tmp != 0)
+       __tmp->_M_add_ref_copy();
+     if (_M_pi != 0)
+       _M_pi->_M_release();
+     _M_pi = __tmp;
+   }
+ return *this;
+      }
+
+      void
+      _M_swap(__shared_count& __r) noexcept
+      {
+ _Sp_counted_base<_Lp>* __tmp = __r._M_pi;
+ __r._M_pi = _M_pi;
+ _M_pi = __tmp;
+      }
+
+      long
+      _M_get_use_count() const noexcept
+      { return _M_pi != 0 ? _M_pi->_M_get_use_count() : 0; }
+
+      bool
+      _M_unique() const noexcept
+      { return this->_M_get_use_count() == 1; }
+
+      void*
+      _M_get_deleter(const std::type_info& __ti) const noexcept
+      { return _M_pi ? _M_pi->_M_get_deleter(__ti) : nullptr; }
+
+      bool
+      _M_less(const __shared_count& __rhs) const noexcept
+      { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }
+
+      bool
+      _M_less(const __weak_count<_Lp>& __rhs) const noexcept
+      { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }
+
+
+      friend inline bool
+      operator==(const __shared_count& __a, const __shared_count& __b) noexcept
+      { return __a._M_pi == __b._M_pi; }
+
+    private:
+      friend class __weak_count<_Lp>;
+
+      _Sp_counted_base<_Lp>* _M_pi;
+    };
+
+
+  template<_Lock_policy _Lp>
+    class __weak_count
+    {
+    public:
+      constexpr __weak_count() noexcept : _M_pi(nullptr)
+      { }
+
+      __weak_count(const __shared_count<_Lp>& __r) noexcept
+      : _M_pi(__r._M_pi)
+      {
+ if (_M_pi != nullptr)
+   _M_pi->_M_weak_add_ref();
+      }
+
+      __weak_count(const __weak_count& __r) noexcept
+      : _M_pi(__r._M_pi)
+      {
+ if (_M_pi != nullptr)
+   _M_pi->_M_weak_add_ref();
+      }
+
+      __weak_count(__weak_count&& __r) noexcept
+      : _M_pi(__r._M_pi)
+      { __r._M_pi = nullptr; }
+
+      ~__weak_count() noexcept
+      {
+ if (_M_pi != nullptr)
+   _M_pi->_M_weak_release();
+      }
+
+      __weak_count&
+      operator=(const __shared_count<_Lp>& __r) noexcept
+      {
+ _Sp_counted_base<_Lp>* __tmp = __r._M_pi;
+ if (__tmp != nullptr)
+   __tmp->_M_weak_add_ref();
+ if (_M_pi != nullptr)
+   _M_pi->_M_weak_release();
+ _M_pi = __tmp;
+ return *this;
+      }
+
+      __weak_count&
+      operator=(const __weak_count& __r) noexcept
+      {
+ _Sp_counted_base<_Lp>* __tmp = __r._M_pi;
+ if (__tmp != nullptr)
+   __tmp->_M_weak_add_ref();
+ if (_M_pi != nullptr)
+   _M_pi->_M_weak_release();
+ _M_pi = __tmp;
+ return *this;
+      }
+
+      __weak_count&
+      operator=(__weak_count&& __r) noexcept
+      {
+ if (_M_pi != nullptr)
+   _M_pi->_M_weak_release();
+ _M_pi = __r._M_pi;
+        __r._M_pi = nullptr;
+ return *this;
+      }
+
+      void
+      _M_swap(__weak_count& __r) noexcept
+      {
+ _Sp_counted_base<_Lp>* __tmp = __r._M_pi;
+ __r._M_pi = _M_pi;
+ _M_pi = __tmp;
+      }
+
+      long
+      _M_get_use_count() const noexcept
+      { return _M_pi != nullptr ? _M_pi->_M_get_use_count() : 0; }
+
+      bool
+      _M_less(const __weak_count& __rhs) const noexcept
+      { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }
+
+      bool
+      _M_less(const __shared_count<_Lp>& __rhs) const noexcept
+      { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }
+
+
+      friend inline bool
+      operator==(const __weak_count& __a, const __weak_count& __b) noexcept
+      { return __a._M_pi == __b._M_pi; }
+
+    private:
+      friend class __shared_count<_Lp>;
+
+      _Sp_counted_base<_Lp>* _M_pi;
+    };
+
+
+  template<_Lock_policy _Lp>
+    inline
+    __shared_count<_Lp>::__shared_count(const __weak_count<_Lp>& __r)
+    : _M_pi(__r._M_pi)
+    {
+      if (_M_pi != nullptr)
+ _M_pi->_M_add_ref_lock();
+      else
+ __throw_bad_weak_ptr();
+    }
+
+
+  template<_Lock_policy _Lp>
+    inline
+    __shared_count<_Lp>::
+    __shared_count(const __weak_count<_Lp>& __r, std::nothrow_t)
+    : _M_pi(__r._M_pi)
+    {
+      if (_M_pi != nullptr)
+ if (!_M_pi->_M_add_ref_lock_nothrow())
+   _M_pi = nullptr;
+    }
+
+#define __cpp_lib_shared_ptr_arrays 201611L
+
+
+
+
+
+  template<typename _Yp_ptr, typename _Tp_ptr>
+    struct __sp_compatible_with
+    : false_type
+    { };
+
+  template<typename _Yp, typename _Tp>
+    struct __sp_compatible_with<_Yp*, _Tp*>
+    : is_convertible<_Yp*, _Tp*>::type
+    { };
+
+  template<typename _Up, size_t _Nm>
+    struct __sp_compatible_with<_Up(*)[_Nm], _Up(*)[]>
+    : true_type
+    { };
+
+  template<typename _Up, size_t _Nm>
+    struct __sp_compatible_with<_Up(*)[_Nm], const _Up(*)[]>
+    : true_type
+    { };
+
+  template<typename _Up, size_t _Nm>
+    struct __sp_compatible_with<_Up(*)[_Nm], volatile _Up(*)[]>
+    : true_type
+    { };
+
+  template<typename _Up, size_t _Nm>
+    struct __sp_compatible_with<_Up(*)[_Nm], const volatile _Up(*)[]>
+    : true_type
+    { };
+
+
+  template<typename _Up, size_t _Nm, typename _Yp, typename = void>
+    struct __sp_is_constructible_arrN
+    : false_type
+    { };
+
+  template<typename _Up, size_t _Nm, typename _Yp>
+    struct __sp_is_constructible_arrN<_Up, _Nm, _Yp, __void_t<_Yp[_Nm]>>
+    : is_convertible<_Yp(*)[_Nm], _Up(*)[_Nm]>::type
+    { };
+
+
+  template<typename _Up, typename _Yp, typename = void>
+    struct __sp_is_constructible_arr
+    : false_type
+    { };
+
+  template<typename _Up, typename _Yp>
+    struct __sp_is_constructible_arr<_Up, _Yp, __void_t<_Yp[]>>
+    : is_convertible<_Yp(*)[], _Up(*)[]>::type
+    { };
+
+
+  template<typename _Tp, typename _Yp>
+    struct __sp_is_constructible;
+
+
+  template<typename _Up, size_t _Nm, typename _Yp>
+    struct __sp_is_constructible<_Up[_Nm], _Yp>
+    : __sp_is_constructible_arrN<_Up, _Nm, _Yp>::type
+    { };
+
+
+  template<typename _Up, typename _Yp>
+    struct __sp_is_constructible<_Up[], _Yp>
+    : __sp_is_constructible_arr<_Up, _Yp>::type
+    { };
+
+
+  template<typename _Tp, typename _Yp>
+    struct __sp_is_constructible
+    : is_convertible<_Yp*, _Tp*>::type
+    { };
+
+
+
+  template<typename _Tp, _Lock_policy _Lp,
+    bool = is_array<_Tp>::value, bool = is_void<_Tp>::value>
+    class __shared_ptr_access
+    {
+    public:
+      using element_type = _Tp;
+
+      element_type&
+      operator*() const noexcept
+      {
+ ;
+ return *_M_get();
+      }
+
+      element_type*
+      operator->() const noexcept
+      {
+ ;
+ return _M_get();
+      }
+
+    private:
+      element_type*
+      _M_get() const noexcept
+      { return static_cast<const __shared_ptr<_Tp, _Lp>*>(this)->get(); }
+    };
+
+
+  template<typename _Tp, _Lock_policy _Lp>
+    class __shared_ptr_access<_Tp, _Lp, false, true>
+    {
+    public:
+      using element_type = _Tp;
+
+      element_type*
+      operator->() const noexcept
+      {
+ auto __ptr = static_cast<const __shared_ptr<_Tp, _Lp>*>(this)->get();
+ ;
+ return __ptr;
+      }
+    };
+
+
+  template<typename _Tp, _Lock_policy _Lp>
+    class __shared_ptr_access<_Tp, _Lp, true, false>
+    {
+    public:
+      using element_type = typename remove_extent<_Tp>::type;
+# 1068 "/usr/include/c++/10.2.0/bits/shared_ptr_base.h" 3
+      element_type&
+      operator[](ptrdiff_t __i) const
+      {
+ ;
+ ;
+ return _M_get()[__i];
+      }
+
+    private:
+      element_type*
+      _M_get() const noexcept
+      { return static_cast<const __shared_ptr<_Tp, _Lp>*>(this)->get(); }
+    };
+
+  template<typename _Tp, _Lock_policy _Lp>
+    class __shared_ptr
+    : public __shared_ptr_access<_Tp, _Lp>
+    {
+    public:
+      using element_type = typename remove_extent<_Tp>::type;
+
+    private:
+
+      template<typename _Yp>
+ using _SafeConv
+   = typename enable_if<__sp_is_constructible<_Tp, _Yp>::value>::type;
+
+
+      template<typename _Yp, typename _Res = void>
+ using _Compatible = typename
+   enable_if<__sp_compatible_with<_Yp*, _Tp*>::value, _Res>::type;
+
+
+      template<typename _Yp>
+ using _Assignable = _Compatible<_Yp, __shared_ptr&>;
+
+
+      template<typename _Yp, typename _Del, typename _Res = void,
+        typename _Ptr = typename unique_ptr<_Yp, _Del>::pointer>
+ using _UniqCompatible = typename enable_if<__and_<
+   __sp_compatible_with<_Yp*, _Tp*>, is_convertible<_Ptr, element_type*>
+   >::value, _Res>::type;
+
+
+      template<typename _Yp, typename _Del>
+ using _UniqAssignable = _UniqCompatible<_Yp, _Del, __shared_ptr&>;
+
+    public:
+
+
+      using weak_type = __weak_ptr<_Tp, _Lp>;
+
+
+      constexpr __shared_ptr() noexcept
+      : _M_ptr(0), _M_refcount()
+      { }
+
+      template<typename _Yp, typename = _SafeConv<_Yp>>
+ explicit
+ __shared_ptr(_Yp* __p)
+ : _M_ptr(__p), _M_refcount(__p, typename is_array<_Tp>::type())
+ {
+   static_assert( !is_void<_Yp>::value, "incomplete type" );
+   static_assert( sizeof(_Yp) > 0, "incomplete type" );
+   _M_enable_shared_from_this_with(__p);
+ }
+
+      template<typename _Yp, typename _Deleter, typename = _SafeConv<_Yp>>
+ __shared_ptr(_Yp* __p, _Deleter __d)
+ : _M_ptr(__p), _M_refcount(__p, std::move(__d))
+ {
+   static_assert(__is_invocable<_Deleter&, _Yp*&>::value,
+       "deleter expression d(p) is well-formed");
+   _M_enable_shared_from_this_with(__p);
+ }
+
+      template<typename _Yp, typename _Deleter, typename _Alloc,
+        typename = _SafeConv<_Yp>>
+ __shared_ptr(_Yp* __p, _Deleter __d, _Alloc __a)
+ : _M_ptr(__p), _M_refcount(__p, std::move(__d), std::move(__a))
+ {
+   static_assert(__is_invocable<_Deleter&, _Yp*&>::value,
+       "deleter expression d(p) is well-formed");
+   _M_enable_shared_from_this_with(__p);
+ }
+
+      template<typename _Deleter>
+ __shared_ptr(nullptr_t __p, _Deleter __d)
+ : _M_ptr(0), _M_refcount(__p, std::move(__d))
+ { }
+
+      template<typename _Deleter, typename _Alloc>
+        __shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a)
+ : _M_ptr(0), _M_refcount(__p, std::move(__d), std::move(__a))
+ { }
+
+
+      template<typename _Yp>
+ __shared_ptr(const __shared_ptr<_Yp, _Lp>& __r,
+       element_type* __p) noexcept
+ : _M_ptr(__p), _M_refcount(__r._M_refcount)
+ { }
+
+
+      template<typename _Yp>
+ __shared_ptr(__shared_ptr<_Yp, _Lp>&& __r,
+       element_type* __p) noexcept
+ : _M_ptr(__p), _M_refcount()
+ {
+   _M_refcount._M_swap(__r._M_refcount);
+   __r._M_ptr = 0;
+ }
+
+      __shared_ptr(const __shared_ptr&) noexcept = default;
+      __shared_ptr& operator=(const __shared_ptr&) noexcept = default;
+      ~__shared_ptr() = default;
+
+      template<typename _Yp, typename = _Compatible<_Yp>>
+ __shared_ptr(const __shared_ptr<_Yp, _Lp>& __r) noexcept
+ : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount)
+ { }
+
+      __shared_ptr(__shared_ptr&& __r) noexcept
+      : _M_ptr(__r._M_ptr), _M_refcount()
+      {
+ _M_refcount._M_swap(__r._M_refcount);
+ __r._M_ptr = 0;
+      }
+
+      template<typename _Yp, typename = _Compatible<_Yp>>
+ __shared_ptr(__shared_ptr<_Yp, _Lp>&& __r) noexcept
+ : _M_ptr(__r._M_ptr), _M_refcount()
+ {
+   _M_refcount._M_swap(__r._M_refcount);
+   __r._M_ptr = 0;
+ }
+
+      template<typename _Yp, typename = _Compatible<_Yp>>
+ explicit __shared_ptr(const __weak_ptr<_Yp, _Lp>& __r)
+ : _M_refcount(__r._M_refcount)
+ {
+
+
+   _M_ptr = __r._M_ptr;
+ }
+
+
+      template<typename _Yp, typename _Del,
+        typename = _UniqCompatible<_Yp, _Del>>
+ __shared_ptr(unique_ptr<_Yp, _Del>&& __r)
+ : _M_ptr(__r.get()), _M_refcount()
+ {
+   auto __raw = __to_address(__r.get());
+   _M_refcount = __shared_count<_Lp>(std::move(__r));
+   _M_enable_shared_from_this_with(__raw);
+ }
+# 1244 "/usr/include/c++/10.2.0/bits/shared_ptr_base.h" 3
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+      template<typename _Yp, typename = _Compatible<_Yp>>
+ __shared_ptr(auto_ptr<_Yp>&& __r);
+#pragma GCC diagnostic pop
+
+
+      constexpr __shared_ptr(nullptr_t) noexcept : __shared_ptr() { }
+
+      template<typename _Yp>
+ _Assignable<_Yp>
+ operator=(const __shared_ptr<_Yp, _Lp>& __r) noexcept
+ {
+   _M_ptr = __r._M_ptr;
+   _M_refcount = __r._M_refcount;
+   return *this;
+ }
+
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+      template<typename _Yp>
+ _Assignable<_Yp>
+ operator=(auto_ptr<_Yp>&& __r)
+ {
+   __shared_ptr(std::move(__r)).swap(*this);
+   return *this;
+ }
+#pragma GCC diagnostic pop
+
+
+      __shared_ptr&
+      operator=(__shared_ptr&& __r) noexcept
+      {
+ __shared_ptr(std::move(__r)).swap(*this);
+ return *this;
+      }
+
+      template<class _Yp>
+ _Assignable<_Yp>
+ operator=(__shared_ptr<_Yp, _Lp>&& __r) noexcept
+ {
+   __shared_ptr(std::move(__r)).swap(*this);
+   return *this;
+ }
+
+      template<typename _Yp, typename _Del>
+ _UniqAssignable<_Yp, _Del>
+ operator=(unique_ptr<_Yp, _Del>&& __r)
+ {
+   __shared_ptr(std::move(__r)).swap(*this);
+   return *this;
+ }
+
+      void
+      reset() noexcept
+      { __shared_ptr().swap(*this); }
+
+      template<typename _Yp>
+ _SafeConv<_Yp>
+ reset(_Yp* __p)
+ {
+
+   ;
+   __shared_ptr(__p).swap(*this);
+ }
+
+      template<typename _Yp, typename _Deleter>
+ _SafeConv<_Yp>
+ reset(_Yp* __p, _Deleter __d)
+ { __shared_ptr(__p, std::move(__d)).swap(*this); }
+
+      template<typename _Yp, typename _Deleter, typename _Alloc>
+ _SafeConv<_Yp>
+ reset(_Yp* __p, _Deleter __d, _Alloc __a)
+        { __shared_ptr(__p, std::move(__d), std::move(__a)).swap(*this); }
+
+
+      element_type*
+      get() const noexcept
+      { return _M_ptr; }
+
+
+      explicit operator bool() const
+      { return _M_ptr == 0 ? false : true; }
+
+
+      bool
+      unique() const noexcept
+      { return _M_refcount._M_unique(); }
+
+
+      long
+      use_count() const noexcept
+      { return _M_refcount._M_get_use_count(); }
+
+
+      void
+      swap(__shared_ptr<_Tp, _Lp>& __other) noexcept
+      {
+ std::swap(_M_ptr, __other._M_ptr);
+ _M_refcount._M_swap(__other._M_refcount);
+      }
+# 1356 "/usr/include/c++/10.2.0/bits/shared_ptr_base.h" 3
+      template<typename _Tp1>
+ bool
+ owner_before(__shared_ptr<_Tp1, _Lp> const& __rhs) const noexcept
+ { return _M_refcount._M_less(__rhs._M_refcount); }
+
+      template<typename _Tp1>
+ bool
+ owner_before(__weak_ptr<_Tp1, _Lp> const& __rhs) const noexcept
+ { return _M_refcount._M_less(__rhs._M_refcount); }
+
+
+    protected:
+
+      template<typename _Alloc, typename... _Args>
+ __shared_ptr(_Sp_alloc_shared_tag<_Alloc> __tag, _Args&&... __args)
+ : _M_ptr(), _M_refcount(_M_ptr, __tag, std::forward<_Args>(__args)...)
+ { _M_enable_shared_from_this_with(_M_ptr); }
+
+      template<typename _Tp1, _Lock_policy _Lp1, typename _Alloc,
+        typename... _Args>
+ friend __shared_ptr<_Tp1, _Lp1>
+ __allocate_shared(const _Alloc& __a, _Args&&... __args);
+
+
+
+      __shared_ptr(const __weak_ptr<_Tp, _Lp>& __r, std::nothrow_t)
+      : _M_refcount(__r._M_refcount, std::nothrow)
+      {
+ _M_ptr = _M_refcount._M_get_use_count() ? __r._M_ptr : nullptr;
+      }
+
+      friend class __weak_ptr<_Tp, _Lp>;
+
+    private:
+
+      template<typename _Yp>
+ using __esft_base_t = decltype(__enable_shared_from_this_base(
+       std::declval<const __shared_count<_Lp>&>(),
+       std::declval<_Yp*>()));
+
+
+      template<typename _Yp, typename = void>
+ struct __has_esft_base
+ : false_type { };
+
+      template<typename _Yp>
+ struct __has_esft_base<_Yp, __void_t<__esft_base_t<_Yp>>>
+ : __not_<is_array<_Tp>> { };
+
+      template<typename _Yp, typename _Yp2 = typename remove_cv<_Yp>::type>
+ typename enable_if<__has_esft_base<_Yp2>::value>::type
+ _M_enable_shared_from_this_with(_Yp* __p) noexcept
+ {
+   if (auto __base = __enable_shared_from_this_base(_M_refcount, __p))
+     __base->_M_weak_assign(const_cast<_Yp2*>(__p), _M_refcount);
+ }
+
+      template<typename _Yp, typename _Yp2 = typename remove_cv<_Yp>::type>
+ typename enable_if<!__has_esft_base<_Yp2>::value>::type
+ _M_enable_shared_from_this_with(_Yp*) noexcept
+ { }
+
+      void*
+      _M_get_deleter(const std::type_info& __ti) const noexcept
+      { return _M_refcount._M_get_deleter(__ti); }
+
+      template<typename _Tp1, _Lock_policy _Lp1> friend class __shared_ptr;
+      template<typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr;
+
+      template<typename _Del, typename _Tp1, _Lock_policy _Lp1>
+ friend _Del* get_deleter(const __shared_ptr<_Tp1, _Lp1>&) noexcept;
+
+      template<typename _Del, typename _Tp1>
+ friend _Del* get_deleter(const shared_ptr<_Tp1>&) noexcept;
+
+      element_type* _M_ptr;
+      __shared_count<_Lp> _M_refcount;
+    };
+
+
+
+  template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
+    inline bool
+    operator==(const __shared_ptr<_Tp1, _Lp>& __a,
+        const __shared_ptr<_Tp2, _Lp>& __b) noexcept
+    { return __a.get() == __b.get(); }
+
+  template<typename _Tp, _Lock_policy _Lp>
+    inline bool
+    operator==(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
+    { return !__a; }
+# 1463 "/usr/include/c++/10.2.0/bits/shared_ptr_base.h" 3
+  template<typename _Tp, _Lock_policy _Lp>
+    inline bool
+    operator==(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
+    { return !__a; }
+
+  template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
+    inline bool
+    operator!=(const __shared_ptr<_Tp1, _Lp>& __a,
+        const __shared_ptr<_Tp2, _Lp>& __b) noexcept
+    { return __a.get() != __b.get(); }
+
+  template<typename _Tp, _Lock_policy _Lp>
+    inline bool
+    operator!=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
+    { return (bool)__a; }
+
+  template<typename _Tp, _Lock_policy _Lp>
+    inline bool
+    operator!=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
+    { return (bool)__a; }
+
+  template<typename _Tp, typename _Up, _Lock_policy _Lp>
+    inline bool
+    operator<(const __shared_ptr<_Tp, _Lp>& __a,
+       const __shared_ptr<_Up, _Lp>& __b) noexcept
+    {
+      using _Tp_elt = typename __shared_ptr<_Tp, _Lp>::element_type;
+      using _Up_elt = typename __shared_ptr<_Up, _Lp>::element_type;
+      using _Vp = typename common_type<_Tp_elt*, _Up_elt*>::type;
+      return less<_Vp>()(__a.get(), __b.get());
+    }
+
+  template<typename _Tp, _Lock_policy _Lp>
+    inline bool
+    operator<(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
+    {
+      using _Tp_elt = typename __shared_ptr<_Tp, _Lp>::element_type;
+      return less<_Tp_elt*>()(__a.get(), nullptr);
+    }
+
+  template<typename _Tp, _Lock_policy _Lp>
+    inline bool
+    operator<(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
+    {
+      using _Tp_elt = typename __shared_ptr<_Tp, _Lp>::element_type;
+      return less<_Tp_elt*>()(nullptr, __a.get());
+    }
+
+  template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
+    inline bool
+    operator<=(const __shared_ptr<_Tp1, _Lp>& __a,
+        const __shared_ptr<_Tp2, _Lp>& __b) noexcept
+    { return !(__b < __a); }
+
+  template<typename _Tp, _Lock_policy _Lp>
+    inline bool
+    operator<=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
+    { return !(nullptr < __a); }
+
+  template<typename _Tp, _Lock_policy _Lp>
+    inline bool
+    operator<=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
+    { return !(__a < nullptr); }
+
+  template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
+    inline bool
+    operator>(const __shared_ptr<_Tp1, _Lp>& __a,
+       const __shared_ptr<_Tp2, _Lp>& __b) noexcept
+    { return (__b < __a); }
+
+  template<typename _Tp, _Lock_policy _Lp>
+    inline bool
+    operator>(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
+    { return nullptr < __a; }
+
+  template<typename _Tp, _Lock_policy _Lp>
+    inline bool
+    operator>(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
+    { return __a < nullptr; }
+
+  template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
+    inline bool
+    operator>=(const __shared_ptr<_Tp1, _Lp>& __a,
+        const __shared_ptr<_Tp2, _Lp>& __b) noexcept
+    { return !(__a < __b); }
+
+  template<typename _Tp, _Lock_policy _Lp>
+    inline bool
+    operator>=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
+    { return !(__a < nullptr); }
+
+  template<typename _Tp, _Lock_policy _Lp>
+    inline bool
+    operator>=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
+    { return !(nullptr < __a); }
+
+
+
+  template<typename _Tp, _Lock_policy _Lp>
+    inline void
+    swap(__shared_ptr<_Tp, _Lp>& __a, __shared_ptr<_Tp, _Lp>& __b) noexcept
+    { __a.swap(__b); }
+# 1573 "/usr/include/c++/10.2.0/bits/shared_ptr_base.h" 3
+  template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
+    inline __shared_ptr<_Tp, _Lp>
+    static_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
+    {
+      using _Sp = __shared_ptr<_Tp, _Lp>;
+      return _Sp(__r, static_cast<typename _Sp::element_type*>(__r.get()));
+    }
+
+
+
+
+
+
+  template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
+    inline __shared_ptr<_Tp, _Lp>
+    const_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
+    {
+      using _Sp = __shared_ptr<_Tp, _Lp>;
+      return _Sp(__r, const_cast<typename _Sp::element_type*>(__r.get()));
+    }
+
+
+
+
+
+
+  template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
+    inline __shared_ptr<_Tp, _Lp>
+    dynamic_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
+    {
+      using _Sp = __shared_ptr<_Tp, _Lp>;
+      if (auto* __p = dynamic_cast<typename _Sp::element_type*>(__r.get()))
+ return _Sp(__r, __p);
+      return _Sp();
+    }
+
+
+  template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
+    inline __shared_ptr<_Tp, _Lp>
+    reinterpret_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
+    {
+      using _Sp = __shared_ptr<_Tp, _Lp>;
+      return _Sp(__r, reinterpret_cast<typename _Sp::element_type*>(__r.get()));
+    }
+
+
+  template<typename _Tp, _Lock_policy _Lp>
+    class __weak_ptr
+    {
+      template<typename _Yp, typename _Res = void>
+ using _Compatible = typename
+   enable_if<__sp_compatible_with<_Yp*, _Tp*>::value, _Res>::type;
+
+
+      template<typename _Yp>
+ using _Assignable = _Compatible<_Yp, __weak_ptr&>;
+
+    public:
+      using element_type = typename remove_extent<_Tp>::type;
+
+      constexpr __weak_ptr() noexcept
+      : _M_ptr(nullptr), _M_refcount()
+      { }
+
+      __weak_ptr(const __weak_ptr&) noexcept = default;
+
+      ~__weak_ptr() = default;
+# 1655 "/usr/include/c++/10.2.0/bits/shared_ptr_base.h" 3
+      template<typename _Yp, typename = _Compatible<_Yp>>
+ __weak_ptr(const __weak_ptr<_Yp, _Lp>& __r) noexcept
+ : _M_refcount(__r._M_refcount)
+        { _M_ptr = __r.lock().get(); }
+
+      template<typename _Yp, typename = _Compatible<_Yp>>
+ __weak_ptr(const __shared_ptr<_Yp, _Lp>& __r) noexcept
+ : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount)
+ { }
+
+      __weak_ptr(__weak_ptr&& __r) noexcept
+      : _M_ptr(__r._M_ptr), _M_refcount(std::move(__r._M_refcount))
+      { __r._M_ptr = nullptr; }
+
+      template<typename _Yp, typename = _Compatible<_Yp>>
+ __weak_ptr(__weak_ptr<_Yp, _Lp>&& __r) noexcept
+ : _M_ptr(__r.lock().get()), _M_refcount(std::move(__r._M_refcount))
+        { __r._M_ptr = nullptr; }
+
+      __weak_ptr&
+      operator=(const __weak_ptr& __r) noexcept = default;
+
+      template<typename _Yp>
+ _Assignable<_Yp>
+ operator=(const __weak_ptr<_Yp, _Lp>& __r) noexcept
+ {
+   _M_ptr = __r.lock().get();
+   _M_refcount = __r._M_refcount;
+   return *this;
+ }
+
+      template<typename _Yp>
+ _Assignable<_Yp>
+ operator=(const __shared_ptr<_Yp, _Lp>& __r) noexcept
+ {
+   _M_ptr = __r._M_ptr;
+   _M_refcount = __r._M_refcount;
+   return *this;
+ }
+
+      __weak_ptr&
+      operator=(__weak_ptr&& __r) noexcept
+      {
+ _M_ptr = __r._M_ptr;
+ _M_refcount = std::move(__r._M_refcount);
+ __r._M_ptr = nullptr;
+ return *this;
+      }
+
+      template<typename _Yp>
+ _Assignable<_Yp>
+ operator=(__weak_ptr<_Yp, _Lp>&& __r) noexcept
+ {
+   _M_ptr = __r.lock().get();
+   _M_refcount = std::move(__r._M_refcount);
+   __r._M_ptr = nullptr;
+   return *this;
+ }
+
+      __shared_ptr<_Tp, _Lp>
+      lock() const noexcept
+      { return __shared_ptr<element_type, _Lp>(*this, std::nothrow); }
+
+      long
+      use_count() const noexcept
+      { return _M_refcount._M_get_use_count(); }
+
+      bool
+      expired() const noexcept
+      { return _M_refcount._M_get_use_count() == 0; }
+
+      template<typename _Tp1>
+ bool
+ owner_before(const __shared_ptr<_Tp1, _Lp>& __rhs) const noexcept
+ { return _M_refcount._M_less(__rhs._M_refcount); }
+
+      template<typename _Tp1>
+ bool
+ owner_before(const __weak_ptr<_Tp1, _Lp>& __rhs) const noexcept
+ { return _M_refcount._M_less(__rhs._M_refcount); }
+
+      void
+      reset() noexcept
+      { __weak_ptr().swap(*this); }
+
+      void
+      swap(__weak_ptr& __s) noexcept
+      {
+ std::swap(_M_ptr, __s._M_ptr);
+ _M_refcount._M_swap(__s._M_refcount);
+      }
+
+    private:
+
+      void
+      _M_assign(_Tp* __ptr, const __shared_count<_Lp>& __refcount) noexcept
+      {
+ if (use_count() == 0)
+   {
+     _M_ptr = __ptr;
+     _M_refcount = __refcount;
+   }
+      }
+
+      template<typename _Tp1, _Lock_policy _Lp1> friend class __shared_ptr;
+      template<typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr;
+      friend class __enable_shared_from_this<_Tp, _Lp>;
+      friend class enable_shared_from_this<_Tp>;
+
+      element_type* _M_ptr;
+      __weak_count<_Lp> _M_refcount;
+    };
+
+
+  template<typename _Tp, _Lock_policy _Lp>
+    inline void
+    swap(__weak_ptr<_Tp, _Lp>& __a, __weak_ptr<_Tp, _Lp>& __b) noexcept
+    { __a.swap(__b); }
+
+  template<typename _Tp, typename _Tp1>
+    struct _Sp_owner_less : public binary_function<_Tp, _Tp, bool>
+    {
+      bool
+      operator()(const _Tp& __lhs, const _Tp& __rhs) const noexcept
+      { return __lhs.owner_before(__rhs); }
+
+      bool
+      operator()(const _Tp& __lhs, const _Tp1& __rhs) const noexcept
+      { return __lhs.owner_before(__rhs); }
+
+      bool
+      operator()(const _Tp1& __lhs, const _Tp& __rhs) const noexcept
+      { return __lhs.owner_before(__rhs); }
+    };
+
+  template<>
+    struct _Sp_owner_less<void, void>
+    {
+      template<typename _Tp, typename _Up>
+ auto
+ operator()(const _Tp& __lhs, const _Up& __rhs) const noexcept
+ -> decltype(__lhs.owner_before(__rhs))
+ { return __lhs.owner_before(__rhs); }
+
+      using is_transparent = void;
+    };
+
+  template<typename _Tp, _Lock_policy _Lp>
+    struct owner_less<__shared_ptr<_Tp, _Lp>>
+    : public _Sp_owner_less<__shared_ptr<_Tp, _Lp>, __weak_ptr<_Tp, _Lp>>
+    { };
+
+  template<typename _Tp, _Lock_policy _Lp>
+    struct owner_less<__weak_ptr<_Tp, _Lp>>
+    : public _Sp_owner_less<__weak_ptr<_Tp, _Lp>, __shared_ptr<_Tp, _Lp>>
+    { };
+
+
+  template<typename _Tp, _Lock_policy _Lp>
+    class __enable_shared_from_this
+    {
+    protected:
+      constexpr __enable_shared_from_this() noexcept { }
+
+      __enable_shared_from_this(const __enable_shared_from_this&) noexcept { }
+
+      __enable_shared_from_this&
+      operator=(const __enable_shared_from_this&) noexcept
+      { return *this; }
+
+      ~__enable_shared_from_this() { }
+
+    public:
+      __shared_ptr<_Tp, _Lp>
+      shared_from_this()
+      { return __shared_ptr<_Tp, _Lp>(this->_M_weak_this); }
+
+      __shared_ptr<const _Tp, _Lp>
+      shared_from_this() const
+      { return __shared_ptr<const _Tp, _Lp>(this->_M_weak_this); }
+
+
+      __weak_ptr<_Tp, _Lp>
+      weak_from_this() noexcept
+      { return this->_M_weak_this; }
+
+      __weak_ptr<const _Tp, _Lp>
+      weak_from_this() const noexcept
+      { return this->_M_weak_this; }
+
+
+    private:
+      template<typename _Tp1>
+ void
+ _M_weak_assign(_Tp1* __p, const __shared_count<_Lp>& __n) const noexcept
+ { _M_weak_this._M_assign(__p, __n); }
+
+      friend const __enable_shared_from_this*
+      __enable_shared_from_this_base(const __shared_count<_Lp>&,
+         const __enable_shared_from_this* __p)
+      { return __p; }
+
+      template<typename, _Lock_policy>
+ friend class __shared_ptr;
+
+      mutable __weak_ptr<_Tp, _Lp> _M_weak_this;
+    };
+
+  template<typename _Tp, _Lock_policy _Lp = __default_lock_policy,
+    typename _Alloc, typename... _Args>
+    inline __shared_ptr<_Tp, _Lp>
+    __allocate_shared(const _Alloc& __a, _Args&&... __args)
+    {
+      return __shared_ptr<_Tp, _Lp>(_Sp_alloc_shared_tag<_Alloc>{__a},
+        std::forward<_Args>(__args)...);
+    }
+
+  template<typename _Tp, _Lock_policy _Lp = __default_lock_policy,
+    typename... _Args>
+    inline __shared_ptr<_Tp, _Lp>
+    __make_shared(_Args&&... __args)
+    {
+      typedef typename std::remove_const<_Tp>::type _Tp_nc;
+      return std::__allocate_shared<_Tp, _Lp>(std::allocator<_Tp_nc>(),
+           std::forward<_Args>(__args)...);
+    }
+
+
+  template<typename _Tp, _Lock_policy _Lp>
+    struct hash<__shared_ptr<_Tp, _Lp>>
+    : public __hash_base<size_t, __shared_ptr<_Tp, _Lp>>
+    {
+      size_t
+      operator()(const __shared_ptr<_Tp, _Lp>& __s) const noexcept
+      {
+ return hash<typename __shared_ptr<_Tp, _Lp>::element_type*>()(
+     __s.get());
+      }
+    };
+
+
+}
+# 53 "/usr/include/c++/10.2.0/bits/shared_ptr.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 67 "/usr/include/c++/10.2.0/bits/shared_ptr.h" 3
+  template<typename _Ch, typename _Tr, typename _Tp, _Lock_policy _Lp>
+    inline std::basic_ostream<_Ch, _Tr>&
+    operator<<(std::basic_ostream<_Ch, _Tr>& __os,
+        const __shared_ptr<_Tp, _Lp>& __p)
+    {
+      __os << __p.get();
+      return __os;
+    }
+
+  template<typename _Del, typename _Tp, _Lock_policy _Lp>
+    inline _Del*
+    get_deleter(const __shared_ptr<_Tp, _Lp>& __p) noexcept
+    {
+
+      return static_cast<_Del*>(__p._M_get_deleter(typeid(_Del)));
+
+
+
+    }
+
+
+
+
+
+  template<typename _Del, typename _Tp>
+    inline _Del*
+    get_deleter(const shared_ptr<_Tp>& __p) noexcept
+    {
+
+      return static_cast<_Del*>(__p._M_get_deleter(typeid(_Del)));
+
+
+
+    }
+# 120 "/usr/include/c++/10.2.0/bits/shared_ptr.h" 3
+  template<typename _Tp>
+    class shared_ptr : public __shared_ptr<_Tp>
+    {
+      template<typename... _Args>
+ using _Constructible = typename enable_if<
+   is_constructible<__shared_ptr<_Tp>, _Args...>::value
+ >::type;
+
+      template<typename _Arg>
+ using _Assignable = typename enable_if<
+   is_assignable<__shared_ptr<_Tp>&, _Arg>::value, shared_ptr&
+ >::type;
+
+    public:
+
+
+      using element_type = typename __shared_ptr<_Tp>::element_type;
+
+
+#define __cpp_lib_shared_ptr_weak_type 201606
+
+      using weak_type = weak_ptr<_Tp>;
+
+
+
+
+
+      constexpr shared_ptr() noexcept : __shared_ptr<_Tp>() { }
+
+      shared_ptr(const shared_ptr&) noexcept = default;
+
+
+
+
+
+
+
+      template<typename _Yp, typename = _Constructible<_Yp*>>
+ explicit
+ shared_ptr(_Yp* __p) : __shared_ptr<_Tp>(__p) { }
+# 174 "/usr/include/c++/10.2.0/bits/shared_ptr.h" 3
+      template<typename _Yp, typename _Deleter,
+        typename = _Constructible<_Yp*, _Deleter>>
+ shared_ptr(_Yp* __p, _Deleter __d)
+        : __shared_ptr<_Tp>(__p, std::move(__d)) { }
+# 192 "/usr/include/c++/10.2.0/bits/shared_ptr.h" 3
+      template<typename _Deleter>
+ shared_ptr(nullptr_t __p, _Deleter __d)
+        : __shared_ptr<_Tp>(__p, std::move(__d)) { }
+# 211 "/usr/include/c++/10.2.0/bits/shared_ptr.h" 3
+      template<typename _Yp, typename _Deleter, typename _Alloc,
+        typename = _Constructible<_Yp*, _Deleter, _Alloc>>
+ shared_ptr(_Yp* __p, _Deleter __d, _Alloc __a)
+ : __shared_ptr<_Tp>(__p, std::move(__d), std::move(__a)) { }
+# 231 "/usr/include/c++/10.2.0/bits/shared_ptr.h" 3
+      template<typename _Deleter, typename _Alloc>
+ shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a)
+ : __shared_ptr<_Tp>(__p, std::move(__d), std::move(__a)) { }
+# 255 "/usr/include/c++/10.2.0/bits/shared_ptr.h" 3
+      template<typename _Yp>
+ shared_ptr(const shared_ptr<_Yp>& __r, element_type* __p) noexcept
+ : __shared_ptr<_Tp>(__r, __p) { }
+# 293 "/usr/include/c++/10.2.0/bits/shared_ptr.h" 3
+      template<typename _Yp,
+        typename = _Constructible<const shared_ptr<_Yp>&>>
+ shared_ptr(const shared_ptr<_Yp>& __r) noexcept
+        : __shared_ptr<_Tp>(__r) { }
+
+
+
+
+
+
+      shared_ptr(shared_ptr&& __r) noexcept
+      : __shared_ptr<_Tp>(std::move(__r)) { }
+
+
+
+
+
+
+      template<typename _Yp, typename = _Constructible<shared_ptr<_Yp>>>
+ shared_ptr(shared_ptr<_Yp>&& __r) noexcept
+ : __shared_ptr<_Tp>(std::move(__r)) { }
+# 323 "/usr/include/c++/10.2.0/bits/shared_ptr.h" 3
+      template<typename _Yp, typename = _Constructible<const weak_ptr<_Yp>&>>
+ explicit shared_ptr(const weak_ptr<_Yp>& __r)
+ : __shared_ptr<_Tp>(__r) { }
+
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+      template<typename _Yp, typename = _Constructible<auto_ptr<_Yp>>>
+ shared_ptr(auto_ptr<_Yp>&& __r);
+#pragma GCC diagnostic pop
+
+
+
+
+      template<typename _Yp, typename _Del,
+        typename = _Constructible<unique_ptr<_Yp, _Del>>>
+ shared_ptr(unique_ptr<_Yp, _Del>&& __r)
+ : __shared_ptr<_Tp>(std::move(__r)) { }
+# 356 "/usr/include/c++/10.2.0/bits/shared_ptr.h" 3
+      constexpr shared_ptr(nullptr_t) noexcept : shared_ptr() { }
+
+      shared_ptr& operator=(const shared_ptr&) noexcept = default;
+
+      template<typename _Yp>
+ _Assignable<const shared_ptr<_Yp>&>
+ operator=(const shared_ptr<_Yp>& __r) noexcept
+ {
+   this->__shared_ptr<_Tp>::operator=(__r);
+   return *this;
+ }
+
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+      template<typename _Yp>
+ _Assignable<auto_ptr<_Yp>>
+ operator=(auto_ptr<_Yp>&& __r)
+ {
+   this->__shared_ptr<_Tp>::operator=(std::move(__r));
+   return *this;
+ }
+#pragma GCC diagnostic pop
+
+
+      shared_ptr&
+      operator=(shared_ptr&& __r) noexcept
+      {
+ this->__shared_ptr<_Tp>::operator=(std::move(__r));
+ return *this;
+      }
+
+      template<class _Yp>
+ _Assignable<shared_ptr<_Yp>>
+ operator=(shared_ptr<_Yp>&& __r) noexcept
+ {
+   this->__shared_ptr<_Tp>::operator=(std::move(__r));
+   return *this;
+ }
+
+      template<typename _Yp, typename _Del>
+ _Assignable<unique_ptr<_Yp, _Del>>
+ operator=(unique_ptr<_Yp, _Del>&& __r)
+ {
+   this->__shared_ptr<_Tp>::operator=(std::move(__r));
+   return *this;
+ }
+
+    private:
+
+      template<typename _Alloc, typename... _Args>
+ shared_ptr(_Sp_alloc_shared_tag<_Alloc> __tag, _Args&&... __args)
+ : __shared_ptr<_Tp>(__tag, std::forward<_Args>(__args)...)
+ { }
+
+      template<typename _Yp, typename _Alloc, typename... _Args>
+ friend shared_ptr<_Yp>
+ allocate_shared(const _Alloc& __a, _Args&&... __args);
+
+
+      shared_ptr(const weak_ptr<_Tp>& __r, std::nothrow_t)
+      : __shared_ptr<_Tp>(__r, std::nothrow) { }
+
+      friend class weak_ptr<_Tp>;
+    };
+
+
+  template<typename _Tp>
+    shared_ptr(weak_ptr<_Tp>) -> shared_ptr<_Tp>;
+  template<typename _Tp, typename _Del>
+    shared_ptr(unique_ptr<_Tp, _Del>) -> shared_ptr<_Tp>;
+
+
+
+
+
+
+
+  template<typename _Tp, typename _Up>
+    [[__nodiscard__]] inline bool
+    operator==(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
+    { return __a.get() == __b.get(); }
+
+
+  template<typename _Tp>
+    [[__nodiscard__]] inline bool
+    operator==(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
+    { return !__a; }
+# 461 "/usr/include/c++/10.2.0/bits/shared_ptr.h" 3
+  template<typename _Tp>
+    [[__nodiscard__]] inline bool
+    operator==(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
+    { return !__a; }
+
+
+  template<typename _Tp, typename _Up>
+    [[__nodiscard__]] inline bool
+    operator!=(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
+    { return __a.get() != __b.get(); }
+
+
+  template<typename _Tp>
+    [[__nodiscard__]] inline bool
+    operator!=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
+    { return (bool)__a; }
+
+
+  template<typename _Tp>
+    [[__nodiscard__]] inline bool
+    operator!=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
+    { return (bool)__a; }
+
+
+  template<typename _Tp, typename _Up>
+    [[__nodiscard__]] inline bool
+    operator<(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
+    {
+      using _Tp_elt = typename shared_ptr<_Tp>::element_type;
+      using _Up_elt = typename shared_ptr<_Up>::element_type;
+      using _Vp = typename common_type<_Tp_elt*, _Up_elt*>::type;
+      return less<_Vp>()(__a.get(), __b.get());
+    }
+
+
+  template<typename _Tp>
+    [[__nodiscard__]] inline bool
+    operator<(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
+    {
+      using _Tp_elt = typename shared_ptr<_Tp>::element_type;
+      return less<_Tp_elt*>()(__a.get(), nullptr);
+    }
+
+
+  template<typename _Tp>
+    [[__nodiscard__]] inline bool
+    operator<(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
+    {
+      using _Tp_elt = typename shared_ptr<_Tp>::element_type;
+      return less<_Tp_elt*>()(nullptr, __a.get());
+    }
+
+
+  template<typename _Tp, typename _Up>
+    [[__nodiscard__]] inline bool
+    operator<=(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
+    { return !(__b < __a); }
+
+
+  template<typename _Tp>
+    [[__nodiscard__]] inline bool
+    operator<=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
+    { return !(nullptr < __a); }
+
+
+  template<typename _Tp>
+    [[__nodiscard__]] inline bool
+    operator<=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
+    { return !(__a < nullptr); }
+
+
+  template<typename _Tp, typename _Up>
+    [[__nodiscard__]] inline bool
+    operator>(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
+    { return (__b < __a); }
+
+
+  template<typename _Tp>
+    [[__nodiscard__]] inline bool
+    operator>(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
+    { return nullptr < __a; }
+
+
+  template<typename _Tp>
+    [[__nodiscard__]] inline bool
+    operator>(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
+    { return __a < nullptr; }
+
+
+  template<typename _Tp, typename _Up>
+    [[__nodiscard__]] inline bool
+    operator>=(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
+    { return !(__a < __b); }
+
+
+  template<typename _Tp>
+    [[__nodiscard__]] inline bool
+    operator>=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
+    { return !(__a < nullptr); }
+
+
+  template<typename _Tp>
+    [[__nodiscard__]] inline bool
+    operator>=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
+    { return !(nullptr < __a); }
+
+
+
+
+
+  template<typename _Tp>
+    inline void
+    swap(shared_ptr<_Tp>& __a, shared_ptr<_Tp>& __b) noexcept
+    { __a.swap(__b); }
+
+
+
+
+  template<typename _Tp, typename _Up>
+    inline shared_ptr<_Tp>
+    static_pointer_cast(const shared_ptr<_Up>& __r) noexcept
+    {
+      using _Sp = shared_ptr<_Tp>;
+      return _Sp(__r, static_cast<typename _Sp::element_type*>(__r.get()));
+    }
+
+
+  template<typename _Tp, typename _Up>
+    inline shared_ptr<_Tp>
+    const_pointer_cast(const shared_ptr<_Up>& __r) noexcept
+    {
+      using _Sp = shared_ptr<_Tp>;
+      return _Sp(__r, const_cast<typename _Sp::element_type*>(__r.get()));
+    }
+
+
+  template<typename _Tp, typename _Up>
+    inline shared_ptr<_Tp>
+    dynamic_pointer_cast(const shared_ptr<_Up>& __r) noexcept
+    {
+      using _Sp = shared_ptr<_Tp>;
+      if (auto* __p = dynamic_cast<typename _Sp::element_type*>(__r.get()))
+ return _Sp(__r, __p);
+      return _Sp();
+    }
+
+
+
+  template<typename _Tp, typename _Up>
+    inline shared_ptr<_Tp>
+    reinterpret_pointer_cast(const shared_ptr<_Up>& __r) noexcept
+    {
+      using _Sp = shared_ptr<_Tp>;
+      return _Sp(__r, reinterpret_cast<typename _Sp::element_type*>(__r.get()));
+    }
+# 684 "/usr/include/c++/10.2.0/bits/shared_ptr.h" 3
+  template<typename _Tp>
+    class weak_ptr : public __weak_ptr<_Tp>
+    {
+      template<typename _Arg>
+ using _Constructible = typename enable_if<
+   is_constructible<__weak_ptr<_Tp>, _Arg>::value
+ >::type;
+
+      template<typename _Arg>
+ using _Assignable = typename enable_if<
+   is_assignable<__weak_ptr<_Tp>&, _Arg>::value, weak_ptr&
+ >::type;
+
+    public:
+      constexpr weak_ptr() noexcept = default;
+
+      template<typename _Yp,
+        typename = _Constructible<const shared_ptr<_Yp>&>>
+ weak_ptr(const shared_ptr<_Yp>& __r) noexcept
+ : __weak_ptr<_Tp>(__r) { }
+
+      weak_ptr(const weak_ptr&) noexcept = default;
+
+      template<typename _Yp, typename = _Constructible<const weak_ptr<_Yp>&>>
+ weak_ptr(const weak_ptr<_Yp>& __r) noexcept
+ : __weak_ptr<_Tp>(__r) { }
+
+      weak_ptr(weak_ptr&&) noexcept = default;
+
+      template<typename _Yp, typename = _Constructible<weak_ptr<_Yp>>>
+ weak_ptr(weak_ptr<_Yp>&& __r) noexcept
+ : __weak_ptr<_Tp>(std::move(__r)) { }
+
+      weak_ptr&
+      operator=(const weak_ptr& __r) noexcept = default;
+
+      template<typename _Yp>
+ _Assignable<const weak_ptr<_Yp>&>
+ operator=(const weak_ptr<_Yp>& __r) noexcept
+ {
+   this->__weak_ptr<_Tp>::operator=(__r);
+   return *this;
+ }
+
+      template<typename _Yp>
+ _Assignable<const shared_ptr<_Yp>&>
+ operator=(const shared_ptr<_Yp>& __r) noexcept
+ {
+   this->__weak_ptr<_Tp>::operator=(__r);
+   return *this;
+ }
+
+      weak_ptr&
+      operator=(weak_ptr&& __r) noexcept = default;
+
+      template<typename _Yp>
+ _Assignable<weak_ptr<_Yp>>
+ operator=(weak_ptr<_Yp>&& __r) noexcept
+ {
+   this->__weak_ptr<_Tp>::operator=(std::move(__r));
+   return *this;
+ }
+
+      shared_ptr<_Tp>
+      lock() const noexcept
+      { return shared_ptr<_Tp>(*this, std::nothrow); }
+    };
+
+
+  template<typename _Tp>
+    weak_ptr(shared_ptr<_Tp>) -> weak_ptr<_Tp>;
+
+
+
+
+
+  template<typename _Tp>
+    inline void
+    swap(weak_ptr<_Tp>& __a, weak_ptr<_Tp>& __b) noexcept
+    { __a.swap(__b); }
+
+
+
+  template<typename _Tp = void>
+    struct owner_less;
+
+
+  template<>
+    struct owner_less<void> : _Sp_owner_less<void, void>
+    { };
+
+
+  template<typename _Tp>
+    struct owner_less<shared_ptr<_Tp>>
+    : public _Sp_owner_less<shared_ptr<_Tp>, weak_ptr<_Tp>>
+    { };
+
+
+  template<typename _Tp>
+    struct owner_less<weak_ptr<_Tp>>
+    : public _Sp_owner_less<weak_ptr<_Tp>, shared_ptr<_Tp>>
+    { };
+
+
+
+
+  template<typename _Tp>
+    class enable_shared_from_this
+    {
+    protected:
+      constexpr enable_shared_from_this() noexcept { }
+
+      enable_shared_from_this(const enable_shared_from_this&) noexcept { }
+
+      enable_shared_from_this&
+      operator=(const enable_shared_from_this&) noexcept
+      { return *this; }
+
+      ~enable_shared_from_this() { }
+
+    public:
+      shared_ptr<_Tp>
+      shared_from_this()
+      { return shared_ptr<_Tp>(this->_M_weak_this); }
+
+      shared_ptr<const _Tp>
+      shared_from_this() const
+      { return shared_ptr<const _Tp>(this->_M_weak_this); }
+
+
+#define __cpp_lib_enable_shared_from_this 201603
+      weak_ptr<_Tp>
+      weak_from_this() noexcept
+      { return this->_M_weak_this; }
+
+      weak_ptr<const _Tp>
+      weak_from_this() const noexcept
+      { return this->_M_weak_this; }
+
+
+    private:
+      template<typename _Tp1>
+ void
+ _M_weak_assign(_Tp1* __p, const __shared_count<>& __n) const noexcept
+ { _M_weak_this._M_assign(__p, __n); }
+
+
+      friend const enable_shared_from_this*
+      __enable_shared_from_this_base(const __shared_count<>&,
+         const enable_shared_from_this* __p)
+      { return __p; }
+
+      template<typename, _Lock_policy>
+ friend class __shared_ptr;
+
+      mutable weak_ptr<_Tp> _M_weak_this;
+    };
+# 855 "/usr/include/c++/10.2.0/bits/shared_ptr.h" 3
+  template<typename _Tp, typename _Alloc, typename... _Args>
+    inline shared_ptr<_Tp>
+    allocate_shared(const _Alloc& __a, _Args&&... __args)
+    {
+      return shared_ptr<_Tp>(_Sp_alloc_shared_tag<_Alloc>{__a},
+        std::forward<_Args>(__args)...);
+    }
+# 870 "/usr/include/c++/10.2.0/bits/shared_ptr.h" 3
+  template<typename _Tp, typename... _Args>
+    inline shared_ptr<_Tp>
+    make_shared(_Args&&... __args)
+    {
+      typedef typename std::remove_cv<_Tp>::type _Tp_nc;
+      return std::allocate_shared<_Tp>(std::allocator<_Tp_nc>(),
+           std::forward<_Args>(__args)...);
+    }
+
+
+  template<typename _Tp>
+    struct hash<shared_ptr<_Tp>>
+    : public __hash_base<size_t, shared_ptr<_Tp>>
+    {
+      size_t
+      operator()(const shared_ptr<_Tp>& __s) const noexcept
+      {
+ return std::hash<typename shared_ptr<_Tp>::element_type*>()(__s.get());
+      }
+    };
+
+
+
+
+
+  namespace __detail::__variant
+  {
+    template<typename> struct _Never_valueless_alt;
+
+
+
+    template<typename _Tp>
+      struct _Never_valueless_alt<std::shared_ptr<_Tp>>
+      : std::true_type
+      { };
+
+
+
+    template<typename _Tp>
+      struct _Never_valueless_alt<std::weak_ptr<_Tp>>
+      : std::true_type
+      { };
+  }
+
+
+
+}
+# 85 "/usr/include/c++/10.2.0/memory" 2 3
+# 1 "/usr/include/c++/10.2.0/bits/shared_ptr_atomic.h" 1 3
+# 31 "/usr/include/c++/10.2.0/bits/shared_ptr_atomic.h" 3
+#define _SHARED_PTR_ATOMIC_H 1
+
+# 1 "/usr/include/c++/10.2.0/bits/atomic_base.h" 1 3
+# 31 "/usr/include/c++/10.2.0/bits/atomic_base.h" 3
+#define _GLIBCXX_ATOMIC_BASE_H 1
+
+       
+# 34 "/usr/include/c++/10.2.0/bits/atomic_base.h" 3
+
+
+
+# 1 "/usr/include/c++/10.2.0/bits/atomic_lockfree_defines.h" 1 3
+# 31 "/usr/include/c++/10.2.0/bits/atomic_lockfree_defines.h" 3
+#define _GLIBCXX_ATOMIC_LOCK_FREE_H 1
+
+       
+# 34 "/usr/include/c++/10.2.0/bits/atomic_lockfree_defines.h" 3
+# 49 "/usr/include/c++/10.2.0/bits/atomic_lockfree_defines.h" 3
+#define ATOMIC_BOOL_LOCK_FREE __GCC_ATOMIC_BOOL_LOCK_FREE
+#define ATOMIC_CHAR_LOCK_FREE __GCC_ATOMIC_CHAR_LOCK_FREE
+#define ATOMIC_WCHAR_T_LOCK_FREE __GCC_ATOMIC_WCHAR_T_LOCK_FREE
+
+
+
+#define ATOMIC_CHAR16_T_LOCK_FREE __GCC_ATOMIC_CHAR16_T_LOCK_FREE
+#define ATOMIC_CHAR32_T_LOCK_FREE __GCC_ATOMIC_CHAR32_T_LOCK_FREE
+#define ATOMIC_SHORT_LOCK_FREE __GCC_ATOMIC_SHORT_LOCK_FREE
+#define ATOMIC_INT_LOCK_FREE __GCC_ATOMIC_INT_LOCK_FREE
+#define ATOMIC_LONG_LOCK_FREE __GCC_ATOMIC_LONG_LOCK_FREE
+#define ATOMIC_LLONG_LOCK_FREE __GCC_ATOMIC_LLONG_LOCK_FREE
+#define ATOMIC_POINTER_LOCK_FREE __GCC_ATOMIC_POINTER_LOCK_FREE
+# 38 "/usr/include/c++/10.2.0/bits/atomic_base.h" 2 3
+
+
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 74 "/usr/include/c++/10.2.0/bits/atomic_base.h" 3
+  typedef enum memory_order
+    {
+      memory_order_relaxed,
+      memory_order_consume,
+      memory_order_acquire,
+      memory_order_release,
+      memory_order_acq_rel,
+      memory_order_seq_cst
+    } memory_order;
+
+
+  enum __memory_order_modifier
+    {
+      __memory_order_mask = 0x0ffff,
+      __memory_order_modifier_mask = 0xffff0000,
+      __memory_order_hle_acquire = 0x10000,
+      __memory_order_hle_release = 0x20000
+    };
+
+  constexpr memory_order
+  operator|(memory_order __m, __memory_order_modifier __mod)
+  {
+    return memory_order(int(__m) | int(__mod));
+  }
+
+  constexpr memory_order
+  operator&(memory_order __m, __memory_order_modifier __mod)
+  {
+    return memory_order(int(__m) & int(__mod));
+  }
+
+
+  constexpr memory_order
+  __cmpexch_failure_order2(memory_order __m) noexcept
+  {
+    return __m == memory_order_acq_rel ? memory_order_acquire
+      : __m == memory_order_release ? memory_order_relaxed : __m;
+  }
+
+  constexpr memory_order
+  __cmpexch_failure_order(memory_order __m) noexcept
+  {
+    return memory_order(__cmpexch_failure_order2(__m & __memory_order_mask)
+      | __memory_order_modifier(__m & __memory_order_modifier_mask));
+  }
+
+  inline __attribute__((__always_inline__)) void
+  atomic_thread_fence(memory_order __m) noexcept
+  { __atomic_thread_fence(int(__m)); }
+
+  inline __attribute__((__always_inline__)) void
+  atomic_signal_fence(memory_order __m) noexcept
+  { __atomic_signal_fence(int(__m)); }
+
+
+  template<typename _Tp>
+    inline _Tp
+    kill_dependency(_Tp __y) noexcept
+    {
+      _Tp __ret(__y);
+      return __ret;
+    }
+
+
+
+  template<typename _IntTp>
+    struct __atomic_base;
+
+
+#define _GLIBCXX20_INIT(I) 
+
+
+
+
+
+#define ATOMIC_VAR_INIT(_VI) { _VI }
+
+  template<typename _Tp>
+    struct atomic;
+
+  template<typename _Tp>
+    struct atomic<_Tp*>;
+
+
+
+    typedef bool __atomic_flag_data_type;
+# 174 "/usr/include/c++/10.2.0/bits/atomic_base.h" 3
+  extern "C" {
+
+  struct __atomic_flag_base
+  {
+    __atomic_flag_data_type _M_i ;
+  };
+
+  }
+
+#define ATOMIC_FLAG_INIT { 0 }
+
+
+  struct atomic_flag : public __atomic_flag_base
+  {
+    atomic_flag() noexcept = default;
+    ~atomic_flag() noexcept = default;
+    atomic_flag(const atomic_flag&) = delete;
+    atomic_flag& operator=(const atomic_flag&) = delete;
+    atomic_flag& operator=(const atomic_flag&) volatile = delete;
+
+
+    constexpr atomic_flag(bool __i) noexcept
+      : __atomic_flag_base{ _S_init(__i) }
+    { }
+
+    inline __attribute__((__always_inline__)) bool
+    test_and_set(memory_order __m = memory_order_seq_cst) noexcept
+    {
+      return __atomic_test_and_set (&_M_i, int(__m));
+    }
+
+    inline __attribute__((__always_inline__)) bool
+    test_and_set(memory_order __m = memory_order_seq_cst) volatile noexcept
+    {
+      return __atomic_test_and_set (&_M_i, int(__m));
+    }
+
+    inline __attribute__((__always_inline__)) void
+    clear(memory_order __m = memory_order_seq_cst) noexcept
+    {
+      memory_order __b = __m & __memory_order_mask;
+      ;
+      ;
+      ;
+
+      __atomic_clear (&_M_i, int(__m));
+    }
+
+    inline __attribute__((__always_inline__)) void
+    clear(memory_order __m = memory_order_seq_cst) volatile noexcept
+    {
+      memory_order __b = __m & __memory_order_mask;
+      ;
+      ;
+      ;
+
+      __atomic_clear (&_M_i, int(__m));
+    }
+
+  private:
+    static constexpr __atomic_flag_data_type
+    _S_init(bool __i)
+    { return __i ? 1 : 0; }
+  };
+# 264 "/usr/include/c++/10.2.0/bits/atomic_base.h" 3
+  template<typename _ITp>
+    struct __atomic_base
+    {
+      using value_type = _ITp;
+      using difference_type = value_type;
+
+    private:
+      typedef _ITp __int_type;
+
+      static constexpr int _S_alignment =
+ sizeof(_ITp) > alignof(_ITp) ? sizeof(_ITp) : alignof(_ITp);
+
+      alignas(_S_alignment) __int_type _M_i ;
+
+    public:
+      __atomic_base() noexcept = default;
+      ~__atomic_base() noexcept = default;
+      __atomic_base(const __atomic_base&) = delete;
+      __atomic_base& operator=(const __atomic_base&) = delete;
+      __atomic_base& operator=(const __atomic_base&) volatile = delete;
+
+
+      constexpr __atomic_base(__int_type __i) noexcept : _M_i (__i) { }
+
+      operator __int_type() const noexcept
+      { return load(); }
+
+      operator __int_type() const volatile noexcept
+      { return load(); }
+
+      __int_type
+      operator=(__int_type __i) noexcept
+      {
+ store(__i);
+ return __i;
+      }
+
+      __int_type
+      operator=(__int_type __i) volatile noexcept
+      {
+ store(__i);
+ return __i;
+      }
+
+      __int_type
+      operator++(int) noexcept
+      { return fetch_add(1); }
+
+      __int_type
+      operator++(int) volatile noexcept
+      { return fetch_add(1); }
+
+      __int_type
+      operator--(int) noexcept
+      { return fetch_sub(1); }
+
+      __int_type
+      operator--(int) volatile noexcept
+      { return fetch_sub(1); }
+
+      __int_type
+      operator++() noexcept
+      { return __atomic_add_fetch(&_M_i, 1, int(memory_order_seq_cst)); }
+
+      __int_type
+      operator++() volatile noexcept
+      { return __atomic_add_fetch(&_M_i, 1, int(memory_order_seq_cst)); }
+
+      __int_type
+      operator--() noexcept
+      { return __atomic_sub_fetch(&_M_i, 1, int(memory_order_seq_cst)); }
+
+      __int_type
+      operator--() volatile noexcept
+      { return __atomic_sub_fetch(&_M_i, 1, int(memory_order_seq_cst)); }
+
+      __int_type
+      operator+=(__int_type __i) noexcept
+      { return __atomic_add_fetch(&_M_i, __i, int(memory_order_seq_cst)); }
+
+      __int_type
+      operator+=(__int_type __i) volatile noexcept
+      { return __atomic_add_fetch(&_M_i, __i, int(memory_order_seq_cst)); }
+
+      __int_type
+      operator-=(__int_type __i) noexcept
+      { return __atomic_sub_fetch(&_M_i, __i, int(memory_order_seq_cst)); }
+
+      __int_type
+      operator-=(__int_type __i) volatile noexcept
+      { return __atomic_sub_fetch(&_M_i, __i, int(memory_order_seq_cst)); }
+
+      __int_type
+      operator&=(__int_type __i) noexcept
+      { return __atomic_and_fetch(&_M_i, __i, int(memory_order_seq_cst)); }
+
+      __int_type
+      operator&=(__int_type __i) volatile noexcept
+      { return __atomic_and_fetch(&_M_i, __i, int(memory_order_seq_cst)); }
+
+      __int_type
+      operator|=(__int_type __i) noexcept
+      { return __atomic_or_fetch(&_M_i, __i, int(memory_order_seq_cst)); }
+
+      __int_type
+      operator|=(__int_type __i) volatile noexcept
+      { return __atomic_or_fetch(&_M_i, __i, int(memory_order_seq_cst)); }
+
+      __int_type
+      operator^=(__int_type __i) noexcept
+      { return __atomic_xor_fetch(&_M_i, __i, int(memory_order_seq_cst)); }
+
+      __int_type
+      operator^=(__int_type __i) volatile noexcept
+      { return __atomic_xor_fetch(&_M_i, __i, int(memory_order_seq_cst)); }
+
+      bool
+      is_lock_free() const noexcept
+      {
+
+ return __atomic_is_lock_free(sizeof(_M_i),
+     reinterpret_cast<void *>(-_S_alignment));
+      }
+
+      bool
+      is_lock_free() const volatile noexcept
+      {
+
+ return __atomic_is_lock_free(sizeof(_M_i),
+     reinterpret_cast<void *>(-_S_alignment));
+      }
+
+      inline __attribute__((__always_inline__)) void
+      store(__int_type __i, memory_order __m = memory_order_seq_cst) noexcept
+      {
+ memory_order __b = __m & __memory_order_mask;
+ ;
+ ;
+ ;
+
+ __atomic_store_n(&_M_i, __i, int(__m));
+      }
+
+      inline __attribute__((__always_inline__)) void
+      store(__int_type __i,
+     memory_order __m = memory_order_seq_cst) volatile noexcept
+      {
+ memory_order __b = __m & __memory_order_mask;
+ ;
+ ;
+ ;
+
+ __atomic_store_n(&_M_i, __i, int(__m));
+      }
+
+      inline __attribute__((__always_inline__)) __int_type
+      load(memory_order __m = memory_order_seq_cst) const noexcept
+      {
+ memory_order __b = __m & __memory_order_mask;
+ ;
+ ;
+
+ return __atomic_load_n(&_M_i, int(__m));
+      }
+
+      inline __attribute__((__always_inline__)) __int_type
+      load(memory_order __m = memory_order_seq_cst) const volatile noexcept
+      {
+ memory_order __b = __m & __memory_order_mask;
+ ;
+ ;
+
+ return __atomic_load_n(&_M_i, int(__m));
+      }
+
+      inline __attribute__((__always_inline__)) __int_type
+      exchange(__int_type __i,
+        memory_order __m = memory_order_seq_cst) noexcept
+      {
+ return __atomic_exchange_n(&_M_i, __i, int(__m));
+      }
+
+
+      inline __attribute__((__always_inline__)) __int_type
+      exchange(__int_type __i,
+        memory_order __m = memory_order_seq_cst) volatile noexcept
+      {
+ return __atomic_exchange_n(&_M_i, __i, int(__m));
+      }
+
+      inline __attribute__((__always_inline__)) bool
+      compare_exchange_weak(__int_type& __i1, __int_type __i2,
+       memory_order __m1, memory_order __m2) noexcept
+      {
+ memory_order __b2 = __m2 & __memory_order_mask;
+ memory_order __b1 = __m1 & __memory_order_mask;
+ ;
+ ;
+ ;
+
+ return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 1,
+        int(__m1), int(__m2));
+      }
+
+      inline __attribute__((__always_inline__)) bool
+      compare_exchange_weak(__int_type& __i1, __int_type __i2,
+       memory_order __m1,
+       memory_order __m2) volatile noexcept
+      {
+ memory_order __b2 = __m2 & __memory_order_mask;
+ memory_order __b1 = __m1 & __memory_order_mask;
+ ;
+ ;
+ ;
+
+ return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 1,
+        int(__m1), int(__m2));
+      }
+
+      inline __attribute__((__always_inline__)) bool
+      compare_exchange_weak(__int_type& __i1, __int_type __i2,
+       memory_order __m = memory_order_seq_cst) noexcept
+      {
+ return compare_exchange_weak(__i1, __i2, __m,
+         __cmpexch_failure_order(__m));
+      }
+
+      inline __attribute__((__always_inline__)) bool
+      compare_exchange_weak(__int_type& __i1, __int_type __i2,
+     memory_order __m = memory_order_seq_cst) volatile noexcept
+      {
+ return compare_exchange_weak(__i1, __i2, __m,
+         __cmpexch_failure_order(__m));
+      }
+
+      inline __attribute__((__always_inline__)) bool
+      compare_exchange_strong(__int_type& __i1, __int_type __i2,
+         memory_order __m1, memory_order __m2) noexcept
+      {
+ memory_order __b2 = __m2 & __memory_order_mask;
+ memory_order __b1 = __m1 & __memory_order_mask;
+ ;
+ ;
+ ;
+
+ return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 0,
+        int(__m1), int(__m2));
+      }
+
+      inline __attribute__((__always_inline__)) bool
+      compare_exchange_strong(__int_type& __i1, __int_type __i2,
+         memory_order __m1,
+         memory_order __m2) volatile noexcept
+      {
+ memory_order __b2 = __m2 & __memory_order_mask;
+ memory_order __b1 = __m1 & __memory_order_mask;
+
+ ;
+ ;
+ ;
+
+ return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 0,
+        int(__m1), int(__m2));
+      }
+
+      inline __attribute__((__always_inline__)) bool
+      compare_exchange_strong(__int_type& __i1, __int_type __i2,
+         memory_order __m = memory_order_seq_cst) noexcept
+      {
+ return compare_exchange_strong(__i1, __i2, __m,
+           __cmpexch_failure_order(__m));
+      }
+
+      inline __attribute__((__always_inline__)) bool
+      compare_exchange_strong(__int_type& __i1, __int_type __i2,
+   memory_order __m = memory_order_seq_cst) volatile noexcept
+      {
+ return compare_exchange_strong(__i1, __i2, __m,
+           __cmpexch_failure_order(__m));
+      }
+
+      inline __attribute__((__always_inline__)) __int_type
+      fetch_add(__int_type __i,
+  memory_order __m = memory_order_seq_cst) noexcept
+      { return __atomic_fetch_add(&_M_i, __i, int(__m)); }
+
+      inline __attribute__((__always_inline__)) __int_type
+      fetch_add(__int_type __i,
+  memory_order __m = memory_order_seq_cst) volatile noexcept
+      { return __atomic_fetch_add(&_M_i, __i, int(__m)); }
+
+      inline __attribute__((__always_inline__)) __int_type
+      fetch_sub(__int_type __i,
+  memory_order __m = memory_order_seq_cst) noexcept
+      { return __atomic_fetch_sub(&_M_i, __i, int(__m)); }
+
+      inline __attribute__((__always_inline__)) __int_type
+      fetch_sub(__int_type __i,
+  memory_order __m = memory_order_seq_cst) volatile noexcept
+      { return __atomic_fetch_sub(&_M_i, __i, int(__m)); }
+
+      inline __attribute__((__always_inline__)) __int_type
+      fetch_and(__int_type __i,
+  memory_order __m = memory_order_seq_cst) noexcept
+      { return __atomic_fetch_and(&_M_i, __i, int(__m)); }
+
+      inline __attribute__((__always_inline__)) __int_type
+      fetch_and(__int_type __i,
+  memory_order __m = memory_order_seq_cst) volatile noexcept
+      { return __atomic_fetch_and(&_M_i, __i, int(__m)); }
+
+      inline __attribute__((__always_inline__)) __int_type
+      fetch_or(__int_type __i,
+        memory_order __m = memory_order_seq_cst) noexcept
+      { return __atomic_fetch_or(&_M_i, __i, int(__m)); }
+
+      inline __attribute__((__always_inline__)) __int_type
+      fetch_or(__int_type __i,
+        memory_order __m = memory_order_seq_cst) volatile noexcept
+      { return __atomic_fetch_or(&_M_i, __i, int(__m)); }
+
+      inline __attribute__((__always_inline__)) __int_type
+      fetch_xor(__int_type __i,
+  memory_order __m = memory_order_seq_cst) noexcept
+      { return __atomic_fetch_xor(&_M_i, __i, int(__m)); }
+
+      inline __attribute__((__always_inline__)) __int_type
+      fetch_xor(__int_type __i,
+  memory_order __m = memory_order_seq_cst) volatile noexcept
+      { return __atomic_fetch_xor(&_M_i, __i, int(__m)); }
+    };
+
+
+
+  template<typename _PTp>
+    struct __atomic_base<_PTp*>
+    {
+    private:
+      typedef _PTp* __pointer_type;
+
+      __pointer_type _M_p ;
+
+
+      constexpr ptrdiff_t
+      _M_type_size(ptrdiff_t __d) const { return __d * sizeof(_PTp); }
+
+      constexpr ptrdiff_t
+      _M_type_size(ptrdiff_t __d) const volatile { return __d * sizeof(_PTp); }
+
+    public:
+      __atomic_base() noexcept = default;
+      ~__atomic_base() noexcept = default;
+      __atomic_base(const __atomic_base&) = delete;
+      __atomic_base& operator=(const __atomic_base&) = delete;
+      __atomic_base& operator=(const __atomic_base&) volatile = delete;
+
+
+      constexpr __atomic_base(__pointer_type __p) noexcept : _M_p (__p) { }
+
+      operator __pointer_type() const noexcept
+      { return load(); }
+
+      operator __pointer_type() const volatile noexcept
+      { return load(); }
+
+      __pointer_type
+      operator=(__pointer_type __p) noexcept
+      {
+ store(__p);
+ return __p;
+      }
+
+      __pointer_type
+      operator=(__pointer_type __p) volatile noexcept
+      {
+ store(__p);
+ return __p;
+      }
+
+      __pointer_type
+      operator++(int) noexcept
+      { return fetch_add(1); }
+
+      __pointer_type
+      operator++(int) volatile noexcept
+      { return fetch_add(1); }
+
+      __pointer_type
+      operator--(int) noexcept
+      { return fetch_sub(1); }
+
+      __pointer_type
+      operator--(int) volatile noexcept
+      { return fetch_sub(1); }
+
+      __pointer_type
+      operator++() noexcept
+      { return __atomic_add_fetch(&_M_p, _M_type_size(1),
+      int(memory_order_seq_cst)); }
+
+      __pointer_type
+      operator++() volatile noexcept
+      { return __atomic_add_fetch(&_M_p, _M_type_size(1),
+      int(memory_order_seq_cst)); }
+
+      __pointer_type
+      operator--() noexcept
+      { return __atomic_sub_fetch(&_M_p, _M_type_size(1),
+      int(memory_order_seq_cst)); }
+
+      __pointer_type
+      operator--() volatile noexcept
+      { return __atomic_sub_fetch(&_M_p, _M_type_size(1),
+      int(memory_order_seq_cst)); }
+
+      __pointer_type
+      operator+=(ptrdiff_t __d) noexcept
+      { return __atomic_add_fetch(&_M_p, _M_type_size(__d),
+      int(memory_order_seq_cst)); }
+
+      __pointer_type
+      operator+=(ptrdiff_t __d) volatile noexcept
+      { return __atomic_add_fetch(&_M_p, _M_type_size(__d),
+      int(memory_order_seq_cst)); }
+
+      __pointer_type
+      operator-=(ptrdiff_t __d) noexcept
+      { return __atomic_sub_fetch(&_M_p, _M_type_size(__d),
+      int(memory_order_seq_cst)); }
+
+      __pointer_type
+      operator-=(ptrdiff_t __d) volatile noexcept
+      { return __atomic_sub_fetch(&_M_p, _M_type_size(__d),
+      int(memory_order_seq_cst)); }
+
+      bool
+      is_lock_free() const noexcept
+      {
+
+ return __atomic_is_lock_free(sizeof(_M_p),
+     reinterpret_cast<void *>(-__alignof(_M_p)));
+      }
+
+      bool
+      is_lock_free() const volatile noexcept
+      {
+
+ return __atomic_is_lock_free(sizeof(_M_p),
+     reinterpret_cast<void *>(-__alignof(_M_p)));
+      }
+
+      inline __attribute__((__always_inline__)) void
+      store(__pointer_type __p,
+     memory_order __m = memory_order_seq_cst) noexcept
+      {
+        memory_order __b = __m & __memory_order_mask;
+
+ ;
+ ;
+ ;
+
+ __atomic_store_n(&_M_p, __p, int(__m));
+      }
+
+      inline __attribute__((__always_inline__)) void
+      store(__pointer_type __p,
+     memory_order __m = memory_order_seq_cst) volatile noexcept
+      {
+ memory_order __b = __m & __memory_order_mask;
+ ;
+ ;
+ ;
+
+ __atomic_store_n(&_M_p, __p, int(__m));
+      }
+
+      inline __attribute__((__always_inline__)) __pointer_type
+      load(memory_order __m = memory_order_seq_cst) const noexcept
+      {
+ memory_order __b = __m & __memory_order_mask;
+ ;
+ ;
+
+ return __atomic_load_n(&_M_p, int(__m));
+      }
+
+      inline __attribute__((__always_inline__)) __pointer_type
+      load(memory_order __m = memory_order_seq_cst) const volatile noexcept
+      {
+ memory_order __b = __m & __memory_order_mask;
+ ;
+ ;
+
+ return __atomic_load_n(&_M_p, int(__m));
+      }
+
+      inline __attribute__((__always_inline__)) __pointer_type
+      exchange(__pointer_type __p,
+        memory_order __m = memory_order_seq_cst) noexcept
+      {
+ return __atomic_exchange_n(&_M_p, __p, int(__m));
+      }
+
+
+      inline __attribute__((__always_inline__)) __pointer_type
+      exchange(__pointer_type __p,
+        memory_order __m = memory_order_seq_cst) volatile noexcept
+      {
+ return __atomic_exchange_n(&_M_p, __p, int(__m));
+      }
+
+      inline __attribute__((__always_inline__)) bool
+      compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
+         memory_order __m1,
+         memory_order __m2) noexcept
+      {
+ memory_order __b2 = __m2 & __memory_order_mask;
+ memory_order __b1 = __m1 & __memory_order_mask;
+ ;
+ ;
+ ;
+
+ return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 0,
+        int(__m1), int(__m2));
+      }
+
+      inline __attribute__((__always_inline__)) bool
+      compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
+         memory_order __m1,
+         memory_order __m2) volatile noexcept
+      {
+ memory_order __b2 = __m2 & __memory_order_mask;
+ memory_order __b1 = __m1 & __memory_order_mask;
+
+ ;
+ ;
+ ;
+
+ return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 0,
+        int(__m1), int(__m2));
+      }
+
+      inline __attribute__((__always_inline__)) __pointer_type
+      fetch_add(ptrdiff_t __d,
+  memory_order __m = memory_order_seq_cst) noexcept
+      { return __atomic_fetch_add(&_M_p, _M_type_size(__d), int(__m)); }
+
+      inline __attribute__((__always_inline__)) __pointer_type
+      fetch_add(ptrdiff_t __d,
+  memory_order __m = memory_order_seq_cst) volatile noexcept
+      { return __atomic_fetch_add(&_M_p, _M_type_size(__d), int(__m)); }
+
+      inline __attribute__((__always_inline__)) __pointer_type
+      fetch_sub(ptrdiff_t __d,
+  memory_order __m = memory_order_seq_cst) noexcept
+      { return __atomic_fetch_sub(&_M_p, _M_type_size(__d), int(__m)); }
+
+      inline __attribute__((__always_inline__)) __pointer_type
+      fetch_sub(ptrdiff_t __d,
+  memory_order __m = memory_order_seq_cst) volatile noexcept
+      { return __atomic_fetch_sub(&_M_p, _M_type_size(__d), int(__m)); }
+    };
+# 1700 "/usr/include/c++/10.2.0/bits/atomic_base.h" 3
+
+}
+# 34 "/usr/include/c++/10.2.0/bits/shared_ptr_atomic.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 47 "/usr/include/c++/10.2.0/bits/shared_ptr_atomic.h" 3
+  struct _Sp_locker
+  {
+    _Sp_locker(const _Sp_locker&) = delete;
+    _Sp_locker& operator=(const _Sp_locker&) = delete;
+
+
+    explicit
+    _Sp_locker(const void*) noexcept;
+    _Sp_locker(const void*, const void*) noexcept;
+    ~_Sp_locker();
+
+  private:
+    unsigned char _M_key1;
+    unsigned char _M_key2;
+
+
+
+  };
+# 74 "/usr/include/c++/10.2.0/bits/shared_ptr_atomic.h" 3
+  template<typename _Tp, _Lock_policy _Lp>
+    inline bool
+    atomic_is_lock_free(const __shared_ptr<_Tp, _Lp>* __p)
+    {
+
+      return __gthread_active_p() == 0;
+
+
+
+    }
+
+  template<typename _Tp>
+    inline bool
+    atomic_is_lock_free(const shared_ptr<_Tp>* __p)
+    { return std::atomic_is_lock_free<_Tp, __default_lock_policy>(__p); }
+# 101 "/usr/include/c++/10.2.0/bits/shared_ptr_atomic.h" 3
+  template<typename _Tp>
+    inline shared_ptr<_Tp>
+    atomic_load_explicit(const shared_ptr<_Tp>* __p, memory_order)
+    {
+      _Sp_locker __lock{__p};
+      return *__p;
+    }
+
+  template<typename _Tp>
+    inline shared_ptr<_Tp>
+    atomic_load(const shared_ptr<_Tp>* __p)
+    { return std::atomic_load_explicit(__p, memory_order_seq_cst); }
+
+  template<typename _Tp, _Lock_policy _Lp>
+    inline __shared_ptr<_Tp, _Lp>
+    atomic_load_explicit(const __shared_ptr<_Tp, _Lp>* __p, memory_order)
+    {
+      _Sp_locker __lock{__p};
+      return *__p;
+    }
+
+  template<typename _Tp, _Lock_policy _Lp>
+    inline __shared_ptr<_Tp, _Lp>
+    atomic_load(const __shared_ptr<_Tp, _Lp>* __p)
+    { return std::atomic_load_explicit(__p, memory_order_seq_cst); }
+# 137 "/usr/include/c++/10.2.0/bits/shared_ptr_atomic.h" 3
+  template<typename _Tp>
+    inline void
+    atomic_store_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r,
+     memory_order)
+    {
+      _Sp_locker __lock{__p};
+      __p->swap(__r);
+    }
+
+  template<typename _Tp>
+    inline void
+    atomic_store(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r)
+    { std::atomic_store_explicit(__p, std::move(__r), memory_order_seq_cst); }
+
+  template<typename _Tp, _Lock_policy _Lp>
+    inline void
+    atomic_store_explicit(__shared_ptr<_Tp, _Lp>* __p,
+     __shared_ptr<_Tp, _Lp> __r,
+     memory_order)
+    {
+      _Sp_locker __lock{__p};
+      __p->swap(__r);
+    }
+
+  template<typename _Tp, _Lock_policy _Lp>
+    inline void
+    atomic_store(__shared_ptr<_Tp, _Lp>* __p, __shared_ptr<_Tp, _Lp> __r)
+    { std::atomic_store_explicit(__p, std::move(__r), memory_order_seq_cst); }
+# 174 "/usr/include/c++/10.2.0/bits/shared_ptr_atomic.h" 3
+  template<typename _Tp>
+    inline shared_ptr<_Tp>
+    atomic_exchange_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r,
+        memory_order)
+    {
+      _Sp_locker __lock{__p};
+      __p->swap(__r);
+      return __r;
+    }
+
+  template<typename _Tp>
+    inline shared_ptr<_Tp>
+    atomic_exchange(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r)
+    {
+      return std::atomic_exchange_explicit(__p, std::move(__r),
+        memory_order_seq_cst);
+    }
+
+  template<typename _Tp, _Lock_policy _Lp>
+    inline __shared_ptr<_Tp, _Lp>
+    atomic_exchange_explicit(__shared_ptr<_Tp, _Lp>* __p,
+        __shared_ptr<_Tp, _Lp> __r,
+        memory_order)
+    {
+      _Sp_locker __lock{__p};
+      __p->swap(__r);
+      return __r;
+    }
+
+  template<typename _Tp, _Lock_policy _Lp>
+    inline __shared_ptr<_Tp, _Lp>
+    atomic_exchange(__shared_ptr<_Tp, _Lp>* __p, __shared_ptr<_Tp, _Lp> __r)
+    {
+      return std::atomic_exchange_explicit(__p, std::move(__r),
+        memory_order_seq_cst);
+    }
+# 223 "/usr/include/c++/10.2.0/bits/shared_ptr_atomic.h" 3
+  template<typename _Tp>
+    bool
+    atomic_compare_exchange_strong_explicit(shared_ptr<_Tp>* __p,
+         shared_ptr<_Tp>* __v,
+         shared_ptr<_Tp> __w,
+         memory_order,
+         memory_order)
+    {
+      shared_ptr<_Tp> __x;
+      _Sp_locker __lock{__p, __v};
+      owner_less<shared_ptr<_Tp>> __less;
+      if (*__p == *__v && !__less(*__p, *__v) && !__less(*__v, *__p))
+ {
+   __x = std::move(*__p);
+   *__p = std::move(__w);
+   return true;
+ }
+      __x = std::move(*__v);
+      *__v = *__p;
+      return false;
+    }
+
+  template<typename _Tp>
+    inline bool
+    atomic_compare_exchange_strong(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v,
+     shared_ptr<_Tp> __w)
+    {
+      return std::atomic_compare_exchange_strong_explicit(__p, __v,
+   std::move(__w), memory_order_seq_cst, memory_order_seq_cst);
+    }
+
+  template<typename _Tp>
+    inline bool
+    atomic_compare_exchange_weak_explicit(shared_ptr<_Tp>* __p,
+       shared_ptr<_Tp>* __v,
+       shared_ptr<_Tp> __w,
+       memory_order __success,
+       memory_order __failure)
+    {
+      return std::atomic_compare_exchange_strong_explicit(__p, __v,
+   std::move(__w), __success, __failure);
+    }
+
+  template<typename _Tp>
+    inline bool
+    atomic_compare_exchange_weak(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v,
+     shared_ptr<_Tp> __w)
+    {
+      return std::atomic_compare_exchange_weak_explicit(__p, __v,
+   std::move(__w), memory_order_seq_cst, memory_order_seq_cst);
+    }
+
+  template<typename _Tp, _Lock_policy _Lp>
+    bool
+    atomic_compare_exchange_strong_explicit(__shared_ptr<_Tp, _Lp>* __p,
+         __shared_ptr<_Tp, _Lp>* __v,
+         __shared_ptr<_Tp, _Lp> __w,
+         memory_order,
+         memory_order)
+    {
+      __shared_ptr<_Tp, _Lp> __x;
+      _Sp_locker __lock{__p, __v};
+      owner_less<__shared_ptr<_Tp, _Lp>> __less;
+      if (*__p == *__v && !__less(*__p, *__v) && !__less(*__v, *__p))
+ {
+   __x = std::move(*__p);
+   *__p = std::move(__w);
+   return true;
+ }
+      __x = std::move(*__v);
+      *__v = *__p;
+      return false;
+    }
+
+  template<typename _Tp, _Lock_policy _Lp>
+    inline bool
+    atomic_compare_exchange_strong(__shared_ptr<_Tp, _Lp>* __p,
+       __shared_ptr<_Tp, _Lp>* __v,
+       __shared_ptr<_Tp, _Lp> __w)
+    {
+      return std::atomic_compare_exchange_strong_explicit(__p, __v,
+   std::move(__w), memory_order_seq_cst, memory_order_seq_cst);
+    }
+
+  template<typename _Tp, _Lock_policy _Lp>
+    inline bool
+    atomic_compare_exchange_weak_explicit(__shared_ptr<_Tp, _Lp>* __p,
+       __shared_ptr<_Tp, _Lp>* __v,
+       __shared_ptr<_Tp, _Lp> __w,
+       memory_order __success,
+       memory_order __failure)
+    {
+      return std::atomic_compare_exchange_strong_explicit(__p, __v,
+   std::move(__w), __success, __failure);
+    }
+
+  template<typename _Tp, _Lock_policy _Lp>
+    inline bool
+    atomic_compare_exchange_weak(__shared_ptr<_Tp, _Lp>* __p,
+     __shared_ptr<_Tp, _Lp>* __v,
+     __shared_ptr<_Tp, _Lp> __w)
+    {
+      return std::atomic_compare_exchange_weak_explicit(__p, __v,
+   std::move(__w), memory_order_seq_cst, memory_order_seq_cst);
+    }
+
+
+
+
+
+
+}
+# 86 "/usr/include/c++/10.2.0/memory" 2 3
+
+# 1 "/usr/include/c++/10.2.0/backward/auto_ptr.h" 1 3
+# 31 "/usr/include/c++/10.2.0/backward/auto_ptr.h" 3
+#define _BACKWARD_AUTO_PTR_H 1
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 47 "/usr/include/c++/10.2.0/backward/auto_ptr.h" 3
+  template<typename _Tp1>
+    struct auto_ptr_ref
+    {
+      _Tp1* _M_ptr;
+
+      explicit
+      auto_ptr_ref(_Tp1* __p): _M_ptr(__p) { }
+    } __attribute__ ((__deprecated__));
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+# 88 "/usr/include/c++/10.2.0/backward/auto_ptr.h" 3
+  template<typename _Tp>
+    class auto_ptr
+    {
+    private:
+      _Tp* _M_ptr;
+
+    public:
+
+      typedef _Tp element_type;
+
+
+
+
+
+
+
+      explicit
+      auto_ptr(element_type* __p = 0) throw() : _M_ptr(__p) { }
+# 114 "/usr/include/c++/10.2.0/backward/auto_ptr.h" 3
+      auto_ptr(auto_ptr& __a) throw() : _M_ptr(__a.release()) { }
+# 126 "/usr/include/c++/10.2.0/backward/auto_ptr.h" 3
+      template<typename _Tp1>
+        auto_ptr(auto_ptr<_Tp1>& __a) throw() : _M_ptr(__a.release()) { }
+# 137 "/usr/include/c++/10.2.0/backward/auto_ptr.h" 3
+      auto_ptr&
+      operator=(auto_ptr& __a) throw()
+      {
+ reset(__a.release());
+ return *this;
+      }
+# 154 "/usr/include/c++/10.2.0/backward/auto_ptr.h" 3
+      template<typename _Tp1>
+        auto_ptr&
+        operator=(auto_ptr<_Tp1>& __a) throw()
+        {
+   reset(__a.release());
+   return *this;
+ }
+# 172 "/usr/include/c++/10.2.0/backward/auto_ptr.h" 3
+      ~auto_ptr() { delete _M_ptr; }
+# 182 "/usr/include/c++/10.2.0/backward/auto_ptr.h" 3
+      element_type&
+      operator*() const throw()
+      {
+ ;
+ return *_M_ptr;
+      }
+
+
+
+
+
+
+
+      element_type*
+      operator->() const throw()
+      {
+ ;
+ return _M_ptr;
+      }
+# 212 "/usr/include/c++/10.2.0/backward/auto_ptr.h" 3
+      element_type*
+      get() const throw() { return _M_ptr; }
+# 226 "/usr/include/c++/10.2.0/backward/auto_ptr.h" 3
+      element_type*
+      release() throw()
+      {
+ element_type* __tmp = _M_ptr;
+ _M_ptr = 0;
+ return __tmp;
+      }
+# 241 "/usr/include/c++/10.2.0/backward/auto_ptr.h" 3
+      void
+      reset(element_type* __p = 0) throw()
+      {
+ if (__p != _M_ptr)
+   {
+     delete _M_ptr;
+     _M_ptr = __p;
+   }
+      }
+# 266 "/usr/include/c++/10.2.0/backward/auto_ptr.h" 3
+      auto_ptr(auto_ptr_ref<element_type> __ref) throw()
+      : _M_ptr(__ref._M_ptr) { }
+
+      auto_ptr&
+      operator=(auto_ptr_ref<element_type> __ref) throw()
+      {
+ if (__ref._M_ptr != this->get())
+   {
+     delete _M_ptr;
+     _M_ptr = __ref._M_ptr;
+   }
+ return *this;
+      }
+
+      template<typename _Tp1>
+        operator auto_ptr_ref<_Tp1>() throw()
+        { return auto_ptr_ref<_Tp1>(this->release()); }
+
+      template<typename _Tp1>
+        operator auto_ptr<_Tp1>() throw()
+        { return auto_ptr<_Tp1>(this->release()); }
+    } __attribute__ ((__deprecated__));
+
+
+
+  template<>
+    class auto_ptr<void>
+    {
+    public:
+      typedef void element_type;
+    } __attribute__ ((__deprecated__));
+
+
+  template<_Lock_policy _Lp>
+  template<typename _Tp>
+    inline
+    __shared_count<_Lp>::__shared_count(std::auto_ptr<_Tp>&& __r)
+    : _M_pi(new _Sp_counted_ptr<_Tp*, _Lp>(__r.get()))
+    { __r.release(); }
+
+  template<typename _Tp, _Lock_policy _Lp>
+  template<typename _Tp1, typename>
+    inline
+    __shared_ptr<_Tp, _Lp>::__shared_ptr(std::auto_ptr<_Tp1>&& __r)
+    : _M_ptr(__r.get()), _M_refcount()
+    {
+     
+      static_assert( sizeof(_Tp1) > 0, "incomplete type" );
+      _Tp1* __tmp = __r.get();
+      _M_refcount = __shared_count<_Lp>(std::move(__r));
+      _M_enable_shared_from_this_with(__tmp);
+    }
+
+  template<typename _Tp>
+  template<typename _Tp1, typename>
+    inline
+    shared_ptr<_Tp>::shared_ptr(std::auto_ptr<_Tp1>&& __r)
+    : __shared_ptr<_Tp>(std::move(__r)) { }
+
+  template<typename _Tp, typename _Dp>
+  template<typename _Up, typename>
+    inline
+    unique_ptr<_Tp, _Dp>::unique_ptr(auto_ptr<_Up>&& __u) noexcept
+    : _M_t(__u.release(), deleter_type()) { }
+
+
+#pragma GCC diagnostic pop
+
+
+}
+# 88 "/usr/include/c++/10.2.0/memory" 2 3
+# 100 "/usr/include/c++/10.2.0/memory" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 122 "/usr/include/c++/10.2.0/memory" 3
+inline void*
+align(size_t __align, size_t __size, void*& __ptr, size_t& __space) noexcept
+{
+
+  const auto __intptr = reinterpret_cast<uintptr_t>(__ptr);
+
+
+
+
+
+
+  const auto __aligned = (__intptr - 1u + __align) & -__align;
+  const auto __diff = __aligned - __intptr;
+  if ((__size + __diff) > __space)
+    return nullptr;
+  else
+    {
+      __space -= __diff;
+      return __ptr = reinterpret_cast<void*>(__aligned);
+    }
+}
+# 158 "/usr/include/c++/10.2.0/memory" 3
+enum class pointer_safety { relaxed, preferred, strict };
+
+
+inline void
+declare_reachable(void*) { }
+
+
+template <typename _Tp>
+  inline _Tp*
+  undeclare_reachable(_Tp* __p) { return __p; }
+
+
+inline void
+declare_no_pointers(char*, size_t) { }
+
+
+inline void
+undeclare_no_pointers(char*, size_t) { }
+
+
+inline pointer_safety
+get_pointer_safety() noexcept { return pointer_safety::relaxed; }
+# 400 "/usr/include/c++/10.2.0/memory" 3
+
+}
+# 411 "/usr/include/c++/10.2.0/memory" 3
+# 1 "/usr/include/c++/10.2.0/pstl/glue_memory_defs.h" 1 3
+# 11 "/usr/include/c++/10.2.0/pstl/glue_memory_defs.h" 3
+#define _PSTL_GLUE_MEMORY_DEFS_H 
+
+# 1 "/usr/include/c++/10.2.0/pstl/execution_defs.h" 1 3
+# 11 "/usr/include/c++/10.2.0/pstl/execution_defs.h" 3
+#define _PSTL_EXECUTION_POLICY_DEFS_H 
+
+
+
+namespace __pstl
+{
+namespace execution
+{
+inline namespace v1
+{
+
+
+class sequenced_policy
+{
+  public:
+
+    static constexpr std::false_type
+    __allow_unsequenced()
+    {
+        return std::false_type{};
+    }
+    static constexpr std::false_type
+    __allow_vector()
+    {
+        return std::false_type{};
+    }
+    static constexpr std::false_type
+    __allow_parallel()
+    {
+        return std::false_type{};
+    }
+};
+
+
+class parallel_policy
+{
+  public:
+
+    static constexpr std::false_type
+    __allow_unsequenced()
+    {
+        return std::false_type{};
+    }
+    static constexpr std::false_type
+    __allow_vector()
+    {
+        return std::false_type{};
+    }
+    static constexpr std::true_type
+    __allow_parallel()
+    {
+        return std::true_type{};
+    }
+};
+
+
+class parallel_unsequenced_policy
+{
+  public:
+
+    static constexpr std::true_type
+    __allow_unsequenced()
+    {
+        return std::true_type{};
+    }
+    static constexpr std::true_type
+    __allow_vector()
+    {
+        return std::true_type{};
+    }
+    static constexpr std::true_type
+    __allow_parallel()
+    {
+        return std::true_type{};
+    }
+};
+
+class unsequenced_policy
+{
+  public:
+
+    static constexpr std::true_type
+    __allow_unsequenced()
+    {
+        return std::true_type{};
+    }
+    static constexpr std::true_type
+    __allow_vector()
+    {
+        return std::true_type{};
+    }
+    static constexpr std::false_type
+    __allow_parallel()
+    {
+        return std::false_type{};
+    }
+};
+
+
+constexpr sequenced_policy seq{};
+constexpr parallel_policy par{};
+constexpr parallel_unsequenced_policy par_unseq{};
+constexpr unsequenced_policy unseq{};
+
+
+template <class _Tp>
+struct is_execution_policy : std::false_type
+{
+};
+
+template <>
+struct is_execution_policy<__pstl::execution::sequenced_policy> : std::true_type
+{
+};
+template <>
+struct is_execution_policy<__pstl::execution::parallel_policy> : std::true_type
+{
+};
+template <>
+struct is_execution_policy<__pstl::execution::parallel_unsequenced_policy> : std::true_type
+{
+};
+template <>
+struct is_execution_policy<__pstl::execution::unsequenced_policy> : std::true_type
+{
+};
+
+
+template <class _Tp>
+constexpr bool is_execution_policy_v = __pstl::execution::is_execution_policy<_Tp>::value;
+
+
+}
+}
+
+namespace __internal
+{
+template <class _ExecPolicy, class _Tp>
+
+using __enable_if_execution_policy =
+    typename std::enable_if<__pstl::execution::is_execution_policy<std::__remove_cvref_t<_ExecPolicy>>::value,
+                            _Tp>::type;
+
+
+
+
+
+}
+
+}
+# 14 "/usr/include/c++/10.2.0/pstl/glue_memory_defs.h" 2 3
+
+namespace std
+{
+
+
+
+template <class _ExecutionPolicy, class _InputIterator, class _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+uninitialized_copy(_ExecutionPolicy&& __exec, _InputIterator __first, _InputIterator __last, _ForwardIterator __result);
+
+template <class _ExecutionPolicy, class _InputIterator, class _Size, class _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+uninitialized_copy_n(_ExecutionPolicy&& __exec, _InputIterator __first, _Size __n, _ForwardIterator __result);
+
+
+
+template <class _ExecutionPolicy, class _InputIterator, class _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+uninitialized_move(_ExecutionPolicy&& __exec, _InputIterator __first, _InputIterator __last, _ForwardIterator __result);
+
+template <class _ExecutionPolicy, class _InputIterator, class _Size, class _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+uninitialized_move_n(_ExecutionPolicy&& __exec, _InputIterator __first, _Size __n, _ForwardIterator __result);
+
+
+
+template <class _ExecutionPolicy, class _ForwardIterator, class _Tp>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
+uninitialized_fill(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value);
+
+template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Tp>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+uninitialized_fill_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n, const _Tp& __value);
+
+
+
+template <class _ExecutionPolicy, class _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
+destroy(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last);
+
+template <class _ExecutionPolicy, class _ForwardIterator, class _Size>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+destroy_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n);
+
+
+
+template <class _ExecutionPolicy, class _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
+uninitialized_default_construct(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last);
+
+template <class _ExecutionPolicy, class _ForwardIterator, class _Size>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+uninitialized_default_construct_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n);
+
+
+
+template <class _ExecutionPolicy, class _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
+uninitialized_value_construct(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last);
+
+template <class _ExecutionPolicy, class _ForwardIterator, class _Size>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+uninitialized_value_construct_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n);
+
+}
+# 412 "/usr/include/c++/10.2.0/memory" 2 3
+
+
+
+#define __cpp_lib_parallel_algorithm 201603L
+# 22 "/usr/include/boost/config/no_tr1/memory.hpp" 2 3 4
+
+
+#undef BOOST_TR1_NO_RECURSION
+#undef BOOST_CONFIG_NO_MEMORY_RECURSION
+# 24 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 2 3 4
+
+# 1 "/usr/include/boost/assert.hpp" 1 3 4
+# 32 "/usr/include/boost/assert.hpp" 3 4
+#undef BOOST_ASSERT
+#undef BOOST_ASSERT_MSG
+#undef BOOST_ASSERT_IS_VOID
+# 58 "/usr/include/boost/assert.hpp" 3 4
+# 1 "/usr/include/assert.h" 1 3 4
+# 34 "/usr/include/assert.h" 3 4
+#define _ASSERT_H 1
+
+
+
+#define __ASSERT_VOID_CAST static_cast<void>
+# 64 "/usr/include/assert.h" 3 4
+extern "C" {
+
+
+extern void __assert_fail (const char *__assertion, const char *__file,
+      unsigned int __line, const char *__function)
+     throw () __attribute__ ((__noreturn__));
+
+
+extern void __assert_perror_fail (int __errnum, const char *__file,
+      unsigned int __line, const char *__function)
+     throw () __attribute__ ((__noreturn__));
+
+
+
+
+extern void __assert (const char *__assertion, const char *__file, int __line)
+     throw () __attribute__ ((__noreturn__));
+
+
+}
+
+
+
+
+
+#define assert(expr) (static_cast <bool> (expr) ? void (0) : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
+# 114 "/usr/include/assert.h" 3 4
+#define assert_perror(errnum) (!(errnum) ? __ASSERT_VOID_CAST (0) : __assert_perror_fail ((errnum), __FILE__, __LINE__, __ASSERT_FUNCTION))
+# 126 "/usr/include/assert.h" 3 4
+#define __ASSERT_FUNCTION __extension__ __PRETTY_FUNCTION__
+# 59 "/usr/include/boost/assert.hpp" 2 3 4
+
+#define BOOST_ASSERT(expr) assert(expr)
+#define BOOST_ASSERT_MSG(expr,msg) assert((expr)&&(msg))
+# 72 "/usr/include/boost/assert.hpp" 3 4
+#undef BOOST_VERIFY
+#undef BOOST_VERIFY_MSG
+# 82 "/usr/include/boost/assert.hpp" 3 4
+#define BOOST_VERIFY(expr) BOOST_ASSERT(expr)
+#define BOOST_VERIFY_MSG(expr,msg) BOOST_ASSERT_MSG(expr,msg)
+# 26 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 2 3 4
+# 1 "/usr/include/boost/checked_delete.hpp" 1 3 4
+# 10 "/usr/include/boost/checked_delete.hpp" 3 4
+#define BOOST_CHECKED_DELETE_HPP 
+
+
+
+
+# 1 "/usr/include/boost/core/checked_delete.hpp" 1 3 4
+
+#define BOOST_CORE_CHECKED_DELETE_HPP 
+# 26 "/usr/include/boost/core/checked_delete.hpp" 3 4
+namespace boost
+{
+
+
+
+template<class T> inline void checked_delete(T * x) noexcept
+{
+
+    typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];
+    (void) sizeof(type_must_be_complete);
+    delete x;
+}
+
+template<class T> inline void checked_array_delete(T * x) noexcept
+{
+    typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];
+    (void) sizeof(type_must_be_complete);
+    delete [] x;
+}
+
+template<class T> struct checked_deleter
+{
+    typedef void result_type;
+    typedef T * argument_type;
+
+    void operator()(T * x) const noexcept
+    {
+
+        boost::checked_delete(x);
+    }
+};
+
+template<class T> struct checked_array_deleter
+{
+    typedef void result_type;
+    typedef T * argument_type;
+
+    void operator()(T * x) const noexcept
+    {
+        boost::checked_array_delete(x);
+    }
+};
+
+}
+# 16 "/usr/include/boost/checked_delete.hpp" 2 3 4
+# 27 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 2 3 4
+# 1 "/usr/include/boost/throw_exception.hpp" 1 3 4
+
+#define UUID_AA15E74A856F11E08B8D93F24824019B 
+# 36 "/usr/include/boost/throw_exception.hpp" 3 4
+# 1 "/usr/include/boost/exception/exception.hpp" 1 3 4
+
+
+
+
+
+
+#define UUID_274DA366004E11DCB1DDFE2E56D89593 
+
+
+
+
+
+
+
+namespace boost { template <class T> class shared_ptr; }
+namespace boost { namespace exception_detail { using boost::shared_ptr; } }
+
+
+
+       
+# 21 "/usr/include/boost/exception/exception.hpp" 3
+
+
+
+
+
+
+namespace
+boost
+    {
+    namespace
+    exception_detail
+        {
+        template <class T>
+        class
+        refcount_ptr
+            {
+            public:
+
+            refcount_ptr():
+                px_(0)
+                {
+                }
+
+            ~refcount_ptr()
+                {
+                release();
+                }
+
+            refcount_ptr( refcount_ptr const & x ):
+                px_(x.px_)
+                {
+                add_ref();
+                }
+
+            refcount_ptr &
+            operator=( refcount_ptr const & x )
+                {
+                adopt(x.px_);
+                return *this;
+                }
+
+            void
+            adopt( T * px )
+                {
+                release();
+                px_=px;
+                add_ref();
+                }
+
+            T *
+            get() const
+                {
+                return px_;
+                }
+
+            private:
+
+            T * px_;
+
+            void
+            add_ref()
+                {
+                if( px_ )
+                    px_->add_ref();
+                }
+
+            void
+            release()
+                {
+                if( px_ && px_->release() )
+                    px_=0;
+                }
+            };
+        }
+
+
+
+    template <class Tag,class T>
+    class error_info;
+
+    typedef error_info<struct throw_function_,char const *> throw_function;
+    typedef error_info<struct throw_file_,char const *> throw_file;
+    typedef error_info<struct throw_line_,int> throw_line;
+
+    template <>
+    class
+    error_info<throw_function_,char const *>
+        {
+        public:
+        typedef char const * value_type;
+        value_type v_;
+        explicit
+        error_info( value_type v ):
+            v_(v)
+            {
+            }
+        };
+
+    template <>
+    class
+    error_info<throw_file_,char const *>
+        {
+        public:
+        typedef char const * value_type;
+        value_type v_;
+        explicit
+        error_info( value_type v ):
+            v_(v)
+            {
+            }
+        };
+
+    template <>
+    class
+    error_info<throw_line_,int>
+        {
+        public:
+        typedef int value_type;
+        value_type v_;
+        explicit
+        error_info( value_type v ):
+            v_(v)
+            {
+            }
+        };
+
+    class
+    __attribute__((__visibility__("default")))
+    exception;
+
+    namespace
+    exception_detail
+        {
+        class error_info_base;
+        struct type_info_;
+
+        struct
+        error_info_container
+            {
+            virtual char const * diagnostic_information( char const * ) const = 0;
+            virtual shared_ptr<error_info_base> get( type_info_ const & ) const = 0;
+            virtual void set( shared_ptr<error_info_base> const &, type_info_ const & ) = 0;
+            virtual void add_ref() const = 0;
+            virtual bool release() const = 0;
+            virtual refcount_ptr<exception_detail::error_info_container> clone() const = 0;
+
+            protected:
+
+            ~error_info_container() noexcept
+                {
+                }
+            };
+
+        template <class>
+        struct get_info;
+
+        template <>
+        struct get_info<throw_function>;
+
+        template <>
+        struct get_info<throw_file>;
+
+        template <>
+        struct get_info<throw_line>;
+
+        template <class>
+        struct set_info_rv;
+
+        template <>
+        struct set_info_rv<throw_function>;
+
+        template <>
+        struct set_info_rv<throw_file>;
+
+        template <>
+        struct set_info_rv<throw_line>;
+
+        char const * get_diagnostic_information( exception const &, char const * );
+
+        void copy_boost_exception( exception *, exception const * );
+
+        template <class E,class Tag,class T>
+        E const & set_info( E const &, error_info<Tag,T> const & );
+
+        template <class E>
+        E const & set_info( E const &, throw_function const & );
+
+        template <class E>
+        E const & set_info( E const &, throw_file const & );
+
+        template <class E>
+        E const & set_info( E const &, throw_line const & );
+        }
+
+    class
+    __attribute__((__visibility__("default")))
+    exception
+        {
+
+        public:
+        template <class Tag> void set( typename Tag::type const & );
+        template <class Tag> typename Tag::type const * get() const;
+
+
+        protected:
+
+        exception():
+            throw_function_(0),
+            throw_file_(0),
+            throw_line_(-1)
+            {
+            }
+# 246 "/usr/include/boost/exception/exception.hpp" 3
+        virtual ~exception() noexcept
+
+            = 0
+
+            ;
+
+
+
+
+        private:
+
+        template <class E>
+        friend E const & exception_detail::set_info( E const &, throw_function const & );
+
+        template <class E>
+        friend E const & exception_detail::set_info( E const &, throw_file const & );
+
+        template <class E>
+        friend E const & exception_detail::set_info( E const &, throw_line const & );
+
+        template <class E,class Tag,class T>
+        friend E const & exception_detail::set_info( E const &, error_info<Tag,T> const & );
+
+        friend char const * exception_detail::get_diagnostic_information( exception const &, char const * );
+
+        template <class>
+        friend struct exception_detail::get_info;
+        friend struct exception_detail::get_info<throw_function>;
+        friend struct exception_detail::get_info<throw_file>;
+        friend struct exception_detail::get_info<throw_line>;
+        template <class>
+        friend struct exception_detail::set_info_rv;
+        friend struct exception_detail::set_info_rv<throw_function>;
+        friend struct exception_detail::set_info_rv<throw_file>;
+        friend struct exception_detail::set_info_rv<throw_line>;
+        friend void exception_detail::copy_boost_exception( exception *, exception const * );
+
+        mutable exception_detail::refcount_ptr<exception_detail::error_info_container> data_;
+        mutable char const * throw_function_;
+        mutable char const * throw_file_;
+        mutable int throw_line_;
+        };
+
+    inline
+    exception::
+    ~exception() noexcept
+        {
+        }
+
+    namespace
+    exception_detail
+        {
+        template <class E>
+        E const &
+        set_info( E const & x, throw_function const & y )
+            {
+            x.throw_function_=y.v_;
+            return x;
+            }
+
+        template <class E>
+        E const &
+        set_info( E const & x, throw_file const & y )
+            {
+            x.throw_file_=y.v_;
+            return x;
+            }
+
+        template <class E>
+        E const &
+        set_info( E const & x, throw_line const & y )
+            {
+            x.throw_line_=y.v_;
+            return x;
+            }
+        }
+
+
+
+    namespace
+    exception_detail
+        {
+        template <class T>
+        struct
+        __attribute__((__visibility__("default")))
+        error_info_injector:
+            public T,
+            public exception
+            {
+            explicit
+            error_info_injector( T const & x ):
+                T(x)
+                {
+                }
+
+            ~error_info_injector() noexcept
+                {
+                }
+            };
+
+        struct large_size { char c[256]; };
+        large_size dispatch_boost_exception( exception const * );
+
+        struct small_size { };
+        small_size dispatch_boost_exception( void const * );
+
+        template <class,int>
+        struct enable_error_info_helper;
+
+        template <class T>
+        struct
+        enable_error_info_helper<T,sizeof(large_size)>
+            {
+            typedef T type;
+            };
+
+        template <class T>
+        struct
+        enable_error_info_helper<T,sizeof(small_size)>
+            {
+            typedef error_info_injector<T> type;
+            };
+
+        template <class T>
+        struct
+        enable_error_info_return_type
+            {
+            typedef typename enable_error_info_helper<T,sizeof(exception_detail::dispatch_boost_exception(static_cast<T *>(0)))>::type type;
+            };
+        }
+
+    template <class T>
+    inline
+    typename
+    exception_detail::enable_error_info_return_type<T>::type
+    enable_error_info( T const & x )
+        {
+        typedef typename exception_detail::enable_error_info_return_type<T>::type rt;
+        return rt(x);
+        }
+
+
+
+    namespace
+    exception_detail
+        {
+        class
+        __attribute__((__visibility__("default")))
+        clone_base
+            {
+            public:
+
+            virtual clone_base const * clone() const = 0;
+            virtual void rethrow() const = 0;
+
+            virtual
+            ~clone_base() noexcept
+                {
+                }
+            };
+
+        inline
+        void
+        copy_boost_exception( exception * a, exception const * b )
+            {
+            refcount_ptr<error_info_container> data;
+            if( error_info_container * d=b->data_.get() )
+                data = d->clone();
+            a->throw_file_ = b->throw_file_;
+            a->throw_line_ = b->throw_line_;
+            a->throw_function_ = b->throw_function_;
+            a->data_ = data;
+            }
+
+        inline
+        void
+        copy_boost_exception( void *, void const * )
+            {
+            }
+
+        template <class T>
+        class
+        __attribute__((__visibility__("default")))
+        clone_impl:
+            public T,
+            public virtual clone_base
+            {
+            struct clone_tag { };
+            clone_impl( clone_impl const & x, clone_tag ):
+                T(x)
+                {
+                copy_boost_exception(this,&x);
+                }
+
+            public:
+
+            explicit
+            clone_impl( T const & x ):
+                T(x)
+                {
+                copy_boost_exception(this,&x);
+                }
+
+            ~clone_impl() noexcept
+                {
+                }
+
+            private:
+
+            clone_base const *
+            clone() const
+                {
+                return new clone_impl(*this,clone_tag());
+                }
+
+            void
+            rethrow() const
+                {
+                throw*this;
+                }
+            };
+        }
+
+    template <class T>
+    inline
+    exception_detail::clone_impl<T>
+    enable_current_exception( T const & x )
+        {
+        return exception_detail::clone_impl<T>(x);
+        }
+
+    template <class T>
+    struct
+    __attribute__((__visibility__("default")))
+    wrapexcept:
+        public exception_detail::clone_impl<typename exception_detail::enable_error_info_return_type<T>::type>
+        {
+        typedef exception_detail::clone_impl<typename exception_detail::enable_error_info_return_type<T>::type> base_type;
+        public:
+        explicit
+        wrapexcept( typename exception_detail::enable_error_info_return_type<T>::type const & x ):
+            base_type( x )
+            {
+            }
+
+        ~wrapexcept() noexcept
+            {
+            }
+        };
+
+    namespace
+    exception_detail
+        {
+        template <class T>
+        struct
+        remove_error_info_injector
+            {
+            typedef T type;
+            };
+
+        template <class T>
+        struct
+        remove_error_info_injector< error_info_injector<T> >
+            {
+            typedef T type;
+            };
+
+        template <class T>
+        inline
+        wrapexcept<typename remove_error_info_injector<T>::type>
+        enable_both( T const & x )
+            {
+            return wrapexcept<typename remove_error_info_injector<T>::type>( enable_error_info( x ) );
+            }
+        }
+    }
+# 37 "/usr/include/boost/throw_exception.hpp" 2 3 4
+
+# 1 "/usr/include/boost/current_function.hpp" 1 3 4
+
+#define BOOST_CURRENT_FUNCTION_HPP_INCLUDED 
+# 22 "/usr/include/boost/current_function.hpp" 3 4
+namespace boost
+{
+
+namespace detail
+{
+
+inline void current_function_helper()
+{
+
+
+
+
+
+
+
+#define BOOST_CURRENT_FUNCTION __PRETTY_FUNCTION__
+# 69 "/usr/include/boost/current_function.hpp" 3 4
+}
+
+}
+
+}
+# 39 "/usr/include/boost/throw_exception.hpp" 2 3 4
+#define BOOST_THROW_EXCEPTION_CURRENT_FUNCTION BOOST_CURRENT_FUNCTION
+
+#define BOOST_THROW_EXCEPTION(x) ::boost::exception_detail::throw_exception_(x,BOOST_THROW_EXCEPTION_CURRENT_FUNCTION,__FILE__,__LINE__)
+
+
+
+
+
+       
+# 48 "/usr/include/boost/throw_exception.hpp" 3
+
+
+
+
+
+namespace boost
+{
+
+
+
+
+
+
+inline void throw_exception_assert_compatibility( std::exception const & ) { }
+
+template<class E> __attribute__ ((__noreturn__)) inline void throw_exception( E const & e )
+{
+
+
+    throw_exception_assert_compatibility(e);
+
+
+    throw exception_detail::enable_both( e );
+
+
+
+}
+
+
+
+
+    namespace
+    exception_detail
+    {
+        template <class E>
+        __attribute__ ((__noreturn__))
+        void
+        throw_exception_( E const & x, char const * current_function, char const * file, int line )
+        {
+            boost::throw_exception(
+                set_info(
+                    set_info(
+                        set_info(
+                            enable_error_info(x),
+                            throw_function(current_function)),
+                        throw_file(file)),
+                    throw_line(line)));
+        }
+    }
+
+}
+# 28 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 2 3 4
+# 1 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 1 3 4
+
+#define BOOST_SMART_PTR_DETAIL_SHARED_COUNT_HPP_INCLUDED 
+# 28 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 3 4
+# 1 "/usr/include/boost/smart_ptr/bad_weak_ptr.hpp" 1 3 4
+
+#define BOOST_SMART_PTR_BAD_WEAK_PTR_HPP_INCLUDED 
+# 27 "/usr/include/boost/smart_ptr/bad_weak_ptr.hpp" 3 4
+namespace boost
+{
+# 46 "/usr/include/boost/smart_ptr/bad_weak_ptr.hpp" 3 4
+class bad_weak_ptr: public std::exception
+{
+public:
+
+    virtual char const * what() const noexcept
+    {
+        return "tr1::bad_weak_ptr";
+    }
+};
+# 64 "/usr/include/boost/smart_ptr/bad_weak_ptr.hpp" 3 4
+}
+# 29 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 2 3 4
+# 1 "/usr/include/boost/smart_ptr/detail/sp_counted_base.hpp" 1 3 4
+
+#define BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_HPP_INCLUDED 
+# 21 "/usr/include/boost/smart_ptr/detail/sp_counted_base.hpp" 3 4
+# 1 "/usr/include/boost/smart_ptr/detail/sp_has_sync.hpp" 1 3 4
+
+#define BOOST_SMART_PTR_DETAIL_SP_HAS_SYNC_HPP_INCLUDED 
+# 27 "/usr/include/boost/smart_ptr/detail/sp_has_sync.hpp" 3 4
+#define BOOST_SP_HAS_SYNC 
+# 22 "/usr/include/boost/smart_ptr/detail/sp_counted_base.hpp" 2 3 4
+# 48 "/usr/include/boost/smart_ptr/detail/sp_counted_base.hpp" 3 4
+# 1 "/usr/include/boost/smart_ptr/detail/sp_counted_base_std_atomic.hpp" 1 3 4
+
+#define BOOST_SMART_PTR_DETAIL_SP_COUNTED_BASE_STD_ATOMIC_HPP_INCLUDED 
+# 18 "/usr/include/boost/smart_ptr/detail/sp_counted_base_std_atomic.hpp" 3 4
+# 1 "/usr/include/boost/smart_ptr/detail/sp_typeinfo_.hpp" 1 3 4
+
+#define BOOST_SMART_PTR_DETAIL_SP_TYPEINFO_HPP_INCLUDED 
+# 42 "/usr/include/boost/smart_ptr/detail/sp_typeinfo_.hpp" 3 4
+namespace boost
+{
+
+namespace detail
+{
+
+typedef std::type_info sp_typeinfo_;
+
+}
+
+}
+
+#define BOOST_SP_TYPEID_(T) typeid(T)
+# 19 "/usr/include/boost/smart_ptr/detail/sp_counted_base_std_atomic.hpp" 2 3 4
+# 1 "/usr/include/boost/smart_ptr/detail/sp_noexcept.hpp" 1 3 4
+
+#define BOOST_SMART_PTR_DETAIL_SP_NOEXCEPT_HPP_INCLUDED 
+# 28 "/usr/include/boost/smart_ptr/detail/sp_noexcept.hpp" 3 4
+#define BOOST_SP_NOEXCEPT BOOST_NOEXCEPT
+# 44 "/usr/include/boost/smart_ptr/detail/sp_noexcept.hpp" 3 4
+#define BOOST_SP_NOEXCEPT_WITH_ASSERT BOOST_SP_NOEXCEPT
+# 20 "/usr/include/boost/smart_ptr/detail/sp_counted_base_std_atomic.hpp" 2 3 4
+
+# 1 "/usr/include/c++/10.2.0/atomic" 1 3 4
+# 33 "/usr/include/c++/10.2.0/atomic" 3 4
+#define _GLIBCXX_ATOMIC 1
+
+       
+# 36 "/usr/include/c++/10.2.0/atomic" 3
+
+
+
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+
+
+
+#define __cpp_lib_atomic_is_always_lock_free 201603
+
+
+  template<typename _Tp>
+    struct atomic;
+
+
+
+  template<>
+  struct atomic<bool>
+  {
+    using value_type = bool;
+
+  private:
+    __atomic_base<bool> _M_base;
+
+  public:
+    atomic() noexcept = default;
+    ~atomic() noexcept = default;
+    atomic(const atomic&) = delete;
+    atomic& operator=(const atomic&) = delete;
+    atomic& operator=(const atomic&) volatile = delete;
+
+    constexpr atomic(bool __i) noexcept : _M_base(__i) { }
+
+    bool
+    operator=(bool __i) noexcept
+    { return _M_base.operator=(__i); }
+
+    bool
+    operator=(bool __i) volatile noexcept
+    { return _M_base.operator=(__i); }
+
+    operator bool() const noexcept
+    { return _M_base.load(); }
+
+    operator bool() const volatile noexcept
+    { return _M_base.load(); }
+
+    bool
+    is_lock_free() const noexcept { return _M_base.is_lock_free(); }
+
+    bool
+    is_lock_free() const volatile noexcept { return _M_base.is_lock_free(); }
+
+
+    static constexpr bool is_always_lock_free = 2 == 2;
+
+
+    void
+    store(bool __i, memory_order __m = memory_order_seq_cst) noexcept
+    { _M_base.store(__i, __m); }
+
+    void
+    store(bool __i, memory_order __m = memory_order_seq_cst) volatile noexcept
+    { _M_base.store(__i, __m); }
+
+    bool
+    load(memory_order __m = memory_order_seq_cst) const noexcept
+    { return _M_base.load(__m); }
+
+    bool
+    load(memory_order __m = memory_order_seq_cst) const volatile noexcept
+    { return _M_base.load(__m); }
+
+    bool
+    exchange(bool __i, memory_order __m = memory_order_seq_cst) noexcept
+    { return _M_base.exchange(__i, __m); }
+
+    bool
+    exchange(bool __i,
+      memory_order __m = memory_order_seq_cst) volatile noexcept
+    { return _M_base.exchange(__i, __m); }
+
+    bool
+    compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1,
+     memory_order __m2) noexcept
+    { return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); }
+
+    bool
+    compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1,
+     memory_order __m2) volatile noexcept
+    { return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); }
+
+    bool
+    compare_exchange_weak(bool& __i1, bool __i2,
+     memory_order __m = memory_order_seq_cst) noexcept
+    { return _M_base.compare_exchange_weak(__i1, __i2, __m); }
+
+    bool
+    compare_exchange_weak(bool& __i1, bool __i2,
+       memory_order __m = memory_order_seq_cst) volatile noexcept
+    { return _M_base.compare_exchange_weak(__i1, __i2, __m); }
+
+    bool
+    compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1,
+       memory_order __m2) noexcept
+    { return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); }
+
+    bool
+    compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1,
+       memory_order __m2) volatile noexcept
+    { return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); }
+
+    bool
+    compare_exchange_strong(bool& __i1, bool __i2,
+       memory_order __m = memory_order_seq_cst) noexcept
+    { return _M_base.compare_exchange_strong(__i1, __i2, __m); }
+
+    bool
+    compare_exchange_strong(bool& __i1, bool __i2,
+      memory_order __m = memory_order_seq_cst) volatile noexcept
+    { return _M_base.compare_exchange_strong(__i1, __i2, __m); }
+  };
+
+
+#define _GLIBCXX20_INIT(I) 
+# 179 "/usr/include/c++/10.2.0/atomic" 3
+  template<typename _Tp>
+    struct atomic
+    {
+      using value_type = _Tp;
+
+    private:
+
+      static constexpr int _S_min_alignment
+ = (sizeof(_Tp) & (sizeof(_Tp) - 1)) || sizeof(_Tp) > 16
+ ? 0 : sizeof(_Tp);
+
+      static constexpr int _S_alignment
+        = _S_min_alignment > alignof(_Tp) ? _S_min_alignment : alignof(_Tp);
+
+      alignas(_S_alignment) _Tp _M_i ;
+
+      static_assert(__is_trivially_copyable(_Tp),
+      "std::atomic requires a trivially copyable type");
+
+      static_assert(sizeof(_Tp) > 0,
+      "Incomplete or zero-sized types are not supported");
+
+    public:
+      atomic() = default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(_Tp __i) noexcept : _M_i(__i) { }
+
+      operator _Tp() const noexcept
+      { return load(); }
+
+      operator _Tp() const volatile noexcept
+      { return load(); }
+
+      _Tp
+      operator=(_Tp __i) noexcept
+      { store(__i); return __i; }
+
+      _Tp
+      operator=(_Tp __i) volatile noexcept
+      { store(__i); return __i; }
+
+      bool
+      is_lock_free() const noexcept
+      {
+
+ return __atomic_is_lock_free(sizeof(_M_i),
+     reinterpret_cast<void *>(-_S_alignment));
+      }
+
+      bool
+      is_lock_free() const volatile noexcept
+      {
+
+ return __atomic_is_lock_free(sizeof(_M_i),
+     reinterpret_cast<void *>(-_S_alignment));
+      }
+
+
+      static constexpr bool is_always_lock_free
+ = __atomic_always_lock_free(sizeof(_M_i), 0);
+
+
+      void
+      store(_Tp __i, memory_order __m = memory_order_seq_cst) noexcept
+      { __atomic_store(std::__addressof(_M_i), std::__addressof(__i), int(__m)); }
+
+      void
+      store(_Tp __i, memory_order __m = memory_order_seq_cst) volatile noexcept
+      { __atomic_store(std::__addressof(_M_i), std::__addressof(__i), int(__m)); }
+
+      _Tp
+      load(memory_order __m = memory_order_seq_cst) const noexcept
+      {
+ alignas(_Tp) unsigned char __buf[sizeof(_Tp)];
+ _Tp* __ptr = reinterpret_cast<_Tp*>(__buf);
+ __atomic_load(std::__addressof(_M_i), __ptr, int(__m));
+ return *__ptr;
+      }
+
+      _Tp
+      load(memory_order __m = memory_order_seq_cst) const volatile noexcept
+      {
+        alignas(_Tp) unsigned char __buf[sizeof(_Tp)];
+ _Tp* __ptr = reinterpret_cast<_Tp*>(__buf);
+ __atomic_load(std::__addressof(_M_i), __ptr, int(__m));
+ return *__ptr;
+      }
+
+      _Tp
+      exchange(_Tp __i, memory_order __m = memory_order_seq_cst) noexcept
+      {
+        alignas(_Tp) unsigned char __buf[sizeof(_Tp)];
+ _Tp* __ptr = reinterpret_cast<_Tp*>(__buf);
+ __atomic_exchange(std::__addressof(_M_i), std::__addressof(__i),
+     __ptr, int(__m));
+ return *__ptr;
+      }
+
+      _Tp
+      exchange(_Tp __i,
+        memory_order __m = memory_order_seq_cst) volatile noexcept
+      {
+        alignas(_Tp) unsigned char __buf[sizeof(_Tp)];
+ _Tp* __ptr = reinterpret_cast<_Tp*>(__buf);
+ __atomic_exchange(std::__addressof(_M_i), std::__addressof(__i),
+     __ptr, int(__m));
+ return *__ptr;
+      }
+
+      bool
+      compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s,
+       memory_order __f) noexcept
+      {
+ return __atomic_compare_exchange(std::__addressof(_M_i),
+      std::__addressof(__e),
+      std::__addressof(__i),
+      true, int(__s), int(__f));
+      }
+
+      bool
+      compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s,
+       memory_order __f) volatile noexcept
+      {
+ return __atomic_compare_exchange(std::__addressof(_M_i),
+      std::__addressof(__e),
+      std::__addressof(__i),
+      true, int(__s), int(__f));
+      }
+
+      bool
+      compare_exchange_weak(_Tp& __e, _Tp __i,
+       memory_order __m = memory_order_seq_cst) noexcept
+      { return compare_exchange_weak(__e, __i, __m,
+                                     __cmpexch_failure_order(__m)); }
+
+      bool
+      compare_exchange_weak(_Tp& __e, _Tp __i,
+       memory_order __m = memory_order_seq_cst) volatile noexcept
+      { return compare_exchange_weak(__e, __i, __m,
+                                     __cmpexch_failure_order(__m)); }
+
+      bool
+      compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s,
+         memory_order __f) noexcept
+      {
+ return __atomic_compare_exchange(std::__addressof(_M_i),
+      std::__addressof(__e),
+      std::__addressof(__i),
+      false, int(__s), int(__f));
+      }
+
+      bool
+      compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s,
+         memory_order __f) volatile noexcept
+      {
+ return __atomic_compare_exchange(std::__addressof(_M_i),
+      std::__addressof(__e),
+      std::__addressof(__i),
+      false, int(__s), int(__f));
+      }
+
+      bool
+      compare_exchange_strong(_Tp& __e, _Tp __i,
+          memory_order __m = memory_order_seq_cst) noexcept
+      { return compare_exchange_strong(__e, __i, __m,
+                                       __cmpexch_failure_order(__m)); }
+
+      bool
+      compare_exchange_strong(_Tp& __e, _Tp __i,
+       memory_order __m = memory_order_seq_cst) volatile noexcept
+      { return compare_exchange_strong(__e, __i, __m,
+                                       __cmpexch_failure_order(__m)); }
+    };
+#undef _GLIBCXX20_INIT
+
+
+  template<typename _Tp>
+    struct atomic<_Tp*>
+    {
+      using value_type = _Tp*;
+      using difference_type = ptrdiff_t;
+
+      typedef _Tp* __pointer_type;
+      typedef __atomic_base<_Tp*> __base_type;
+      __base_type _M_b;
+
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(__pointer_type __p) noexcept : _M_b(__p) { }
+
+      operator __pointer_type() const noexcept
+      { return __pointer_type(_M_b); }
+
+      operator __pointer_type() const volatile noexcept
+      { return __pointer_type(_M_b); }
+
+      __pointer_type
+      operator=(__pointer_type __p) noexcept
+      { return _M_b.operator=(__p); }
+
+      __pointer_type
+      operator=(__pointer_type __p) volatile noexcept
+      { return _M_b.operator=(__p); }
+
+      __pointer_type
+      operator++(int) noexcept
+      {
+
+ static_assert( is_object<_Tp>::value, "pointer to object type" );
+
+ return _M_b++;
+      }
+
+      __pointer_type
+      operator++(int) volatile noexcept
+      {
+
+ static_assert( is_object<_Tp>::value, "pointer to object type" );
+
+ return _M_b++;
+      }
+
+      __pointer_type
+      operator--(int) noexcept
+      {
+
+ static_assert( is_object<_Tp>::value, "pointer to object type" );
+
+ return _M_b--;
+      }
+
+      __pointer_type
+      operator--(int) volatile noexcept
+      {
+
+ static_assert( is_object<_Tp>::value, "pointer to object type" );
+
+ return _M_b--;
+      }
+
+      __pointer_type
+      operator++() noexcept
+      {
+
+ static_assert( is_object<_Tp>::value, "pointer to object type" );
+
+ return ++_M_b;
+      }
+
+      __pointer_type
+      operator++() volatile noexcept
+      {
+
+ static_assert( is_object<_Tp>::value, "pointer to object type" );
+
+ return ++_M_b;
+      }
+
+      __pointer_type
+      operator--() noexcept
+      {
+
+ static_assert( is_object<_Tp>::value, "pointer to object type" );
+
+ return --_M_b;
+      }
+
+      __pointer_type
+      operator--() volatile noexcept
+      {
+
+ static_assert( is_object<_Tp>::value, "pointer to object type" );
+
+ return --_M_b;
+      }
+
+      __pointer_type
+      operator+=(ptrdiff_t __d) noexcept
+      {
+
+ static_assert( is_object<_Tp>::value, "pointer to object type" );
+
+ return _M_b.operator+=(__d);
+      }
+
+      __pointer_type
+      operator+=(ptrdiff_t __d) volatile noexcept
+      {
+
+ static_assert( is_object<_Tp>::value, "pointer to object type" );
+
+ return _M_b.operator+=(__d);
+      }
+
+      __pointer_type
+      operator-=(ptrdiff_t __d) noexcept
+      {
+
+ static_assert( is_object<_Tp>::value, "pointer to object type" );
+
+ return _M_b.operator-=(__d);
+      }
+
+      __pointer_type
+      operator-=(ptrdiff_t __d) volatile noexcept
+      {
+
+ static_assert( is_object<_Tp>::value, "pointer to object type" );
+
+ return _M_b.operator-=(__d);
+      }
+
+      bool
+      is_lock_free() const noexcept
+      { return _M_b.is_lock_free(); }
+
+      bool
+      is_lock_free() const volatile noexcept
+      { return _M_b.is_lock_free(); }
+
+
+    static constexpr bool is_always_lock_free = 2 == 2;
+
+
+      void
+      store(__pointer_type __p,
+     memory_order __m = memory_order_seq_cst) noexcept
+      { return _M_b.store(__p, __m); }
+
+      void
+      store(__pointer_type __p,
+     memory_order __m = memory_order_seq_cst) volatile noexcept
+      { return _M_b.store(__p, __m); }
+
+      __pointer_type
+      load(memory_order __m = memory_order_seq_cst) const noexcept
+      { return _M_b.load(__m); }
+
+      __pointer_type
+      load(memory_order __m = memory_order_seq_cst) const volatile noexcept
+      { return _M_b.load(__m); }
+
+      __pointer_type
+      exchange(__pointer_type __p,
+        memory_order __m = memory_order_seq_cst) noexcept
+      { return _M_b.exchange(__p, __m); }
+
+      __pointer_type
+      exchange(__pointer_type __p,
+        memory_order __m = memory_order_seq_cst) volatile noexcept
+      { return _M_b.exchange(__p, __m); }
+
+      bool
+      compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
+       memory_order __m1, memory_order __m2) noexcept
+      { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
+
+      bool
+      compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
+       memory_order __m1,
+       memory_order __m2) volatile noexcept
+      { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
+
+      bool
+      compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
+       memory_order __m = memory_order_seq_cst) noexcept
+      {
+ return compare_exchange_weak(__p1, __p2, __m,
+         __cmpexch_failure_order(__m));
+      }
+
+      bool
+      compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
+      memory_order __m = memory_order_seq_cst) volatile noexcept
+      {
+ return compare_exchange_weak(__p1, __p2, __m,
+         __cmpexch_failure_order(__m));
+      }
+
+      bool
+      compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
+         memory_order __m1, memory_order __m2) noexcept
+      { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
+
+      bool
+      compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
+         memory_order __m1,
+         memory_order __m2) volatile noexcept
+      { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
+
+      bool
+      compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
+         memory_order __m = memory_order_seq_cst) noexcept
+      {
+ return _M_b.compare_exchange_strong(__p1, __p2, __m,
+         __cmpexch_failure_order(__m));
+      }
+
+      bool
+      compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
+      memory_order __m = memory_order_seq_cst) volatile noexcept
+      {
+ return _M_b.compare_exchange_strong(__p1, __p2, __m,
+         __cmpexch_failure_order(__m));
+      }
+
+      __pointer_type
+      fetch_add(ptrdiff_t __d,
+  memory_order __m = memory_order_seq_cst) noexcept
+      {
+
+ static_assert( is_object<_Tp>::value, "pointer to object type" );
+
+ return _M_b.fetch_add(__d, __m);
+      }
+
+      __pointer_type
+      fetch_add(ptrdiff_t __d,
+  memory_order __m = memory_order_seq_cst) volatile noexcept
+      {
+
+ static_assert( is_object<_Tp>::value, "pointer to object type" );
+
+ return _M_b.fetch_add(__d, __m);
+      }
+
+      __pointer_type
+      fetch_sub(ptrdiff_t __d,
+  memory_order __m = memory_order_seq_cst) noexcept
+      {
+
+ static_assert( is_object<_Tp>::value, "pointer to object type" );
+
+ return _M_b.fetch_sub(__d, __m);
+      }
+
+      __pointer_type
+      fetch_sub(ptrdiff_t __d,
+  memory_order __m = memory_order_seq_cst) volatile noexcept
+      {
+
+ static_assert( is_object<_Tp>::value, "pointer to object type" );
+
+ return _M_b.fetch_sub(__d, __m);
+      }
+    };
+
+
+
+  template<>
+    struct atomic<char> : __atomic_base<char>
+    {
+      typedef char __integral_type;
+      typedef __atomic_base<char> __base_type;
+
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
+
+      using __base_type::operator __integral_type;
+      using __base_type::operator=;
+
+
+    static constexpr bool is_always_lock_free = 2 == 2;
+
+    };
+
+
+  template<>
+    struct atomic<signed char> : __atomic_base<signed char>
+    {
+      typedef signed char __integral_type;
+      typedef __atomic_base<signed char> __base_type;
+
+      atomic() noexcept= default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
+
+      using __base_type::operator __integral_type;
+      using __base_type::operator=;
+
+
+    static constexpr bool is_always_lock_free = 2 == 2;
+
+    };
+
+
+  template<>
+    struct atomic<unsigned char> : __atomic_base<unsigned char>
+    {
+      typedef unsigned char __integral_type;
+      typedef __atomic_base<unsigned char> __base_type;
+
+      atomic() noexcept= default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
+
+      using __base_type::operator __integral_type;
+      using __base_type::operator=;
+
+
+    static constexpr bool is_always_lock_free = 2 == 2;
+
+    };
+
+
+  template<>
+    struct atomic<short> : __atomic_base<short>
+    {
+      typedef short __integral_type;
+      typedef __atomic_base<short> __base_type;
+
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
+
+      using __base_type::operator __integral_type;
+      using __base_type::operator=;
+
+
+    static constexpr bool is_always_lock_free = 2 == 2;
+
+    };
+
+
+  template<>
+    struct atomic<unsigned short> : __atomic_base<unsigned short>
+    {
+      typedef unsigned short __integral_type;
+      typedef __atomic_base<unsigned short> __base_type;
+
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
+
+      using __base_type::operator __integral_type;
+      using __base_type::operator=;
+
+
+    static constexpr bool is_always_lock_free = 2 == 2;
+
+    };
+
+
+  template<>
+    struct atomic<int> : __atomic_base<int>
+    {
+      typedef int __integral_type;
+      typedef __atomic_base<int> __base_type;
+
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
+
+      using __base_type::operator __integral_type;
+      using __base_type::operator=;
+
+
+    static constexpr bool is_always_lock_free = 2 == 2;
+
+    };
+
+
+  template<>
+    struct atomic<unsigned int> : __atomic_base<unsigned int>
+    {
+      typedef unsigned int __integral_type;
+      typedef __atomic_base<unsigned int> __base_type;
+
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
+
+      using __base_type::operator __integral_type;
+      using __base_type::operator=;
+
+
+    static constexpr bool is_always_lock_free = 2 == 2;
+
+    };
+
+
+  template<>
+    struct atomic<long> : __atomic_base<long>
+    {
+      typedef long __integral_type;
+      typedef __atomic_base<long> __base_type;
+
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
+
+      using __base_type::operator __integral_type;
+      using __base_type::operator=;
+
+
+    static constexpr bool is_always_lock_free = 2 == 2;
+
+    };
+
+
+  template<>
+    struct atomic<unsigned long> : __atomic_base<unsigned long>
+    {
+      typedef unsigned long __integral_type;
+      typedef __atomic_base<unsigned long> __base_type;
+
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
+
+      using __base_type::operator __integral_type;
+      using __base_type::operator=;
+
+
+    static constexpr bool is_always_lock_free = 2 == 2;
+
+    };
+
+
+  template<>
+    struct atomic<long long> : __atomic_base<long long>
+    {
+      typedef long long __integral_type;
+      typedef __atomic_base<long long> __base_type;
+
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
+
+      using __base_type::operator __integral_type;
+      using __base_type::operator=;
+
+
+    static constexpr bool is_always_lock_free = 2 == 2;
+
+    };
+
+
+  template<>
+    struct atomic<unsigned long long> : __atomic_base<unsigned long long>
+    {
+      typedef unsigned long long __integral_type;
+      typedef __atomic_base<unsigned long long> __base_type;
+
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
+
+      using __base_type::operator __integral_type;
+      using __base_type::operator=;
+
+
+    static constexpr bool is_always_lock_free = 2 == 2;
+
+    };
+
+
+  template<>
+    struct atomic<wchar_t> : __atomic_base<wchar_t>
+    {
+      typedef wchar_t __integral_type;
+      typedef __atomic_base<wchar_t> __base_type;
+
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
+
+      using __base_type::operator __integral_type;
+      using __base_type::operator=;
+
+
+    static constexpr bool is_always_lock_free = 2 == 2;
+
+    };
+# 937 "/usr/include/c++/10.2.0/atomic" 3
+  template<>
+    struct atomic<char16_t> : __atomic_base<char16_t>
+    {
+      typedef char16_t __integral_type;
+      typedef __atomic_base<char16_t> __base_type;
+
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
+
+      using __base_type::operator __integral_type;
+      using __base_type::operator=;
+
+
+    static constexpr bool is_always_lock_free = 2 == 2;
+
+    };
+
+
+  template<>
+    struct atomic<char32_t> : __atomic_base<char32_t>
+    {
+      typedef char32_t __integral_type;
+      typedef __atomic_base<char32_t> __base_type;
+
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
+
+      using __base_type::operator __integral_type;
+      using __base_type::operator=;
+
+
+    static constexpr bool is_always_lock_free = 2 == 2;
+
+    };
+
+
+
+  typedef atomic<bool> atomic_bool;
+
+
+  typedef atomic<char> atomic_char;
+
+
+  typedef atomic<signed char> atomic_schar;
+
+
+  typedef atomic<unsigned char> atomic_uchar;
+
+
+  typedef atomic<short> atomic_short;
+
+
+  typedef atomic<unsigned short> atomic_ushort;
+
+
+  typedef atomic<int> atomic_int;
+
+
+  typedef atomic<unsigned int> atomic_uint;
+
+
+  typedef atomic<long> atomic_long;
+
+
+  typedef atomic<unsigned long> atomic_ulong;
+
+
+  typedef atomic<long long> atomic_llong;
+
+
+  typedef atomic<unsigned long long> atomic_ullong;
+
+
+  typedef atomic<wchar_t> atomic_wchar_t;
+
+
+
+
+
+
+
+  typedef atomic<char16_t> atomic_char16_t;
+
+
+  typedef atomic<char32_t> atomic_char32_t;
+
+
+
+
+
+
+  typedef atomic<int8_t> atomic_int8_t;
+
+
+  typedef atomic<uint8_t> atomic_uint8_t;
+
+
+  typedef atomic<int16_t> atomic_int16_t;
+
+
+  typedef atomic<uint16_t> atomic_uint16_t;
+
+
+  typedef atomic<int32_t> atomic_int32_t;
+
+
+  typedef atomic<uint32_t> atomic_uint32_t;
+
+
+  typedef atomic<int64_t> atomic_int64_t;
+
+
+  typedef atomic<uint64_t> atomic_uint64_t;
+
+
+
+  typedef atomic<int_least8_t> atomic_int_least8_t;
+
+
+  typedef atomic<uint_least8_t> atomic_uint_least8_t;
+
+
+  typedef atomic<int_least16_t> atomic_int_least16_t;
+
+
+  typedef atomic<uint_least16_t> atomic_uint_least16_t;
+
+
+  typedef atomic<int_least32_t> atomic_int_least32_t;
+
+
+  typedef atomic<uint_least32_t> atomic_uint_least32_t;
+
+
+  typedef atomic<int_least64_t> atomic_int_least64_t;
+
+
+  typedef atomic<uint_least64_t> atomic_uint_least64_t;
+
+
+
+  typedef atomic<int_fast8_t> atomic_int_fast8_t;
+
+
+  typedef atomic<uint_fast8_t> atomic_uint_fast8_t;
+
+
+  typedef atomic<int_fast16_t> atomic_int_fast16_t;
+
+
+  typedef atomic<uint_fast16_t> atomic_uint_fast16_t;
+
+
+  typedef atomic<int_fast32_t> atomic_int_fast32_t;
+
+
+  typedef atomic<uint_fast32_t> atomic_uint_fast32_t;
+
+
+  typedef atomic<int_fast64_t> atomic_int_fast64_t;
+
+
+  typedef atomic<uint_fast64_t> atomic_uint_fast64_t;
+
+
+
+
+  typedef atomic<intptr_t> atomic_intptr_t;
+
+
+  typedef atomic<uintptr_t> atomic_uintptr_t;
+
+
+  typedef atomic<size_t> atomic_size_t;
+
+
+  typedef atomic<ptrdiff_t> atomic_ptrdiff_t;
+
+
+
+  typedef atomic<intmax_t> atomic_intmax_t;
+
+
+  typedef atomic<uintmax_t> atomic_uintmax_t;
+
+
+
+  inline bool
+  atomic_flag_test_and_set_explicit(atomic_flag* __a,
+        memory_order __m) noexcept
+  { return __a->test_and_set(__m); }
+
+  inline bool
+  atomic_flag_test_and_set_explicit(volatile atomic_flag* __a,
+        memory_order __m) noexcept
+  { return __a->test_and_set(__m); }
+
+  inline void
+  atomic_flag_clear_explicit(atomic_flag* __a, memory_order __m) noexcept
+  { __a->clear(__m); }
+
+  inline void
+  atomic_flag_clear_explicit(volatile atomic_flag* __a,
+        memory_order __m) noexcept
+  { __a->clear(__m); }
+
+  inline bool
+  atomic_flag_test_and_set(atomic_flag* __a) noexcept
+  { return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); }
+
+  inline bool
+  atomic_flag_test_and_set(volatile atomic_flag* __a) noexcept
+  { return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); }
+
+  inline void
+  atomic_flag_clear(atomic_flag* __a) noexcept
+  { atomic_flag_clear_explicit(__a, memory_order_seq_cst); }
+
+  inline void
+  atomic_flag_clear(volatile atomic_flag* __a) noexcept
+  { atomic_flag_clear_explicit(__a, memory_order_seq_cst); }
+
+
+  template<typename _Tp>
+    using __atomic_val_t = typename atomic<_Tp>::value_type;
+  template<typename _Tp>
+    using __atomic_diff_t = typename atomic<_Tp>::difference_type;
+
+
+
+  template<typename _ITp>
+    inline bool
+    atomic_is_lock_free(const atomic<_ITp>* __a) noexcept
+    { return __a->is_lock_free(); }
+
+  template<typename _ITp>
+    inline bool
+    atomic_is_lock_free(const volatile atomic<_ITp>* __a) noexcept
+    { return __a->is_lock_free(); }
+
+  template<typename _ITp>
+    inline void
+    atomic_init(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept
+    { __a->store(__i, memory_order_relaxed); }
+
+  template<typename _ITp>
+    inline void
+    atomic_init(volatile atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept
+    { __a->store(__i, memory_order_relaxed); }
+
+  template<typename _ITp>
+    inline void
+    atomic_store_explicit(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i,
+     memory_order __m) noexcept
+    { __a->store(__i, __m); }
+
+  template<typename _ITp>
+    inline void
+    atomic_store_explicit(volatile atomic<_ITp>* __a, __atomic_val_t<_ITp> __i,
+     memory_order __m) noexcept
+    { __a->store(__i, __m); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_load_explicit(const atomic<_ITp>* __a, memory_order __m) noexcept
+    { return __a->load(__m); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_load_explicit(const volatile atomic<_ITp>* __a,
+    memory_order __m) noexcept
+    { return __a->load(__m); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_exchange_explicit(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i,
+        memory_order __m) noexcept
+    { return __a->exchange(__i, __m); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_exchange_explicit(volatile atomic<_ITp>* __a,
+        __atomic_val_t<_ITp> __i,
+        memory_order __m) noexcept
+    { return __a->exchange(__i, __m); }
+
+  template<typename _ITp>
+    inline bool
+    atomic_compare_exchange_weak_explicit(atomic<_ITp>* __a,
+       __atomic_val_t<_ITp>* __i1,
+       __atomic_val_t<_ITp> __i2,
+       memory_order __m1,
+       memory_order __m2) noexcept
+    { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); }
+
+  template<typename _ITp>
+    inline bool
+    atomic_compare_exchange_weak_explicit(volatile atomic<_ITp>* __a,
+       __atomic_val_t<_ITp>* __i1,
+       __atomic_val_t<_ITp> __i2,
+       memory_order __m1,
+       memory_order __m2) noexcept
+    { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); }
+
+  template<typename _ITp>
+    inline bool
+    atomic_compare_exchange_strong_explicit(atomic<_ITp>* __a,
+         __atomic_val_t<_ITp>* __i1,
+         __atomic_val_t<_ITp> __i2,
+         memory_order __m1,
+         memory_order __m2) noexcept
+    { return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); }
+
+  template<typename _ITp>
+    inline bool
+    atomic_compare_exchange_strong_explicit(volatile atomic<_ITp>* __a,
+         __atomic_val_t<_ITp>* __i1,
+         __atomic_val_t<_ITp> __i2,
+         memory_order __m1,
+         memory_order __m2) noexcept
+    { return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); }
+
+
+  template<typename _ITp>
+    inline void
+    atomic_store(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept
+    { atomic_store_explicit(__a, __i, memory_order_seq_cst); }
+
+  template<typename _ITp>
+    inline void
+    atomic_store(volatile atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept
+    { atomic_store_explicit(__a, __i, memory_order_seq_cst); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_load(const atomic<_ITp>* __a) noexcept
+    { return atomic_load_explicit(__a, memory_order_seq_cst); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_load(const volatile atomic<_ITp>* __a) noexcept
+    { return atomic_load_explicit(__a, memory_order_seq_cst); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_exchange(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept
+    { return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_exchange(volatile atomic<_ITp>* __a,
+      __atomic_val_t<_ITp> __i) noexcept
+    { return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); }
+
+  template<typename _ITp>
+    inline bool
+    atomic_compare_exchange_weak(atomic<_ITp>* __a,
+     __atomic_val_t<_ITp>* __i1,
+     __atomic_val_t<_ITp> __i2) noexcept
+    {
+      return atomic_compare_exchange_weak_explicit(__a, __i1, __i2,
+         memory_order_seq_cst,
+         memory_order_seq_cst);
+    }
+
+  template<typename _ITp>
+    inline bool
+    atomic_compare_exchange_weak(volatile atomic<_ITp>* __a,
+     __atomic_val_t<_ITp>* __i1,
+     __atomic_val_t<_ITp> __i2) noexcept
+    {
+      return atomic_compare_exchange_weak_explicit(__a, __i1, __i2,
+         memory_order_seq_cst,
+         memory_order_seq_cst);
+    }
+
+  template<typename _ITp>
+    inline bool
+    atomic_compare_exchange_strong(atomic<_ITp>* __a,
+       __atomic_val_t<_ITp>* __i1,
+       __atomic_val_t<_ITp> __i2) noexcept
+    {
+      return atomic_compare_exchange_strong_explicit(__a, __i1, __i2,
+           memory_order_seq_cst,
+           memory_order_seq_cst);
+    }
+
+  template<typename _ITp>
+    inline bool
+    atomic_compare_exchange_strong(volatile atomic<_ITp>* __a,
+       __atomic_val_t<_ITp>* __i1,
+       __atomic_val_t<_ITp> __i2) noexcept
+    {
+      return atomic_compare_exchange_strong_explicit(__a, __i1, __i2,
+           memory_order_seq_cst,
+           memory_order_seq_cst);
+    }
+
+
+
+
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_add_explicit(atomic<_ITp>* __a,
+         __atomic_diff_t<_ITp> __i,
+         memory_order __m) noexcept
+    { return __a->fetch_add(__i, __m); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_add_explicit(volatile atomic<_ITp>* __a,
+         __atomic_diff_t<_ITp> __i,
+         memory_order __m) noexcept
+    { return __a->fetch_add(__i, __m); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_sub_explicit(atomic<_ITp>* __a,
+         __atomic_diff_t<_ITp> __i,
+         memory_order __m) noexcept
+    { return __a->fetch_sub(__i, __m); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_sub_explicit(volatile atomic<_ITp>* __a,
+         __atomic_diff_t<_ITp> __i,
+         memory_order __m) noexcept
+    { return __a->fetch_sub(__i, __m); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_and_explicit(__atomic_base<_ITp>* __a,
+         __atomic_val_t<_ITp> __i,
+         memory_order __m) noexcept
+    { return __a->fetch_and(__i, __m); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_and_explicit(volatile __atomic_base<_ITp>* __a,
+         __atomic_val_t<_ITp> __i,
+         memory_order __m) noexcept
+    { return __a->fetch_and(__i, __m); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_or_explicit(__atomic_base<_ITp>* __a,
+        __atomic_val_t<_ITp> __i,
+        memory_order __m) noexcept
+    { return __a->fetch_or(__i, __m); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_or_explicit(volatile __atomic_base<_ITp>* __a,
+        __atomic_val_t<_ITp> __i,
+        memory_order __m) noexcept
+    { return __a->fetch_or(__i, __m); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_xor_explicit(__atomic_base<_ITp>* __a,
+         __atomic_val_t<_ITp> __i,
+         memory_order __m) noexcept
+    { return __a->fetch_xor(__i, __m); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_xor_explicit(volatile __atomic_base<_ITp>* __a,
+         __atomic_val_t<_ITp> __i,
+         memory_order __m) noexcept
+    { return __a->fetch_xor(__i, __m); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_add(atomic<_ITp>* __a,
+       __atomic_diff_t<_ITp> __i) noexcept
+    { return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_add(volatile atomic<_ITp>* __a,
+       __atomic_diff_t<_ITp> __i) noexcept
+    { return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_sub(atomic<_ITp>* __a,
+       __atomic_diff_t<_ITp> __i) noexcept
+    { return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_sub(volatile atomic<_ITp>* __a,
+       __atomic_diff_t<_ITp> __i) noexcept
+    { return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_and(__atomic_base<_ITp>* __a,
+       __atomic_val_t<_ITp> __i) noexcept
+    { return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_and(volatile __atomic_base<_ITp>* __a,
+       __atomic_val_t<_ITp> __i) noexcept
+    { return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_or(__atomic_base<_ITp>* __a,
+      __atomic_val_t<_ITp> __i) noexcept
+    { return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_or(volatile __atomic_base<_ITp>* __a,
+      __atomic_val_t<_ITp> __i) noexcept
+    { return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_xor(__atomic_base<_ITp>* __a,
+       __atomic_val_t<_ITp> __i) noexcept
+    { return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_xor(volatile __atomic_base<_ITp>* __a,
+       __atomic_val_t<_ITp> __i) noexcept
+    { return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); }
+# 1547 "/usr/include/c++/10.2.0/atomic" 3
+
+}
+# 22 "/usr/include/boost/smart_ptr/detail/sp_counted_base_std_atomic.hpp" 2 3 4
+
+
+namespace boost
+{
+
+namespace detail
+{
+
+inline void atomic_increment( std::atomic_int_least32_t * pw ) noexcept
+{
+    pw->fetch_add( 1, std::memory_order_relaxed );
+}
+
+inline std::int_least32_t atomic_decrement( std::atomic_int_least32_t * pw ) noexcept
+{
+    return pw->fetch_sub( 1, std::memory_order_acq_rel );
+}
+
+inline std::int_least32_t atomic_conditional_increment( std::atomic_int_least32_t * pw ) noexcept
+{
+
+
+
+
+    std::int_least32_t r = pw->load( std::memory_order_relaxed );
+
+    for( ;; )
+    {
+        if( r == 0 )
+        {
+            return r;
+        }
+
+        if( pw->compare_exchange_weak( r, r + 1, std::memory_order_relaxed, std::memory_order_relaxed ) )
+        {
+            return r;
+        }
+    }
+}
+
+class __attribute__((__visibility__("default"))) sp_counted_base
+{
+private:
+
+    sp_counted_base( sp_counted_base const & );
+    sp_counted_base & operator= ( sp_counted_base const & );
+
+    std::atomic_int_least32_t use_count_;
+    std::atomic_int_least32_t weak_count_;
+
+public:
+
+    sp_counted_base() noexcept: use_count_( 1 ), weak_count_( 1 )
+    {
+    }
+
+    virtual ~sp_counted_base()
+    {
+    }
+
+
+
+
+    virtual void dispose() noexcept = 0;
+
+
+
+    virtual void destroy() noexcept
+    {
+        delete this;
+    }
+
+    virtual void * get_deleter( sp_typeinfo_ const & ti ) noexcept = 0;
+    virtual void * get_local_deleter( sp_typeinfo_ const & ti ) noexcept = 0;
+    virtual void * get_untyped_deleter() noexcept = 0;
+
+    void add_ref_copy() noexcept
+    {
+        atomic_increment( &use_count_ );
+    }
+
+    bool add_ref_lock() noexcept
+    {
+        return atomic_conditional_increment( &use_count_ ) != 0;
+    }
+
+    void release() noexcept
+    {
+        if( atomic_decrement( &use_count_ ) == 1 )
+        {
+            dispose();
+            weak_release();
+        }
+    }
+
+    void weak_add_ref() noexcept
+    {
+        atomic_increment( &weak_count_ );
+    }
+
+    void weak_release() noexcept
+    {
+        if( atomic_decrement( &weak_count_ ) == 1 )
+        {
+            destroy();
+        }
+    }
+
+    long use_count() const noexcept
+    {
+        return use_count_.load( std::memory_order_acquire );
+    }
+};
+
+}
+
+}
+# 49 "/usr/include/boost/smart_ptr/detail/sp_counted_base.hpp" 2 3 4
+# 94 "/usr/include/boost/smart_ptr/detail/sp_counted_base.hpp" 3 4
+#undef BOOST_SP_HAS_CLANG_C11_ATOMICS
+# 30 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 2 3 4
+# 1 "/usr/include/boost/smart_ptr/detail/sp_counted_impl.hpp" 1 3 4
+
+#define BOOST_SMART_PTR_DETAIL_SP_COUNTED_IMPL_HPP_INCLUDED 
+# 42 "/usr/include/boost/smart_ptr/detail/sp_counted_impl.hpp" 3 4
+namespace boost
+{
+# 52 "/usr/include/boost/smart_ptr/detail/sp_counted_impl.hpp" 3 4
+namespace detail
+{
+
+
+
+template<class D> class local_sp_deleter;
+
+template<class D> D * get_local_deleter( D * ) noexcept
+{
+    return 0;
+}
+
+template<class D> D * get_local_deleter( local_sp_deleter<D> * p ) noexcept;
+
+
+
+template<class X> class __attribute__((__visibility__("default"))) sp_counted_impl_p: public sp_counted_base
+{
+private:
+
+    X * px_;
+
+    sp_counted_impl_p( sp_counted_impl_p const & );
+    sp_counted_impl_p & operator= ( sp_counted_impl_p const & );
+
+    typedef sp_counted_impl_p<X> this_type;
+
+public:
+
+    explicit sp_counted_impl_p( X * px ): px_( px )
+    {
+
+
+
+    }
+
+    virtual void dispose() noexcept
+    {
+
+
+
+        boost::checked_delete( px_ );
+    }
+
+    virtual void * get_deleter( sp_typeinfo_ const & ) noexcept
+    {
+        return 0;
+    }
+
+    virtual void * get_local_deleter( sp_typeinfo_ const & ) noexcept
+    {
+        return 0;
+    }
+
+    virtual void * get_untyped_deleter() noexcept
+    {
+        return 0;
+    }
+# 138 "/usr/include/boost/smart_ptr/detail/sp_counted_impl.hpp" 3 4
+};
+# 147 "/usr/include/boost/smart_ptr/detail/sp_counted_impl.hpp" 3 4
+template<class P, class D> class __attribute__((__visibility__("default"))) sp_counted_impl_pd: public sp_counted_base
+{
+private:
+
+    P ptr;
+    D del;
+
+    sp_counted_impl_pd( sp_counted_impl_pd const & );
+    sp_counted_impl_pd & operator= ( sp_counted_impl_pd const & );
+
+    typedef sp_counted_impl_pd<P, D> this_type;
+
+public:
+
+
+
+    sp_counted_impl_pd( P p, D & d ): ptr( p ), del( d )
+    {
+    }
+
+    sp_counted_impl_pd( P p ): ptr( p ), del()
+    {
+    }
+
+    virtual void dispose() noexcept
+    {
+        del( ptr );
+    }
+
+    virtual void * get_deleter( sp_typeinfo_ const & ti ) noexcept
+    {
+        return ti == typeid(D)? &reinterpret_cast<char&>( del ): 0;
+    }
+
+    virtual void * get_local_deleter( sp_typeinfo_ const & ti ) noexcept
+    {
+        return ti == typeid(D)? boost::detail::get_local_deleter( boost::addressof( del ) ): 0;
+    }
+
+    virtual void * get_untyped_deleter() noexcept
+    {
+        return &reinterpret_cast<char&>( del );
+    }
+# 218 "/usr/include/boost/smart_ptr/detail/sp_counted_impl.hpp" 3 4
+};
+
+template<class P, class D, class A> class __attribute__((__visibility__("default"))) sp_counted_impl_pda: public sp_counted_base
+{
+private:
+
+    P p_;
+    D d_;
+    A a_;
+
+    sp_counted_impl_pda( sp_counted_impl_pda const & );
+    sp_counted_impl_pda & operator= ( sp_counted_impl_pda const & );
+
+    typedef sp_counted_impl_pda<P, D, A> this_type;
+
+public:
+
+
+
+    sp_counted_impl_pda( P p, D & d, A a ): p_( p ), d_( d ), a_( a )
+    {
+    }
+
+    sp_counted_impl_pda( P p, A a ): p_( p ), d_( a ), a_( a )
+    {
+    }
+
+    virtual void dispose() noexcept
+    {
+        d_( p_ );
+    }
+
+    virtual void destroy() noexcept
+    {
+
+
+        typedef typename std::allocator_traits<A>::template rebind_alloc< this_type > A2;
+
+
+
+
+
+
+
+        A2 a2( a_ );
+
+        this->~this_type();
+
+        a2.deallocate( this, 1 );
+    }
+
+    virtual void * get_deleter( sp_typeinfo_ const & ti ) noexcept
+    {
+        return ti == typeid(D)? &reinterpret_cast<char&>( d_ ): 0;
+    }
+
+    virtual void * get_local_deleter( sp_typeinfo_ const & ti ) noexcept
+    {
+        return ti == typeid(D)? boost::detail::get_local_deleter( boost::addressof( d_ ) ): 0;
+    }
+
+    virtual void * get_untyped_deleter() noexcept
+    {
+        return &reinterpret_cast<char&>( d_ );
+    }
+};
+
+
+
+
+
+}
+
+}
+# 31 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 2 3 4
+# 1 "/usr/include/boost/smart_ptr/detail/sp_disable_deprecated.hpp" 1 3 4
+
+#define BOOST_SMART_PTR_DETAIL_SP_DISABLE_DEPRECATED_HPP_INCLUDED 
+# 27 "/usr/include/boost/smart_ptr/detail/sp_disable_deprecated.hpp" 3 4
+#define BOOST_SP_DISABLE_DEPRECATED 
+# 32 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 2 3 4
+
+
+
+
+
+
+
+# 1 "/usr/include/c++/10.2.0/functional" 1 3 4
+# 44 "/usr/include/c++/10.2.0/functional" 3 4
+#define _GLIBCXX_FUNCTIONAL 1
+
+       
+# 47 "/usr/include/c++/10.2.0/functional" 3
+# 59 "/usr/include/c++/10.2.0/functional" 3
+# 1 "/usr/include/c++/10.2.0/bits/std_function.h" 1 3
+# 31 "/usr/include/c++/10.2.0/bits/std_function.h" 3
+#define _GLIBCXX_STD_FUNCTION_H 1
+
+       
+# 34 "/usr/include/c++/10.2.0/bits/std_function.h" 3
+# 47 "/usr/include/c++/10.2.0/bits/std_function.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+
+
+  class bad_function_call : public std::exception
+  {
+  public:
+    virtual ~bad_function_call() noexcept;
+
+    const char* what() const noexcept;
+  };
+
+
+
+
+
+
+
+  template<typename _Tp>
+    struct __is_location_invariant
+    : is_trivially_copyable<_Tp>::type
+    { };
+
+  class _Undefined_class;
+
+  union _Nocopy_types
+  {
+    void* _M_object;
+    const void* _M_const_object;
+    void (*_M_function_pointer)();
+    void (_Undefined_class::*_M_member_pointer)();
+  };
+
+  union [[gnu::may_alias]] _Any_data
+  {
+    void* _M_access() { return &_M_pod_data[0]; }
+    const void* _M_access() const { return &_M_pod_data[0]; }
+
+    template<typename _Tp>
+      _Tp&
+      _M_access()
+      { return *static_cast<_Tp*>(_M_access()); }
+
+    template<typename _Tp>
+      const _Tp&
+      _M_access() const
+      { return *static_cast<const _Tp*>(_M_access()); }
+
+    _Nocopy_types _M_unused;
+    char _M_pod_data[sizeof(_Nocopy_types)];
+  };
+
+  enum _Manager_operation
+  {
+    __get_type_info,
+    __get_functor_ptr,
+    __clone_functor,
+    __destroy_functor
+  };
+
+  template<typename _Signature>
+    class function;
+
+
+  class _Function_base
+  {
+  public:
+    static const size_t _M_max_size = sizeof(_Nocopy_types);
+    static const size_t _M_max_align = __alignof__(_Nocopy_types);
+
+    template<typename _Functor>
+      class _Base_manager
+      {
+      protected:
+ static const bool __stored_locally =
+ (__is_location_invariant<_Functor>::value
+  && sizeof(_Functor) <= _M_max_size
+  && __alignof__(_Functor) <= _M_max_align
+  && (_M_max_align % __alignof__(_Functor) == 0));
+
+ typedef integral_constant<bool, __stored_locally> _Local_storage;
+
+
+ static _Functor*
+ _M_get_pointer(const _Any_data& __source)
+ {
+   if constexpr (__stored_locally)
+     {
+       const _Functor& __f = __source._M_access<_Functor>();
+       return const_cast<_Functor*>(std::__addressof(__f));
+     }
+   else
+     return __source._M_access<_Functor*>();
+ }
+
+
+
+ static void
+ _M_clone(_Any_data& __dest, const _Any_data& __source, true_type)
+ {
+   ::new (__dest._M_access()) _Functor(__source._M_access<_Functor>());
+ }
+
+
+
+ static void
+ _M_clone(_Any_data& __dest, const _Any_data& __source, false_type)
+ {
+   __dest._M_access<_Functor*>() =
+     new _Functor(*__source._M_access<const _Functor*>());
+ }
+
+
+
+ static void
+ _M_destroy(_Any_data& __victim, true_type)
+ {
+   __victim._M_access<_Functor>().~_Functor();
+ }
+
+
+ static void
+ _M_destroy(_Any_data& __victim, false_type)
+ {
+   delete __victim._M_access<_Functor*>();
+ }
+
+      public:
+ static bool
+ _M_manager(_Any_data& __dest, const _Any_data& __source,
+     _Manager_operation __op)
+ {
+   switch (__op)
+     {
+
+     case __get_type_info:
+       __dest._M_access<const type_info*>() = &typeid(_Functor);
+       break;
+
+     case __get_functor_ptr:
+       __dest._M_access<_Functor*>() = _M_get_pointer(__source);
+       break;
+
+     case __clone_functor:
+       _M_clone(__dest, __source, _Local_storage());
+       break;
+
+     case __destroy_functor:
+       _M_destroy(__dest, _Local_storage());
+       break;
+     }
+   return false;
+ }
+
+ static void
+ _M_init_functor(_Any_data& __functor, _Functor&& __f)
+ { _M_init_functor(__functor, std::move(__f), _Local_storage()); }
+
+ template<typename _Signature>
+   static bool
+   _M_not_empty_function(const function<_Signature>& __f)
+   { return static_cast<bool>(__f); }
+
+ template<typename _Tp>
+   static bool
+   _M_not_empty_function(_Tp* __fp)
+   { return __fp != nullptr; }
+
+ template<typename _Class, typename _Tp>
+   static bool
+   _M_not_empty_function(_Tp _Class::* __mp)
+   { return __mp != nullptr; }
+
+ template<typename _Tp>
+   static bool
+   _M_not_empty_function(const _Tp&)
+   { return true; }
+
+      private:
+ static void
+ _M_init_functor(_Any_data& __functor, _Functor&& __f, true_type)
+ { ::new (__functor._M_access()) _Functor(std::move(__f)); }
+
+ static void
+ _M_init_functor(_Any_data& __functor, _Functor&& __f, false_type)
+ { __functor._M_access<_Functor*>() = new _Functor(std::move(__f)); }
+      };
+
+    _Function_base() : _M_manager(nullptr) { }
+
+    ~_Function_base()
+    {
+      if (_M_manager)
+ _M_manager(_M_functor, _M_functor, __destroy_functor);
+    }
+
+    bool _M_empty() const { return !_M_manager; }
+
+    typedef bool (*_Manager_type)(_Any_data&, const _Any_data&,
+      _Manager_operation);
+
+    _Any_data _M_functor;
+    _Manager_type _M_manager;
+  };
+
+  template<typename _Signature, typename _Functor>
+    class _Function_handler;
+
+  template<typename _Res, typename _Functor, typename... _ArgTypes>
+    class _Function_handler<_Res(_ArgTypes...), _Functor>
+    : public _Function_base::_Base_manager<_Functor>
+    {
+      typedef _Function_base::_Base_manager<_Functor> _Base;
+
+    public:
+      static bool
+      _M_manager(_Any_data& __dest, const _Any_data& __source,
+   _Manager_operation __op)
+      {
+ switch (__op)
+   {
+
+   case __get_type_info:
+     __dest._M_access<const type_info*>() = &typeid(_Functor);
+     break;
+
+   case __get_functor_ptr:
+     __dest._M_access<_Functor*>() = _Base::_M_get_pointer(__source);
+     break;
+
+   default:
+     _Base::_M_manager(__dest, __source, __op);
+   }
+ return false;
+      }
+
+      static _Res
+      _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
+      {
+ return std::__invoke_r<_Res>(*_Base::_M_get_pointer(__functor),
+         std::forward<_ArgTypes>(__args)...);
+      }
+    };
+
+
+
+
+
+
+
+  template<typename _Res, typename... _ArgTypes>
+    class function<_Res(_ArgTypes...)>
+    : public _Maybe_unary_or_binary_function<_Res, _ArgTypes...>,
+      private _Function_base
+    {
+      template<typename _Func,
+        typename _Res2 = __invoke_result<_Func&, _ArgTypes...>>
+ struct _Callable
+ : __is_invocable_impl<_Res2, _Res>::type
+ { };
+
+
+
+      template<typename _Tp>
+ struct _Callable<function, _Tp> : false_type { };
+
+      template<typename _Cond, typename _Tp>
+ using _Requires = typename enable_if<_Cond::value, _Tp>::type;
+
+    public:
+      typedef _Res result_type;
+
+
+
+
+
+
+
+      function() noexcept
+      : _Function_base() { }
+
+
+
+
+
+      function(nullptr_t) noexcept
+      : _Function_base() { }
+# 348 "/usr/include/c++/10.2.0/bits/std_function.h" 3
+      function(const function& __x);
+# 357 "/usr/include/c++/10.2.0/bits/std_function.h" 3
+      function(function&& __x) noexcept : _Function_base()
+      {
+ __x.swap(*this);
+      }
+# 378 "/usr/include/c++/10.2.0/bits/std_function.h" 3
+      template<typename _Functor,
+        typename = _Requires<__not_<is_same<_Functor, function>>, void>,
+        typename = _Requires<_Callable<_Functor>, void>>
+ function(_Functor);
+# 395 "/usr/include/c++/10.2.0/bits/std_function.h" 3
+      function&
+      operator=(const function& __x)
+      {
+ function(__x).swap(*this);
+ return *this;
+      }
+# 413 "/usr/include/c++/10.2.0/bits/std_function.h" 3
+      function&
+      operator=(function&& __x) noexcept
+      {
+ function(std::move(__x)).swap(*this);
+ return *this;
+      }
+# 427 "/usr/include/c++/10.2.0/bits/std_function.h" 3
+      function&
+      operator=(nullptr_t) noexcept
+      {
+ if (_M_manager)
+   {
+     _M_manager(_M_functor, _M_functor, __destroy_functor);
+     _M_manager = nullptr;
+     _M_invoker = nullptr;
+   }
+ return *this;
+      }
+# 455 "/usr/include/c++/10.2.0/bits/std_function.h" 3
+      template<typename _Functor>
+ _Requires<_Callable<typename decay<_Functor>::type>, function&>
+ operator=(_Functor&& __f)
+ {
+   function(std::forward<_Functor>(__f)).swap(*this);
+   return *this;
+ }
+
+
+      template<typename _Functor>
+ function&
+ operator=(reference_wrapper<_Functor> __f) noexcept
+ {
+   function(__f).swap(*this);
+   return *this;
+ }
+# 481 "/usr/include/c++/10.2.0/bits/std_function.h" 3
+      void swap(function& __x) noexcept
+      {
+ std::swap(_M_functor, __x._M_functor);
+ std::swap(_M_manager, __x._M_manager);
+ std::swap(_M_invoker, __x._M_invoker);
+      }
+# 498 "/usr/include/c++/10.2.0/bits/std_function.h" 3
+      explicit operator bool() const noexcept
+      { return !_M_empty(); }
+# 511 "/usr/include/c++/10.2.0/bits/std_function.h" 3
+      _Res operator()(_ArgTypes... __args) const;
+# 524 "/usr/include/c++/10.2.0/bits/std_function.h" 3
+      const type_info& target_type() const noexcept;
+# 537 "/usr/include/c++/10.2.0/bits/std_function.h" 3
+      template<typename _Functor> _Functor* target() noexcept;
+
+      template<typename _Functor> const _Functor* target() const noexcept;
+
+
+
+    private:
+      using _Invoker_type = _Res (*)(const _Any_data&, _ArgTypes&&...);
+      _Invoker_type _M_invoker;
+  };
+
+
+  template<typename>
+    struct __function_guide_helper
+    { };
+
+  template<typename _Res, typename _Tp, bool _Nx, typename... _Args>
+    struct __function_guide_helper<
+      _Res (_Tp::*) (_Args...) noexcept(_Nx)
+    >
+    { using type = _Res(_Args...); };
+
+  template<typename _Res, typename _Tp, bool _Nx, typename... _Args>
+    struct __function_guide_helper<
+      _Res (_Tp::*) (_Args...) & noexcept(_Nx)
+    >
+    { using type = _Res(_Args...); };
+
+  template<typename _Res, typename _Tp, bool _Nx, typename... _Args>
+    struct __function_guide_helper<
+      _Res (_Tp::*) (_Args...) const noexcept(_Nx)
+    >
+    { using type = _Res(_Args...); };
+
+  template<typename _Res, typename _Tp, bool _Nx, typename... _Args>
+    struct __function_guide_helper<
+      _Res (_Tp::*) (_Args...) const & noexcept(_Nx)
+    >
+    { using type = _Res(_Args...); };
+
+  template<typename _Res, typename... _ArgTypes>
+    function(_Res(*)(_ArgTypes...)) -> function<_Res(_ArgTypes...)>;
+
+  template<typename _Functor, typename _Signature = typename
+    __function_guide_helper<decltype(&_Functor::operator())>::type>
+    function(_Functor) -> function<_Signature>;
+
+
+
+  template<typename _Res, typename... _ArgTypes>
+    function<_Res(_ArgTypes...)>::
+    function(const function& __x)
+    : _Function_base()
+    {
+      if (static_cast<bool>(__x))
+ {
+   __x._M_manager(_M_functor, __x._M_functor, __clone_functor);
+   _M_invoker = __x._M_invoker;
+   _M_manager = __x._M_manager;
+ }
+    }
+
+  template<typename _Res, typename... _ArgTypes>
+    template<typename _Functor, typename, typename>
+      function<_Res(_ArgTypes...)>::
+      function(_Functor __f)
+      : _Function_base()
+      {
+ typedef _Function_handler<_Res(_ArgTypes...), _Functor> _My_handler;
+
+ if (_My_handler::_M_not_empty_function(__f))
+   {
+     _My_handler::_M_init_functor(_M_functor, std::move(__f));
+     _M_invoker = &_My_handler::_M_invoke;
+     _M_manager = &_My_handler::_M_manager;
+   }
+      }
+
+  template<typename _Res, typename... _ArgTypes>
+    _Res
+    function<_Res(_ArgTypes...)>::
+    operator()(_ArgTypes... __args) const
+    {
+      if (_M_empty())
+ __throw_bad_function_call();
+      return _M_invoker(_M_functor, std::forward<_ArgTypes>(__args)...);
+    }
+
+
+  template<typename _Res, typename... _ArgTypes>
+    const type_info&
+    function<_Res(_ArgTypes...)>::
+    target_type() const noexcept
+    {
+      if (_M_manager)
+ {
+   _Any_data __typeinfo_result;
+   _M_manager(__typeinfo_result, _M_functor, __get_type_info);
+   return *__typeinfo_result._M_access<const type_info*>();
+ }
+      else
+ return typeid(void);
+    }
+
+  template<typename _Res, typename... _ArgTypes>
+    template<typename _Functor>
+      _Functor*
+      function<_Res(_ArgTypes...)>::
+      target() noexcept
+      {
+ const function* __const_this = this;
+ const _Functor* __func = __const_this->template target<_Functor>();
+ return const_cast<_Functor*>(__func);
+      }
+
+  template<typename _Res, typename... _ArgTypes>
+    template<typename _Functor>
+      const _Functor*
+      function<_Res(_ArgTypes...)>::
+      target() const noexcept
+      {
+ if (typeid(_Functor) == target_type() && _M_manager)
+   {
+     _Any_data __ptr;
+     _M_manager(__ptr, _M_functor, __get_functor_ptr);
+     return __ptr._M_access<const _Functor*>();
+   }
+ else
+   return nullptr;
+      }
+# 678 "/usr/include/c++/10.2.0/bits/std_function.h" 3
+  template<typename _Res, typename... _Args>
+    inline bool
+    operator==(const function<_Res(_Args...)>& __f, nullptr_t) noexcept
+    { return !static_cast<bool>(__f); }
+
+
+
+  template<typename _Res, typename... _Args>
+    inline bool
+    operator==(nullptr_t, const function<_Res(_Args...)>& __f) noexcept
+    { return !static_cast<bool>(__f); }
+# 697 "/usr/include/c++/10.2.0/bits/std_function.h" 3
+  template<typename _Res, typename... _Args>
+    inline bool
+    operator!=(const function<_Res(_Args...)>& __f, nullptr_t) noexcept
+    { return static_cast<bool>(__f); }
+
+
+  template<typename _Res, typename... _Args>
+    inline bool
+    operator!=(nullptr_t, const function<_Res(_Args...)>& __f) noexcept
+    { return static_cast<bool>(__f); }
+# 718 "/usr/include/c++/10.2.0/bits/std_function.h" 3
+  template<typename _Res, typename... _Args>
+    inline void
+    swap(function<_Res(_Args...)>& __x, function<_Res(_Args...)>& __y) noexcept
+    { __x.swap(__y); }
+
+
+  namespace __detail::__variant
+  {
+    template<typename> struct _Never_valueless_alt;
+
+
+
+    template<typename _Signature>
+      struct _Never_valueless_alt<std::function<_Signature>>
+      : std::true_type
+      { };
+  }
+
+
+
+}
+# 60 "/usr/include/c++/10.2.0/functional" 2 3
+
+# 1 "/usr/include/c++/10.2.0/unordered_map" 1 3
+# 30 "/usr/include/c++/10.2.0/unordered_map" 3
+#define _GLIBCXX_UNORDERED_MAP 1
+
+       
+# 33 "/usr/include/c++/10.2.0/unordered_map" 3
+# 46 "/usr/include/c++/10.2.0/unordered_map" 3
+# 1 "/usr/include/c++/10.2.0/bits/hashtable.h" 1 3
+# 31 "/usr/include/c++/10.2.0/bits/hashtable.h" 3
+#define _HASHTABLE_H 1
+
+       
+# 34 "/usr/include/c++/10.2.0/bits/hashtable.h" 3
+
+# 1 "/usr/include/c++/10.2.0/bits/hashtable_policy.h" 1 3
+# 32 "/usr/include/c++/10.2.0/bits/hashtable_policy.h" 3
+#define _HASHTABLE_POLICY_H 1
+
+
+# 1 "/usr/include/c++/10.2.0/limits" 1 3
+# 38 "/usr/include/c++/10.2.0/limits" 3
+#define _GLIBCXX_NUMERIC_LIMITS 1
+
+       
+# 41 "/usr/include/c++/10.2.0/limits" 3
+# 80 "/usr/include/c++/10.2.0/limits" 3
+#define __glibcxx_integral_traps true
+# 89 "/usr/include/c++/10.2.0/limits" 3
+#define __glibcxx_float_has_denorm_loss false
+
+
+#define __glibcxx_float_traps false
+
+
+#define __glibcxx_float_tinyness_before false
+
+
+
+
+
+
+
+#define __glibcxx_double_has_denorm_loss false
+
+
+#define __glibcxx_double_traps false
+
+
+#define __glibcxx_double_tinyness_before false
+
+
+
+
+
+
+
+#define __glibcxx_long_double_has_denorm_loss false
+
+
+#define __glibcxx_long_double_traps false
+
+
+#define __glibcxx_long_double_tinyness_before false
+
+
+
+
+#define __glibcxx_signed_b(T,B) ((T)(-1) < 0)
+
+#define __glibcxx_min_b(T,B) (__glibcxx_signed_b (T,B) ? -__glibcxx_max_b (T,B) - 1 : (T)0)
+
+
+#define __glibcxx_max_b(T,B) (__glibcxx_signed_b (T,B) ? (((((T)1 << (__glibcxx_digits_b (T,B) - 1)) - 1) << 1) + 1) : ~(T)0)
+
+
+
+#define __glibcxx_digits_b(T,B) (B - __glibcxx_signed_b (T,B))
+
+
+
+#define __glibcxx_digits10_b(T,B) (__glibcxx_digits_b (T,B) * 643L / 2136)
+
+
+#define __glibcxx_signed(T) __glibcxx_signed_b (T, sizeof(T) * __CHAR_BIT__)
+
+#define __glibcxx_min(T) __glibcxx_min_b (T, sizeof(T) * __CHAR_BIT__)
+
+#define __glibcxx_max(T) __glibcxx_max_b (T, sizeof(T) * __CHAR_BIT__)
+
+#define __glibcxx_digits(T) __glibcxx_digits_b (T, sizeof(T) * __CHAR_BIT__)
+
+#define __glibcxx_digits10(T) __glibcxx_digits10_b (T, sizeof(T) * __CHAR_BIT__)
+
+
+#define __glibcxx_max_digits10(T) (2 + (T) * 643L / 2136)
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+
+
+  enum float_round_style
+  {
+    round_indeterminate = -1,
+    round_toward_zero = 0,
+    round_to_nearest = 1,
+    round_toward_infinity = 2,
+    round_toward_neg_infinity = 3
+  };
+
+
+
+
+
+
+
+  enum float_denorm_style
+  {
+
+    denorm_indeterminate = -1,
+
+    denorm_absent = 0,
+
+    denorm_present = 1
+  };
+# 202 "/usr/include/c++/10.2.0/limits" 3
+  struct __numeric_limits_base
+  {
+
+
+    static constexpr bool is_specialized = false;
+
+
+
+
+    static constexpr int digits = 0;
+
+
+    static constexpr int digits10 = 0;
+
+
+
+
+    static constexpr int max_digits10 = 0;
+
+
+
+    static constexpr bool is_signed = false;
+
+
+    static constexpr bool is_integer = false;
+
+
+
+
+    static constexpr bool is_exact = false;
+
+
+
+    static constexpr int radix = 0;
+
+
+
+    static constexpr int min_exponent = 0;
+
+
+
+    static constexpr int min_exponent10 = 0;
+
+
+
+
+    static constexpr int max_exponent = 0;
+
+
+
+    static constexpr int max_exponent10 = 0;
+
+
+    static constexpr bool has_infinity = false;
+
+
+
+    static constexpr bool has_quiet_NaN = false;
+
+
+
+    static constexpr bool has_signaling_NaN = false;
+
+
+    static constexpr float_denorm_style has_denorm = denorm_absent;
+
+
+
+    static constexpr bool has_denorm_loss = false;
+
+
+
+    static constexpr bool is_iec559 = false;
+
+
+
+
+    static constexpr bool is_bounded = false;
+# 288 "/usr/include/c++/10.2.0/limits" 3
+    static constexpr bool is_modulo = false;
+
+
+    static constexpr bool traps = false;
+
+
+    static constexpr bool tinyness_before = false;
+
+
+
+
+    static constexpr float_round_style round_style =
+          round_toward_zero;
+  };
+# 311 "/usr/include/c++/10.2.0/limits" 3
+  template<typename _Tp>
+    struct numeric_limits : public __numeric_limits_base
+    {
+
+
+      static constexpr _Tp
+      min() noexcept { return _Tp(); }
+
+
+      static constexpr _Tp
+      max() noexcept { return _Tp(); }
+
+
+
+
+      static constexpr _Tp
+      lowest() noexcept { return _Tp(); }
+
+
+
+
+      static constexpr _Tp
+      epsilon() noexcept { return _Tp(); }
+
+
+      static constexpr _Tp
+      round_error() noexcept { return _Tp(); }
+
+
+      static constexpr _Tp
+      infinity() noexcept { return _Tp(); }
+
+
+
+      static constexpr _Tp
+      quiet_NaN() noexcept { return _Tp(); }
+
+
+
+      static constexpr _Tp
+      signaling_NaN() noexcept { return _Tp(); }
+
+
+
+
+      static constexpr _Tp
+      denorm_min() noexcept { return _Tp(); }
+    };
+
+
+
+
+  template<typename _Tp>
+    struct numeric_limits<const _Tp>
+    : public numeric_limits<_Tp> { };
+
+  template<typename _Tp>
+    struct numeric_limits<volatile _Tp>
+    : public numeric_limits<_Tp> { };
+
+  template<typename _Tp>
+    struct numeric_limits<const volatile _Tp>
+    : public numeric_limits<_Tp> { };
+# 383 "/usr/include/c++/10.2.0/limits" 3
+  template<>
+    struct numeric_limits<bool>
+    {
+      static constexpr bool is_specialized = true;
+
+      static constexpr bool
+      min() noexcept { return false; }
+
+      static constexpr bool
+      max() noexcept { return true; }
+
+
+      static constexpr bool
+      lowest() noexcept { return min(); }
+
+      static constexpr int digits = 1;
+      static constexpr int digits10 = 0;
+
+      static constexpr int max_digits10 = 0;
+
+      static constexpr bool is_signed = false;
+      static constexpr bool is_integer = true;
+      static constexpr bool is_exact = true;
+      static constexpr int radix = 2;
+
+      static constexpr bool
+      epsilon() noexcept { return false; }
+
+      static constexpr bool
+      round_error() noexcept { return false; }
+
+      static constexpr int min_exponent = 0;
+      static constexpr int min_exponent10 = 0;
+      static constexpr int max_exponent = 0;
+      static constexpr int max_exponent10 = 0;
+
+      static constexpr bool has_infinity = false;
+      static constexpr bool has_quiet_NaN = false;
+      static constexpr bool has_signaling_NaN = false;
+      static constexpr float_denorm_style has_denorm
+       = denorm_absent;
+      static constexpr bool has_denorm_loss = false;
+
+      static constexpr bool
+      infinity() noexcept { return false; }
+
+      static constexpr bool
+      quiet_NaN() noexcept { return false; }
+
+      static constexpr bool
+      signaling_NaN() noexcept { return false; }
+
+      static constexpr bool
+      denorm_min() noexcept { return false; }
+
+      static constexpr bool is_iec559 = false;
+      static constexpr bool is_bounded = true;
+      static constexpr bool is_modulo = false;
+
+
+
+
+      static constexpr bool traps = true;
+      static constexpr bool tinyness_before = false;
+      static constexpr float_round_style round_style
+       = round_toward_zero;
+    };
+
+
+  template<>
+    struct numeric_limits<char>
+    {
+      static constexpr bool is_specialized = true;
+
+      static constexpr char
+      min() noexcept { return (((char)(-1) < 0) ? -(((char)(-1) < 0) ? (((((char)1 << ((sizeof(char) * 8 - ((char)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char)0) - 1 : (char)0); }
+
+      static constexpr char
+      max() noexcept { return (((char)(-1) < 0) ? (((((char)1 << ((sizeof(char) * 8 - ((char)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char)0); }
+
+
+      static constexpr char
+      lowest() noexcept { return min(); }
+
+
+      static constexpr int digits = (sizeof(char) * 8 - ((char)(-1) < 0));
+      static constexpr int digits10 = ((sizeof(char) * 8 - ((char)(-1) < 0)) * 643L / 2136);
+
+      static constexpr int max_digits10 = 0;
+
+      static constexpr bool is_signed = ((char)(-1) < 0);
+      static constexpr bool is_integer = true;
+      static constexpr bool is_exact = true;
+      static constexpr int radix = 2;
+
+      static constexpr char
+      epsilon() noexcept { return 0; }
+
+      static constexpr char
+      round_error() noexcept { return 0; }
+
+      static constexpr int min_exponent = 0;
+      static constexpr int min_exponent10 = 0;
+      static constexpr int max_exponent = 0;
+      static constexpr int max_exponent10 = 0;
+
+      static constexpr bool has_infinity = false;
+      static constexpr bool has_quiet_NaN = false;
+      static constexpr bool has_signaling_NaN = false;
+      static constexpr float_denorm_style has_denorm
+       = denorm_absent;
+      static constexpr bool has_denorm_loss = false;
+
+      static constexpr
+      char infinity() noexcept { return char(); }
+
+      static constexpr char
+      quiet_NaN() noexcept { return char(); }
+
+      static constexpr char
+      signaling_NaN() noexcept { return char(); }
+
+      static constexpr char
+      denorm_min() noexcept { return static_cast<char>(0); }
+
+      static constexpr bool is_iec559 = false;
+      static constexpr bool is_bounded = true;
+      static constexpr bool is_modulo = !is_signed;
+
+      static constexpr bool traps = true;
+      static constexpr bool tinyness_before = false;
+      static constexpr float_round_style round_style
+       = round_toward_zero;
+    };
+
+
+  template<>
+    struct numeric_limits<signed char>
+    {
+      static constexpr bool is_specialized = true;
+
+      static constexpr signed char
+      min() noexcept { return -0x7f - 1; }
+
+      static constexpr signed char
+      max() noexcept { return 0x7f; }
+
+
+      static constexpr signed char
+      lowest() noexcept { return min(); }
+
+
+      static constexpr int digits = (sizeof(signed char) * 8 - ((signed char)(-1) < 0));
+      static constexpr int digits10
+       = ((sizeof(signed char) * 8 - ((signed char)(-1) < 0)) * 643L / 2136);
+
+      static constexpr int max_digits10 = 0;
+
+      static constexpr bool is_signed = true;
+      static constexpr bool is_integer = true;
+      static constexpr bool is_exact = true;
+      static constexpr int radix = 2;
+
+      static constexpr signed char
+      epsilon() noexcept { return 0; }
+
+      static constexpr signed char
+      round_error() noexcept { return 0; }
+
+      static constexpr int min_exponent = 0;
+      static constexpr int min_exponent10 = 0;
+      static constexpr int max_exponent = 0;
+      static constexpr int max_exponent10 = 0;
+
+      static constexpr bool has_infinity = false;
+      static constexpr bool has_quiet_NaN = false;
+      static constexpr bool has_signaling_NaN = false;
+      static constexpr float_denorm_style has_denorm
+       = denorm_absent;
+      static constexpr bool has_denorm_loss = false;
+
+      static constexpr signed char
+      infinity() noexcept { return static_cast<signed char>(0); }
+
+      static constexpr signed char
+      quiet_NaN() noexcept { return static_cast<signed char>(0); }
+
+      static constexpr signed char
+      signaling_NaN() noexcept
+      { return static_cast<signed char>(0); }
+
+      static constexpr signed char
+      denorm_min() noexcept
+      { return static_cast<signed char>(0); }
+
+      static constexpr bool is_iec559 = false;
+      static constexpr bool is_bounded = true;
+      static constexpr bool is_modulo = false;
+
+      static constexpr bool traps = true;
+      static constexpr bool tinyness_before = false;
+      static constexpr float_round_style round_style
+       = round_toward_zero;
+    };
+
+
+  template<>
+    struct numeric_limits<unsigned char>
+    {
+      static constexpr bool is_specialized = true;
+
+      static constexpr unsigned char
+      min() noexcept { return 0; }
+
+      static constexpr unsigned char
+      max() noexcept { return 0x7f * 2U + 1; }
+
+
+      static constexpr unsigned char
+      lowest() noexcept { return min(); }
+
+
+      static constexpr int digits
+       = (sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0));
+      static constexpr int digits10
+       = ((sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0)) * 643L / 2136);
+
+      static constexpr int max_digits10 = 0;
+
+      static constexpr bool is_signed = false;
+      static constexpr bool is_integer = true;
+      static constexpr bool is_exact = true;
+      static constexpr int radix = 2;
+
+      static constexpr unsigned char
+      epsilon() noexcept { return 0; }
+
+      static constexpr unsigned char
+      round_error() noexcept { return 0; }
+
+      static constexpr int min_exponent = 0;
+      static constexpr int min_exponent10 = 0;
+      static constexpr int max_exponent = 0;
+      static constexpr int max_exponent10 = 0;
+
+      static constexpr bool has_infinity = false;
+      static constexpr bool has_quiet_NaN = false;
+      static constexpr bool has_signaling_NaN = false;
+      static constexpr float_denorm_style has_denorm
+       = denorm_absent;
+      static constexpr bool has_denorm_loss = false;
+
+      static constexpr unsigned char
+      infinity() noexcept
+      { return static_cast<unsigned char>(0); }
+
+      static constexpr unsigned char
+      quiet_NaN() noexcept
+      { return static_cast<unsigned char>(0); }
+
+      static constexpr unsigned char
+      signaling_NaN() noexcept
+      { return static_cast<unsigned char>(0); }
+
+      static constexpr unsigned char
+      denorm_min() noexcept
+      { return static_cast<unsigned char>(0); }
+
+      static constexpr bool is_iec559 = false;
+      static constexpr bool is_bounded = true;
+      static constexpr bool is_modulo = true;
+
+      static constexpr bool traps = true;
+      static constexpr bool tinyness_before = false;
+      static constexpr float_round_style round_style
+       = round_toward_zero;
+    };
+
+
+  template<>
+    struct numeric_limits<wchar_t>
+    {
+      static constexpr bool is_specialized = true;
+
+      static constexpr wchar_t
+      min() noexcept { return (((wchar_t)(-1) < 0) ? -(((wchar_t)(-1) < 0) ? (((((wchar_t)1 << ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(wchar_t)0) - 1 : (wchar_t)0); }
+
+      static constexpr wchar_t
+      max() noexcept { return (((wchar_t)(-1) < 0) ? (((((wchar_t)1 << ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(wchar_t)0); }
+
+
+      static constexpr wchar_t
+      lowest() noexcept { return min(); }
+
+
+      static constexpr int digits = (sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0));
+      static constexpr int digits10
+       = ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) * 643L / 2136);
+
+      static constexpr int max_digits10 = 0;
+
+      static constexpr bool is_signed = ((wchar_t)(-1) < 0);
+      static constexpr bool is_integer = true;
+      static constexpr bool is_exact = true;
+      static constexpr int radix = 2;
+
+      static constexpr wchar_t
+      epsilon() noexcept { return 0; }
+
+      static constexpr wchar_t
+      round_error() noexcept { return 0; }
+
+      static constexpr int min_exponent = 0;
+      static constexpr int min_exponent10 = 0;
+      static constexpr int max_exponent = 0;
+      static constexpr int max_exponent10 = 0;
+
+      static constexpr bool has_infinity = false;
+      static constexpr bool has_quiet_NaN = false;
+      static constexpr bool has_signaling_NaN = false;
+      static constexpr float_denorm_style has_denorm
+       = denorm_absent;
+      static constexpr bool has_denorm_loss = false;
+
+      static constexpr wchar_t
+      infinity() noexcept { return wchar_t(); }
+
+      static constexpr wchar_t
+      quiet_NaN() noexcept { return wchar_t(); }
+
+      static constexpr wchar_t
+      signaling_NaN() noexcept { return wchar_t(); }
+
+      static constexpr wchar_t
+      denorm_min() noexcept { return wchar_t(); }
+
+      static constexpr bool is_iec559 = false;
+      static constexpr bool is_bounded = true;
+      static constexpr bool is_modulo = !is_signed;
+
+      static constexpr bool traps = true;
+      static constexpr bool tinyness_before = false;
+      static constexpr float_round_style round_style
+       = round_toward_zero;
+    };
+# 796 "/usr/include/c++/10.2.0/limits" 3
+  template<>
+    struct numeric_limits<char16_t>
+    {
+      static constexpr bool is_specialized = true;
+
+      static constexpr char16_t
+      min() noexcept { return (((char16_t)(-1) < 0) ? -(((char16_t)(-1) < 0) ? (((((char16_t)1 << ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char16_t)0) - 1 : (char16_t)0); }
+
+      static constexpr char16_t
+      max() noexcept { return (((char16_t)(-1) < 0) ? (((((char16_t)1 << ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char16_t)0); }
+
+      static constexpr char16_t
+      lowest() noexcept { return min(); }
+
+      static constexpr int digits = (sizeof(char16_t) * 8 - ((char16_t)(-1) < 0));
+      static constexpr int digits10 = ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) * 643L / 2136);
+      static constexpr int max_digits10 = 0;
+      static constexpr bool is_signed = ((char16_t)(-1) < 0);
+      static constexpr bool is_integer = true;
+      static constexpr bool is_exact = true;
+      static constexpr int radix = 2;
+
+      static constexpr char16_t
+      epsilon() noexcept { return 0; }
+
+      static constexpr char16_t
+      round_error() noexcept { return 0; }
+
+      static constexpr int min_exponent = 0;
+      static constexpr int min_exponent10 = 0;
+      static constexpr int max_exponent = 0;
+      static constexpr int max_exponent10 = 0;
+
+      static constexpr bool has_infinity = false;
+      static constexpr bool has_quiet_NaN = false;
+      static constexpr bool has_signaling_NaN = false;
+      static constexpr float_denorm_style has_denorm = denorm_absent;
+      static constexpr bool has_denorm_loss = false;
+
+      static constexpr char16_t
+      infinity() noexcept { return char16_t(); }
+
+      static constexpr char16_t
+      quiet_NaN() noexcept { return char16_t(); }
+
+      static constexpr char16_t
+      signaling_NaN() noexcept { return char16_t(); }
+
+      static constexpr char16_t
+      denorm_min() noexcept { return char16_t(); }
+
+      static constexpr bool is_iec559 = false;
+      static constexpr bool is_bounded = true;
+      static constexpr bool is_modulo = !is_signed;
+
+      static constexpr bool traps = true;
+      static constexpr bool tinyness_before = false;
+      static constexpr float_round_style round_style = round_toward_zero;
+    };
+
+
+  template<>
+    struct numeric_limits<char32_t>
+    {
+      static constexpr bool is_specialized = true;
+
+      static constexpr char32_t
+      min() noexcept { return (((char32_t)(-1) < 0) ? -(((char32_t)(-1) < 0) ? (((((char32_t)1 << ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char32_t)0) - 1 : (char32_t)0); }
+
+      static constexpr char32_t
+      max() noexcept { return (((char32_t)(-1) < 0) ? (((((char32_t)1 << ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char32_t)0); }
+
+      static constexpr char32_t
+      lowest() noexcept { return min(); }
+
+      static constexpr int digits = (sizeof(char32_t) * 8 - ((char32_t)(-1) < 0));
+      static constexpr int digits10 = ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) * 643L / 2136);
+      static constexpr int max_digits10 = 0;
+      static constexpr bool is_signed = ((char32_t)(-1) < 0);
+      static constexpr bool is_integer = true;
+      static constexpr bool is_exact = true;
+      static constexpr int radix = 2;
+
+      static constexpr char32_t
+      epsilon() noexcept { return 0; }
+
+      static constexpr char32_t
+      round_error() noexcept { return 0; }
+
+      static constexpr int min_exponent = 0;
+      static constexpr int min_exponent10 = 0;
+      static constexpr int max_exponent = 0;
+      static constexpr int max_exponent10 = 0;
+
+      static constexpr bool has_infinity = false;
+      static constexpr bool has_quiet_NaN = false;
+      static constexpr bool has_signaling_NaN = false;
+      static constexpr float_denorm_style has_denorm = denorm_absent;
+      static constexpr bool has_denorm_loss = false;
+
+      static constexpr char32_t
+      infinity() noexcept { return char32_t(); }
+
+      static constexpr char32_t
+      quiet_NaN() noexcept { return char32_t(); }
+
+      static constexpr char32_t
+      signaling_NaN() noexcept { return char32_t(); }
+
+      static constexpr char32_t
+      denorm_min() noexcept { return char32_t(); }
+
+      static constexpr bool is_iec559 = false;
+      static constexpr bool is_bounded = true;
+      static constexpr bool is_modulo = !is_signed;
+
+      static constexpr bool traps = true;
+      static constexpr bool tinyness_before = false;
+      static constexpr float_round_style round_style = round_toward_zero;
+    };
+
+
+
+  template<>
+    struct numeric_limits<short>
+    {
+      static constexpr bool is_specialized = true;
+
+      static constexpr short
+      min() noexcept { return -0x7fff - 1; }
+
+      static constexpr short
+      max() noexcept { return 0x7fff; }
+
+
+      static constexpr short
+      lowest() noexcept { return min(); }
+
+
+      static constexpr int digits = (sizeof(short) * 8 - ((short)(-1) < 0));
+      static constexpr int digits10 = ((sizeof(short) * 8 - ((short)(-1) < 0)) * 643L / 2136);
+
+      static constexpr int max_digits10 = 0;
+
+      static constexpr bool is_signed = true;
+      static constexpr bool is_integer = true;
+      static constexpr bool is_exact = true;
+      static constexpr int radix = 2;
+
+      static constexpr short
+      epsilon() noexcept { return 0; }
+
+      static constexpr short
+      round_error() noexcept { return 0; }
+
+      static constexpr int min_exponent = 0;
+      static constexpr int min_exponent10 = 0;
+      static constexpr int max_exponent = 0;
+      static constexpr int max_exponent10 = 0;
+
+      static constexpr bool has_infinity = false;
+      static constexpr bool has_quiet_NaN = false;
+      static constexpr bool has_signaling_NaN = false;
+      static constexpr float_denorm_style has_denorm
+       = denorm_absent;
+      static constexpr bool has_denorm_loss = false;
+
+      static constexpr short
+      infinity() noexcept { return short(); }
+
+      static constexpr short
+      quiet_NaN() noexcept { return short(); }
+
+      static constexpr short
+      signaling_NaN() noexcept { return short(); }
+
+      static constexpr short
+      denorm_min() noexcept { return short(); }
+
+      static constexpr bool is_iec559 = false;
+      static constexpr bool is_bounded = true;
+      static constexpr bool is_modulo = false;
+
+      static constexpr bool traps = true;
+      static constexpr bool tinyness_before = false;
+      static constexpr float_round_style round_style
+       = round_toward_zero;
+    };
+
+
+  template<>
+    struct numeric_limits<unsigned short>
+    {
+      static constexpr bool is_specialized = true;
+
+      static constexpr unsigned short
+      min() noexcept { return 0; }
+
+      static constexpr unsigned short
+      max() noexcept { return 0x7fff * 2U + 1; }
+
+
+      static constexpr unsigned short
+      lowest() noexcept { return min(); }
+
+
+      static constexpr int digits
+       = (sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0));
+      static constexpr int digits10
+       = ((sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0)) * 643L / 2136);
+
+      static constexpr int max_digits10 = 0;
+
+      static constexpr bool is_signed = false;
+      static constexpr bool is_integer = true;
+      static constexpr bool is_exact = true;
+      static constexpr int radix = 2;
+
+      static constexpr unsigned short
+      epsilon() noexcept { return 0; }
+
+      static constexpr unsigned short
+      round_error() noexcept { return 0; }
+
+      static constexpr int min_exponent = 0;
+      static constexpr int min_exponent10 = 0;
+      static constexpr int max_exponent = 0;
+      static constexpr int max_exponent10 = 0;
+
+      static constexpr bool has_infinity = false;
+      static constexpr bool has_quiet_NaN = false;
+      static constexpr bool has_signaling_NaN = false;
+      static constexpr float_denorm_style has_denorm
+       = denorm_absent;
+      static constexpr bool has_denorm_loss = false;
+
+      static constexpr unsigned short
+      infinity() noexcept
+      { return static_cast<unsigned short>(0); }
+
+      static constexpr unsigned short
+      quiet_NaN() noexcept
+      { return static_cast<unsigned short>(0); }
+
+      static constexpr unsigned short
+      signaling_NaN() noexcept
+      { return static_cast<unsigned short>(0); }
+
+      static constexpr unsigned short
+      denorm_min() noexcept
+      { return static_cast<unsigned short>(0); }
+
+      static constexpr bool is_iec559 = false;
+      static constexpr bool is_bounded = true;
+      static constexpr bool is_modulo = true;
+
+      static constexpr bool traps = true;
+      static constexpr bool tinyness_before = false;
+      static constexpr float_round_style round_style
+       = round_toward_zero;
+    };
+
+
+  template<>
+    struct numeric_limits<int>
+    {
+      static constexpr bool is_specialized = true;
+
+      static constexpr int
+      min() noexcept { return -0x7fffffff - 1; }
+
+      static constexpr int
+      max() noexcept { return 0x7fffffff; }
+
+
+      static constexpr int
+      lowest() noexcept { return min(); }
+
+
+      static constexpr int digits = (sizeof(int) * 8 - ((int)(-1) < 0));
+      static constexpr int digits10 = ((sizeof(int) * 8 - ((int)(-1) < 0)) * 643L / 2136);
+
+      static constexpr int max_digits10 = 0;
+
+      static constexpr bool is_signed = true;
+      static constexpr bool is_integer = true;
+      static constexpr bool is_exact = true;
+      static constexpr int radix = 2;
+
+      static constexpr int
+      epsilon() noexcept { return 0; }
+
+      static constexpr int
+      round_error() noexcept { return 0; }
+
+      static constexpr int min_exponent = 0;
+      static constexpr int min_exponent10 = 0;
+      static constexpr int max_exponent = 0;
+      static constexpr int max_exponent10 = 0;
+
+      static constexpr bool has_infinity = false;
+      static constexpr bool has_quiet_NaN = false;
+      static constexpr bool has_signaling_NaN = false;
+      static constexpr float_denorm_style has_denorm
+       = denorm_absent;
+      static constexpr bool has_denorm_loss = false;
+
+      static constexpr int
+      infinity() noexcept { return static_cast<int>(0); }
+
+      static constexpr int
+      quiet_NaN() noexcept { return static_cast<int>(0); }
+
+      static constexpr int
+      signaling_NaN() noexcept { return static_cast<int>(0); }
+
+      static constexpr int
+      denorm_min() noexcept { return static_cast<int>(0); }
+
+      static constexpr bool is_iec559 = false;
+      static constexpr bool is_bounded = true;
+      static constexpr bool is_modulo = false;
+
+      static constexpr bool traps = true;
+      static constexpr bool tinyness_before = false;
+      static constexpr float_round_style round_style
+       = round_toward_zero;
+    };
+
+
+  template<>
+    struct numeric_limits<unsigned int>
+    {
+      static constexpr bool is_specialized = true;
+
+      static constexpr unsigned int
+      min() noexcept { return 0; }
+
+      static constexpr unsigned int
+      max() noexcept { return 0x7fffffff * 2U + 1; }
+
+
+      static constexpr unsigned int
+      lowest() noexcept { return min(); }
+
+
+      static constexpr int digits
+       = (sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0));
+      static constexpr int digits10
+       = ((sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0)) * 643L / 2136);
+
+      static constexpr int max_digits10 = 0;
+
+      static constexpr bool is_signed = false;
+      static constexpr bool is_integer = true;
+      static constexpr bool is_exact = true;
+      static constexpr int radix = 2;
+
+      static constexpr unsigned int
+      epsilon() noexcept { return 0; }
+
+      static constexpr unsigned int
+      round_error() noexcept { return 0; }
+
+      static constexpr int min_exponent = 0;
+      static constexpr int min_exponent10 = 0;
+      static constexpr int max_exponent = 0;
+      static constexpr int max_exponent10 = 0;
+
+      static constexpr bool has_infinity = false;
+      static constexpr bool has_quiet_NaN = false;
+      static constexpr bool has_signaling_NaN = false;
+      static constexpr float_denorm_style has_denorm
+       = denorm_absent;
+      static constexpr bool has_denorm_loss = false;
+
+      static constexpr unsigned int
+      infinity() noexcept { return static_cast<unsigned int>(0); }
+
+      static constexpr unsigned int
+      quiet_NaN() noexcept
+      { return static_cast<unsigned int>(0); }
+
+      static constexpr unsigned int
+      signaling_NaN() noexcept
+      { return static_cast<unsigned int>(0); }
+
+      static constexpr unsigned int
+      denorm_min() noexcept
+      { return static_cast<unsigned int>(0); }
+
+      static constexpr bool is_iec559 = false;
+      static constexpr bool is_bounded = true;
+      static constexpr bool is_modulo = true;
+
+      static constexpr bool traps = true;
+      static constexpr bool tinyness_before = false;
+      static constexpr float_round_style round_style
+       = round_toward_zero;
+    };
+
+
+  template<>
+    struct numeric_limits<long>
+    {
+      static constexpr bool is_specialized = true;
+
+      static constexpr long
+      min() noexcept { return -0x7fffffffffffffffL - 1; }
+
+      static constexpr long
+      max() noexcept { return 0x7fffffffffffffffL; }
+
+
+      static constexpr long
+      lowest() noexcept { return min(); }
+
+
+      static constexpr int digits = (sizeof(long) * 8 - ((long)(-1) < 0));
+      static constexpr int digits10 = ((sizeof(long) * 8 - ((long)(-1) < 0)) * 643L / 2136);
+
+      static constexpr int max_digits10 = 0;
+
+      static constexpr bool is_signed = true;
+      static constexpr bool is_integer = true;
+      static constexpr bool is_exact = true;
+      static constexpr int radix = 2;
+
+      static constexpr long
+      epsilon() noexcept { return 0; }
+
+      static constexpr long
+      round_error() noexcept { return 0; }
+
+      static constexpr int min_exponent = 0;
+      static constexpr int min_exponent10 = 0;
+      static constexpr int max_exponent = 0;
+      static constexpr int max_exponent10 = 0;
+
+      static constexpr bool has_infinity = false;
+      static constexpr bool has_quiet_NaN = false;
+      static constexpr bool has_signaling_NaN = false;
+      static constexpr float_denorm_style has_denorm
+       = denorm_absent;
+      static constexpr bool has_denorm_loss = false;
+
+      static constexpr long
+      infinity() noexcept { return static_cast<long>(0); }
+
+      static constexpr long
+      quiet_NaN() noexcept { return static_cast<long>(0); }
+
+      static constexpr long
+      signaling_NaN() noexcept { return static_cast<long>(0); }
+
+      static constexpr long
+      denorm_min() noexcept { return static_cast<long>(0); }
+
+      static constexpr bool is_iec559 = false;
+      static constexpr bool is_bounded = true;
+      static constexpr bool is_modulo = false;
+
+      static constexpr bool traps = true;
+      static constexpr bool tinyness_before = false;
+      static constexpr float_round_style round_style
+       = round_toward_zero;
+    };
+
+
+  template<>
+    struct numeric_limits<unsigned long>
+    {
+      static constexpr bool is_specialized = true;
+
+      static constexpr unsigned long
+      min() noexcept { return 0; }
+
+      static constexpr unsigned long
+      max() noexcept { return 0x7fffffffffffffffL * 2UL + 1; }
+
+
+      static constexpr unsigned long
+      lowest() noexcept { return min(); }
+
+
+      static constexpr int digits
+       = (sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0));
+      static constexpr int digits10
+       = ((sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0)) * 643L / 2136);
+
+      static constexpr int max_digits10 = 0;
+
+      static constexpr bool is_signed = false;
+      static constexpr bool is_integer = true;
+      static constexpr bool is_exact = true;
+      static constexpr int radix = 2;
+
+      static constexpr unsigned long
+      epsilon() noexcept { return 0; }
+
+      static constexpr unsigned long
+      round_error() noexcept { return 0; }
+
+      static constexpr int min_exponent = 0;
+      static constexpr int min_exponent10 = 0;
+      static constexpr int max_exponent = 0;
+      static constexpr int max_exponent10 = 0;
+
+      static constexpr bool has_infinity = false;
+      static constexpr bool has_quiet_NaN = false;
+      static constexpr bool has_signaling_NaN = false;
+      static constexpr float_denorm_style has_denorm
+       = denorm_absent;
+      static constexpr bool has_denorm_loss = false;
+
+      static constexpr unsigned long
+      infinity() noexcept
+      { return static_cast<unsigned long>(0); }
+
+      static constexpr unsigned long
+      quiet_NaN() noexcept
+      { return static_cast<unsigned long>(0); }
+
+      static constexpr unsigned long
+      signaling_NaN() noexcept
+      { return static_cast<unsigned long>(0); }
+
+      static constexpr unsigned long
+      denorm_min() noexcept
+      { return static_cast<unsigned long>(0); }
+
+      static constexpr bool is_iec559 = false;
+      static constexpr bool is_bounded = true;
+      static constexpr bool is_modulo = true;
+
+      static constexpr bool traps = true;
+      static constexpr bool tinyness_before = false;
+      static constexpr float_round_style round_style
+       = round_toward_zero;
+    };
+
+
+  template<>
+    struct numeric_limits<long long>
+    {
+      static constexpr bool is_specialized = true;
+
+      static constexpr long long
+      min() noexcept { return -0x7fffffffffffffffLL - 1; }
+
+      static constexpr long long
+      max() noexcept { return 0x7fffffffffffffffLL; }
+
+
+      static constexpr long long
+      lowest() noexcept { return min(); }
+
+
+      static constexpr int digits
+       = (sizeof(long long) * 8 - ((long long)(-1) < 0));
+      static constexpr int digits10
+       = ((sizeof(long long) * 8 - ((long long)(-1) < 0)) * 643L / 2136);
+
+      static constexpr int max_digits10 = 0;
+
+      static constexpr bool is_signed = true;
+      static constexpr bool is_integer = true;
+      static constexpr bool is_exact = true;
+      static constexpr int radix = 2;
+
+      static constexpr long long
+      epsilon() noexcept { return 0; }
+
+      static constexpr long long
+      round_error() noexcept { return 0; }
+
+      static constexpr int min_exponent = 0;
+      static constexpr int min_exponent10 = 0;
+      static constexpr int max_exponent = 0;
+      static constexpr int max_exponent10 = 0;
+
+      static constexpr bool has_infinity = false;
+      static constexpr bool has_quiet_NaN = false;
+      static constexpr bool has_signaling_NaN = false;
+      static constexpr float_denorm_style has_denorm
+       = denorm_absent;
+      static constexpr bool has_denorm_loss = false;
+
+      static constexpr long long
+      infinity() noexcept { return static_cast<long long>(0); }
+
+      static constexpr long long
+      quiet_NaN() noexcept { return static_cast<long long>(0); }
+
+      static constexpr long long
+      signaling_NaN() noexcept
+      { return static_cast<long long>(0); }
+
+      static constexpr long long
+      denorm_min() noexcept { return static_cast<long long>(0); }
+
+      static constexpr bool is_iec559 = false;
+      static constexpr bool is_bounded = true;
+      static constexpr bool is_modulo = false;
+
+      static constexpr bool traps = true;
+      static constexpr bool tinyness_before = false;
+      static constexpr float_round_style round_style
+       = round_toward_zero;
+    };
+
+
+  template<>
+    struct numeric_limits<unsigned long long>
+    {
+      static constexpr bool is_specialized = true;
+
+      static constexpr unsigned long long
+      min() noexcept { return 0; }
+
+      static constexpr unsigned long long
+      max() noexcept { return 0x7fffffffffffffffLL * 2ULL + 1; }
+
+
+      static constexpr unsigned long long
+      lowest() noexcept { return min(); }
+
+
+      static constexpr int digits
+       = (sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0));
+      static constexpr int digits10
+       = ((sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0)) * 643L / 2136);
+
+      static constexpr int max_digits10 = 0;
+
+      static constexpr bool is_signed = false;
+      static constexpr bool is_integer = true;
+      static constexpr bool is_exact = true;
+      static constexpr int radix = 2;
+
+      static constexpr unsigned long long
+      epsilon() noexcept { return 0; }
+
+      static constexpr unsigned long long
+      round_error() noexcept { return 0; }
+
+      static constexpr int min_exponent = 0;
+      static constexpr int min_exponent10 = 0;
+      static constexpr int max_exponent = 0;
+      static constexpr int max_exponent10 = 0;
+
+      static constexpr bool has_infinity = false;
+      static constexpr bool has_quiet_NaN = false;
+      static constexpr bool has_signaling_NaN = false;
+      static constexpr float_denorm_style has_denorm
+       = denorm_absent;
+      static constexpr bool has_denorm_loss = false;
+
+      static constexpr unsigned long long
+      infinity() noexcept
+      { return static_cast<unsigned long long>(0); }
+
+      static constexpr unsigned long long
+      quiet_NaN() noexcept
+      { return static_cast<unsigned long long>(0); }
+
+      static constexpr unsigned long long
+      signaling_NaN() noexcept
+      { return static_cast<unsigned long long>(0); }
+
+      static constexpr unsigned long long
+      denorm_min() noexcept
+      { return static_cast<unsigned long long>(0); }
+
+      static constexpr bool is_iec559 = false;
+      static constexpr bool is_bounded = true;
+      static constexpr bool is_modulo = true;
+
+      static constexpr bool traps = true;
+      static constexpr bool tinyness_before = false;
+      static constexpr float_round_style round_style
+       = round_toward_zero;
+    };
+# 1659 "/usr/include/c++/10.2.0/limits" 3
+  template<>
+    struct numeric_limits<float>
+    {
+      static constexpr bool is_specialized = true;
+
+      static constexpr float
+      min() noexcept { return 1.17549435082228750796873653722224568e-38F; }
+
+      static constexpr float
+      max() noexcept { return 3.40282346638528859811704183484516925e+38F; }
+
+
+      static constexpr float
+      lowest() noexcept { return -3.40282346638528859811704183484516925e+38F; }
+
+
+      static constexpr int digits = 24;
+      static constexpr int digits10 = 6;
+
+      static constexpr int max_digits10
+  = (2 + (24) * 643L / 2136);
+
+      static constexpr bool is_signed = true;
+      static constexpr bool is_integer = false;
+      static constexpr bool is_exact = false;
+      static constexpr int radix = 2;
+
+      static constexpr float
+      epsilon() noexcept { return 1.19209289550781250000000000000000000e-7F; }
+
+      static constexpr float
+      round_error() noexcept { return 0.5F; }
+
+      static constexpr int min_exponent = (-125);
+      static constexpr int min_exponent10 = (-37);
+      static constexpr int max_exponent = 128;
+      static constexpr int max_exponent10 = 38;
+
+      static constexpr bool has_infinity = 1;
+      static constexpr bool has_quiet_NaN = 1;
+      static constexpr bool has_signaling_NaN = has_quiet_NaN;
+      static constexpr float_denorm_style has_denorm
+ = bool(1) ? denorm_present : denorm_absent;
+      static constexpr bool has_denorm_loss
+       = false;
+
+      static constexpr float
+      infinity() noexcept { return __builtin_huge_valf(); }
+
+      static constexpr float
+      quiet_NaN() noexcept { return __builtin_nanf(""); }
+
+      static constexpr float
+      signaling_NaN() noexcept { return __builtin_nansf(""); }
+
+      static constexpr float
+      denorm_min() noexcept { return 1.40129846432481707092372958328991613e-45F; }
+
+      static constexpr bool is_iec559
+ = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
+      static constexpr bool is_bounded = true;
+      static constexpr bool is_modulo = false;
+
+      static constexpr bool traps = false;
+      static constexpr bool tinyness_before
+       = false;
+      static constexpr float_round_style round_style
+       = round_to_nearest;
+    };
+
+#undef __glibcxx_float_has_denorm_loss
+#undef __glibcxx_float_traps
+#undef __glibcxx_float_tinyness_before
+
+
+  template<>
+    struct numeric_limits<double>
+    {
+      static constexpr bool is_specialized = true;
+
+      static constexpr double
+      min() noexcept { return double(2.22507385850720138309023271733240406e-308L); }
+
+      static constexpr double
+      max() noexcept { return double(1.79769313486231570814527423731704357e+308L); }
+
+
+      static constexpr double
+      lowest() noexcept { return -double(1.79769313486231570814527423731704357e+308L); }
+
+
+      static constexpr int digits = 53;
+      static constexpr int digits10 = 15;
+
+      static constexpr int max_digits10
+  = (2 + (53) * 643L / 2136);
+
+      static constexpr bool is_signed = true;
+      static constexpr bool is_integer = false;
+      static constexpr bool is_exact = false;
+      static constexpr int radix = 2;
+
+      static constexpr double
+      epsilon() noexcept { return double(2.22044604925031308084726333618164062e-16L); }
+
+      static constexpr double
+      round_error() noexcept { return 0.5; }
+
+      static constexpr int min_exponent = (-1021);
+      static constexpr int min_exponent10 = (-307);
+      static constexpr int max_exponent = 1024;
+      static constexpr int max_exponent10 = 308;
+
+      static constexpr bool has_infinity = 1;
+      static constexpr bool has_quiet_NaN = 1;
+      static constexpr bool has_signaling_NaN = has_quiet_NaN;
+      static constexpr float_denorm_style has_denorm
+ = bool(1) ? denorm_present : denorm_absent;
+      static constexpr bool has_denorm_loss
+        = false;
+
+      static constexpr double
+      infinity() noexcept { return __builtin_huge_val(); }
+
+      static constexpr double
+      quiet_NaN() noexcept { return __builtin_nan(""); }
+
+      static constexpr double
+      signaling_NaN() noexcept { return __builtin_nans(""); }
+
+      static constexpr double
+      denorm_min() noexcept { return double(4.94065645841246544176568792868221372e-324L); }
+
+      static constexpr bool is_iec559
+ = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
+      static constexpr bool is_bounded = true;
+      static constexpr bool is_modulo = false;
+
+      static constexpr bool traps = false;
+      static constexpr bool tinyness_before
+       = false;
+      static constexpr float_round_style round_style
+       = round_to_nearest;
+    };
+
+#undef __glibcxx_double_has_denorm_loss
+#undef __glibcxx_double_traps
+#undef __glibcxx_double_tinyness_before
+
+
+  template<>
+    struct numeric_limits<long double>
+    {
+      static constexpr bool is_specialized = true;
+
+      static constexpr long double
+      min() noexcept { return 3.36210314311209350626267781732175260e-4932L; }
+
+      static constexpr long double
+      max() noexcept { return 1.18973149535723176502126385303097021e+4932L; }
+
+
+      static constexpr long double
+      lowest() noexcept { return -1.18973149535723176502126385303097021e+4932L; }
+
+
+      static constexpr int digits = 64;
+      static constexpr int digits10 = 18;
+
+      static constexpr int max_digits10
+  = (2 + (64) * 643L / 2136);
+
+      static constexpr bool is_signed = true;
+      static constexpr bool is_integer = false;
+      static constexpr bool is_exact = false;
+      static constexpr int radix = 2;
+
+      static constexpr long double
+      epsilon() noexcept { return 1.08420217248550443400745280086994171e-19L; }
+
+      static constexpr long double
+      round_error() noexcept { return 0.5L; }
+
+      static constexpr int min_exponent = (-16381);
+      static constexpr int min_exponent10 = (-4931);
+      static constexpr int max_exponent = 16384;
+      static constexpr int max_exponent10 = 4932;
+
+      static constexpr bool has_infinity = 1;
+      static constexpr bool has_quiet_NaN = 1;
+      static constexpr bool has_signaling_NaN = has_quiet_NaN;
+      static constexpr float_denorm_style has_denorm
+ = bool(1) ? denorm_present : denorm_absent;
+      static constexpr bool has_denorm_loss
+ = false;
+
+      static constexpr long double
+      infinity() noexcept { return __builtin_huge_vall(); }
+
+      static constexpr long double
+      quiet_NaN() noexcept { return __builtin_nanl(""); }
+
+      static constexpr long double
+      signaling_NaN() noexcept { return __builtin_nansl(""); }
+
+      static constexpr long double
+      denorm_min() noexcept { return 3.64519953188247460252840593361941982e-4951L; }
+
+      static constexpr bool is_iec559
+ = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
+      static constexpr bool is_bounded = true;
+      static constexpr bool is_modulo = false;
+
+      static constexpr bool traps = false;
+      static constexpr bool tinyness_before =
+      false;
+      static constexpr float_round_style round_style =
+            round_to_nearest;
+    };
+
+#undef __glibcxx_long_double_has_denorm_loss
+#undef __glibcxx_long_double_traps
+#undef __glibcxx_long_double_tinyness_before
+
+
+}
+
+#undef __glibcxx_signed
+#undef __glibcxx_min
+#undef __glibcxx_max
+#undef __glibcxx_digits
+#undef __glibcxx_digits10
+#undef __glibcxx_max_digits10
+# 36 "/usr/include/c++/10.2.0/bits/hashtable_policy.h" 2 3
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  template<typename _Key, typename _Value, typename _Alloc,
+    typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits>
+    class _Hashtable;
+
+namespace __detail
+{
+
+
+
+
+
+  template<typename _Key, typename _Value,
+    typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _Traits>
+    struct _Hashtable_base;
+
+
+
+  template<class _Iterator>
+    inline typename std::iterator_traits<_Iterator>::difference_type
+    __distance_fw(_Iterator __first, _Iterator __last,
+    std::input_iterator_tag)
+    { return __first != __last ? 1 : 0; }
+
+  template<class _Iterator>
+    inline typename std::iterator_traits<_Iterator>::difference_type
+    __distance_fw(_Iterator __first, _Iterator __last,
+    std::forward_iterator_tag)
+    { return std::distance(__first, __last); }
+
+  template<class _Iterator>
+    inline typename std::iterator_traits<_Iterator>::difference_type
+    __distance_fw(_Iterator __first, _Iterator __last)
+    { return __distance_fw(__first, __last,
+      std::__iterator_category(__first)); }
+
+  struct _Identity
+  {
+    template<typename _Tp>
+      _Tp&&
+      operator()(_Tp&& __x) const
+      { return std::forward<_Tp>(__x); }
+  };
+
+  struct _Select1st
+  {
+    template<typename _Tp>
+      auto
+      operator()(_Tp&& __x) const
+      -> decltype(std::get<0>(std::forward<_Tp>(__x)))
+      { return std::get<0>(std::forward<_Tp>(__x)); }
+  };
+
+  template<typename _NodeAlloc>
+    struct _Hashtable_alloc;
+
+
+
+  template<typename _NodeAlloc>
+    struct _ReuseOrAllocNode
+    {
+    private:
+      using __node_alloc_type = _NodeAlloc;
+      using __hashtable_alloc = _Hashtable_alloc<__node_alloc_type>;
+      using __node_alloc_traits =
+ typename __hashtable_alloc::__node_alloc_traits;
+      using __node_type = typename __hashtable_alloc::__node_type;
+
+    public:
+      _ReuseOrAllocNode(__node_type* __nodes, __hashtable_alloc& __h)
+      : _M_nodes(__nodes), _M_h(__h) { }
+      _ReuseOrAllocNode(const _ReuseOrAllocNode&) = delete;
+
+      ~_ReuseOrAllocNode()
+      { _M_h._M_deallocate_nodes(_M_nodes); }
+
+      template<typename _Arg>
+ __node_type*
+ operator()(_Arg&& __arg) const
+ {
+   if (_M_nodes)
+     {
+       __node_type* __node = _M_nodes;
+       _M_nodes = _M_nodes->_M_next();
+       __node->_M_nxt = nullptr;
+       auto& __a = _M_h._M_node_allocator();
+       __node_alloc_traits::destroy(__a, __node->_M_valptr());
+       try
+  {
+    __node_alloc_traits::construct(__a, __node->_M_valptr(),
+       std::forward<_Arg>(__arg));
+  }
+       catch(...)
+  {
+    _M_h._M_deallocate_node_ptr(__node);
+    throw;
+  }
+       return __node;
+     }
+   return _M_h._M_allocate_node(std::forward<_Arg>(__arg));
+ }
+
+    private:
+      mutable __node_type* _M_nodes;
+      __hashtable_alloc& _M_h;
+    };
+
+
+
+  template<typename _NodeAlloc>
+    struct _AllocNode
+    {
+    private:
+      using __hashtable_alloc = _Hashtable_alloc<_NodeAlloc>;
+      using __node_type = typename __hashtable_alloc::__node_type;
+
+    public:
+      _AllocNode(__hashtable_alloc& __h)
+      : _M_h(__h) { }
+
+      template<typename _Arg>
+ __node_type*
+ operator()(_Arg&& __arg) const
+ { return _M_h._M_allocate_node(std::forward<_Arg>(__arg)); }
+
+    private:
+      __hashtable_alloc& _M_h;
+    };
+# 198 "/usr/include/c++/10.2.0/bits/hashtable_policy.h" 3
+  template<bool _Cache_hash_code, bool _Constant_iterators, bool _Unique_keys>
+    struct _Hashtable_traits
+    {
+      using __hash_cached = __bool_constant<_Cache_hash_code>;
+      using __constant_iterators = __bool_constant<_Constant_iterators>;
+      using __unique_keys = __bool_constant<_Unique_keys>;
+    };
+# 214 "/usr/include/c++/10.2.0/bits/hashtable_policy.h" 3
+  struct _Hash_node_base
+  {
+    _Hash_node_base* _M_nxt;
+
+    _Hash_node_base() noexcept : _M_nxt() { }
+
+    _Hash_node_base(_Hash_node_base* __next) noexcept : _M_nxt(__next) { }
+  };
+
+
+
+
+
+
+  template<typename _Value>
+    struct _Hash_node_value_base : _Hash_node_base
+    {
+      typedef _Value value_type;
+
+      __gnu_cxx::__aligned_buffer<_Value> _M_storage;
+
+      _Value*
+      _M_valptr() noexcept
+      { return _M_storage._M_ptr(); }
+
+      const _Value*
+      _M_valptr() const noexcept
+      { return _M_storage._M_ptr(); }
+
+      _Value&
+      _M_v() noexcept
+      { return *_M_valptr(); }
+
+      const _Value&
+      _M_v() const noexcept
+      { return *_M_valptr(); }
+    };
+
+
+
+
+  template<typename _Value, bool _Cache_hash_code>
+    struct _Hash_node;
+
+
+
+
+
+
+  template<typename _Value>
+    struct _Hash_node<_Value, true> : _Hash_node_value_base<_Value>
+    {
+      std::size_t _M_hash_code;
+
+      _Hash_node*
+      _M_next() const noexcept
+      { return static_cast<_Hash_node*>(this->_M_nxt); }
+    };
+
+
+
+
+
+
+  template<typename _Value>
+    struct _Hash_node<_Value, false> : _Hash_node_value_base<_Value>
+    {
+      _Hash_node*
+      _M_next() const noexcept
+      { return static_cast<_Hash_node*>(this->_M_nxt); }
+    };
+
+
+  template<typename _Value, bool _Cache_hash_code>
+    struct _Node_iterator_base
+    {
+      using __node_type = _Hash_node<_Value, _Cache_hash_code>;
+
+      __node_type* _M_cur;
+
+      _Node_iterator_base(__node_type* __p) noexcept
+      : _M_cur(__p) { }
+
+      void
+      _M_incr() noexcept
+      { _M_cur = _M_cur->_M_next(); }
+    };
+
+  template<typename _Value, bool _Cache_hash_code>
+    inline bool
+    operator==(const _Node_iterator_base<_Value, _Cache_hash_code>& __x,
+        const _Node_iterator_base<_Value, _Cache_hash_code >& __y)
+    noexcept
+    { return __x._M_cur == __y._M_cur; }
+
+  template<typename _Value, bool _Cache_hash_code>
+    inline bool
+    operator!=(const _Node_iterator_base<_Value, _Cache_hash_code>& __x,
+        const _Node_iterator_base<_Value, _Cache_hash_code>& __y)
+    noexcept
+    { return __x._M_cur != __y._M_cur; }
+
+
+  template<typename _Value, bool __constant_iterators, bool __cache>
+    struct _Node_iterator
+    : public _Node_iterator_base<_Value, __cache>
+    {
+    private:
+      using __base_type = _Node_iterator_base<_Value, __cache>;
+      using __node_type = typename __base_type::__node_type;
+
+    public:
+      typedef _Value value_type;
+      typedef std::ptrdiff_t difference_type;
+      typedef std::forward_iterator_tag iterator_category;
+
+      using pointer = typename std::conditional<__constant_iterators,
+      const _Value*, _Value*>::type;
+
+      using reference = typename std::conditional<__constant_iterators,
+        const _Value&, _Value&>::type;
+
+      _Node_iterator() noexcept
+      : __base_type(0) { }
+
+      explicit
+      _Node_iterator(__node_type* __p) noexcept
+      : __base_type(__p) { }
+
+      reference
+      operator*() const noexcept
+      { return this->_M_cur->_M_v(); }
+
+      pointer
+      operator->() const noexcept
+      { return this->_M_cur->_M_valptr(); }
+
+      _Node_iterator&
+      operator++() noexcept
+      {
+ this->_M_incr();
+ return *this;
+      }
+
+      _Node_iterator
+      operator++(int) noexcept
+      {
+ _Node_iterator __tmp(*this);
+ this->_M_incr();
+ return __tmp;
+      }
+    };
+
+
+  template<typename _Value, bool __constant_iterators, bool __cache>
+    struct _Node_const_iterator
+    : public _Node_iterator_base<_Value, __cache>
+    {
+    private:
+      using __base_type = _Node_iterator_base<_Value, __cache>;
+      using __node_type = typename __base_type::__node_type;
+
+    public:
+      typedef _Value value_type;
+      typedef std::ptrdiff_t difference_type;
+      typedef std::forward_iterator_tag iterator_category;
+
+      typedef const _Value* pointer;
+      typedef const _Value& reference;
+
+      _Node_const_iterator() noexcept
+      : __base_type(0) { }
+
+      explicit
+      _Node_const_iterator(__node_type* __p) noexcept
+      : __base_type(__p) { }
+
+      _Node_const_iterator(const _Node_iterator<_Value, __constant_iterators,
+      __cache>& __x) noexcept
+      : __base_type(__x._M_cur) { }
+
+      reference
+      operator*() const noexcept
+      { return this->_M_cur->_M_v(); }
+
+      pointer
+      operator->() const noexcept
+      { return this->_M_cur->_M_valptr(); }
+
+      _Node_const_iterator&
+      operator++() noexcept
+      {
+ this->_M_incr();
+ return *this;
+      }
+
+      _Node_const_iterator
+      operator++(int) noexcept
+      {
+ _Node_const_iterator __tmp(*this);
+ this->_M_incr();
+ return __tmp;
+      }
+    };
+
+
+
+
+
+
+  struct _Mod_range_hashing
+  {
+    typedef std::size_t first_argument_type;
+    typedef std::size_t second_argument_type;
+    typedef std::size_t result_type;
+
+    result_type
+    operator()(first_argument_type __num,
+        second_argument_type __den) const noexcept
+    { return __num % __den; }
+  };
+
+
+
+
+
+
+  struct _Default_ranged_hash { };
+
+
+
+  struct _Prime_rehash_policy
+  {
+    using __has_load_factor = true_type;
+
+    _Prime_rehash_policy(float __z = 1.0) noexcept
+    : _M_max_load_factor(__z), _M_next_resize(0) { }
+
+    float
+    max_load_factor() const noexcept
+    { return _M_max_load_factor; }
+
+
+    std::size_t
+    _M_next_bkt(std::size_t __n) const;
+
+
+    std::size_t
+    _M_bkt_for_elements(std::size_t __n) const
+    { return __builtin_ceill(__n / (long double)_M_max_load_factor); }
+
+
+
+
+
+    std::pair<bool, std::size_t>
+    _M_need_rehash(std::size_t __n_bkt, std::size_t __n_elt,
+     std::size_t __n_ins) const;
+
+    typedef std::size_t _State;
+
+    _State
+    _M_state() const
+    { return _M_next_resize; }
+
+    void
+    _M_reset() noexcept
+    { _M_next_resize = 0; }
+
+    void
+    _M_reset(_State __state)
+    { _M_next_resize = __state; }
+
+    static const std::size_t _S_growth_factor = 2;
+
+    float _M_max_load_factor;
+    mutable std::size_t _M_next_resize;
+  };
+
+
+  struct _Mask_range_hashing
+  {
+    typedef std::size_t first_argument_type;
+    typedef std::size_t second_argument_type;
+    typedef std::size_t result_type;
+
+    result_type
+    operator()(first_argument_type __num,
+        second_argument_type __den) const noexcept
+    { return __num & (__den - 1); }
+  };
+
+
+  inline std::size_t
+  __clp2(std::size_t __n) noexcept
+  {
+
+    if (__n < 2)
+      return __n;
+    const unsigned __lz = sizeof(size_t) > sizeof(long)
+      ? __builtin_clzll(__n - 1ull)
+      : __builtin_clzl(__n - 1ul);
+
+    return (size_t(1) << (numeric_limits<size_t>::digits - __lz - 1)) << 1;
+  }
+
+
+
+  struct _Power2_rehash_policy
+  {
+    using __has_load_factor = true_type;
+
+    _Power2_rehash_policy(float __z = 1.0) noexcept
+    : _M_max_load_factor(__z), _M_next_resize(0) { }
+
+    float
+    max_load_factor() const noexcept
+    { return _M_max_load_factor; }
+
+
+
+    std::size_t
+    _M_next_bkt(std::size_t __n) noexcept
+    {
+      if (__n == 0)
+
+
+
+ return 1;
+
+      const auto __max_width = std::min<size_t>(sizeof(size_t), 8);
+      const auto __max_bkt = size_t(1) << (__max_width * 8 - 1);
+      std::size_t __res = __clp2(__n);
+
+      if (__res == 0)
+ __res = __max_bkt;
+      else if (__res == 1)
+
+
+
+ __res = 2;
+
+      if (__res == __max_bkt)
+
+
+
+ _M_next_resize = numeric_limits<size_t>::max();
+      else
+ _M_next_resize
+   = __builtin_floorl(__res * (long double)_M_max_load_factor);
+
+      return __res;
+    }
+
+
+    std::size_t
+    _M_bkt_for_elements(std::size_t __n) const noexcept
+    { return __builtin_ceill(__n / (long double)_M_max_load_factor); }
+
+
+
+
+
+    std::pair<bool, std::size_t>
+    _M_need_rehash(std::size_t __n_bkt, std::size_t __n_elt,
+     std::size_t __n_ins) noexcept
+    {
+      if (__n_elt + __n_ins > _M_next_resize)
+ {
+
+
+
+   long double __min_bkts
+     = std::max<std::size_t>(__n_elt + __n_ins, _M_next_resize ? 0 : 11)
+       / (long double)_M_max_load_factor;
+   if (__min_bkts >= __n_bkt)
+     return { true,
+       _M_next_bkt(std::max<std::size_t>(__builtin_floorl(__min_bkts) + 1,
+      __n_bkt * _S_growth_factor)) };
+
+   _M_next_resize
+     = __builtin_floorl(__n_bkt * (long double)_M_max_load_factor);
+   return { false, 0 };
+ }
+      else
+ return { false, 0 };
+    }
+
+    typedef std::size_t _State;
+
+    _State
+    _M_state() const noexcept
+    { return _M_next_resize; }
+
+    void
+    _M_reset() noexcept
+    { _M_next_resize = 0; }
+
+    void
+    _M_reset(_State __state) noexcept
+    { _M_next_resize = __state; }
+
+    static const std::size_t _S_growth_factor = 2;
+
+    float _M_max_load_factor;
+    std::size_t _M_next_resize;
+  };
+# 640 "/usr/include/c++/10.2.0/bits/hashtable_policy.h" 3
+  template<typename _Key, typename _Value, typename _Alloc,
+    typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits,
+    bool _Unique_keys = _Traits::__unique_keys::value>
+    struct _Map_base { };
+
+
+  template<typename _Key, typename _Pair, typename _Alloc, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits>
+    struct _Map_base<_Key, _Pair, _Alloc, _Select1st, _Equal,
+       _H1, _H2, _Hash, _RehashPolicy, _Traits, false>
+    {
+      using mapped_type = typename std::tuple_element<1, _Pair>::type;
+    };
+
+
+  template<typename _Key, typename _Pair, typename _Alloc, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits>
+    struct _Map_base<_Key, _Pair, _Alloc, _Select1st, _Equal,
+       _H1, _H2, _Hash, _RehashPolicy, _Traits, true>
+    {
+    private:
+      using __hashtable_base = __detail::_Hashtable_base<_Key, _Pair,
+        _Select1st,
+       _Equal, _H1, _H2, _Hash,
+         _Traits>;
+
+      using __hashtable = _Hashtable<_Key, _Pair, _Alloc,
+         _Select1st, _Equal,
+         _H1, _H2, _Hash, _RehashPolicy, _Traits>;
+
+      using __hash_code = typename __hashtable_base::__hash_code;
+      using __node_type = typename __hashtable_base::__node_type;
+
+    public:
+      using key_type = typename __hashtable_base::key_type;
+      using iterator = typename __hashtable_base::iterator;
+      using mapped_type = typename std::tuple_element<1, _Pair>::type;
+
+      mapped_type&
+      operator[](const key_type& __k);
+
+      mapped_type&
+      operator[](key_type&& __k);
+
+
+
+      mapped_type&
+      at(const key_type& __k);
+
+      const mapped_type&
+      at(const key_type& __k) const;
+    };
+
+  template<typename _Key, typename _Pair, typename _Alloc, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits>
+    auto
+    _Map_base<_Key, _Pair, _Alloc, _Select1st, _Equal,
+       _H1, _H2, _Hash, _RehashPolicy, _Traits, true>::
+    operator[](const key_type& __k)
+    -> mapped_type&
+    {
+      __hashtable* __h = static_cast<__hashtable*>(this);
+      __hash_code __code = __h->_M_hash_code(__k);
+      std::size_t __bkt = __h->_M_bucket_index(__k, __code);
+      if (__node_type* __node = __h->_M_find_node(__bkt, __k, __code))
+ return __node->_M_v().second;
+
+      typename __hashtable::_Scoped_node __node {
+ __h,
+ std::piecewise_construct,
+ std::tuple<const key_type&>(__k),
+ std::tuple<>()
+      };
+      auto __pos
+ = __h->_M_insert_unique_node(__k, __bkt, __code, __node._M_node);
+      __node._M_node = nullptr;
+      return __pos->second;
+    }
+
+  template<typename _Key, typename _Pair, typename _Alloc, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits>
+    auto
+    _Map_base<_Key, _Pair, _Alloc, _Select1st, _Equal,
+       _H1, _H2, _Hash, _RehashPolicy, _Traits, true>::
+    operator[](key_type&& __k)
+    -> mapped_type&
+    {
+      __hashtable* __h = static_cast<__hashtable*>(this);
+      __hash_code __code = __h->_M_hash_code(__k);
+      std::size_t __bkt = __h->_M_bucket_index(__k, __code);
+      if (__node_type* __node = __h->_M_find_node(__bkt, __k, __code))
+ return __node->_M_v().second;
+
+      typename __hashtable::_Scoped_node __node {
+ __h,
+ std::piecewise_construct,
+ std::forward_as_tuple(std::move(__k)),
+ std::tuple<>()
+      };
+      auto __pos
+ = __h->_M_insert_unique_node(__k, __bkt, __code, __node._M_node);
+      __node._M_node = nullptr;
+      return __pos->second;
+    }
+
+  template<typename _Key, typename _Pair, typename _Alloc, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits>
+    auto
+    _Map_base<_Key, _Pair, _Alloc, _Select1st, _Equal,
+       _H1, _H2, _Hash, _RehashPolicy, _Traits, true>::
+    at(const key_type& __k)
+    -> mapped_type&
+    {
+      __hashtable* __h = static_cast<__hashtable*>(this);
+      __hash_code __code = __h->_M_hash_code(__k);
+      std::size_t __bkt = __h->_M_bucket_index(__k, __code);
+      __node_type* __p = __h->_M_find_node(__bkt, __k, __code);
+
+      if (!__p)
+ __throw_out_of_range(("_Map_base::at"));
+      return __p->_M_v().second;
+    }
+
+  template<typename _Key, typename _Pair, typename _Alloc, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits>
+    auto
+    _Map_base<_Key, _Pair, _Alloc, _Select1st, _Equal,
+       _H1, _H2, _Hash, _RehashPolicy, _Traits, true>::
+    at(const key_type& __k) const
+    -> const mapped_type&
+    {
+      const __hashtable* __h = static_cast<const __hashtable*>(this);
+      __hash_code __code = __h->_M_hash_code(__k);
+      std::size_t __bkt = __h->_M_bucket_index(__k, __code);
+      __node_type* __p = __h->_M_find_node(__bkt, __k, __code);
+
+      if (!__p)
+ __throw_out_of_range(("_Map_base::at"));
+      return __p->_M_v().second;
+    }
+
+
+
+
+
+
+  template<typename _Key, typename _Value, typename _Alloc,
+    typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits>
+    struct _Insert_base
+    {
+    protected:
+      using __hashtable = _Hashtable<_Key, _Value, _Alloc, _ExtractKey,
+         _Equal, _H1, _H2, _Hash,
+         _RehashPolicy, _Traits>;
+
+      using __hashtable_base = _Hashtable_base<_Key, _Value, _ExtractKey,
+            _Equal, _H1, _H2, _Hash,
+            _Traits>;
+
+      using value_type = typename __hashtable_base::value_type;
+      using iterator = typename __hashtable_base::iterator;
+      using const_iterator = typename __hashtable_base::const_iterator;
+      using size_type = typename __hashtable_base::size_type;
+
+      using __unique_keys = typename __hashtable_base::__unique_keys;
+      using __ireturn_type = typename __hashtable_base::__ireturn_type;
+      using __node_type = _Hash_node<_Value, _Traits::__hash_cached::value>;
+      using __node_alloc_type = __alloc_rebind<_Alloc, __node_type>;
+      using __node_gen_type = _AllocNode<__node_alloc_type>;
+
+      __hashtable&
+      _M_conjure_hashtable()
+      { return *(static_cast<__hashtable*>(this)); }
+
+      template<typename _InputIterator, typename _NodeGetter>
+ void
+ _M_insert_range(_InputIterator __first, _InputIterator __last,
+   const _NodeGetter&, true_type);
+
+      template<typename _InputIterator, typename _NodeGetter>
+ void
+ _M_insert_range(_InputIterator __first, _InputIterator __last,
+   const _NodeGetter&, false_type);
+
+    public:
+      __ireturn_type
+      insert(const value_type& __v)
+      {
+ __hashtable& __h = _M_conjure_hashtable();
+ __node_gen_type __node_gen(__h);
+ return __h._M_insert(__v, __node_gen, __unique_keys());
+      }
+
+      iterator
+      insert(const_iterator __hint, const value_type& __v)
+      {
+ __hashtable& __h = _M_conjure_hashtable();
+ __node_gen_type __node_gen(__h);
+ return __h._M_insert(__hint, __v, __node_gen, __unique_keys());
+      }
+
+      void
+      insert(initializer_list<value_type> __l)
+      { this->insert(__l.begin(), __l.end()); }
+
+      template<typename _InputIterator>
+ void
+ insert(_InputIterator __first, _InputIterator __last)
+ {
+   __hashtable& __h = _M_conjure_hashtable();
+   __node_gen_type __node_gen(__h);
+   return _M_insert_range(__first, __last, __node_gen, __unique_keys());
+ }
+    };
+
+  template<typename _Key, typename _Value, typename _Alloc,
+    typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits>
+    template<typename _InputIterator, typename _NodeGetter>
+      void
+      _Insert_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash,
+      _RehashPolicy, _Traits>::
+      _M_insert_range(_InputIterator __first, _InputIterator __last,
+        const _NodeGetter& __node_gen, true_type)
+      {
+ size_type __n_elt = __detail::__distance_fw(__first, __last);
+ if (__n_elt == 0)
+   return;
+
+ __hashtable& __h = _M_conjure_hashtable();
+ for (; __first != __last; ++__first)
+   {
+     if (__h._M_insert(*__first, __node_gen, __unique_keys(),
+         __n_elt).second)
+       __n_elt = 1;
+     else if (__n_elt != 1)
+       --__n_elt;
+   }
+      }
+
+  template<typename _Key, typename _Value, typename _Alloc,
+    typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits>
+    template<typename _InputIterator, typename _NodeGetter>
+      void
+      _Insert_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash,
+      _RehashPolicy, _Traits>::
+      _M_insert_range(_InputIterator __first, _InputIterator __last,
+        const _NodeGetter& __node_gen, false_type)
+      {
+ using __rehash_type = typename __hashtable::__rehash_type;
+ using __rehash_state = typename __hashtable::__rehash_state;
+ using pair_type = std::pair<bool, std::size_t>;
+
+ size_type __n_elt = __detail::__distance_fw(__first, __last);
+ if (__n_elt == 0)
+   return;
+
+ __hashtable& __h = _M_conjure_hashtable();
+ __rehash_type& __rehash = __h._M_rehash_policy;
+ const __rehash_state& __saved_state = __rehash._M_state();
+ pair_type __do_rehash = __rehash._M_need_rehash(__h._M_bucket_count,
+       __h._M_element_count,
+       __n_elt);
+
+ if (__do_rehash.first)
+   __h._M_rehash(__do_rehash.second, __saved_state);
+
+ for (; __first != __last; ++__first)
+   __h._M_insert(*__first, __node_gen, __unique_keys());
+      }
+
+
+
+
+
+
+
+  template<typename _Key, typename _Value, typename _Alloc,
+    typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits,
+    bool _Constant_iterators = _Traits::__constant_iterators::value>
+    struct _Insert;
+
+
+  template<typename _Key, typename _Value, typename _Alloc,
+    typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits>
+    struct _Insert<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash,
+     _RehashPolicy, _Traits, true>
+    : public _Insert_base<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+      _H1, _H2, _Hash, _RehashPolicy, _Traits>
+    {
+      using __base_type = _Insert_base<_Key, _Value, _Alloc, _ExtractKey,
+     _Equal, _H1, _H2, _Hash,
+     _RehashPolicy, _Traits>;
+
+      using __hashtable_base = _Hashtable_base<_Key, _Value, _ExtractKey,
+            _Equal, _H1, _H2, _Hash,
+            _Traits>;
+
+      using value_type = typename __base_type::value_type;
+      using iterator = typename __base_type::iterator;
+      using const_iterator = typename __base_type::const_iterator;
+
+      using __unique_keys = typename __base_type::__unique_keys;
+      using __ireturn_type = typename __hashtable_base::__ireturn_type;
+      using __hashtable = typename __base_type::__hashtable;
+      using __node_gen_type = typename __base_type::__node_gen_type;
+
+      using __base_type::insert;
+
+      __ireturn_type
+      insert(value_type&& __v)
+      {
+ __hashtable& __h = this->_M_conjure_hashtable();
+ __node_gen_type __node_gen(__h);
+ return __h._M_insert(std::move(__v), __node_gen, __unique_keys());
+      }
+
+      iterator
+      insert(const_iterator __hint, value_type&& __v)
+      {
+ __hashtable& __h = this->_M_conjure_hashtable();
+ __node_gen_type __node_gen(__h);
+ return __h._M_insert(__hint, std::move(__v), __node_gen,
+        __unique_keys());
+      }
+    };
+
+
+  template<typename _Key, typename _Value, typename _Alloc,
+    typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits>
+    struct _Insert<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash,
+     _RehashPolicy, _Traits, false>
+    : public _Insert_base<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+      _H1, _H2, _Hash, _RehashPolicy, _Traits>
+    {
+      using __base_type = _Insert_base<_Key, _Value, _Alloc, _ExtractKey,
+           _Equal, _H1, _H2, _Hash,
+           _RehashPolicy, _Traits>;
+      using value_type = typename __base_type::value_type;
+      using iterator = typename __base_type::iterator;
+      using const_iterator = typename __base_type::const_iterator;
+
+      using __unique_keys = typename __base_type::__unique_keys;
+      using __hashtable = typename __base_type::__hashtable;
+      using __ireturn_type = typename __base_type::__ireturn_type;
+
+      using __base_type::insert;
+
+      template<typename _Pair>
+ using __is_cons = std::is_constructible<value_type, _Pair&&>;
+
+      template<typename _Pair>
+ using _IFcons = std::enable_if<__is_cons<_Pair>::value>;
+
+      template<typename _Pair>
+ using _IFconsp = typename _IFcons<_Pair>::type;
+
+      template<typename _Pair, typename = _IFconsp<_Pair>>
+ __ireturn_type
+ insert(_Pair&& __v)
+ {
+   __hashtable& __h = this->_M_conjure_hashtable();
+   return __h._M_emplace(__unique_keys(), std::forward<_Pair>(__v));
+ }
+
+      template<typename _Pair, typename = _IFconsp<_Pair>>
+ iterator
+ insert(const_iterator __hint, _Pair&& __v)
+ {
+   __hashtable& __h = this->_M_conjure_hashtable();
+   return __h._M_emplace(__hint, __unique_keys(),
+    std::forward<_Pair>(__v));
+ }
+   };
+
+  template<typename _Policy>
+    using __has_load_factor = typename _Policy::__has_load_factor;
+
+
+
+
+
+
+
+  template<typename _Key, typename _Value, typename _Alloc,
+    typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits,
+    typename =
+      __detected_or_t<false_type, __has_load_factor, _RehashPolicy>>
+    struct _Rehash_base;
+
+
+  template<typename _Key, typename _Value, typename _Alloc,
+    typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits>
+    struct _Rehash_base<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits,
+        false_type>
+    {
+    };
+
+
+  template<typename _Key, typename _Value, typename _Alloc,
+    typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits>
+    struct _Rehash_base<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+   _H1, _H2, _Hash, _RehashPolicy, _Traits,
+   true_type>
+    {
+      using __hashtable = _Hashtable<_Key, _Value, _Alloc, _ExtractKey,
+         _Equal, _H1, _H2, _Hash,
+         _RehashPolicy, _Traits>;
+
+      float
+      max_load_factor() const noexcept
+      {
+ const __hashtable* __this = static_cast<const __hashtable*>(this);
+ return __this->__rehash_policy().max_load_factor();
+      }
+
+      void
+      max_load_factor(float __z)
+      {
+ __hashtable* __this = static_cast<__hashtable*>(this);
+ __this->__rehash_policy(_RehashPolicy(__z));
+      }
+
+      void
+      reserve(std::size_t __n)
+      {
+ __hashtable* __this = static_cast<__hashtable*>(this);
+ __this->rehash(__this->__rehash_policy()._M_bkt_for_elements(__n));
+      }
+    };
+
+
+
+
+
+
+
+  template<int _Nm, typename _Tp,
+    bool __use_ebo = !__is_final(_Tp) && __is_empty(_Tp)>
+    struct _Hashtable_ebo_helper;
+
+
+  template<int _Nm, typename _Tp>
+    struct _Hashtable_ebo_helper<_Nm, _Tp, true>
+    : private _Tp
+    {
+      _Hashtable_ebo_helper() = default;
+
+      template<typename _OtherTp>
+ _Hashtable_ebo_helper(_OtherTp&& __tp)
+ : _Tp(std::forward<_OtherTp>(__tp))
+ { }
+
+      const _Tp& _M_cget() const { return static_cast<const _Tp&>(*this); }
+      _Tp& _M_get() { return static_cast<_Tp&>(*this); }
+    };
+
+
+  template<int _Nm, typename _Tp>
+    struct _Hashtable_ebo_helper<_Nm, _Tp, false>
+    {
+      _Hashtable_ebo_helper() = default;
+
+      template<typename _OtherTp>
+ _Hashtable_ebo_helper(_OtherTp&& __tp)
+ : _M_tp(std::forward<_OtherTp>(__tp))
+ { }
+
+      const _Tp& _M_cget() const { return _M_tp; }
+      _Tp& _M_get() { return _M_tp; }
+
+    private:
+      _Tp _M_tp;
+    };
+
+
+
+
+
+
+
+  template<typename _Key, typename _Value, typename _ExtractKey,
+    typename _H1, typename _H2, typename _Hash,
+    bool __cache_hash_code>
+    struct _Local_iterator_base;
+# 1172 "/usr/include/c++/10.2.0/bits/hashtable_policy.h" 3
+  template<typename _Key, typename _Value, typename _ExtractKey,
+    typename _H1, typename _H2, typename _Hash,
+    bool __cache_hash_code>
+    struct _Hash_code_base;
+
+
+
+  template<typename _Key, typename _Value, typename _ExtractKey,
+    typename _H1, typename _H2, typename _Hash>
+    struct _Hash_code_base<_Key, _Value, _ExtractKey, _H1, _H2, _Hash, false>
+    : private _Hashtable_ebo_helper<0, _ExtractKey>,
+      private _Hashtable_ebo_helper<1, _Hash>
+    {
+    private:
+      using __ebo_extract_key = _Hashtable_ebo_helper<0, _ExtractKey>;
+      using __ebo_hash = _Hashtable_ebo_helper<1, _Hash>;
+
+    protected:
+      typedef void* __hash_code;
+      typedef _Hash_node<_Value, false> __node_type;
+
+
+
+      _Hash_code_base() = default;
+
+      _Hash_code_base(const _ExtractKey& __ex, const _H1&, const _H2&,
+        const _Hash& __h)
+      : __ebo_extract_key(__ex), __ebo_hash(__h) { }
+
+      __hash_code
+      _M_hash_code(const _Key& __key) const
+      { return 0; }
+
+      std::size_t
+      _M_bucket_index(const _Key& __k, __hash_code,
+        std::size_t __bkt_count) const
+      { return _M_ranged_hash()(__k, __bkt_count); }
+
+      std::size_t
+      _M_bucket_index(const __node_type* __p, std::size_t __bkt_count) const
+ noexcept( noexcept(declval<const _Hash&>()(declval<const _Key&>(),
+         (std::size_t)0)) )
+      { return _M_ranged_hash()(_M_extract()(__p->_M_v()), __bkt_count); }
+
+      void
+      _M_store_code(__node_type*, __hash_code) const
+      { }
+
+      void
+      _M_copy_code(__node_type*, const __node_type*) const
+      { }
+
+      void
+      _M_swap(_Hash_code_base& __x)
+      {
+ std::swap(__ebo_extract_key::_M_get(),
+    __x.__ebo_extract_key::_M_get());
+ std::swap(__ebo_hash::_M_get(), __x.__ebo_hash::_M_get());
+      }
+
+      const _ExtractKey&
+      _M_extract() const { return __ebo_extract_key::_M_cget(); }
+
+      const _Hash&
+      _M_ranged_hash() const { return __ebo_hash::_M_cget(); }
+    };
+
+
+
+
+
+
+
+  template<typename _Key, typename _Value, typename _ExtractKey,
+    typename _H1, typename _H2, typename _Hash>
+    struct _Hash_code_base<_Key, _Value, _ExtractKey, _H1, _H2, _Hash, true>;
+
+
+
+
+  template<typename _Key, typename _Value, typename _ExtractKey,
+    typename _H1, typename _H2>
+    struct _Hash_code_base<_Key, _Value, _ExtractKey, _H1, _H2,
+      _Default_ranged_hash, false>
+    : private _Hashtable_ebo_helper<0, _ExtractKey>,
+      private _Hashtable_ebo_helper<1, _H1>,
+      private _Hashtable_ebo_helper<2, _H2>
+    {
+    private:
+      using __ebo_extract_key = _Hashtable_ebo_helper<0, _ExtractKey>;
+      using __ebo_h1 = _Hashtable_ebo_helper<1, _H1>;
+      using __ebo_h2 = _Hashtable_ebo_helper<2, _H2>;
+
+
+      friend struct _Local_iterator_base<_Key, _Value, _ExtractKey, _H1, _H2,
+      _Default_ranged_hash, false>;
+
+    public:
+      typedef _H1 hasher;
+
+      hasher
+      hash_function() const
+      { return _M_h1(); }
+
+    protected:
+      typedef std::size_t __hash_code;
+      typedef _Hash_node<_Value, false> __node_type;
+
+
+
+      _Hash_code_base() = default;
+
+      _Hash_code_base(const _ExtractKey& __ex,
+        const _H1& __h1, const _H2& __h2,
+        const _Default_ranged_hash&)
+      : __ebo_extract_key(__ex), __ebo_h1(__h1), __ebo_h2(__h2) { }
+
+      __hash_code
+      _M_hash_code(const _Key& __k) const
+      {
+ static_assert(__is_invocable<const _H1&, const _Key&>{},
+     "hash function must be invocable with an argument of key type");
+ return _M_h1()(__k);
+      }
+
+      std::size_t
+      _M_bucket_index(const _Key&, __hash_code __c,
+        std::size_t __bkt_count) const
+      { return _M_h2()(__c, __bkt_count); }
+
+      std::size_t
+      _M_bucket_index(const __node_type* __p, std::size_t __bkt_count) const
+ noexcept( noexcept(declval<const _H1&>()(declval<const _Key&>()))
+    && noexcept(declval<const _H2&>()((__hash_code)0,
+          (std::size_t)0)) )
+      { return _M_h2()(_M_h1()(_M_extract()(__p->_M_v())), __bkt_count); }
+
+      void
+      _M_store_code(__node_type*, __hash_code) const
+      { }
+
+      void
+      _M_copy_code(__node_type*, const __node_type*) const
+      { }
+
+      void
+      _M_swap(_Hash_code_base& __x)
+      {
+ std::swap(__ebo_extract_key::_M_get(),
+    __x.__ebo_extract_key::_M_get());
+ std::swap(__ebo_h1::_M_get(), __x.__ebo_h1::_M_get());
+ std::swap(__ebo_h2::_M_get(), __x.__ebo_h2::_M_get());
+      }
+
+      const _ExtractKey&
+      _M_extract() const { return __ebo_extract_key::_M_cget(); }
+
+      const _H1&
+      _M_h1() const { return __ebo_h1::_M_cget(); }
+
+      const _H2&
+      _M_h2() const { return __ebo_h2::_M_cget(); }
+    };
+
+
+
+
+  template<typename _Key, typename _Value, typename _ExtractKey,
+    typename _H1, typename _H2>
+    struct _Hash_code_base<_Key, _Value, _ExtractKey, _H1, _H2,
+      _Default_ranged_hash, true>
+    : private _Hashtable_ebo_helper<0, _ExtractKey>,
+      private _Hashtable_ebo_helper<1, _H1>,
+      private _Hashtable_ebo_helper<2, _H2>
+    {
+    private:
+
+      friend struct _Local_iterator_base<_Key, _Value, _ExtractKey, _H1, _H2,
+      _Default_ranged_hash, true>;
+
+      using __ebo_extract_key = _Hashtable_ebo_helper<0, _ExtractKey>;
+      using __ebo_h1 = _Hashtable_ebo_helper<1, _H1>;
+      using __ebo_h2 = _Hashtable_ebo_helper<2, _H2>;
+
+    public:
+      typedef _H1 hasher;
+
+      hasher
+      hash_function() const
+      { return _M_h1(); }
+
+    protected:
+      typedef std::size_t __hash_code;
+      typedef _Hash_node<_Value, true> __node_type;
+
+
+      _Hash_code_base() = default;
+      _Hash_code_base(const _ExtractKey& __ex,
+        const _H1& __h1, const _H2& __h2,
+        const _Default_ranged_hash&)
+      : __ebo_extract_key(__ex), __ebo_h1(__h1), __ebo_h2(__h2) { }
+
+      __hash_code
+      _M_hash_code(const _Key& __k) const
+      {
+ static_assert(__is_invocable<const _H1&, const _Key&>{},
+     "hash function must be invocable with an argument of key type");
+ return _M_h1()(__k);
+      }
+
+      std::size_t
+      _M_bucket_index(const _Key&, __hash_code __c,
+        std::size_t __bkt_count) const
+      { return _M_h2()(__c, __bkt_count); }
+
+      std::size_t
+      _M_bucket_index(const __node_type* __p, std::size_t __bkt_count) const
+ noexcept( noexcept(declval<const _H2&>()((__hash_code)0,
+       (std::size_t)0)) )
+      { return _M_h2()(__p->_M_hash_code, __bkt_count); }
+
+      void
+      _M_store_code(__node_type* __n, __hash_code __c) const
+      { __n->_M_hash_code = __c; }
+
+      void
+      _M_copy_code(__node_type* __to, const __node_type* __from) const
+      { __to->_M_hash_code = __from->_M_hash_code; }
+
+      void
+      _M_swap(_Hash_code_base& __x)
+      {
+ std::swap(__ebo_extract_key::_M_get(),
+    __x.__ebo_extract_key::_M_get());
+ std::swap(__ebo_h1::_M_get(), __x.__ebo_h1::_M_get());
+ std::swap(__ebo_h2::_M_get(), __x.__ebo_h2::_M_get());
+      }
+
+      const _ExtractKey&
+      _M_extract() const { return __ebo_extract_key::_M_cget(); }
+
+      const _H1&
+      _M_h1() const { return __ebo_h1::_M_cget(); }
+
+      const _H2&
+      _M_h2() const { return __ebo_h2::_M_cget(); }
+    };
+
+
+  template<typename _Key, typename _Value, typename _ExtractKey,
+    typename _H1, typename _H2, typename _Hash>
+    struct _Local_iterator_base<_Key, _Value, _ExtractKey,
+    _H1, _H2, _Hash, true>
+    : private _Hashtable_ebo_helper<0, _H2>
+    {
+    protected:
+      using __base_type = _Hashtable_ebo_helper<0, _H2>;
+      using __hash_code_base = _Hash_code_base<_Key, _Value, _ExtractKey,
+            _H1, _H2, _Hash, true>;
+
+      _Local_iterator_base() = default;
+      _Local_iterator_base(const __hash_code_base& __base,
+      _Hash_node<_Value, true>* __p,
+      std::size_t __bkt, std::size_t __bkt_count)
+      : __base_type(__base._M_h2()),
+ _M_cur(__p), _M_bucket(__bkt), _M_bucket_count(__bkt_count) { }
+
+      void
+      _M_incr()
+      {
+ _M_cur = _M_cur->_M_next();
+ if (_M_cur)
+   {
+     std::size_t __bkt
+       = __base_type::_M_get()(_M_cur->_M_hash_code,
+        _M_bucket_count);
+     if (__bkt != _M_bucket)
+       _M_cur = nullptr;
+   }
+      }
+
+      _Hash_node<_Value, true>* _M_cur;
+      std::size_t _M_bucket;
+      std::size_t _M_bucket_count;
+
+    public:
+      const void*
+      _M_curr() const { return _M_cur; }
+
+      std::size_t
+      _M_get_bucket() const { return _M_bucket; }
+    };
+
+
+
+
+
+  template<typename _Tp, bool _IsEmpty = std::is_empty<_Tp>::value>
+    struct _Hash_code_storage
+    {
+      __gnu_cxx::__aligned_buffer<_Tp> _M_storage;
+
+      _Tp*
+      _M_h() { return _M_storage._M_ptr(); }
+
+      const _Tp*
+      _M_h() const { return _M_storage._M_ptr(); }
+    };
+
+
+  template<typename _Tp>
+    struct _Hash_code_storage<_Tp, true>
+    {
+      static_assert( std::is_empty<_Tp>::value, "Type must be empty" );
+
+
+
+      _Tp*
+      _M_h() { return reinterpret_cast<_Tp*>(this); }
+
+      const _Tp*
+      _M_h() const { return reinterpret_cast<const _Tp*>(this); }
+    };
+
+  template<typename _Key, typename _Value, typename _ExtractKey,
+    typename _H1, typename _H2, typename _Hash>
+    using __hash_code_for_local_iter
+      = _Hash_code_storage<_Hash_code_base<_Key, _Value, _ExtractKey,
+        _H1, _H2, _Hash, false>>;
+
+
+  template<typename _Key, typename _Value, typename _ExtractKey,
+    typename _H1, typename _H2, typename _Hash>
+    struct _Local_iterator_base<_Key, _Value, _ExtractKey,
+    _H1, _H2, _Hash, false>
+    : __hash_code_for_local_iter<_Key, _Value, _ExtractKey, _H1, _H2, _Hash>
+    {
+    protected:
+      using __hash_code_base = _Hash_code_base<_Key, _Value, _ExtractKey,
+            _H1, _H2, _Hash, false>;
+
+      _Local_iterator_base() : _M_bucket_count(-1) { }
+
+      _Local_iterator_base(const __hash_code_base& __base,
+      _Hash_node<_Value, false>* __p,
+      std::size_t __bkt, std::size_t __bkt_count)
+      : _M_cur(__p), _M_bucket(__bkt), _M_bucket_count(__bkt_count)
+      { _M_init(__base); }
+
+      ~_Local_iterator_base()
+      {
+ if (_M_bucket_count != -1)
+   _M_destroy();
+      }
+
+      _Local_iterator_base(const _Local_iterator_base& __iter)
+      : _M_cur(__iter._M_cur), _M_bucket(__iter._M_bucket),
+        _M_bucket_count(__iter._M_bucket_count)
+      {
+ if (_M_bucket_count != -1)
+   _M_init(*__iter._M_h());
+      }
+
+      _Local_iterator_base&
+      operator=(const _Local_iterator_base& __iter)
+      {
+ if (_M_bucket_count != -1)
+   _M_destroy();
+ _M_cur = __iter._M_cur;
+ _M_bucket = __iter._M_bucket;
+ _M_bucket_count = __iter._M_bucket_count;
+ if (_M_bucket_count != -1)
+   _M_init(*__iter._M_h());
+ return *this;
+      }
+
+      void
+      _M_incr()
+      {
+ _M_cur = _M_cur->_M_next();
+ if (_M_cur)
+   {
+     std::size_t __bkt = this->_M_h()->_M_bucket_index(_M_cur,
+             _M_bucket_count);
+     if (__bkt != _M_bucket)
+       _M_cur = nullptr;
+   }
+      }
+
+      _Hash_node<_Value, false>* _M_cur;
+      std::size_t _M_bucket;
+      std::size_t _M_bucket_count;
+
+      void
+      _M_init(const __hash_code_base& __base)
+      { ::new(this->_M_h()) __hash_code_base(__base); }
+
+      void
+      _M_destroy() { this->_M_h()->~__hash_code_base(); }
+
+    public:
+      const void*
+      _M_curr() const { return _M_cur; }
+
+      std::size_t
+      _M_get_bucket() const { return _M_bucket; }
+    };
+
+  template<typename _Key, typename _Value, typename _ExtractKey,
+    typename _H1, typename _H2, typename _Hash, bool __cache>
+    inline bool
+    operator==(const _Local_iterator_base<_Key, _Value, _ExtractKey,
+       _H1, _H2, _Hash, __cache>& __x,
+        const _Local_iterator_base<_Key, _Value, _ExtractKey,
+       _H1, _H2, _Hash, __cache>& __y)
+    { return __x._M_curr() == __y._M_curr(); }
+
+  template<typename _Key, typename _Value, typename _ExtractKey,
+    typename _H1, typename _H2, typename _Hash, bool __cache>
+    inline bool
+    operator!=(const _Local_iterator_base<_Key, _Value, _ExtractKey,
+       _H1, _H2, _Hash, __cache>& __x,
+        const _Local_iterator_base<_Key, _Value, _ExtractKey,
+       _H1, _H2, _Hash, __cache>& __y)
+    { return __x._M_curr() != __y._M_curr(); }
+
+
+  template<typename _Key, typename _Value, typename _ExtractKey,
+    typename _H1, typename _H2, typename _Hash,
+    bool __constant_iterators, bool __cache>
+    struct _Local_iterator
+    : public _Local_iterator_base<_Key, _Value, _ExtractKey,
+      _H1, _H2, _Hash, __cache>
+    {
+    private:
+      using __base_type = _Local_iterator_base<_Key, _Value, _ExtractKey,
+            _H1, _H2, _Hash, __cache>;
+      using __hash_code_base = typename __base_type::__hash_code_base;
+    public:
+      typedef _Value value_type;
+      typedef typename std::conditional<__constant_iterators,
+     const _Value*, _Value*>::type
+             pointer;
+      typedef typename std::conditional<__constant_iterators,
+     const _Value&, _Value&>::type
+             reference;
+      typedef std::ptrdiff_t difference_type;
+      typedef std::forward_iterator_tag iterator_category;
+
+      _Local_iterator() = default;
+
+      _Local_iterator(const __hash_code_base& __base,
+        _Hash_node<_Value, __cache>* __n,
+        std::size_t __bkt, std::size_t __bkt_count)
+      : __base_type(__base, __n, __bkt, __bkt_count)
+      { }
+
+      reference
+      operator*() const
+      { return this->_M_cur->_M_v(); }
+
+      pointer
+      operator->() const
+      { return this->_M_cur->_M_valptr(); }
+
+      _Local_iterator&
+      operator++()
+      {
+ this->_M_incr();
+ return *this;
+      }
+
+      _Local_iterator
+      operator++(int)
+      {
+ _Local_iterator __tmp(*this);
+ this->_M_incr();
+ return __tmp;
+      }
+    };
+
+
+  template<typename _Key, typename _Value, typename _ExtractKey,
+    typename _H1, typename _H2, typename _Hash,
+    bool __constant_iterators, bool __cache>
+    struct _Local_const_iterator
+    : public _Local_iterator_base<_Key, _Value, _ExtractKey,
+      _H1, _H2, _Hash, __cache>
+    {
+    private:
+      using __base_type = _Local_iterator_base<_Key, _Value, _ExtractKey,
+            _H1, _H2, _Hash, __cache>;
+      using __hash_code_base = typename __base_type::__hash_code_base;
+
+    public:
+      typedef _Value value_type;
+      typedef const _Value* pointer;
+      typedef const _Value& reference;
+      typedef std::ptrdiff_t difference_type;
+      typedef std::forward_iterator_tag iterator_category;
+
+      _Local_const_iterator() = default;
+
+      _Local_const_iterator(const __hash_code_base& __base,
+       _Hash_node<_Value, __cache>* __n,
+       std::size_t __bkt, std::size_t __bkt_count)
+      : __base_type(__base, __n, __bkt, __bkt_count)
+      { }
+
+      _Local_const_iterator(const _Local_iterator<_Key, _Value, _ExtractKey,
+        _H1, _H2, _Hash,
+        __constant_iterators,
+        __cache>& __x)
+      : __base_type(__x)
+      { }
+
+      reference
+      operator*() const
+      { return this->_M_cur->_M_v(); }
+
+      pointer
+      operator->() const
+      { return this->_M_cur->_M_valptr(); }
+
+      _Local_const_iterator&
+      operator++()
+      {
+ this->_M_incr();
+ return *this;
+      }
+
+      _Local_const_iterator
+      operator++(int)
+      {
+ _Local_const_iterator __tmp(*this);
+ this->_M_incr();
+ return __tmp;
+      }
+    };
+# 1722 "/usr/include/c++/10.2.0/bits/hashtable_policy.h" 3
+  template<typename _Key, typename _Value,
+    typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _Traits>
+  struct _Hashtable_base
+  : public _Hash_code_base<_Key, _Value, _ExtractKey, _H1, _H2, _Hash,
+      _Traits::__hash_cached::value>,
+    private _Hashtable_ebo_helper<0, _Equal>
+  {
+  public:
+    typedef _Key key_type;
+    typedef _Value value_type;
+    typedef _Equal key_equal;
+    typedef std::size_t size_type;
+    typedef std::ptrdiff_t difference_type;
+
+    using __traits_type = _Traits;
+    using __hash_cached = typename __traits_type::__hash_cached;
+    using __constant_iterators = typename __traits_type::__constant_iterators;
+    using __unique_keys = typename __traits_type::__unique_keys;
+
+    using __hash_code_base = _Hash_code_base<_Key, _Value, _ExtractKey,
+          _H1, _H2, _Hash,
+          __hash_cached::value>;
+
+    using __hash_code = typename __hash_code_base::__hash_code;
+    using __node_type = typename __hash_code_base::__node_type;
+
+    using iterator = __detail::_Node_iterator<value_type,
+           __constant_iterators::value,
+           __hash_cached::value>;
+
+    using const_iterator = __detail::_Node_const_iterator<value_type,
+         __constant_iterators::value,
+         __hash_cached::value>;
+
+    using local_iterator = __detail::_Local_iterator<key_type, value_type,
+        _ExtractKey, _H1, _H2, _Hash,
+        __constant_iterators::value,
+           __hash_cached::value>;
+
+    using const_local_iterator = __detail::_Local_const_iterator<key_type,
+         value_type,
+     _ExtractKey, _H1, _H2, _Hash,
+     __constant_iterators::value,
+     __hash_cached::value>;
+
+    using __ireturn_type = typename std::conditional<__unique_keys::value,
+           std::pair<iterator, bool>,
+           iterator>::type;
+  private:
+    using _EqualEBO = _Hashtable_ebo_helper<0, _Equal>;
+
+    template<typename _NodeT>
+      struct _Equal_hash_code
+      {
+       static bool
+       _S_equals(__hash_code, const _NodeT&)
+       { return true; }
+      };
+
+    template<typename _Ptr2>
+      struct _Equal_hash_code<_Hash_node<_Ptr2, true>>
+      {
+       static bool
+       _S_equals(__hash_code __c, const _Hash_node<_Ptr2, true>& __n)
+       { return __c == __n._M_hash_code; }
+      };
+
+  protected:
+    _Hashtable_base() = default;
+    _Hashtable_base(const _ExtractKey& __ex, const _H1& __h1, const _H2& __h2,
+      const _Hash& __hash, const _Equal& __eq)
+    : __hash_code_base(__ex, __h1, __h2, __hash), _EqualEBO(__eq)
+    { }
+
+    bool
+    _M_equals(const _Key& __k, __hash_code __c, __node_type* __n) const
+    {
+      static_assert(__is_invocable<const _Equal&, const _Key&, const _Key&>{},
+   "key equality predicate must be invocable with two arguments of "
+   "key type");
+      return _Equal_hash_code<__node_type>::_S_equals(__c, *__n)
+ && _M_eq()(__k, this->_M_extract()(__n->_M_v()));
+    }
+
+    void
+    _M_swap(_Hashtable_base& __x)
+    {
+      __hash_code_base::_M_swap(__x);
+      std::swap(_EqualEBO::_M_get(), __x._EqualEBO::_M_get());
+    }
+
+    const _Equal&
+    _M_eq() const { return _EqualEBO::_M_cget(); }
+  };
+# 1826 "/usr/include/c++/10.2.0/bits/hashtable_policy.h" 3
+  template<typename _Key, typename _Value, typename _Alloc,
+    typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits,
+    bool _Unique_keys = _Traits::__unique_keys::value>
+    struct _Equality;
+
+
+  template<typename _Key, typename _Value, typename _Alloc,
+    typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits>
+    struct _Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+       _H1, _H2, _Hash, _RehashPolicy, _Traits, true>
+    {
+      using __hashtable = _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+         _H1, _H2, _Hash, _RehashPolicy, _Traits>;
+
+      bool
+      _M_equal(const __hashtable&) const;
+    };
+
+  template<typename _Key, typename _Value, typename _Alloc,
+    typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits>
+    bool
+    _Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+       _H1, _H2, _Hash, _RehashPolicy, _Traits, true>::
+    _M_equal(const __hashtable& __other) const
+    {
+      using __node_base = typename __hashtable::__node_base;
+      using __node_type = typename __hashtable::__node_type;
+      const __hashtable* __this = static_cast<const __hashtable*>(this);
+      if (__this->size() != __other.size())
+ return false;
+
+      for (auto __itx = __this->begin(); __itx != __this->end(); ++__itx)
+ {
+   std::size_t __ybkt = __other._M_bucket_index(__itx._M_cur);
+   __node_base* __prev_n = __other._M_buckets[__ybkt];
+   if (!__prev_n)
+     return false;
+
+   for (__node_type* __n = static_cast<__node_type*>(__prev_n->_M_nxt);;
+        __n = __n->_M_next())
+     {
+       if (__n->_M_v() == *__itx)
+  break;
+
+       if (!__n->_M_nxt
+    || __other._M_bucket_index(__n->_M_next()) != __ybkt)
+  return false;
+     }
+ }
+
+      return true;
+    }
+
+
+  template<typename _Key, typename _Value, typename _Alloc,
+    typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits>
+    struct _Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+       _H1, _H2, _Hash, _RehashPolicy, _Traits, false>
+    {
+      using __hashtable = _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+         _H1, _H2, _Hash, _RehashPolicy, _Traits>;
+
+      bool
+      _M_equal(const __hashtable&) const;
+    };
+
+  template<typename _Key, typename _Value, typename _Alloc,
+    typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits>
+    bool
+    _Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+       _H1, _H2, _Hash, _RehashPolicy, _Traits, false>::
+    _M_equal(const __hashtable& __other) const
+    {
+      using __node_base = typename __hashtable::__node_base;
+      using __node_type = typename __hashtable::__node_type;
+      const __hashtable* __this = static_cast<const __hashtable*>(this);
+      if (__this->size() != __other.size())
+ return false;
+
+      for (auto __itx = __this->begin(); __itx != __this->end();)
+ {
+   std::size_t __x_count = 1;
+   auto __itx_end = __itx;
+   for (++__itx_end; __itx_end != __this->end()
+   && __this->key_eq()(_ExtractKey()(*__itx),
+         _ExtractKey()(*__itx_end));
+        ++__itx_end)
+     ++__x_count;
+
+   std::size_t __ybkt = __other._M_bucket_index(__itx._M_cur);
+   __node_base* __y_prev_n = __other._M_buckets[__ybkt];
+   if (!__y_prev_n)
+     return false;
+
+   __node_type* __y_n = static_cast<__node_type*>(__y_prev_n->_M_nxt);
+   for (;; __y_n = __y_n->_M_next())
+     {
+       if (__this->key_eq()(_ExtractKey()(__y_n->_M_v()),
+       _ExtractKey()(*__itx)))
+  break;
+
+       if (!__y_n->_M_nxt
+    || __other._M_bucket_index(__y_n->_M_next()) != __ybkt)
+  return false;
+     }
+
+   typename __hashtable::const_iterator __ity(__y_n);
+   for (auto __ity_end = __ity; __ity_end != __other.end(); ++__ity_end)
+     if (--__x_count == 0)
+       break;
+
+   if (__x_count != 0)
+     return false;
+
+   if (!std::is_permutation(__itx, __itx_end, __ity))
+     return false;
+
+   __itx = __itx_end;
+ }
+      return true;
+    }
+
+
+
+
+
+  template<typename _NodeAlloc>
+    struct _Hashtable_alloc : private _Hashtable_ebo_helper<0, _NodeAlloc>
+    {
+    private:
+      using __ebo_node_alloc = _Hashtable_ebo_helper<0, _NodeAlloc>;
+    public:
+      using __node_type = typename _NodeAlloc::value_type;
+      using __node_alloc_type = _NodeAlloc;
+
+      using __node_alloc_traits = __gnu_cxx::__alloc_traits<__node_alloc_type>;
+
+      using __value_alloc_traits = typename __node_alloc_traits::template
+ rebind_traits<typename __node_type::value_type>;
+
+      using __node_base = __detail::_Hash_node_base;
+      using __bucket_type = __node_base*;
+      using __bucket_alloc_type =
+ __alloc_rebind<__node_alloc_type, __bucket_type>;
+      using __bucket_alloc_traits = std::allocator_traits<__bucket_alloc_type>;
+
+      _Hashtable_alloc() = default;
+      _Hashtable_alloc(const _Hashtable_alloc&) = default;
+      _Hashtable_alloc(_Hashtable_alloc&&) = default;
+
+      template<typename _Alloc>
+ _Hashtable_alloc(_Alloc&& __a)
+ : __ebo_node_alloc(std::forward<_Alloc>(__a))
+ { }
+
+      __node_alloc_type&
+      _M_node_allocator()
+      { return __ebo_node_alloc::_M_get(); }
+
+      const __node_alloc_type&
+      _M_node_allocator() const
+      { return __ebo_node_alloc::_M_cget(); }
+
+
+      template<typename... _Args>
+ __node_type*
+ _M_allocate_node(_Args&&... __args);
+
+
+      void
+      _M_deallocate_node(__node_type* __n);
+
+
+      void
+      _M_deallocate_node_ptr(__node_type* __n);
+
+
+
+      void
+      _M_deallocate_nodes(__node_type* __n);
+
+      __bucket_type*
+      _M_allocate_buckets(std::size_t __bkt_count);
+
+      void
+      _M_deallocate_buckets(__bucket_type*, std::size_t __bkt_count);
+    };
+
+
+
+  template<typename _NodeAlloc>
+    template<typename... _Args>
+      auto
+      _Hashtable_alloc<_NodeAlloc>::_M_allocate_node(_Args&&... __args)
+      -> __node_type*
+      {
+ auto __nptr = __node_alloc_traits::allocate(_M_node_allocator(), 1);
+ __node_type* __n = std::__to_address(__nptr);
+ try
+   {
+     ::new ((void*)__n) __node_type;
+     __node_alloc_traits::construct(_M_node_allocator(),
+        __n->_M_valptr(),
+        std::forward<_Args>(__args)...);
+     return __n;
+   }
+ catch(...)
+   {
+     __node_alloc_traits::deallocate(_M_node_allocator(), __nptr, 1);
+     throw;
+   }
+      }
+
+  template<typename _NodeAlloc>
+    void
+    _Hashtable_alloc<_NodeAlloc>::_M_deallocate_node(__node_type* __n)
+    {
+      __node_alloc_traits::destroy(_M_node_allocator(), __n->_M_valptr());
+      _M_deallocate_node_ptr(__n);
+    }
+
+  template<typename _NodeAlloc>
+    void
+    _Hashtable_alloc<_NodeAlloc>::_M_deallocate_node_ptr(__node_type* __n)
+    {
+      typedef typename __node_alloc_traits::pointer _Ptr;
+      auto __ptr = std::pointer_traits<_Ptr>::pointer_to(*__n);
+      __n->~__node_type();
+      __node_alloc_traits::deallocate(_M_node_allocator(), __ptr, 1);
+    }
+
+  template<typename _NodeAlloc>
+    void
+    _Hashtable_alloc<_NodeAlloc>::_M_deallocate_nodes(__node_type* __n)
+    {
+      while (__n)
+ {
+   __node_type* __tmp = __n;
+   __n = __n->_M_next();
+   _M_deallocate_node(__tmp);
+ }
+    }
+
+  template<typename _NodeAlloc>
+    typename _Hashtable_alloc<_NodeAlloc>::__bucket_type*
+    _Hashtable_alloc<_NodeAlloc>::_M_allocate_buckets(std::size_t __bkt_count)
+    {
+      __bucket_alloc_type __alloc(_M_node_allocator());
+
+      auto __ptr = __bucket_alloc_traits::allocate(__alloc, __bkt_count);
+      __bucket_type* __p = std::__to_address(__ptr);
+      __builtin_memset(__p, 0, __bkt_count * sizeof(__bucket_type));
+      return __p;
+    }
+
+  template<typename _NodeAlloc>
+    void
+    _Hashtable_alloc<_NodeAlloc>::_M_deallocate_buckets(__bucket_type* __bkts,
+       std::size_t __bkt_count)
+    {
+      typedef typename __bucket_alloc_traits::pointer _Ptr;
+      auto __ptr = std::pointer_traits<_Ptr>::pointer_to(*__bkts);
+      __bucket_alloc_type __alloc(_M_node_allocator());
+      __bucket_alloc_traits::deallocate(__alloc, __ptr, __bkt_count);
+    }
+
+
+}
+
+}
+# 36 "/usr/include/c++/10.2.0/bits/hashtable.h" 2 3
+
+# 1 "/usr/include/c++/10.2.0/bits/node_handle.h" 1 3
+# 32 "/usr/include/c++/10.2.0/bits/node_handle.h" 3
+#define _NODE_HANDLE 1
+
+       
+# 35 "/usr/include/c++/10.2.0/bits/node_handle.h" 3
+
+
+#define __cpp_lib_node_extract 201606
+
+# 1 "/usr/include/c++/10.2.0/optional" 1 3
+# 30 "/usr/include/c++/10.2.0/optional" 3
+#define _GLIBCXX_OPTIONAL 1
+
+       
+# 33 "/usr/include/c++/10.2.0/optional" 3
+# 43 "/usr/include/c++/10.2.0/optional" 3
+# 1 "/usr/include/c++/10.2.0/bits/enable_special_members.h" 1 3
+# 31 "/usr/include/c++/10.2.0/bits/enable_special_members.h" 3
+#define _ENABLE_SPECIAL_MEMBERS_H 1
+
+       
+# 34 "/usr/include/c++/10.2.0/bits/enable_special_members.h" 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  struct _Enable_default_constructor_tag
+  {
+    explicit constexpr _Enable_default_constructor_tag() = default;
+  };
+
+
+
+
+
+
+template<bool _Switch, typename _Tag = void>
+  struct _Enable_default_constructor
+  {
+    constexpr _Enable_default_constructor() noexcept = default;
+    constexpr _Enable_default_constructor(_Enable_default_constructor const&)
+      noexcept = default;
+    constexpr _Enable_default_constructor(_Enable_default_constructor&&)
+      noexcept = default;
+    _Enable_default_constructor&
+    operator=(_Enable_default_constructor const&) noexcept = default;
+    _Enable_default_constructor&
+    operator=(_Enable_default_constructor&&) noexcept = default;
+
+
+    constexpr explicit
+    _Enable_default_constructor(_Enable_default_constructor_tag) { }
+  };
+
+
+
+
+
+
+
+template<bool _Switch, typename _Tag = void>
+  struct _Enable_destructor { };
+
+
+
+
+
+
+template<bool _Copy, bool _CopyAssignment,
+         bool _Move, bool _MoveAssignment,
+         typename _Tag = void>
+  struct _Enable_copy_move { };
+# 93 "/usr/include/c++/10.2.0/bits/enable_special_members.h" 3
+template<bool _Default, bool _Destructor,
+         bool _Copy, bool _CopyAssignment,
+         bool _Move, bool _MoveAssignment,
+         typename _Tag = void>
+  struct _Enable_special_members
+  : private _Enable_default_constructor<_Default, _Tag>,
+    private _Enable_destructor<_Destructor, _Tag>,
+    private _Enable_copy_move<_Copy, _CopyAssignment,
+                              _Move, _MoveAssignment,
+                              _Tag>
+  { };
+
+
+
+template<typename _Tag>
+  struct _Enable_default_constructor<false, _Tag>
+  {
+    constexpr _Enable_default_constructor() noexcept = delete;
+    constexpr _Enable_default_constructor(_Enable_default_constructor const&)
+      noexcept = default;
+    constexpr _Enable_default_constructor(_Enable_default_constructor&&)
+      noexcept = default;
+    _Enable_default_constructor&
+    operator=(_Enable_default_constructor const&) noexcept = default;
+    _Enable_default_constructor&
+    operator=(_Enable_default_constructor&&) noexcept = default;
+
+
+    constexpr explicit
+    _Enable_default_constructor(_Enable_default_constructor_tag) { }
+  };
+
+template<typename _Tag>
+  struct _Enable_destructor<false, _Tag>
+  { ~_Enable_destructor() noexcept = delete; };
+
+template<typename _Tag>
+  struct _Enable_copy_move<false, true, true, true, _Tag>
+  {
+    constexpr _Enable_copy_move() noexcept = default;
+    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete;
+    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move const&) noexcept = default;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move&&) noexcept = default;
+  };
+
+template<typename _Tag>
+  struct _Enable_copy_move<true, false, true, true, _Tag>
+  {
+    constexpr _Enable_copy_move() noexcept = default;
+    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default;
+    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move const&) noexcept = delete;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move&&) noexcept = default;
+  };
+
+template<typename _Tag>
+  struct _Enable_copy_move<false, false, true, true, _Tag>
+  {
+    constexpr _Enable_copy_move() noexcept = default;
+    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete;
+    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move const&) noexcept = delete;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move&&) noexcept = default;
+  };
+
+template<typename _Tag>
+  struct _Enable_copy_move<true, true, false, true, _Tag>
+  {
+    constexpr _Enable_copy_move() noexcept = default;
+    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default;
+    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move const&) noexcept = default;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move&&) noexcept = default;
+  };
+
+template<typename _Tag>
+  struct _Enable_copy_move<false, true, false, true, _Tag>
+  {
+    constexpr _Enable_copy_move() noexcept = default;
+    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete;
+    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move const&) noexcept = default;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move&&) noexcept = default;
+  };
+
+template<typename _Tag>
+  struct _Enable_copy_move<true, false, false, true, _Tag>
+  {
+    constexpr _Enable_copy_move() noexcept = default;
+    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default;
+    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move const&) noexcept = delete;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move&&) noexcept = default;
+  };
+
+template<typename _Tag>
+  struct _Enable_copy_move<false, false, false, true, _Tag>
+  {
+    constexpr _Enable_copy_move() noexcept = default;
+    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete;
+    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move const&) noexcept = delete;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move&&) noexcept = default;
+  };
+
+template<typename _Tag>
+  struct _Enable_copy_move<true, true, true, false, _Tag>
+  {
+    constexpr _Enable_copy_move() noexcept = default;
+    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default;
+    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move const&) noexcept = default;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move&&) noexcept = delete;
+  };
+
+template<typename _Tag>
+  struct _Enable_copy_move<false, true, true, false, _Tag>
+  {
+    constexpr _Enable_copy_move() noexcept = default;
+    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete;
+    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move const&) noexcept = default;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move&&) noexcept = delete;
+  };
+
+template<typename _Tag>
+  struct _Enable_copy_move<true, false, true, false, _Tag>
+  {
+    constexpr _Enable_copy_move() noexcept = default;
+    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default;
+    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move const&) noexcept = delete;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move&&) noexcept = delete;
+  };
+
+template<typename _Tag>
+  struct _Enable_copy_move<false, false, true, false, _Tag>
+  {
+    constexpr _Enable_copy_move() noexcept = default;
+    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete;
+    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move const&) noexcept = delete;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move&&) noexcept = delete;
+  };
+
+template<typename _Tag>
+  struct _Enable_copy_move<true, true, false, false, _Tag>
+  {
+    constexpr _Enable_copy_move() noexcept = default;
+    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default;
+    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move const&) noexcept = default;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move&&) noexcept = delete;
+  };
+
+template<typename _Tag>
+  struct _Enable_copy_move<false, true, false, false, _Tag>
+  {
+    constexpr _Enable_copy_move() noexcept = default;
+    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete;
+    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move const&) noexcept = default;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move&&) noexcept = delete;
+  };
+
+template<typename _Tag>
+  struct _Enable_copy_move<true, false, false, false, _Tag>
+  {
+    constexpr _Enable_copy_move() noexcept = default;
+    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default;
+    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move const&) noexcept = delete;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move&&) noexcept = delete;
+  };
+
+template<typename _Tag>
+  struct _Enable_copy_move<false, false, false, false, _Tag>
+  {
+    constexpr _Enable_copy_move() noexcept = default;
+    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete;
+    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move const&) noexcept = delete;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move&&) noexcept = delete;
+  };
+
+
+}
+# 44 "/usr/include/c++/10.2.0/optional" 2 3
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+
+
+#define __cpp_lib_optional 201606L
+
+  template<typename _Tp>
+    class optional;
+
+
+  struct nullopt_t
+  {
+
+
+
+
+
+    enum class _Construct { _Token };
+
+
+    explicit constexpr nullopt_t(_Construct) { }
+  };
+
+
+  inline constexpr nullopt_t nullopt { nullopt_t::_Construct::_Token };
+
+
+
+
+
+
+  class bad_optional_access : public exception
+  {
+  public:
+    bad_optional_access() { }
+
+    virtual const char* what() const noexcept override
+    { return "bad optional access"; }
+
+    virtual ~bad_optional_access() noexcept = default;
+  };
+
+  void
+  __throw_bad_optional_access()
+  __attribute__((__noreturn__));
+
+
+  inline void
+  __throw_bad_optional_access()
+  { (throw (bad_optional_access())); }
+
+
+
+  template <typename _Tp>
+    struct _Optional_payload_base
+    {
+      using _Stored_type = remove_const_t<_Tp>;
+
+      _Optional_payload_base() = default;
+      ~_Optional_payload_base() = default;
+
+      template<typename... _Args>
+ constexpr
+ _Optional_payload_base(in_place_t __tag, _Args&&... __args)
+ : _M_payload(__tag, std::forward<_Args>(__args)...),
+   _M_engaged(true)
+ { }
+
+      template<typename _Up, typename... _Args>
+ constexpr
+ _Optional_payload_base(std::initializer_list<_Up> __il,
+          _Args&&... __args)
+ : _M_payload(__il, std::forward<_Args>(__args)...),
+   _M_engaged(true)
+ { }
+
+
+
+      constexpr
+      _Optional_payload_base(bool __engaged,
+        const _Optional_payload_base& __other)
+      {
+ if (__other._M_engaged)
+   this->_M_construct(__other._M_get());
+      }
+
+
+
+      constexpr
+      _Optional_payload_base(bool __engaged,
+        _Optional_payload_base&& __other)
+      {
+ if (__other._M_engaged)
+   this->_M_construct(std::move(__other._M_get()));
+      }
+
+
+
+      _Optional_payload_base(const _Optional_payload_base&) = default;
+
+
+
+      _Optional_payload_base(_Optional_payload_base&&) = default;
+
+      _Optional_payload_base&
+      operator=(const _Optional_payload_base&) = default;
+
+      _Optional_payload_base&
+      operator=(_Optional_payload_base&&) = default;
+
+
+      constexpr void
+      _M_copy_assign(const _Optional_payload_base& __other)
+      {
+        if (this->_M_engaged && __other._M_engaged)
+          this->_M_get() = __other._M_get();
+        else
+   {
+     if (__other._M_engaged)
+       this->_M_construct(__other._M_get());
+     else
+       this->_M_reset();
+   }
+      }
+
+
+      constexpr void
+      _M_move_assign(_Optional_payload_base&& __other)
+      noexcept(__and_v<is_nothrow_move_constructible<_Tp>,
+         is_nothrow_move_assignable<_Tp>>)
+      {
+ if (this->_M_engaged && __other._M_engaged)
+   this->_M_get() = std::move(__other._M_get());
+ else
+   {
+     if (__other._M_engaged)
+       this->_M_construct(std::move(__other._M_get()));
+     else
+       this->_M_reset();
+   }
+      }
+
+      struct _Empty_byte { };
+
+      template<typename _Up, bool = is_trivially_destructible_v<_Up>>
+ union _Storage
+ {
+   constexpr _Storage() noexcept : _M_empty() { }
+
+   template<typename... _Args>
+     constexpr
+     _Storage(in_place_t, _Args&&... __args)
+     : _M_value(std::forward<_Args>(__args)...)
+     { }
+
+   template<typename _Vp, typename... _Args>
+     constexpr
+     _Storage(std::initializer_list<_Vp> __il, _Args&&... __args)
+     : _M_value(__il, std::forward<_Args>(__args)...)
+     { }
+
+   _Empty_byte _M_empty;
+          _Up _M_value;
+ };
+
+      template<typename _Up>
+ union _Storage<_Up, false>
+ {
+   constexpr _Storage() noexcept : _M_empty() { }
+
+   template<typename... _Args>
+     constexpr
+     _Storage(in_place_t, _Args&&... __args)
+     : _M_value(std::forward<_Args>(__args)...)
+     { }
+
+   template<typename _Vp, typename... _Args>
+     constexpr
+     _Storage(std::initializer_list<_Vp> __il, _Args&&... __args)
+     : _M_value(__il, std::forward<_Args>(__args)...)
+     { }
+
+
+   ~_Storage() { }
+
+   _Empty_byte _M_empty;
+          _Up _M_value;
+ };
+
+      _Storage<_Stored_type> _M_payload;
+
+      bool _M_engaged = false;
+
+      template<typename... _Args>
+        void
+        _M_construct(_Args&&... __args)
+        noexcept(is_nothrow_constructible_v<_Stored_type, _Args...>)
+        {
+          ::new ((void *) std::__addressof(this->_M_payload))
+            _Stored_type(std::forward<_Args>(__args)...);
+          this->_M_engaged = true;
+        }
+
+      constexpr void
+      _M_destroy() noexcept
+      {
+ _M_engaged = false;
+ _M_payload._M_value.~_Stored_type();
+      }
+
+
+
+
+
+      constexpr _Tp&
+      _M_get() noexcept
+      { return this->_M_payload._M_value; }
+
+      constexpr const _Tp&
+      _M_get() const noexcept
+      { return this->_M_payload._M_value; }
+
+
+      constexpr void
+      _M_reset() noexcept
+      {
+ if (this->_M_engaged)
+   _M_destroy();
+      }
+    };
+
+
+  template <typename _Tp,
+     bool =
+       is_trivially_destructible_v<_Tp>,
+     bool =
+       is_trivially_copy_assignable_v<_Tp>
+       && is_trivially_copy_constructible_v<_Tp>,
+     bool =
+       is_trivially_move_assignable_v<_Tp>
+       && is_trivially_move_constructible_v<_Tp>>
+    struct _Optional_payload;
+
+
+  template <typename _Tp>
+    struct _Optional_payload<_Tp, true, true, true>
+    : _Optional_payload_base<_Tp>
+    {
+      using _Optional_payload_base<_Tp>::_Optional_payload_base;
+
+      _Optional_payload() = default;
+    };
+
+
+  template <typename _Tp>
+    struct _Optional_payload<_Tp, true, false, true>
+    : _Optional_payload_base<_Tp>
+    {
+      using _Optional_payload_base<_Tp>::_Optional_payload_base;
+
+      _Optional_payload() = default;
+      ~_Optional_payload() = default;
+      _Optional_payload(const _Optional_payload&) = default;
+      _Optional_payload(_Optional_payload&&) = default;
+      _Optional_payload& operator=(_Optional_payload&&) = default;
+
+
+      constexpr
+      _Optional_payload&
+      operator=(const _Optional_payload& __other)
+      {
+ this->_M_copy_assign(__other);
+ return *this;
+      }
+    };
+
+
+  template <typename _Tp>
+    struct _Optional_payload<_Tp, true, true, false>
+    : _Optional_payload_base<_Tp>
+    {
+      using _Optional_payload_base<_Tp>::_Optional_payload_base;
+
+      _Optional_payload() = default;
+      ~_Optional_payload() = default;
+      _Optional_payload(const _Optional_payload&) = default;
+      _Optional_payload(_Optional_payload&&) = default;
+      _Optional_payload& operator=(const _Optional_payload&) = default;
+
+
+      constexpr
+      _Optional_payload&
+      operator=(_Optional_payload&& __other)
+      noexcept(__and_v<is_nothrow_move_constructible<_Tp>,
+         is_nothrow_move_assignable<_Tp>>)
+      {
+ this->_M_move_assign(std::move(__other));
+ return *this;
+      }
+    };
+
+
+  template <typename _Tp>
+    struct _Optional_payload<_Tp, true, false, false>
+    : _Optional_payload_base<_Tp>
+    {
+      using _Optional_payload_base<_Tp>::_Optional_payload_base;
+
+      _Optional_payload() = default;
+      ~_Optional_payload() = default;
+      _Optional_payload(const _Optional_payload&) = default;
+      _Optional_payload(_Optional_payload&&) = default;
+
+
+      constexpr
+      _Optional_payload&
+      operator=(const _Optional_payload& __other)
+      {
+ this->_M_copy_assign(__other);
+ return *this;
+      }
+
+
+      constexpr
+      _Optional_payload&
+      operator=(_Optional_payload&& __other)
+      noexcept(__and_v<is_nothrow_move_constructible<_Tp>,
+         is_nothrow_move_assignable<_Tp>>)
+      {
+ this->_M_move_assign(std::move(__other));
+ return *this;
+      }
+    };
+
+
+  template <typename _Tp, bool _Copy, bool _Move>
+    struct _Optional_payload<_Tp, false, _Copy, _Move>
+    : _Optional_payload<_Tp, true, false, false>
+    {
+
+      using _Optional_payload<_Tp, true, false, false>::_Optional_payload;
+      _Optional_payload() = default;
+      _Optional_payload(const _Optional_payload&) = default;
+      _Optional_payload(_Optional_payload&&) = default;
+      _Optional_payload& operator=(const _Optional_payload&) = default;
+      _Optional_payload& operator=(_Optional_payload&&) = default;
+
+
+      ~_Optional_payload() { this->_M_reset(); }
+    };
+
+
+
+  template<typename _Tp, typename _Dp>
+    class _Optional_base_impl
+    {
+    protected:
+      using _Stored_type = remove_const_t<_Tp>;
+
+
+
+      template<typename... _Args>
+ void
+ _M_construct(_Args&&... __args)
+ noexcept(is_nothrow_constructible_v<_Stored_type, _Args...>)
+ {
+   ::new
+     (std::__addressof(static_cast<_Dp*>(this)->_M_payload._M_payload))
+     _Stored_type(std::forward<_Args>(__args)...);
+   static_cast<_Dp*>(this)->_M_payload._M_engaged = true;
+ }
+
+      void
+      _M_destruct() noexcept
+      { static_cast<_Dp*>(this)->_M_payload._M_destroy(); }
+
+
+      constexpr void
+      _M_reset() noexcept
+      { static_cast<_Dp*>(this)->_M_payload._M_reset(); }
+
+      constexpr bool _M_is_engaged() const noexcept
+      { return static_cast<const _Dp*>(this)->_M_payload._M_engaged; }
+
+
+      constexpr _Tp&
+      _M_get() noexcept
+      {
+ ;
+ return static_cast<_Dp*>(this)->_M_payload._M_get();
+      }
+
+      constexpr const _Tp&
+      _M_get() const noexcept
+      {
+ ;
+ return static_cast<const _Dp*>(this)->_M_payload._M_get();
+      }
+    };
+# 471 "/usr/include/c++/10.2.0/optional" 3
+  template<typename _Tp,
+    bool = is_trivially_copy_constructible_v<_Tp>,
+    bool = is_trivially_move_constructible_v<_Tp>>
+    struct _Optional_base
+      : _Optional_base_impl<_Tp, _Optional_base<_Tp>>
+    {
+
+      constexpr _Optional_base() = default;
+
+
+      template<typename... _Args,
+        enable_if_t<is_constructible_v<_Tp, _Args&&...>, bool> = false>
+        constexpr explicit _Optional_base(in_place_t, _Args&&... __args)
+        : _M_payload(in_place,
+       std::forward<_Args>(__args)...) { }
+
+      template<typename _Up, typename... _Args,
+               enable_if_t<is_constructible_v<_Tp,
+           initializer_list<_Up>&,
+           _Args&&...>, bool> = false>
+        constexpr explicit _Optional_base(in_place_t,
+                                          initializer_list<_Up> __il,
+                                          _Args&&... __args)
+        : _M_payload(in_place,
+       __il, std::forward<_Args>(__args)...)
+        { }
+
+
+      constexpr _Optional_base(const _Optional_base& __other)
+ : _M_payload(__other._M_payload._M_engaged,
+       __other._M_payload)
+      { }
+
+      constexpr _Optional_base(_Optional_base&& __other)
+      noexcept(is_nothrow_move_constructible_v<_Tp>)
+ : _M_payload(__other._M_payload._M_engaged,
+       std::move(__other._M_payload))
+      { }
+
+
+      _Optional_base& operator=(const _Optional_base&) = default;
+      _Optional_base& operator=(_Optional_base&&) = default;
+
+      _Optional_payload<_Tp> _M_payload;
+    };
+
+  template<typename _Tp>
+    struct _Optional_base<_Tp, false, true>
+      : _Optional_base_impl<_Tp, _Optional_base<_Tp>>
+    {
+
+      constexpr _Optional_base() = default;
+
+
+      template<typename... _Args,
+        enable_if_t<is_constructible_v<_Tp, _Args&&...>, bool> = false>
+        constexpr explicit _Optional_base(in_place_t, _Args&&... __args)
+        : _M_payload(in_place,
+       std::forward<_Args>(__args)...) { }
+
+      template<typename _Up, typename... _Args,
+               enable_if_t<is_constructible_v<_Tp,
+           initializer_list<_Up>&,
+           _Args&&...>, bool> = false>
+        constexpr explicit _Optional_base(in_place_t,
+                                          initializer_list<_Up> __il,
+                                          _Args&&... __args)
+        : _M_payload(in_place,
+       __il, std::forward<_Args>(__args)...)
+        { }
+
+
+      constexpr _Optional_base(const _Optional_base& __other)
+ : _M_payload(__other._M_payload._M_engaged,
+       __other._M_payload)
+      { }
+
+      constexpr _Optional_base(_Optional_base&& __other) = default;
+
+
+      _Optional_base& operator=(const _Optional_base&) = default;
+      _Optional_base& operator=(_Optional_base&&) = default;
+
+      _Optional_payload<_Tp> _M_payload;
+    };
+
+  template<typename _Tp>
+    struct _Optional_base<_Tp, true, false>
+      : _Optional_base_impl<_Tp, _Optional_base<_Tp>>
+    {
+
+      constexpr _Optional_base() = default;
+
+
+      template<typename... _Args,
+        enable_if_t<is_constructible_v<_Tp, _Args&&...>, bool> = false>
+        constexpr explicit _Optional_base(in_place_t, _Args&&... __args)
+        : _M_payload(in_place,
+       std::forward<_Args>(__args)...) { }
+
+      template<typename _Up, typename... _Args,
+               enable_if_t<is_constructible_v<_Tp,
+           initializer_list<_Up>&,
+           _Args&&...>, bool> = false>
+        constexpr explicit _Optional_base(in_place_t,
+                                          initializer_list<_Up> __il,
+                                          _Args&&... __args)
+        : _M_payload(in_place,
+       __il, std::forward<_Args>(__args)...)
+        { }
+
+
+      constexpr _Optional_base(const _Optional_base& __other) = default;
+
+      constexpr _Optional_base(_Optional_base&& __other)
+      noexcept(is_nothrow_move_constructible_v<_Tp>)
+ : _M_payload(__other._M_payload._M_engaged,
+       std::move(__other._M_payload))
+      { }
+
+
+      _Optional_base& operator=(const _Optional_base&) = default;
+      _Optional_base& operator=(_Optional_base&&) = default;
+
+      _Optional_payload<_Tp> _M_payload;
+    };
+
+  template<typename _Tp>
+    struct _Optional_base<_Tp, true, true>
+      : _Optional_base_impl<_Tp, _Optional_base<_Tp>>
+    {
+
+      constexpr _Optional_base() = default;
+
+
+      template<typename... _Args,
+        enable_if_t<is_constructible_v<_Tp, _Args&&...>, bool> = false>
+        constexpr explicit _Optional_base(in_place_t, _Args&&... __args)
+        : _M_payload(in_place,
+       std::forward<_Args>(__args)...) { }
+
+      template<typename _Up, typename... _Args,
+               enable_if_t<is_constructible_v<_Tp,
+           initializer_list<_Up>&,
+           _Args&&...>, bool> = false>
+        constexpr explicit _Optional_base(in_place_t,
+                                          initializer_list<_Up> __il,
+                                          _Args&&... __args)
+        : _M_payload(in_place,
+       __il, std::forward<_Args>(__args)...)
+        { }
+
+
+      constexpr _Optional_base(const _Optional_base& __other) = default;
+      constexpr _Optional_base(_Optional_base&& __other) = default;
+
+
+      _Optional_base& operator=(const _Optional_base&) = default;
+      _Optional_base& operator=(_Optional_base&&) = default;
+
+      _Optional_payload<_Tp> _M_payload;
+    };
+
+  template<typename _Tp>
+  class optional;
+
+  template<typename _Tp, typename _Up>
+    using __converts_from_optional =
+      __or_<is_constructible<_Tp, const optional<_Up>&>,
+     is_constructible<_Tp, optional<_Up>&>,
+     is_constructible<_Tp, const optional<_Up>&&>,
+     is_constructible<_Tp, optional<_Up>&&>,
+     is_convertible<const optional<_Up>&, _Tp>,
+     is_convertible<optional<_Up>&, _Tp>,
+     is_convertible<const optional<_Up>&&, _Tp>,
+     is_convertible<optional<_Up>&&, _Tp>>;
+
+  template<typename _Tp, typename _Up>
+    using __assigns_from_optional =
+      __or_<is_assignable<_Tp&, const optional<_Up>&>,
+     is_assignable<_Tp&, optional<_Up>&>,
+     is_assignable<_Tp&, const optional<_Up>&&>,
+     is_assignable<_Tp&, optional<_Up>&&>>;
+
+
+
+
+  template<typename _Tp>
+    class optional
+    : private _Optional_base<_Tp>,
+      private _Enable_copy_move<
+
+ is_copy_constructible_v<_Tp>,
+
+ __and_v<is_copy_constructible<_Tp>, is_copy_assignable<_Tp>>,
+
+ is_move_constructible_v<_Tp>,
+
+ __and_v<is_move_constructible<_Tp>, is_move_assignable<_Tp>>,
+
+ optional<_Tp>>
+    {
+      static_assert(!is_same_v<remove_cv_t<_Tp>, nullopt_t>);
+      static_assert(!is_same_v<remove_cv_t<_Tp>, in_place_t>);
+      static_assert(!is_reference_v<_Tp>);
+
+    private:
+      using _Base = _Optional_base<_Tp>;
+
+
+      template<typename _Up>
+ using __not_self = __not_<is_same<optional, __remove_cvref_t<_Up>>>;
+      template<typename _Up>
+ using __not_tag = __not_<is_same<in_place_t, __remove_cvref_t<_Up>>>;
+      template<typename... _Cond>
+ using _Requires = enable_if_t<__and_v<_Cond...>, bool>;
+
+    public:
+      using value_type = _Tp;
+
+      constexpr optional() = default;
+
+      constexpr optional(nullopt_t) noexcept { }
+
+
+      template<typename _Up = _Tp,
+        _Requires<__not_self<_Up>, __not_tag<_Up>,
+    is_constructible<_Tp, _Up&&>,
+    is_convertible<_Up&&, _Tp>> = true>
+ constexpr
+ optional(_Up&& __t)
+ : _Base(std::in_place, std::forward<_Up>(__t)) { }
+
+      template<typename _Up = _Tp,
+        _Requires<__not_self<_Up>, __not_tag<_Up>,
+    is_constructible<_Tp, _Up&&>,
+    __not_<is_convertible<_Up&&, _Tp>>> = false>
+ explicit constexpr
+ optional(_Up&& __t)
+        : _Base(std::in_place, std::forward<_Up>(__t)) { }
+
+      template<typename _Up,
+        _Requires<__not_<is_same<_Tp, _Up>>,
+    is_constructible<_Tp, const _Up&>,
+    is_convertible<const _Up&, _Tp>,
+    __not_<__converts_from_optional<_Tp, _Up>>> = true>
+ constexpr
+ optional(const optional<_Up>& __t)
+ {
+   if (__t)
+     emplace(*__t);
+ }
+
+      template<typename _Up,
+        _Requires<__not_<is_same<_Tp, _Up>>,
+    is_constructible<_Tp, const _Up&>,
+    __not_<is_convertible<const _Up&, _Tp>>,
+    __not_<__converts_from_optional<_Tp, _Up>>> = false>
+ explicit constexpr
+ optional(const optional<_Up>& __t)
+ {
+   if (__t)
+     emplace(*__t);
+ }
+
+      template <typename _Up,
+  _Requires<__not_<is_same<_Tp, _Up>>,
+     is_constructible<_Tp, _Up&&>,
+     is_convertible<_Up&&, _Tp>,
+     __not_<__converts_from_optional<_Tp, _Up>>> = true>
+ constexpr
+ optional(optional<_Up>&& __t)
+ {
+   if (__t)
+     emplace(std::move(*__t));
+ }
+
+      template <typename _Up,
+  _Requires<__not_<is_same<_Tp, _Up>>,
+     is_constructible<_Tp, _Up&&>,
+     __not_<is_convertible<_Up&&, _Tp>>,
+     __not_<__converts_from_optional<_Tp, _Up>>> = false>
+ explicit constexpr
+ optional(optional<_Up>&& __t)
+ {
+   if (__t)
+     emplace(std::move(*__t));
+ }
+
+      template<typename... _Args,
+        _Requires<is_constructible<_Tp, _Args&&...>> = false>
+ explicit constexpr
+ optional(in_place_t, _Args&&... __args)
+ : _Base(std::in_place, std::forward<_Args>(__args)...) { }
+
+      template<typename _Up, typename... _Args,
+        _Requires<is_constructible<_Tp,
+       initializer_list<_Up>&,
+       _Args&&...>> = false>
+ explicit constexpr
+ optional(in_place_t, initializer_list<_Up> __il, _Args&&... __args)
+ : _Base(std::in_place, __il, std::forward<_Args>(__args)...) { }
+
+
+      optional&
+      operator=(nullopt_t) noexcept
+      {
+ this->_M_reset();
+ return *this;
+      }
+
+      template<typename _Up = _Tp>
+ enable_if_t<__and_v<__not_self<_Up>,
+       __not_<__and_<is_scalar<_Tp>,
+       is_same<_Tp, decay_t<_Up>>>>,
+       is_constructible<_Tp, _Up>,
+       is_assignable<_Tp&, _Up>>,
+      optional&>
+ operator=(_Up&& __u)
+ {
+   if (this->_M_is_engaged())
+     this->_M_get() = std::forward<_Up>(__u);
+   else
+     this->_M_construct(std::forward<_Up>(__u));
+
+   return *this;
+ }
+
+      template<typename _Up>
+ enable_if_t<__and_v<__not_<is_same<_Tp, _Up>>,
+       is_constructible<_Tp, const _Up&>,
+       is_assignable<_Tp&, _Up>,
+       __not_<__converts_from_optional<_Tp, _Up>>,
+       __not_<__assigns_from_optional<_Tp, _Up>>>,
+      optional&>
+ operator=(const optional<_Up>& __u)
+ {
+   if (__u)
+     {
+       if (this->_M_is_engaged())
+  this->_M_get() = *__u;
+       else
+  this->_M_construct(*__u);
+     }
+   else
+     {
+       this->_M_reset();
+     }
+   return *this;
+ }
+
+      template<typename _Up>
+        enable_if_t<__and_v<__not_<is_same<_Tp, _Up>>,
+       is_constructible<_Tp, _Up>,
+       is_assignable<_Tp&, _Up>,
+       __not_<__converts_from_optional<_Tp, _Up>>,
+       __not_<__assigns_from_optional<_Tp, _Up>>>,
+      optional&>
+ operator=(optional<_Up>&& __u)
+ {
+   if (__u)
+     {
+       if (this->_M_is_engaged())
+  this->_M_get() = std::move(*__u);
+       else
+  this->_M_construct(std::move(*__u));
+     }
+   else
+     {
+       this->_M_reset();
+     }
+
+   return *this;
+ }
+
+      template<typename... _Args>
+ enable_if_t<is_constructible_v<_Tp, _Args&&...>, _Tp&>
+ emplace(_Args&&... __args)
+ {
+   this->_M_reset();
+   this->_M_construct(std::forward<_Args>(__args)...);
+   return this->_M_get();
+ }
+
+      template<typename _Up, typename... _Args>
+ enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&,
+           _Args&&...>, _Tp&>
+ emplace(initializer_list<_Up> __il, _Args&&... __args)
+ {
+   this->_M_reset();
+   this->_M_construct(__il, std::forward<_Args>(__args)...);
+   return this->_M_get();
+ }
+
+
+
+
+      void
+      swap(optional& __other)
+      noexcept(is_nothrow_move_constructible_v<_Tp>
+        && is_nothrow_swappable_v<_Tp>)
+      {
+ using std::swap;
+
+ if (this->_M_is_engaged() && __other._M_is_engaged())
+   swap(this->_M_get(), __other._M_get());
+ else if (this->_M_is_engaged())
+   {
+     __other._M_construct(std::move(this->_M_get()));
+     this->_M_destruct();
+   }
+ else if (__other._M_is_engaged())
+   {
+     this->_M_construct(std::move(__other._M_get()));
+     __other._M_destruct();
+   }
+      }
+
+
+      constexpr const _Tp*
+      operator->() const
+      { return std::__addressof(this->_M_get()); }
+
+      constexpr _Tp*
+      operator->()
+      { return std::__addressof(this->_M_get()); }
+
+      constexpr const _Tp&
+      operator*() const&
+      { return this->_M_get(); }
+
+      constexpr _Tp&
+      operator*()&
+      { return this->_M_get(); }
+
+      constexpr _Tp&&
+      operator*()&&
+      { return std::move(this->_M_get()); }
+
+      constexpr const _Tp&&
+      operator*() const&&
+      { return std::move(this->_M_get()); }
+
+      constexpr explicit operator bool() const noexcept
+      { return this->_M_is_engaged(); }
+
+      constexpr bool has_value() const noexcept
+      { return this->_M_is_engaged(); }
+
+      constexpr const _Tp&
+      value() const&
+      {
+ return this->_M_is_engaged()
+   ? this->_M_get()
+   : (__throw_bad_optional_access(), this->_M_get());
+      }
+
+      constexpr _Tp&
+      value()&
+      {
+ return this->_M_is_engaged()
+   ? this->_M_get()
+   : (__throw_bad_optional_access(), this->_M_get());
+      }
+
+      constexpr _Tp&&
+      value()&&
+      {
+ return this->_M_is_engaged()
+   ? std::move(this->_M_get())
+   : (__throw_bad_optional_access(), std::move(this->_M_get()));
+      }
+
+      constexpr const _Tp&&
+      value() const&&
+      {
+ return this->_M_is_engaged()
+   ? std::move(this->_M_get())
+   : (__throw_bad_optional_access(), std::move(this->_M_get()));
+      }
+
+      template<typename _Up>
+ constexpr _Tp
+ value_or(_Up&& __u) const&
+ {
+   static_assert(is_copy_constructible_v<_Tp>);
+   static_assert(is_convertible_v<_Up&&, _Tp>);
+
+   return this->_M_is_engaged()
+     ? this->_M_get() : static_cast<_Tp>(std::forward<_Up>(__u));
+ }
+
+      template<typename _Up>
+ constexpr _Tp
+ value_or(_Up&& __u) &&
+ {
+   static_assert(is_move_constructible_v<_Tp>);
+   static_assert(is_convertible_v<_Up&&, _Tp>);
+
+   return this->_M_is_engaged()
+     ? std::move(this->_M_get())
+     : static_cast<_Tp>(std::forward<_Up>(__u));
+ }
+
+      void reset() noexcept { this->_M_reset(); }
+    };
+
+  template<typename _Tp>
+    using __optional_relop_t =
+      enable_if_t<is_convertible<_Tp, bool>::value, bool>;
+
+
+  template<typename _Tp, typename _Up>
+    constexpr auto
+    operator==(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
+    -> __optional_relop_t<decltype(declval<_Tp>() == declval<_Up>())>
+    {
+      return static_cast<bool>(__lhs) == static_cast<bool>(__rhs)
+      && (!__lhs || *__lhs == *__rhs);
+    }
+
+  template<typename _Tp, typename _Up>
+    constexpr auto
+    operator!=(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
+    -> __optional_relop_t<decltype(declval<_Tp>() != declval<_Up>())>
+    {
+      return static_cast<bool>(__lhs) != static_cast<bool>(__rhs)
+ || (static_cast<bool>(__lhs) && *__lhs != *__rhs);
+    }
+
+  template<typename _Tp, typename _Up>
+    constexpr auto
+    operator<(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
+    -> __optional_relop_t<decltype(declval<_Tp>() < declval<_Up>())>
+    {
+      return static_cast<bool>(__rhs) && (!__lhs || *__lhs < *__rhs);
+    }
+
+  template<typename _Tp, typename _Up>
+    constexpr auto
+    operator>(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
+    -> __optional_relop_t<decltype(declval<_Tp>() > declval<_Up>())>
+    {
+      return static_cast<bool>(__lhs) && (!__rhs || *__lhs > *__rhs);
+    }
+
+  template<typename _Tp, typename _Up>
+    constexpr auto
+    operator<=(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
+    -> __optional_relop_t<decltype(declval<_Tp>() <= declval<_Up>())>
+    {
+      return !__lhs || (static_cast<bool>(__rhs) && *__lhs <= *__rhs);
+    }
+
+  template<typename _Tp, typename _Up>
+    constexpr auto
+    operator>=(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
+    -> __optional_relop_t<decltype(declval<_Tp>() >= declval<_Up>())>
+    {
+      return !__rhs || (static_cast<bool>(__lhs) && *__lhs >= *__rhs);
+    }
+# 1043 "/usr/include/c++/10.2.0/optional" 3
+  template<typename _Tp>
+    constexpr bool
+    operator==(const optional<_Tp>& __lhs, nullopt_t) noexcept
+    { return !__lhs; }
+
+
+
+
+
+
+
+  template<typename _Tp>
+    constexpr bool
+    operator==(nullopt_t, const optional<_Tp>& __rhs) noexcept
+    { return !__rhs; }
+
+  template<typename _Tp>
+    constexpr bool
+    operator!=(const optional<_Tp>& __lhs, nullopt_t) noexcept
+    { return static_cast<bool>(__lhs); }
+
+  template<typename _Tp>
+    constexpr bool
+    operator!=(nullopt_t, const optional<_Tp>& __rhs) noexcept
+    { return static_cast<bool>(__rhs); }
+
+  template<typename _Tp>
+    constexpr bool
+    operator<(const optional<_Tp>& , nullopt_t) noexcept
+    { return false; }
+
+  template<typename _Tp>
+    constexpr bool
+    operator<(nullopt_t, const optional<_Tp>& __rhs) noexcept
+    { return static_cast<bool>(__rhs); }
+
+  template<typename _Tp>
+    constexpr bool
+    operator>(const optional<_Tp>& __lhs, nullopt_t) noexcept
+    { return static_cast<bool>(__lhs); }
+
+  template<typename _Tp>
+    constexpr bool
+    operator>(nullopt_t, const optional<_Tp>& ) noexcept
+    { return false; }
+
+  template<typename _Tp>
+    constexpr bool
+    operator<=(const optional<_Tp>& __lhs, nullopt_t) noexcept
+    { return !__lhs; }
+
+  template<typename _Tp>
+    constexpr bool
+    operator<=(nullopt_t, const optional<_Tp>& ) noexcept
+    { return true; }
+
+  template<typename _Tp>
+    constexpr bool
+    operator>=(const optional<_Tp>& , nullopt_t) noexcept
+    { return true; }
+
+  template<typename _Tp>
+    constexpr bool
+    operator>=(nullopt_t, const optional<_Tp>& __rhs) noexcept
+    { return !__rhs; }
+
+
+
+  template<typename _Tp, typename _Up>
+    constexpr auto
+    operator==(const optional<_Tp>& __lhs, const _Up& __rhs)
+    -> __optional_relop_t<decltype(declval<_Tp>() == declval<_Up>())>
+    { return __lhs && *__lhs == __rhs; }
+
+  template<typename _Tp, typename _Up>
+    constexpr auto
+    operator==(const _Up& __lhs, const optional<_Tp>& __rhs)
+    -> __optional_relop_t<decltype(declval<_Up>() == declval<_Tp>())>
+    { return __rhs && __lhs == *__rhs; }
+
+  template<typename _Tp, typename _Up>
+    constexpr auto
+    operator!=(const optional<_Tp>& __lhs, const _Up& __rhs)
+    -> __optional_relop_t<decltype(declval<_Tp>() != declval<_Up>())>
+    { return !__lhs || *__lhs != __rhs; }
+
+  template<typename _Tp, typename _Up>
+    constexpr auto
+    operator!=(const _Up& __lhs, const optional<_Tp>& __rhs)
+    -> __optional_relop_t<decltype(declval<_Up>() != declval<_Tp>())>
+    { return !__rhs || __lhs != *__rhs; }
+
+  template<typename _Tp, typename _Up>
+    constexpr auto
+    operator<(const optional<_Tp>& __lhs, const _Up& __rhs)
+    -> __optional_relop_t<decltype(declval<_Tp>() < declval<_Up>())>
+    { return !__lhs || *__lhs < __rhs; }
+
+  template<typename _Tp, typename _Up>
+    constexpr auto
+    operator<(const _Up& __lhs, const optional<_Tp>& __rhs)
+    -> __optional_relop_t<decltype(declval<_Up>() < declval<_Tp>())>
+    { return __rhs && __lhs < *__rhs; }
+
+  template<typename _Tp, typename _Up>
+    constexpr auto
+    operator>(const optional<_Tp>& __lhs, const _Up& __rhs)
+    -> __optional_relop_t<decltype(declval<_Tp>() > declval<_Up>())>
+    { return __lhs && *__lhs > __rhs; }
+
+  template<typename _Tp, typename _Up>
+    constexpr auto
+    operator>(const _Up& __lhs, const optional<_Tp>& __rhs)
+    -> __optional_relop_t<decltype(declval<_Up>() > declval<_Tp>())>
+    { return !__rhs || __lhs > *__rhs; }
+
+  template<typename _Tp, typename _Up>
+    constexpr auto
+    operator<=(const optional<_Tp>& __lhs, const _Up& __rhs)
+    -> __optional_relop_t<decltype(declval<_Tp>() <= declval<_Up>())>
+    { return !__lhs || *__lhs <= __rhs; }
+
+  template<typename _Tp, typename _Up>
+    constexpr auto
+    operator<=(const _Up& __lhs, const optional<_Tp>& __rhs)
+    -> __optional_relop_t<decltype(declval<_Up>() <= declval<_Tp>())>
+    { return __rhs && __lhs <= *__rhs; }
+
+  template<typename _Tp, typename _Up>
+    constexpr auto
+    operator>=(const optional<_Tp>& __lhs, const _Up& __rhs)
+    -> __optional_relop_t<decltype(declval<_Tp>() >= declval<_Up>())>
+    { return __lhs && *__lhs >= __rhs; }
+
+  template<typename _Tp, typename _Up>
+    constexpr auto
+    operator>=(const _Up& __lhs, const optional<_Tp>& __rhs)
+    -> __optional_relop_t<decltype(declval<_Up>() >= declval<_Tp>())>
+    { return !__rhs || __lhs >= *__rhs; }
+# 1194 "/usr/include/c++/10.2.0/optional" 3
+  template<typename _Tp>
+    inline enable_if_t<is_move_constructible_v<_Tp> && is_swappable_v<_Tp>>
+    swap(optional<_Tp>& __lhs, optional<_Tp>& __rhs)
+    noexcept(noexcept(__lhs.swap(__rhs)))
+    { __lhs.swap(__rhs); }
+
+  template<typename _Tp>
+    enable_if_t<!(is_move_constructible_v<_Tp> && is_swappable_v<_Tp>)>
+    swap(optional<_Tp>&, optional<_Tp>&) = delete;
+
+  template<typename _Tp>
+    constexpr optional<decay_t<_Tp>>
+    make_optional(_Tp&& __t)
+    { return optional<decay_t<_Tp>> { std::forward<_Tp>(__t) }; }
+
+  template<typename _Tp, typename ..._Args>
+    constexpr optional<_Tp>
+    make_optional(_Args&&... __args)
+    { return optional<_Tp> { in_place, std::forward<_Args>(__args)... }; }
+
+  template<typename _Tp, typename _Up, typename ..._Args>
+    constexpr optional<_Tp>
+    make_optional(initializer_list<_Up> __il, _Args&&... __args)
+    { return optional<_Tp> { in_place, __il, std::forward<_Args>(__args)... }; }
+
+
+
+  template<typename _Tp, typename _Up = remove_const_t<_Tp>,
+           bool = __poison_hash<_Up>::__enable_hash_call>
+    struct __optional_hash_call_base
+    {
+      size_t
+      operator()(const optional<_Tp>& __t) const
+      noexcept(noexcept(hash<_Up>{}(*__t)))
+      {
+
+
+        constexpr size_t __magic_disengaged_hash = static_cast<size_t>(-3333);
+        return __t ? hash<_Up>{}(*__t) : __magic_disengaged_hash;
+      }
+    };
+
+  template<typename _Tp, typename _Up>
+    struct __optional_hash_call_base<_Tp, _Up, false> {};
+
+  template<typename _Tp>
+    struct hash<optional<_Tp>>
+    : private __poison_hash<remove_const_t<_Tp>>,
+      public __optional_hash_call_base<_Tp>
+    {
+      using result_type [[__deprecated__]] = size_t;
+      using argument_type [[__deprecated__]] = optional<_Tp>;
+    };
+
+  template<typename _Tp>
+    struct __is_fast_hash<hash<optional<_Tp>>> : __is_fast_hash<hash<_Tp>>
+    { };
+
+
+
+
+  template <typename _Tp> optional(_Tp) -> optional<_Tp>;
+
+
+
+}
+# 40 "/usr/include/c++/10.2.0/bits/node_handle.h" 2 3
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+  template<typename _Val, typename _NodeAlloc>
+    class _Node_handle_common
+    {
+      using _AllocTraits = allocator_traits<_NodeAlloc>;
+
+    public:
+      using allocator_type = __alloc_rebind<_NodeAlloc, _Val>;
+
+      allocator_type
+      get_allocator() const noexcept
+      {
+ ;
+ return allocator_type(*_M_alloc);
+      }
+
+      explicit operator bool() const noexcept { return _M_ptr != nullptr; }
+
+      [[nodiscard]] bool empty() const noexcept { return _M_ptr == nullptr; }
+
+    protected:
+      constexpr _Node_handle_common() noexcept : _M_ptr(), _M_alloc() {}
+
+      ~_Node_handle_common() { _M_destroy(); }
+
+      _Node_handle_common(_Node_handle_common&& __nh) noexcept
+      : _M_ptr(__nh._M_ptr), _M_alloc(std::move(__nh._M_alloc))
+      {
+ __nh._M_ptr = nullptr;
+ __nh._M_alloc = nullopt;
+      }
+
+      _Node_handle_common&
+      operator=(_Node_handle_common&& __nh) noexcept
+      {
+ _M_destroy();
+ _M_ptr = __nh._M_ptr;
+ if constexpr (is_move_assignable_v<_NodeAlloc>)
+   {
+     if (_AllocTraits::propagate_on_container_move_assignment::value
+  || !this->_M_alloc)
+       this->_M_alloc = std::move(__nh._M_alloc);
+     else
+       {
+  ;
+       }
+   }
+ else
+   {
+     ;
+   }
+ __nh._M_ptr = nullptr;
+ __nh._M_alloc = nullopt;
+ return *this;
+      }
+
+      _Node_handle_common(typename _AllocTraits::pointer __ptr,
+     const _NodeAlloc& __alloc)
+      : _M_ptr(__ptr), _M_alloc(__alloc) { }
+
+      void
+      _M_swap(_Node_handle_common& __nh) noexcept
+      {
+ using std::swap;
+ swap(_M_ptr, __nh._M_ptr);
+ if (_AllocTraits::propagate_on_container_swap::value
+     || !_M_alloc || !__nh._M_alloc)
+   _M_alloc.swap(__nh._M_alloc);
+ else
+   {
+     ;
+   }
+      }
+
+    private:
+      void
+      _M_destroy() noexcept
+      {
+ if (_M_ptr != nullptr)
+   {
+     allocator_type __alloc(*_M_alloc);
+     allocator_traits<allocator_type>::destroy(__alloc,
+            _M_ptr->_M_valptr());
+     _AllocTraits::deallocate(*_M_alloc, _M_ptr, 1);
+   }
+      }
+
+    protected:
+      typename _AllocTraits::pointer _M_ptr;
+    private:
+      optional<_NodeAlloc> _M_alloc;
+
+      template<typename _Key2, typename _Value2, typename _KeyOfValue,
+        typename _Compare, typename _ValueAlloc>
+ friend class _Rb_tree;
+    };
+
+
+  template<typename _Key, typename _Value, typename _NodeAlloc>
+    class _Node_handle : public _Node_handle_common<_Value, _NodeAlloc>
+    {
+    public:
+      constexpr _Node_handle() noexcept = default;
+      ~_Node_handle() = default;
+      _Node_handle(_Node_handle&&) noexcept = default;
+
+      _Node_handle&
+      operator=(_Node_handle&&) noexcept = default;
+
+      using key_type = _Key;
+      using mapped_type = typename _Value::second_type;
+
+      key_type&
+      key() const noexcept
+      {
+ ;
+ return *_M_pkey;
+      }
+
+      mapped_type&
+      mapped() const noexcept
+      {
+ ;
+ return *_M_pmapped;
+      }
+
+      void
+      swap(_Node_handle& __nh) noexcept
+      {
+ this->_M_swap(__nh);
+ using std::swap;
+ swap(_M_pkey, __nh._M_pkey);
+ swap(_M_pmapped, __nh._M_pmapped);
+      }
+
+      friend void
+      swap(_Node_handle& __x, _Node_handle& __y)
+      noexcept(noexcept(__x.swap(__y)))
+      { __x.swap(__y); }
+
+    private:
+      using _AllocTraits = allocator_traits<_NodeAlloc>;
+
+      _Node_handle(typename _AllocTraits::pointer __ptr,
+     const _NodeAlloc& __alloc)
+      : _Node_handle_common<_Value, _NodeAlloc>(__ptr, __alloc)
+      {
+ if (__ptr)
+   {
+     auto& __key = const_cast<_Key&>(__ptr->_M_valptr()->first);
+     _M_pkey = _S_pointer_to(__key);
+     _M_pmapped = _S_pointer_to(__ptr->_M_valptr()->second);
+   }
+ else
+   {
+     _M_pkey = nullptr;
+     _M_pmapped = nullptr;
+   }
+      }
+
+      template<typename _Tp>
+ using __pointer
+   = __ptr_rebind<typename _AllocTraits::pointer,
+    remove_reference_t<_Tp>>;
+
+      __pointer<_Key> _M_pkey = nullptr;
+      __pointer<typename _Value::second_type> _M_pmapped = nullptr;
+
+      template<typename _Tp>
+ __pointer<_Tp>
+ _S_pointer_to(_Tp& __obj)
+ { return pointer_traits<__pointer<_Tp>>::pointer_to(__obj); }
+
+      const key_type&
+      _M_key() const noexcept { return key(); }
+
+      template<typename _Key2, typename _Value2, typename _KeyOfValue,
+        typename _Compare, typename _ValueAlloc>
+ friend class _Rb_tree;
+
+      template<typename _Key2, typename _Value2, typename _ValueAlloc,
+        typename _ExtractKey, typename _Equal,
+        typename _H1, typename _H2, typename _Hash,
+        typename _RehashPolicy, typename _Traits>
+ friend class _Hashtable;
+    };
+
+
+  template<typename _Value, typename _NodeAlloc>
+    class _Node_handle<_Value, _Value, _NodeAlloc>
+    : public _Node_handle_common<_Value, _NodeAlloc>
+    {
+    public:
+      constexpr _Node_handle() noexcept = default;
+      ~_Node_handle() = default;
+      _Node_handle(_Node_handle&&) noexcept = default;
+
+      _Node_handle&
+      operator=(_Node_handle&&) noexcept = default;
+
+      using value_type = _Value;
+
+      value_type&
+      value() const noexcept
+      {
+ ;
+ return *this->_M_ptr->_M_valptr();
+      }
+
+      void
+      swap(_Node_handle& __nh) noexcept
+      { this->_M_swap(__nh); }
+
+      friend void
+      swap(_Node_handle& __x, _Node_handle& __y)
+      noexcept(noexcept(__x.swap(__y)))
+      { __x.swap(__y); }
+
+    private:
+      using _AllocTraits = allocator_traits<_NodeAlloc>;
+
+      _Node_handle(typename _AllocTraits::pointer __ptr,
+     const _NodeAlloc& __alloc)
+      : _Node_handle_common<_Value, _NodeAlloc>(__ptr, __alloc) { }
+
+      const value_type&
+      _M_key() const noexcept { return value(); }
+
+      template<typename _Key, typename _Val, typename _KeyOfValue,
+        typename _Compare, typename _Alloc>
+ friend class _Rb_tree;
+
+      template<typename _Key2, typename _Value2, typename _ValueAlloc,
+        typename _ExtractKey, typename _Equal,
+        typename _H1, typename _H2, typename _Hash,
+        typename _RehashPolicy, typename _Traits>
+ friend class _Hashtable;
+    };
+
+
+  template<typename _Iterator, typename _NodeHandle>
+    struct _Node_insert_return
+    {
+      _Iterator position = _Iterator();
+      bool inserted = false;
+      _NodeHandle node;
+    };
+
+
+}
+# 38 "/usr/include/c++/10.2.0/bits/hashtable.h" 2 3
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  template<typename _Tp, typename _Hash>
+    using __cache_default
+      = __not_<__and_<
+         __is_fast_hash<_Hash>,
+
+         __is_nothrow_invocable<const _Hash&, const _Tp&>>>;
+# 169 "/usr/include/c++/10.2.0/bits/hashtable.h" 3
+  template<typename _Key, typename _Value, typename _Alloc,
+    typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits>
+    class _Hashtable
+    : public __detail::_Hashtable_base<_Key, _Value, _ExtractKey, _Equal,
+           _H1, _H2, _Hash, _Traits>,
+      public __detail::_Map_base<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+     _H1, _H2, _Hash, _RehashPolicy, _Traits>,
+      public __detail::_Insert<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+          _H1, _H2, _Hash, _RehashPolicy, _Traits>,
+      public __detail::_Rehash_base<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>,
+      public __detail::_Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+     _H1, _H2, _Hash, _RehashPolicy, _Traits>,
+      private __detail::_Hashtable_alloc<
+ __alloc_rebind<_Alloc,
+         __detail::_Hash_node<_Value,
+         _Traits::__hash_cached::value>>>
+    {
+      static_assert(is_same<typename remove_cv<_Value>::type, _Value>::value,
+   "unordered container must have a non-const, non-volatile value_type");
+
+      static_assert(is_same<typename _Alloc::value_type, _Value>{},
+   "unordered container must have the same value_type as its allocator");
+
+
+      using __traits_type = _Traits;
+      using __hash_cached = typename __traits_type::__hash_cached;
+      using __node_type = __detail::_Hash_node<_Value, __hash_cached::value>;
+      using __node_alloc_type = __alloc_rebind<_Alloc, __node_type>;
+
+      using __hashtable_alloc = __detail::_Hashtable_alloc<__node_alloc_type>;
+
+      using __value_alloc_traits =
+ typename __hashtable_alloc::__value_alloc_traits;
+      using __node_alloc_traits =
+ typename __hashtable_alloc::__node_alloc_traits;
+      using __node_base = typename __hashtable_alloc::__node_base;
+      using __bucket_type = typename __hashtable_alloc::__bucket_type;
+
+    public:
+      typedef _Key key_type;
+      typedef _Value value_type;
+      typedef _Alloc allocator_type;
+      typedef _Equal key_equal;
+
+
+
+      typedef typename __value_alloc_traits::pointer pointer;
+      typedef typename __value_alloc_traits::const_pointer const_pointer;
+      typedef value_type& reference;
+      typedef const value_type& const_reference;
+
+    private:
+      using __rehash_type = _RehashPolicy;
+      using __rehash_state = typename __rehash_type::_State;
+
+      using __constant_iterators = typename __traits_type::__constant_iterators;
+      using __unique_keys = typename __traits_type::__unique_keys;
+
+      using __key_extract = typename std::conditional<
+          __constant_iterators::value,
+                 __detail::_Identity,
+          __detail::_Select1st>::type;
+
+      using __hashtable_base = __detail::
+          _Hashtable_base<_Key, _Value, _ExtractKey,
+           _Equal, _H1, _H2, _Hash, _Traits>;
+
+      using __hash_code_base = typename __hashtable_base::__hash_code_base;
+      using __hash_code = typename __hashtable_base::__hash_code;
+      using __ireturn_type = typename __hashtable_base::__ireturn_type;
+
+      using __map_base = __detail::_Map_base<_Key, _Value, _Alloc, _ExtractKey,
+          _Equal, _H1, _H2, _Hash,
+          _RehashPolicy, _Traits>;
+
+      using __rehash_base = __detail::_Rehash_base<_Key, _Value, _Alloc,
+         _ExtractKey, _Equal,
+         _H1, _H2, _Hash,
+         _RehashPolicy, _Traits>;
+
+      using __eq_base = __detail::_Equality<_Key, _Value, _Alloc, _ExtractKey,
+         _Equal, _H1, _H2, _Hash,
+         _RehashPolicy, _Traits>;
+
+      using __reuse_or_alloc_node_gen_t =
+ __detail::_ReuseOrAllocNode<__node_alloc_type>;
+      using __alloc_node_gen_t =
+ __detail::_AllocNode<__node_alloc_type>;
+
+
+      struct _Scoped_node
+      {
+
+ _Scoped_node(__node_type* __n, __hashtable_alloc* __h)
+ : _M_h(__h), _M_node(__n) { }
+
+
+ template<typename... _Args>
+   _Scoped_node(__hashtable_alloc* __h, _Args&&... __args)
+   : _M_h(__h),
+     _M_node(__h->_M_allocate_node(std::forward<_Args>(__args)...))
+   { }
+
+
+ ~_Scoped_node() { if (_M_node) _M_h->_M_deallocate_node(_M_node); };
+
+ _Scoped_node(const _Scoped_node&) = delete;
+ _Scoped_node& operator=(const _Scoped_node&) = delete;
+
+ __hashtable_alloc* _M_h;
+ __node_type* _M_node;
+      };
+
+      template<typename _Ht>
+ static constexpr
+ typename conditional<std::is_lvalue_reference<_Ht>::value,
+        const value_type&, value_type&&>::type
+ __fwd_value_for(value_type& __val) noexcept
+ { return std::move(__val); }
+
+
+      template<typename _Cond>
+ using __if_hash_cached = __or_<__not_<__hash_cached>, _Cond>;
+
+      template<typename _Cond>
+ using __if_hash_not_cached = __or_<__hash_cached, _Cond>;
+
+
+
+
+
+      struct __hash_code_base_access : __hash_code_base
+      { using __hash_code_base::_M_bucket_index; };
+
+
+
+      static_assert(noexcept(declval<const __hash_code_base_access&>()
+        ._M_bucket_index((const __node_type*)nullptr,
+           (std::size_t)0)),
+      "Cache the hash code or qualify your functors involved"
+      " in hash code and bucket index computation with noexcept");
+
+
+
+      static_assert(__if_hash_cached<is_default_constructible<_H2>>::value,
+      "Functor used to map hash code to bucket index"
+      " must be default constructible");
+
+      template<typename _Keya, typename _Valuea, typename _Alloca,
+        typename _ExtractKeya, typename _Equala,
+        typename _H1a, typename _H2a, typename _Hasha,
+        typename _RehashPolicya, typename _Traitsa,
+        bool _Unique_keysa>
+ friend struct __detail::_Map_base;
+
+      template<typename _Keya, typename _Valuea, typename _Alloca,
+        typename _ExtractKeya, typename _Equala,
+        typename _H1a, typename _H2a, typename _Hasha,
+        typename _RehashPolicya, typename _Traitsa>
+ friend struct __detail::_Insert_base;
+
+      template<typename _Keya, typename _Valuea, typename _Alloca,
+        typename _ExtractKeya, typename _Equala,
+        typename _H1a, typename _H2a, typename _Hasha,
+        typename _RehashPolicya, typename _Traitsa,
+        bool _Constant_iteratorsa>
+ friend struct __detail::_Insert;
+
+      template<typename _Keya, typename _Valuea, typename _Alloca,
+        typename _ExtractKeya, typename _Equala,
+        typename _H1a, typename _H2a, typename _Hasha,
+        typename _RehashPolicya, typename _Traitsa,
+        bool _Unique_keysa>
+ friend struct __detail::_Equality;
+
+    public:
+      using size_type = typename __hashtable_base::size_type;
+      using difference_type = typename __hashtable_base::difference_type;
+
+      using iterator = typename __hashtable_base::iterator;
+      using const_iterator = typename __hashtable_base::const_iterator;
+
+      using local_iterator = typename __hashtable_base::local_iterator;
+      using const_local_iterator = typename __hashtable_base::
+       const_local_iterator;
+
+
+      using node_type = _Node_handle<_Key, _Value, __node_alloc_type>;
+      using insert_return_type = _Node_insert_return<iterator, node_type>;
+
+
+    private:
+      __bucket_type* _M_buckets = &_M_single_bucket;
+      size_type _M_bucket_count = 1;
+      __node_base _M_before_begin;
+      size_type _M_element_count = 0;
+      _RehashPolicy _M_rehash_policy;
+
+
+
+
+
+
+
+      __bucket_type _M_single_bucket = nullptr;
+
+      bool
+      _M_uses_single_bucket(__bucket_type* __bkts) const
+      { return __builtin_expect(__bkts == &_M_single_bucket, false); }
+
+      bool
+      _M_uses_single_bucket() const
+      { return _M_uses_single_bucket(_M_buckets); }
+
+      __hashtable_alloc&
+      _M_base_alloc() { return *this; }
+
+      __bucket_type*
+      _M_allocate_buckets(size_type __bkt_count)
+      {
+ if (__builtin_expect(__bkt_count == 1, false))
+   {
+     _M_single_bucket = nullptr;
+     return &_M_single_bucket;
+   }
+
+ return __hashtable_alloc::_M_allocate_buckets(__bkt_count);
+      }
+
+      void
+      _M_deallocate_buckets(__bucket_type* __bkts, size_type __bkt_count)
+      {
+ if (_M_uses_single_bucket(__bkts))
+   return;
+
+ __hashtable_alloc::_M_deallocate_buckets(__bkts, __bkt_count);
+      }
+
+      void
+      _M_deallocate_buckets()
+      { _M_deallocate_buckets(_M_buckets, _M_bucket_count); }
+
+
+
+      __node_type*
+      _M_bucket_begin(size_type __bkt) const;
+
+      __node_type*
+      _M_begin() const
+      { return static_cast<__node_type*>(_M_before_begin._M_nxt); }
+
+
+
+      template<typename _Ht>
+ void
+ _M_assign_elements(_Ht&&);
+
+      template<typename _Ht, typename _NodeGenerator>
+ void
+ _M_assign(_Ht&&, const _NodeGenerator&);
+
+      void
+      _M_move_assign(_Hashtable&&, true_type);
+
+      void
+      _M_move_assign(_Hashtable&&, false_type);
+
+      void
+      _M_reset() noexcept;
+
+      _Hashtable(const _H1& __h1, const _H2& __h2, const _Hash& __h,
+   const _Equal& __eq, const _ExtractKey& __exk,
+   const allocator_type& __a)
+      : __hashtable_base(__exk, __h1, __h2, __h, __eq),
+ __hashtable_alloc(__node_alloc_type(__a))
+      { }
+
+    public:
+
+      _Hashtable() = default;
+      _Hashtable(size_type __bkt_count_hint,
+   const _H1&, const _H2&, const _Hash&,
+   const _Equal&, const _ExtractKey&,
+   const allocator_type&);
+
+      template<typename _InputIterator>
+ _Hashtable(_InputIterator __first, _InputIterator __last,
+     size_type __bkt_count_hint,
+     const _H1&, const _H2&, const _Hash&,
+     const _Equal&, const _ExtractKey&,
+     const allocator_type&);
+
+      _Hashtable(const _Hashtable&);
+
+      _Hashtable(_Hashtable&&) noexcept;
+
+      _Hashtable(const _Hashtable&, const allocator_type&);
+
+      _Hashtable(_Hashtable&&, const allocator_type&);
+
+
+      explicit
+      _Hashtable(const allocator_type& __a)
+      : __hashtable_alloc(__node_alloc_type(__a))
+      { }
+
+      explicit
+      _Hashtable(size_type __bkt_count_hint,
+   const _H1& __hf = _H1(),
+   const key_equal& __eql = key_equal(),
+   const allocator_type& __a = allocator_type())
+      : _Hashtable(__bkt_count_hint, __hf, _H2(), _Hash(), __eql,
+     __key_extract(), __a)
+      { }
+
+      template<typename _InputIterator>
+ _Hashtable(_InputIterator __f, _InputIterator __l,
+     size_type __bkt_count_hint = 0,
+     const _H1& __hf = _H1(),
+     const key_equal& __eql = key_equal(),
+     const allocator_type& __a = allocator_type())
+ : _Hashtable(__f, __l, __bkt_count_hint, __hf, _H2(), _Hash(), __eql,
+       __key_extract(), __a)
+ { }
+
+      _Hashtable(initializer_list<value_type> __l,
+   size_type __bkt_count_hint = 0,
+   const _H1& __hf = _H1(),
+   const key_equal& __eql = key_equal(),
+   const allocator_type& __a = allocator_type())
+      : _Hashtable(__l.begin(), __l.end(), __bkt_count_hint,
+     __hf, _H2(), _Hash(), __eql,
+     __key_extract(), __a)
+      { }
+
+      _Hashtable&
+      operator=(const _Hashtable& __ht);
+
+      _Hashtable&
+      operator=(_Hashtable&& __ht)
+      noexcept(__node_alloc_traits::_S_nothrow_move()
+        && is_nothrow_move_assignable<_H1>::value
+        && is_nothrow_move_assignable<_Equal>::value)
+      {
+        constexpr bool __move_storage =
+   __node_alloc_traits::_S_propagate_on_move_assign()
+   || __node_alloc_traits::_S_always_equal();
+ _M_move_assign(std::move(__ht), __bool_constant<__move_storage>());
+ return *this;
+      }
+
+      _Hashtable&
+      operator=(initializer_list<value_type> __l)
+      {
+ __reuse_or_alloc_node_gen_t __roan(_M_begin(), *this);
+ _M_before_begin._M_nxt = nullptr;
+ clear();
+ this->_M_insert_range(__l.begin(), __l.end(), __roan, __unique_keys());
+ return *this;
+      }
+
+      ~_Hashtable() noexcept;
+
+      void
+      swap(_Hashtable&)
+      noexcept(__and_<__is_nothrow_swappable<_H1>,
+                   __is_nothrow_swappable<_Equal>>::value);
+
+
+      iterator
+      begin() noexcept
+      { return iterator(_M_begin()); }
+
+      const_iterator
+      begin() const noexcept
+      { return const_iterator(_M_begin()); }
+
+      iterator
+      end() noexcept
+      { return iterator(nullptr); }
+
+      const_iterator
+      end() const noexcept
+      { return const_iterator(nullptr); }
+
+      const_iterator
+      cbegin() const noexcept
+      { return const_iterator(_M_begin()); }
+
+      const_iterator
+      cend() const noexcept
+      { return const_iterator(nullptr); }
+
+      size_type
+      size() const noexcept
+      { return _M_element_count; }
+
+      [[__nodiscard__]] bool
+      empty() const noexcept
+      { return size() == 0; }
+
+      allocator_type
+      get_allocator() const noexcept
+      { return allocator_type(this->_M_node_allocator()); }
+
+      size_type
+      max_size() const noexcept
+      { return __node_alloc_traits::max_size(this->_M_node_allocator()); }
+
+
+      key_equal
+      key_eq() const
+      { return this->_M_eq(); }
+
+
+
+
+      size_type
+      bucket_count() const noexcept
+      { return _M_bucket_count; }
+
+      size_type
+      max_bucket_count() const noexcept
+      { return max_size(); }
+
+      size_type
+      bucket_size(size_type __bkt) const
+      { return std::distance(begin(__bkt), end(__bkt)); }
+
+      size_type
+      bucket(const key_type& __k) const
+      { return _M_bucket_index(__k, this->_M_hash_code(__k)); }
+
+      local_iterator
+      begin(size_type __bkt)
+      {
+ return local_iterator(*this, _M_bucket_begin(__bkt),
+         __bkt, _M_bucket_count);
+      }
+
+      local_iterator
+      end(size_type __bkt)
+      { return local_iterator(*this, nullptr, __bkt, _M_bucket_count); }
+
+      const_local_iterator
+      begin(size_type __bkt) const
+      {
+ return const_local_iterator(*this, _M_bucket_begin(__bkt),
+        __bkt, _M_bucket_count);
+      }
+
+      const_local_iterator
+      end(size_type __bkt) const
+      { return const_local_iterator(*this, nullptr, __bkt, _M_bucket_count); }
+
+
+      const_local_iterator
+      cbegin(size_type __bkt) const
+      {
+ return const_local_iterator(*this, _M_bucket_begin(__bkt),
+        __bkt, _M_bucket_count);
+      }
+
+      const_local_iterator
+      cend(size_type __bkt) const
+      { return const_local_iterator(*this, nullptr, __bkt, _M_bucket_count); }
+
+      float
+      load_factor() const noexcept
+      {
+ return static_cast<float>(size()) / static_cast<float>(bucket_count());
+      }
+
+
+
+
+
+
+      const _RehashPolicy&
+      __rehash_policy() const
+      { return _M_rehash_policy; }
+
+      void
+      __rehash_policy(const _RehashPolicy& __pol)
+      { _M_rehash_policy = __pol; }
+
+
+      iterator
+      find(const key_type& __k);
+
+      const_iterator
+      find(const key_type& __k) const;
+
+      size_type
+      count(const key_type& __k) const;
+
+      std::pair<iterator, iterator>
+      equal_range(const key_type& __k);
+
+      std::pair<const_iterator, const_iterator>
+      equal_range(const key_type& __k) const;
+
+    protected:
+
+      size_type
+      _M_bucket_index(__node_type* __n) const noexcept
+      { return __hash_code_base::_M_bucket_index(__n, _M_bucket_count); }
+
+      size_type
+      _M_bucket_index(const key_type& __k, __hash_code __c) const
+      { return __hash_code_base::_M_bucket_index(__k, __c, _M_bucket_count); }
+
+
+
+      __node_base*
+      _M_find_before_node(size_type, const key_type&, __hash_code) const;
+
+      __node_type*
+      _M_find_node(size_type __bkt, const key_type& __key,
+     __hash_code __c) const
+      {
+ __node_base* __before_n = _M_find_before_node(__bkt, __key, __c);
+ if (__before_n)
+   return static_cast<__node_type*>(__before_n->_M_nxt);
+ return nullptr;
+      }
+
+
+      void
+      _M_insert_bucket_begin(size_type, __node_type*);
+
+
+      void
+      _M_remove_bucket_begin(size_type __bkt, __node_type* __next_n,
+        size_type __next_bkt);
+
+
+      __node_base*
+      _M_get_previous_node(size_type __bkt, __node_base* __n);
+
+
+
+
+      iterator
+      _M_insert_unique_node(const key_type& __k, size_type __bkt,
+       __hash_code __code, __node_type* __n,
+       size_type __n_elt = 1);
+
+
+
+      iterator
+      _M_insert_multi_node(__node_type* __hint, const key_type& __k,
+      __hash_code __code, __node_type* __n);
+
+      template<typename... _Args>
+ std::pair<iterator, bool>
+ _M_emplace(true_type, _Args&&... __args);
+
+      template<typename... _Args>
+ iterator
+ _M_emplace(false_type __uk, _Args&&... __args)
+ { return _M_emplace(cend(), __uk, std::forward<_Args>(__args)...); }
+
+
+      template<typename... _Args>
+ iterator
+ _M_emplace(const_iterator, true_type __uk, _Args&&... __args)
+ { return _M_emplace(__uk, std::forward<_Args>(__args)...).first; }
+
+      template<typename... _Args>
+ iterator
+ _M_emplace(const_iterator, false_type, _Args&&... __args);
+
+      template<typename _Arg, typename _NodeGenerator>
+ std::pair<iterator, bool>
+ _M_insert(_Arg&&, const _NodeGenerator&, true_type, size_type = 1);
+
+      template<typename _Arg, typename _NodeGenerator>
+ iterator
+ _M_insert(_Arg&& __arg, const _NodeGenerator& __node_gen,
+    false_type __uk)
+ {
+   return _M_insert(cend(), std::forward<_Arg>(__arg), __node_gen,
+      __uk);
+ }
+
+
+      template<typename _Arg, typename _NodeGenerator>
+ iterator
+ _M_insert(const_iterator, _Arg&& __arg,
+    const _NodeGenerator& __node_gen, true_type __uk)
+ {
+   return
+     _M_insert(std::forward<_Arg>(__arg), __node_gen, __uk).first;
+ }
+
+
+      template<typename _Arg, typename _NodeGenerator>
+ iterator
+ _M_insert(const_iterator, _Arg&&,
+    const _NodeGenerator&, false_type);
+
+      size_type
+      _M_erase(true_type, const key_type&);
+
+      size_type
+      _M_erase(false_type, const key_type&);
+
+      iterator
+      _M_erase(size_type __bkt, __node_base* __prev_n, __node_type* __n);
+
+    public:
+
+      template<typename... _Args>
+ __ireturn_type
+ emplace(_Args&&... __args)
+ { return _M_emplace(__unique_keys(), std::forward<_Args>(__args)...); }
+
+      template<typename... _Args>
+ iterator
+ emplace_hint(const_iterator __hint, _Args&&... __args)
+ {
+   return _M_emplace(__hint, __unique_keys(),
+       std::forward<_Args>(__args)...);
+ }
+
+
+
+
+      iterator
+      erase(const_iterator);
+
+
+      iterator
+      erase(iterator __it)
+      { return erase(const_iterator(__it)); }
+
+      size_type
+      erase(const key_type& __k)
+      { return _M_erase(__unique_keys(), __k); }
+
+      iterator
+      erase(const_iterator, const_iterator);
+
+      void
+      clear() noexcept;
+
+
+
+      void rehash(size_type __bkt_count);
+
+
+
+
+
+
+      insert_return_type
+      _M_reinsert_node(node_type&& __nh)
+      {
+ insert_return_type __ret;
+ if (__nh.empty())
+   __ret.position = end();
+ else
+   {
+     ;
+
+     const key_type& __k = __nh._M_key();
+     __hash_code __code = this->_M_hash_code(__k);
+     size_type __bkt = _M_bucket_index(__k, __code);
+     if (__node_type* __n = _M_find_node(__bkt, __k, __code))
+       {
+  __ret.node = std::move(__nh);
+  __ret.position = iterator(__n);
+  __ret.inserted = false;
+       }
+     else
+       {
+  __ret.position
+    = _M_insert_unique_node(__k, __bkt, __code, __nh._M_ptr);
+  __nh._M_ptr = nullptr;
+  __ret.inserted = true;
+       }
+   }
+ return __ret;
+      }
+
+
+      iterator
+      _M_reinsert_node_multi(const_iterator __hint, node_type&& __nh)
+      {
+ if (__nh.empty())
+   return end();
+
+ ;
+
+ const key_type& __k = __nh._M_key();
+ auto __code = this->_M_hash_code(__k);
+ auto __ret
+   = _M_insert_multi_node(__hint._M_cur, __k, __code, __nh._M_ptr);
+ __nh._M_ptr = nullptr;
+ return __ret;
+      }
+
+    private:
+      node_type
+      _M_extract_node(size_t __bkt, __node_base* __prev_n)
+      {
+ __node_type* __n = static_cast<__node_type*>(__prev_n->_M_nxt);
+ if (__prev_n == _M_buckets[__bkt])
+   _M_remove_bucket_begin(__bkt, __n->_M_next(),
+      __n->_M_nxt ? _M_bucket_index(__n->_M_next()) : 0);
+ else if (__n->_M_nxt)
+   {
+     size_type __next_bkt = _M_bucket_index(__n->_M_next());
+     if (__next_bkt != __bkt)
+       _M_buckets[__next_bkt] = __prev_n;
+   }
+
+ __prev_n->_M_nxt = __n->_M_nxt;
+ __n->_M_nxt = nullptr;
+ --_M_element_count;
+ return { __n, this->_M_node_allocator() };
+      }
+
+    public:
+
+      node_type
+      extract(const_iterator __pos)
+      {
+ size_t __bkt = _M_bucket_index(__pos._M_cur);
+ return _M_extract_node(__bkt,
+          _M_get_previous_node(__bkt, __pos._M_cur));
+      }
+
+
+      node_type
+      extract(const _Key& __k)
+      {
+ node_type __nh;
+ __hash_code __code = this->_M_hash_code(__k);
+ std::size_t __bkt = _M_bucket_index(__k, __code);
+ if (__node_base* __prev_node = _M_find_before_node(__bkt, __k, __code))
+   __nh = _M_extract_node(__bkt, __prev_node);
+ return __nh;
+      }
+
+
+      template<typename _Compatible_Hashtable>
+ void
+ _M_merge_unique(_Compatible_Hashtable& __src) noexcept
+ {
+   static_assert(is_same_v<typename _Compatible_Hashtable::node_type,
+       node_type>, "Node types are compatible");
+   ;
+
+   auto __n_elt = __src.size();
+   for (auto __i = __src.begin(), __end = __src.end(); __i != __end;)
+     {
+       auto __pos = __i++;
+       const key_type& __k = this->_M_extract()(*__pos);
+       __hash_code __code = this->_M_hash_code(__k);
+       size_type __bkt = _M_bucket_index(__k, __code);
+       if (_M_find_node(__bkt, __k, __code) == nullptr)
+  {
+    auto __nh = __src.extract(__pos);
+    _M_insert_unique_node(__k, __bkt, __code, __nh._M_ptr,
+     __n_elt);
+    __nh._M_ptr = nullptr;
+    __n_elt = 1;
+  }
+       else if (__n_elt != 1)
+  --__n_elt;
+     }
+ }
+
+
+      template<typename _Compatible_Hashtable>
+ void
+ _M_merge_multi(_Compatible_Hashtable& __src) noexcept
+ {
+   static_assert(is_same_v<typename _Compatible_Hashtable::node_type,
+       node_type>, "Node types are compatible");
+   ;
+
+   this->reserve(size() + __src.size());
+   for (auto __i = __src.begin(), __end = __src.end(); __i != __end;)
+     _M_reinsert_node_multi(cend(), __src.extract(__i++));
+ }
+
+
+    private:
+
+      void _M_rehash_aux(size_type __bkt_count, true_type);
+
+
+      void _M_rehash_aux(size_type __bkt_count, false_type);
+
+
+
+      void _M_rehash(size_type __bkt_count, const __rehash_state& __state);
+    };
+
+
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    auto
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _M_bucket_begin(size_type __bkt) const
+    -> __node_type*
+    {
+      __node_base* __n = _M_buckets[__bkt];
+      return __n ? static_cast<__node_type*>(__n->_M_nxt) : nullptr;
+    }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _Hashtable(size_type __bkt_count_hint,
+        const _H1& __h1, const _H2& __h2, const _Hash& __h,
+        const _Equal& __eq, const _ExtractKey& __exk,
+        const allocator_type& __a)
+    : _Hashtable(__h1, __h2, __h, __eq, __exk, __a)
+    {
+      auto __bkt_count = _M_rehash_policy._M_next_bkt(__bkt_count_hint);
+      if (__bkt_count > _M_bucket_count)
+ {
+   _M_buckets = _M_allocate_buckets(__bkt_count);
+   _M_bucket_count = __bkt_count;
+ }
+    }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    template<typename _InputIterator>
+      _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+   _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+      _Hashtable(_InputIterator __f, _InputIterator __l,
+   size_type __bkt_count_hint,
+   const _H1& __h1, const _H2& __h2, const _Hash& __h,
+   const _Equal& __eq, const _ExtractKey& __exk,
+   const allocator_type& __a)
+      : _Hashtable(__h1, __h2, __h, __eq, __exk, __a)
+      {
+ auto __nb_elems = __detail::__distance_fw(__f, __l);
+ auto __bkt_count =
+   _M_rehash_policy._M_next_bkt(
+     std::max(_M_rehash_policy._M_bkt_for_elements(__nb_elems),
+       __bkt_count_hint));
+
+ if (__bkt_count > _M_bucket_count)
+   {
+     _M_buckets = _M_allocate_buckets(__bkt_count);
+     _M_bucket_count = __bkt_count;
+   }
+
+ for (; __f != __l; ++__f)
+   this->insert(*__f);
+      }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    auto
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    operator=(const _Hashtable& __ht)
+    -> _Hashtable&
+    {
+      if (&__ht == this)
+ return *this;
+
+      if (__node_alloc_traits::_S_propagate_on_copy_assign())
+ {
+   auto& __this_alloc = this->_M_node_allocator();
+   auto& __that_alloc = __ht._M_node_allocator();
+   if (!__node_alloc_traits::_S_always_equal()
+       && __this_alloc != __that_alloc)
+     {
+
+       this->_M_deallocate_nodes(_M_begin());
+       _M_before_begin._M_nxt = nullptr;
+       _M_deallocate_buckets();
+       _M_buckets = nullptr;
+       std::__alloc_on_copy(__this_alloc, __that_alloc);
+       __hashtable_base::operator=(__ht);
+       _M_bucket_count = __ht._M_bucket_count;
+       _M_element_count = __ht._M_element_count;
+       _M_rehash_policy = __ht._M_rehash_policy;
+       __alloc_node_gen_t __alloc_node_gen(*this);
+       try
+  {
+    _M_assign(__ht, __alloc_node_gen);
+  }
+       catch(...)
+  {
+
+
+    _M_reset();
+    throw;
+  }
+       return *this;
+     }
+   std::__alloc_on_copy(__this_alloc, __that_alloc);
+ }
+
+
+      _M_assign_elements(__ht);
+      return *this;
+    }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    template<typename _Ht>
+      void
+      _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+   _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+      _M_assign_elements(_Ht&& __ht)
+      {
+ __bucket_type* __former_buckets = nullptr;
+ std::size_t __former_bucket_count = _M_bucket_count;
+ const __rehash_state& __former_state = _M_rehash_policy._M_state();
+
+ if (_M_bucket_count != __ht._M_bucket_count)
+   {
+     __former_buckets = _M_buckets;
+     _M_buckets = _M_allocate_buckets(__ht._M_bucket_count);
+     _M_bucket_count = __ht._M_bucket_count;
+   }
+ else
+   __builtin_memset(_M_buckets, 0,
+      _M_bucket_count * sizeof(__bucket_type));
+
+ try
+   {
+     __hashtable_base::operator=(std::forward<_Ht>(__ht));
+     _M_element_count = __ht._M_element_count;
+     _M_rehash_policy = __ht._M_rehash_policy;
+     __reuse_or_alloc_node_gen_t __roan(_M_begin(), *this);
+     _M_before_begin._M_nxt = nullptr;
+     _M_assign(std::forward<_Ht>(__ht), __roan);
+     if (__former_buckets)
+       _M_deallocate_buckets(__former_buckets, __former_bucket_count);
+   }
+ catch(...)
+   {
+     if (__former_buckets)
+       {
+
+  _M_deallocate_buckets();
+  _M_rehash_policy._M_reset(__former_state);
+  _M_buckets = __former_buckets;
+  _M_bucket_count = __former_bucket_count;
+       }
+     __builtin_memset(_M_buckets, 0,
+        _M_bucket_count * sizeof(__bucket_type));
+     throw;
+   }
+      }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    template<typename _Ht, typename _NodeGenerator>
+      void
+      _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+   _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+      _M_assign(_Ht&& __ht, const _NodeGenerator& __node_gen)
+      {
+ __bucket_type* __buckets = nullptr;
+ if (!_M_buckets)
+   _M_buckets = __buckets = _M_allocate_buckets(_M_bucket_count);
+
+ try
+   {
+     if (!__ht._M_before_begin._M_nxt)
+       return;
+
+
+
+     __node_type* __ht_n = __ht._M_begin();
+     __node_type* __this_n
+       = __node_gen(__fwd_value_for<_Ht>(__ht_n->_M_v()));
+     this->_M_copy_code(__this_n, __ht_n);
+     _M_before_begin._M_nxt = __this_n;
+     _M_buckets[_M_bucket_index(__this_n)] = &_M_before_begin;
+
+
+     __node_base* __prev_n = __this_n;
+     for (__ht_n = __ht_n->_M_next(); __ht_n; __ht_n = __ht_n->_M_next())
+       {
+  __this_n = __node_gen(__fwd_value_for<_Ht>(__ht_n->_M_v()));
+  __prev_n->_M_nxt = __this_n;
+  this->_M_copy_code(__this_n, __ht_n);
+  size_type __bkt = _M_bucket_index(__this_n);
+  if (!_M_buckets[__bkt])
+    _M_buckets[__bkt] = __prev_n;
+  __prev_n = __this_n;
+       }
+   }
+ catch(...)
+   {
+     clear();
+     if (__buckets)
+       _M_deallocate_buckets();
+     throw;
+   }
+      }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    void
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _M_reset() noexcept
+    {
+      _M_rehash_policy._M_reset();
+      _M_bucket_count = 1;
+      _M_single_bucket = nullptr;
+      _M_buckets = &_M_single_bucket;
+      _M_before_begin._M_nxt = nullptr;
+      _M_element_count = 0;
+    }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    void
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _M_move_assign(_Hashtable&& __ht, true_type)
+    {
+      this->_M_deallocate_nodes(_M_begin());
+      _M_deallocate_buckets();
+      __hashtable_base::operator=(std::move(__ht));
+      _M_rehash_policy = __ht._M_rehash_policy;
+      if (!__ht._M_uses_single_bucket())
+ _M_buckets = __ht._M_buckets;
+      else
+ {
+   _M_buckets = &_M_single_bucket;
+   _M_single_bucket = __ht._M_single_bucket;
+ }
+      _M_bucket_count = __ht._M_bucket_count;
+      _M_before_begin._M_nxt = __ht._M_before_begin._M_nxt;
+      _M_element_count = __ht._M_element_count;
+      std::__alloc_on_move(this->_M_node_allocator(), __ht._M_node_allocator());
+
+
+
+      if (_M_begin())
+ _M_buckets[_M_bucket_index(_M_begin())] = &_M_before_begin;
+      __ht._M_reset();
+    }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    void
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _M_move_assign(_Hashtable&& __ht, false_type)
+    {
+      if (__ht._M_node_allocator() == this->_M_node_allocator())
+ _M_move_assign(std::move(__ht), true_type());
+      else
+ {
+
+   _M_assign_elements(std::move(__ht));
+   __ht.clear();
+ }
+    }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _Hashtable(const _Hashtable& __ht)
+    : __hashtable_base(__ht),
+      __map_base(__ht),
+      __rehash_base(__ht),
+      __hashtable_alloc(
+ __node_alloc_traits::_S_select_on_copy(__ht._M_node_allocator())),
+      _M_buckets(nullptr),
+      _M_bucket_count(__ht._M_bucket_count),
+      _M_element_count(__ht._M_element_count),
+      _M_rehash_policy(__ht._M_rehash_policy)
+    {
+      __alloc_node_gen_t __alloc_node_gen(*this);
+      _M_assign(__ht, __alloc_node_gen);
+    }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _Hashtable(_Hashtable&& __ht) noexcept
+    : __hashtable_base(__ht),
+      __map_base(__ht),
+      __rehash_base(__ht),
+      __hashtable_alloc(std::move(__ht._M_base_alloc())),
+      _M_buckets(__ht._M_buckets),
+      _M_bucket_count(__ht._M_bucket_count),
+      _M_before_begin(__ht._M_before_begin._M_nxt),
+      _M_element_count(__ht._M_element_count),
+      _M_rehash_policy(__ht._M_rehash_policy)
+    {
+
+      if (__ht._M_uses_single_bucket())
+ {
+   _M_buckets = &_M_single_bucket;
+   _M_single_bucket = __ht._M_single_bucket;
+ }
+
+
+
+      if (_M_begin())
+ _M_buckets[_M_bucket_index(_M_begin())] = &_M_before_begin;
+
+      __ht._M_reset();
+    }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _Hashtable(const _Hashtable& __ht, const allocator_type& __a)
+    : __hashtable_base(__ht),
+      __map_base(__ht),
+      __rehash_base(__ht),
+      __hashtable_alloc(__node_alloc_type(__a)),
+      _M_buckets(),
+      _M_bucket_count(__ht._M_bucket_count),
+      _M_element_count(__ht._M_element_count),
+      _M_rehash_policy(__ht._M_rehash_policy)
+    {
+      __alloc_node_gen_t __alloc_node_gen(*this);
+      _M_assign(__ht, __alloc_node_gen);
+    }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _Hashtable(_Hashtable&& __ht, const allocator_type& __a)
+    : __hashtable_base(__ht),
+      __map_base(__ht),
+      __rehash_base(__ht),
+      __hashtable_alloc(__node_alloc_type(__a)),
+      _M_buckets(nullptr),
+      _M_bucket_count(__ht._M_bucket_count),
+      _M_element_count(__ht._M_element_count),
+      _M_rehash_policy(__ht._M_rehash_policy)
+    {
+      if (__ht._M_node_allocator() == this->_M_node_allocator())
+ {
+   if (__ht._M_uses_single_bucket())
+     {
+       _M_buckets = &_M_single_bucket;
+       _M_single_bucket = __ht._M_single_bucket;
+     }
+   else
+     _M_buckets = __ht._M_buckets;
+
+   _M_before_begin._M_nxt = __ht._M_before_begin._M_nxt;
+
+
+   if (_M_begin())
+     _M_buckets[_M_bucket_index(_M_begin())] = &_M_before_begin;
+   __ht._M_reset();
+ }
+      else
+ {
+   __alloc_node_gen_t __alloc_gen(*this);
+
+   using _Fwd_Ht = typename
+     conditional<__move_if_noexcept_cond<value_type>::value,
+   const _Hashtable&, _Hashtable&&>::type;
+   _M_assign(std::forward<_Fwd_Ht>(__ht), __alloc_gen);
+   __ht.clear();
+ }
+    }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    ~_Hashtable() noexcept
+    {
+      clear();
+      _M_deallocate_buckets();
+    }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    void
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    swap(_Hashtable& __x)
+    noexcept(__and_<__is_nothrow_swappable<_H1>,
+                 __is_nothrow_swappable<_Equal>>::value)
+    {
+
+
+
+      this->_M_swap(__x);
+
+      std::__alloc_on_swap(this->_M_node_allocator(), __x._M_node_allocator());
+      std::swap(_M_rehash_policy, __x._M_rehash_policy);
+
+
+      if (this->_M_uses_single_bucket())
+ {
+   if (!__x._M_uses_single_bucket())
+     {
+       _M_buckets = __x._M_buckets;
+       __x._M_buckets = &__x._M_single_bucket;
+     }
+ }
+      else if (__x._M_uses_single_bucket())
+ {
+   __x._M_buckets = _M_buckets;
+   _M_buckets = &_M_single_bucket;
+ }
+      else
+ std::swap(_M_buckets, __x._M_buckets);
+
+      std::swap(_M_bucket_count, __x._M_bucket_count);
+      std::swap(_M_before_begin._M_nxt, __x._M_before_begin._M_nxt);
+      std::swap(_M_element_count, __x._M_element_count);
+      std::swap(_M_single_bucket, __x._M_single_bucket);
+
+
+
+      if (_M_begin())
+ _M_buckets[_M_bucket_index(_M_begin())] = &_M_before_begin;
+
+      if (__x._M_begin())
+ __x._M_buckets[__x._M_bucket_index(__x._M_begin())]
+   = &__x._M_before_begin;
+    }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    auto
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    find(const key_type& __k)
+    -> iterator
+    {
+      __hash_code __code = this->_M_hash_code(__k);
+      std::size_t __bkt = _M_bucket_index(__k, __code);
+      __node_type* __p = _M_find_node(__bkt, __k, __code);
+      return __p ? iterator(__p) : end();
+    }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    auto
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    find(const key_type& __k) const
+    -> const_iterator
+    {
+      __hash_code __code = this->_M_hash_code(__k);
+      std::size_t __bkt = _M_bucket_index(__k, __code);
+      __node_type* __p = _M_find_node(__bkt, __k, __code);
+      return __p ? const_iterator(__p) : end();
+    }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    auto
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    count(const key_type& __k) const
+    -> size_type
+    {
+      __hash_code __code = this->_M_hash_code(__k);
+      std::size_t __bkt = _M_bucket_index(__k, __code);
+      __node_type* __p = _M_bucket_begin(__bkt);
+      if (!__p)
+ return 0;
+
+      std::size_t __result = 0;
+      for (;; __p = __p->_M_next())
+ {
+   if (this->_M_equals(__k, __code, __p))
+     ++__result;
+   else if (__result)
+
+
+
+     break;
+   if (!__p->_M_nxt || _M_bucket_index(__p->_M_next()) != __bkt)
+     break;
+ }
+      return __result;
+    }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    auto
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    equal_range(const key_type& __k)
+    -> pair<iterator, iterator>
+    {
+      __hash_code __code = this->_M_hash_code(__k);
+      std::size_t __bkt = _M_bucket_index(__k, __code);
+      __node_type* __p = _M_find_node(__bkt, __k, __code);
+
+      if (__p)
+ {
+   __node_type* __p1 = __p->_M_next();
+   while (__p1 && _M_bucket_index(__p1) == __bkt
+   && this->_M_equals(__k, __code, __p1))
+     __p1 = __p1->_M_next();
+
+   return std::make_pair(iterator(__p), iterator(__p1));
+ }
+      else
+ return std::make_pair(end(), end());
+    }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    auto
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    equal_range(const key_type& __k) const
+    -> pair<const_iterator, const_iterator>
+    {
+      __hash_code __code = this->_M_hash_code(__k);
+      std::size_t __bkt = _M_bucket_index(__k, __code);
+      __node_type* __p = _M_find_node(__bkt, __k, __code);
+
+      if (__p)
+ {
+   __node_type* __p1 = __p->_M_next();
+   while (__p1 && _M_bucket_index(__p1) == __bkt
+   && this->_M_equals(__k, __code, __p1))
+     __p1 = __p1->_M_next();
+
+   return std::make_pair(const_iterator(__p), const_iterator(__p1));
+ }
+      else
+ return std::make_pair(end(), end());
+    }
+
+
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    auto
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _M_find_before_node(size_type __bkt, const key_type& __k,
+   __hash_code __code) const
+    -> __node_base*
+    {
+      __node_base* __prev_p = _M_buckets[__bkt];
+      if (!__prev_p)
+ return nullptr;
+
+      for (__node_type* __p = static_cast<__node_type*>(__prev_p->_M_nxt);;
+    __p = __p->_M_next())
+ {
+   if (this->_M_equals(__k, __code, __p))
+     return __prev_p;
+
+   if (!__p->_M_nxt || _M_bucket_index(__p->_M_next()) != __bkt)
+     break;
+   __prev_p = __p;
+ }
+      return nullptr;
+    }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    void
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _M_insert_bucket_begin(size_type __bkt, __node_type* __node)
+    {
+      if (_M_buckets[__bkt])
+ {
+
+
+   __node->_M_nxt = _M_buckets[__bkt]->_M_nxt;
+   _M_buckets[__bkt]->_M_nxt = __node;
+ }
+      else
+ {
+
+
+
+   __node->_M_nxt = _M_before_begin._M_nxt;
+   _M_before_begin._M_nxt = __node;
+   if (__node->_M_nxt)
+
+
+     _M_buckets[_M_bucket_index(__node->_M_next())] = __node;
+   _M_buckets[__bkt] = &_M_before_begin;
+ }
+    }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    void
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _M_remove_bucket_begin(size_type __bkt, __node_type* __next,
+      size_type __next_bkt)
+    {
+      if (!__next || __next_bkt != __bkt)
+ {
+
+
+   if (__next)
+     _M_buckets[__next_bkt] = _M_buckets[__bkt];
+
+
+   if (&_M_before_begin == _M_buckets[__bkt])
+     _M_before_begin._M_nxt = __next;
+   _M_buckets[__bkt] = nullptr;
+ }
+    }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    auto
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _M_get_previous_node(size_type __bkt, __node_base* __n)
+    -> __node_base*
+    {
+      __node_base* __prev_n = _M_buckets[__bkt];
+      while (__prev_n->_M_nxt != __n)
+ __prev_n = __prev_n->_M_nxt;
+      return __prev_n;
+    }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    template<typename... _Args>
+      auto
+      _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+   _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+      _M_emplace(true_type, _Args&&... __args)
+      -> pair<iterator, bool>
+      {
+
+ _Scoped_node __node { this, std::forward<_Args>(__args)... };
+ const key_type& __k = this->_M_extract()(__node._M_node->_M_v());
+ __hash_code __code = this->_M_hash_code(__k);
+ size_type __bkt = _M_bucket_index(__k, __code);
+ if (__node_type* __p = _M_find_node(__bkt, __k, __code))
+
+   return std::make_pair(iterator(__p), false);
+
+
+ auto __pos = _M_insert_unique_node(__k, __bkt, __code, __node._M_node);
+ __node._M_node = nullptr;
+ return { __pos, true };
+      }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    template<typename... _Args>
+      auto
+      _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+   _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+      _M_emplace(const_iterator __hint, false_type, _Args&&... __args)
+      -> iterator
+      {
+
+ _Scoped_node __node { this, std::forward<_Args>(__args)... };
+ const key_type& __k = this->_M_extract()(__node._M_node->_M_v());
+
+ __hash_code __code = this->_M_hash_code(__k);
+ auto __pos
+   = _M_insert_multi_node(__hint._M_cur, __k, __code, __node._M_node);
+ __node._M_node = nullptr;
+ return __pos;
+      }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    auto
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _M_insert_unique_node(const key_type& __k, size_type __bkt,
+     __hash_code __code, __node_type* __node,
+     size_type __n_elt)
+    -> iterator
+    {
+      const __rehash_state& __saved_state = _M_rehash_policy._M_state();
+      std::pair<bool, std::size_t> __do_rehash
+ = _M_rehash_policy._M_need_rehash(_M_bucket_count, _M_element_count,
+       __n_elt);
+
+      if (__do_rehash.first)
+ {
+   _M_rehash(__do_rehash.second, __saved_state);
+   __bkt = _M_bucket_index(__k, __code);
+ }
+
+      this->_M_store_code(__node, __code);
+
+
+      _M_insert_bucket_begin(__bkt, __node);
+      ++_M_element_count;
+      return iterator(__node);
+    }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    auto
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _M_insert_multi_node(__node_type* __hint, const key_type& __k,
+    __hash_code __code, __node_type* __node)
+    -> iterator
+    {
+      const __rehash_state& __saved_state = _M_rehash_policy._M_state();
+      std::pair<bool, std::size_t> __do_rehash
+ = _M_rehash_policy._M_need_rehash(_M_bucket_count, _M_element_count, 1);
+
+      if (__do_rehash.first)
+ _M_rehash(__do_rehash.second, __saved_state);
+
+      this->_M_store_code(__node, __code);
+      size_type __bkt = _M_bucket_index(__k, __code);
+
+
+
+      __node_base* __prev
+ = __builtin_expect(__hint != nullptr, false)
+   && this->_M_equals(__k, __code, __hint)
+     ? __hint
+     : _M_find_before_node(__bkt, __k, __code);
+      if (__prev)
+ {
+
+   __node->_M_nxt = __prev->_M_nxt;
+   __prev->_M_nxt = __node;
+   if (__builtin_expect(__prev == __hint, false))
+
+
+     if (__node->_M_nxt
+  && !this->_M_equals(__k, __code, __node->_M_next()))
+       {
+  size_type __next_bkt = _M_bucket_index(__node->_M_next());
+  if (__next_bkt != __bkt)
+    _M_buckets[__next_bkt] = __node;
+       }
+ }
+      else
+
+
+
+ _M_insert_bucket_begin(__bkt, __node);
+      ++_M_element_count;
+      return iterator(__node);
+    }
+
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    template<typename _Arg, typename _NodeGenerator>
+      auto
+      _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+   _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+      _M_insert(_Arg&& __v, const _NodeGenerator& __node_gen, true_type,
+  size_type __n_elt)
+      -> pair<iterator, bool>
+      {
+ const key_type& __k = this->_M_extract()(__v);
+ __hash_code __code = this->_M_hash_code(__k);
+ size_type __bkt = _M_bucket_index(__k, __code);
+
+ if (__node_type* __node = _M_find_node(__bkt, __k, __code))
+   return { iterator(__node), false };
+
+ _Scoped_node __node{ __node_gen(std::forward<_Arg>(__v)), this };
+ auto __pos
+   = _M_insert_unique_node(__k, __bkt, __code, __node._M_node, __n_elt);
+ __node._M_node = nullptr;
+ return { __pos, true };
+      }
+
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    template<typename _Arg, typename _NodeGenerator>
+      auto
+      _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+   _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+      _M_insert(const_iterator __hint, _Arg&& __v,
+  const _NodeGenerator& __node_gen, false_type)
+      -> iterator
+      {
+
+
+ __hash_code __code = this->_M_hash_code(this->_M_extract()(__v));
+
+
+ _Scoped_node __node{ __node_gen(std::forward<_Arg>(__v)), this };
+ const key_type& __k = this->_M_extract()(__node._M_node->_M_v());
+ auto __pos
+   = _M_insert_multi_node(__hint._M_cur, __k, __code, __node._M_node);
+ __node._M_node = nullptr;
+ return __pos;
+      }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    auto
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    erase(const_iterator __it)
+    -> iterator
+    {
+      __node_type* __n = __it._M_cur;
+      std::size_t __bkt = _M_bucket_index(__n);
+
+
+
+
+      __node_base* __prev_n = _M_get_previous_node(__bkt, __n);
+      return _M_erase(__bkt, __prev_n, __n);
+    }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    auto
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _M_erase(size_type __bkt, __node_base* __prev_n, __node_type* __n)
+    -> iterator
+    {
+      if (__prev_n == _M_buckets[__bkt])
+ _M_remove_bucket_begin(__bkt, __n->_M_next(),
+    __n->_M_nxt ? _M_bucket_index(__n->_M_next()) : 0);
+      else if (__n->_M_nxt)
+ {
+   size_type __next_bkt = _M_bucket_index(__n->_M_next());
+   if (__next_bkt != __bkt)
+     _M_buckets[__next_bkt] = __prev_n;
+ }
+
+      __prev_n->_M_nxt = __n->_M_nxt;
+      iterator __result(__n->_M_next());
+      this->_M_deallocate_node(__n);
+      --_M_element_count;
+
+      return __result;
+    }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    auto
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _M_erase(true_type, const key_type& __k)
+    -> size_type
+    {
+      __hash_code __code = this->_M_hash_code(__k);
+      std::size_t __bkt = _M_bucket_index(__k, __code);
+
+
+      __node_base* __prev_n = _M_find_before_node(__bkt, __k, __code);
+      if (!__prev_n)
+ return 0;
+
+
+      __node_type* __n = static_cast<__node_type*>(__prev_n->_M_nxt);
+      _M_erase(__bkt, __prev_n, __n);
+      return 1;
+    }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    auto
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _M_erase(false_type, const key_type& __k)
+    -> size_type
+    {
+      __hash_code __code = this->_M_hash_code(__k);
+      std::size_t __bkt = _M_bucket_index(__k, __code);
+
+
+      __node_base* __prev_n = _M_find_before_node(__bkt, __k, __code);
+      if (!__prev_n)
+ return 0;
+
+
+
+
+
+
+
+      __node_type* __n = static_cast<__node_type*>(__prev_n->_M_nxt);
+      __node_type* __n_last = __n;
+      std::size_t __n_last_bkt = __bkt;
+      do
+ {
+   __n_last = __n_last->_M_next();
+   if (!__n_last)
+     break;
+   __n_last_bkt = _M_bucket_index(__n_last);
+ }
+      while (__n_last_bkt == __bkt && this->_M_equals(__k, __code, __n_last));
+
+
+      size_type __result = 0;
+      do
+ {
+   __node_type* __p = __n->_M_next();
+   this->_M_deallocate_node(__n);
+   __n = __p;
+   ++__result;
+   --_M_element_count;
+ }
+      while (__n != __n_last);
+
+      if (__prev_n == _M_buckets[__bkt])
+ _M_remove_bucket_begin(__bkt, __n_last, __n_last_bkt);
+      else if (__n_last && __n_last_bkt != __bkt)
+ _M_buckets[__n_last_bkt] = __prev_n;
+      __prev_n->_M_nxt = __n_last;
+      return __result;
+    }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    auto
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    erase(const_iterator __first, const_iterator __last)
+    -> iterator
+    {
+      __node_type* __n = __first._M_cur;
+      __node_type* __last_n = __last._M_cur;
+      if (__n == __last_n)
+ return iterator(__n);
+
+      std::size_t __bkt = _M_bucket_index(__n);
+
+      __node_base* __prev_n = _M_get_previous_node(__bkt, __n);
+      bool __is_bucket_begin = __n == _M_bucket_begin(__bkt);
+      std::size_t __n_bkt = __bkt;
+      for (;;)
+ {
+   do
+     {
+       __node_type* __tmp = __n;
+       __n = __n->_M_next();
+       this->_M_deallocate_node(__tmp);
+       --_M_element_count;
+       if (!__n)
+  break;
+       __n_bkt = _M_bucket_index(__n);
+     }
+   while (__n != __last_n && __n_bkt == __bkt);
+   if (__is_bucket_begin)
+     _M_remove_bucket_begin(__bkt, __n, __n_bkt);
+   if (__n == __last_n)
+     break;
+   __is_bucket_begin = true;
+   __bkt = __n_bkt;
+ }
+
+      if (__n && (__n_bkt != __bkt || __is_bucket_begin))
+ _M_buckets[__n_bkt] = __prev_n;
+      __prev_n->_M_nxt = __n;
+      return iterator(__n);
+    }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    void
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    clear() noexcept
+    {
+      this->_M_deallocate_nodes(_M_begin());
+      __builtin_memset(_M_buckets, 0, _M_bucket_count * sizeof(__bucket_type));
+      _M_element_count = 0;
+      _M_before_begin._M_nxt = nullptr;
+    }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    void
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    rehash(size_type __bkt_count)
+    {
+      const __rehash_state& __saved_state = _M_rehash_policy._M_state();
+      __bkt_count
+ = std::max(_M_rehash_policy._M_bkt_for_elements(_M_element_count + 1),
+     __bkt_count);
+      __bkt_count = _M_rehash_policy._M_next_bkt(__bkt_count);
+
+      if (__bkt_count != _M_bucket_count)
+ _M_rehash(__bkt_count, __saved_state);
+      else
+
+
+ _M_rehash_policy._M_reset(__saved_state);
+    }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    void
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _M_rehash(size_type __bkt_count, const __rehash_state& __state)
+    {
+      try
+ {
+   _M_rehash_aux(__bkt_count, __unique_keys());
+ }
+      catch(...)
+ {
+
+
+   _M_rehash_policy._M_reset(__state);
+   throw;
+ }
+    }
+
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    void
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _M_rehash_aux(size_type __bkt_count, true_type)
+    {
+      __bucket_type* __new_buckets = _M_allocate_buckets(__bkt_count);
+      __node_type* __p = _M_begin();
+      _M_before_begin._M_nxt = nullptr;
+      std::size_t __bbegin_bkt = 0;
+      while (__p)
+ {
+   __node_type* __next = __p->_M_next();
+   std::size_t __bkt
+     = __hash_code_base::_M_bucket_index(__p, __bkt_count);
+   if (!__new_buckets[__bkt])
+     {
+       __p->_M_nxt = _M_before_begin._M_nxt;
+       _M_before_begin._M_nxt = __p;
+       __new_buckets[__bkt] = &_M_before_begin;
+       if (__p->_M_nxt)
+  __new_buckets[__bbegin_bkt] = __p;
+       __bbegin_bkt = __bkt;
+     }
+   else
+     {
+       __p->_M_nxt = __new_buckets[__bkt]->_M_nxt;
+       __new_buckets[__bkt]->_M_nxt = __p;
+     }
+   __p = __next;
+ }
+
+      _M_deallocate_buckets();
+      _M_bucket_count = __bkt_count;
+      _M_buckets = __new_buckets;
+    }
+
+
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    void
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _M_rehash_aux(size_type __bkt_count, false_type)
+    {
+      __bucket_type* __new_buckets = _M_allocate_buckets(__bkt_count);
+
+      __node_type* __p = _M_begin();
+      _M_before_begin._M_nxt = nullptr;
+      std::size_t __bbegin_bkt = 0;
+      std::size_t __prev_bkt = 0;
+      __node_type* __prev_p = nullptr;
+      bool __check_bucket = false;
+
+      while (__p)
+ {
+   __node_type* __next = __p->_M_next();
+   std::size_t __bkt
+     = __hash_code_base::_M_bucket_index(__p, __bkt_count);
+
+   if (__prev_p && __prev_bkt == __bkt)
+     {
+
+
+
+       __p->_M_nxt = __prev_p->_M_nxt;
+       __prev_p->_M_nxt = __p;
+
+
+
+
+
+
+       __check_bucket = true;
+     }
+   else
+     {
+       if (__check_bucket)
+  {
+
+
+    if (__prev_p->_M_nxt)
+      {
+        std::size_t __next_bkt
+   = __hash_code_base::_M_bucket_index(__prev_p->_M_next(),
+           __bkt_count);
+        if (__next_bkt != __prev_bkt)
+   __new_buckets[__next_bkt] = __prev_p;
+      }
+    __check_bucket = false;
+  }
+
+       if (!__new_buckets[__bkt])
+  {
+    __p->_M_nxt = _M_before_begin._M_nxt;
+    _M_before_begin._M_nxt = __p;
+    __new_buckets[__bkt] = &_M_before_begin;
+    if (__p->_M_nxt)
+      __new_buckets[__bbegin_bkt] = __p;
+    __bbegin_bkt = __bkt;
+  }
+       else
+  {
+    __p->_M_nxt = __new_buckets[__bkt]->_M_nxt;
+    __new_buckets[__bkt]->_M_nxt = __p;
+  }
+     }
+   __prev_p = __p;
+   __prev_bkt = __bkt;
+   __p = __next;
+ }
+
+      if (__check_bucket && __prev_p->_M_nxt)
+ {
+   std::size_t __next_bkt
+     = __hash_code_base::_M_bucket_index(__prev_p->_M_next(),
+      __bkt_count);
+   if (__next_bkt != __prev_bkt)
+     __new_buckets[__next_bkt] = __prev_p;
+ }
+
+      _M_deallocate_buckets();
+      _M_bucket_count = __bkt_count;
+      _M_buckets = __new_buckets;
+    }
+
+
+  template<typename, typename, typename> class _Hash_merge_helper { };
+
+
+
+
+  template<typename _Hash>
+    using _RequireNotAllocatorOrIntegral
+      = __enable_if_t<!__or_<is_integral<_Hash>, __is_allocator<_Hash>>::value>;
+
+
+
+}
+# 47 "/usr/include/c++/10.2.0/unordered_map" 2 3
+# 1 "/usr/include/c++/10.2.0/bits/unordered_map.h" 1 3
+# 31 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+#define _UNORDERED_MAP_H 
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+  template<bool _Cache>
+    using __umap_traits = __detail::_Hashtable_traits<_Cache, false, true>;
+
+  template<typename _Key,
+    typename _Tp,
+    typename _Hash = hash<_Key>,
+    typename _Pred = std::equal_to<_Key>,
+    typename _Alloc = std::allocator<std::pair<const _Key, _Tp> >,
+    typename _Tr = __umap_traits<__cache_default<_Key, _Hash>::value>>
+    using __umap_hashtable = _Hashtable<_Key, std::pair<const _Key, _Tp>,
+                                        _Alloc, __detail::_Select1st,
+            _Pred, _Hash,
+            __detail::_Mod_range_hashing,
+            __detail::_Default_ranged_hash,
+            __detail::_Prime_rehash_policy, _Tr>;
+
+
+  template<bool _Cache>
+    using __ummap_traits = __detail::_Hashtable_traits<_Cache, false, false>;
+
+  template<typename _Key,
+    typename _Tp,
+    typename _Hash = hash<_Key>,
+    typename _Pred = std::equal_to<_Key>,
+    typename _Alloc = std::allocator<std::pair<const _Key, _Tp> >,
+    typename _Tr = __ummap_traits<__cache_default<_Key, _Hash>::value>>
+    using __ummap_hashtable = _Hashtable<_Key, std::pair<const _Key, _Tp>,
+      _Alloc, __detail::_Select1st,
+      _Pred, _Hash,
+      __detail::_Mod_range_hashing,
+      __detail::_Default_ranged_hash,
+      __detail::_Prime_rehash_policy, _Tr>;
+
+  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+    class unordered_multimap;
+# 98 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+  template<typename _Key, typename _Tp,
+    typename _Hash = hash<_Key>,
+    typename _Pred = equal_to<_Key>,
+    typename _Alloc = allocator<std::pair<const _Key, _Tp>>>
+    class unordered_map
+    {
+      typedef __umap_hashtable<_Key, _Tp, _Hash, _Pred, _Alloc> _Hashtable;
+      _Hashtable _M_h;
+
+    public:
+
+
+
+      typedef typename _Hashtable::key_type key_type;
+      typedef typename _Hashtable::value_type value_type;
+      typedef typename _Hashtable::mapped_type mapped_type;
+      typedef typename _Hashtable::hasher hasher;
+      typedef typename _Hashtable::key_equal key_equal;
+      typedef typename _Hashtable::allocator_type allocator_type;
+
+
+
+
+      typedef typename _Hashtable::pointer pointer;
+      typedef typename _Hashtable::const_pointer const_pointer;
+      typedef typename _Hashtable::reference reference;
+      typedef typename _Hashtable::const_reference const_reference;
+      typedef typename _Hashtable::iterator iterator;
+      typedef typename _Hashtable::const_iterator const_iterator;
+      typedef typename _Hashtable::local_iterator local_iterator;
+      typedef typename _Hashtable::const_local_iterator const_local_iterator;
+      typedef typename _Hashtable::size_type size_type;
+      typedef typename _Hashtable::difference_type difference_type;
+
+
+
+      using node_type = typename _Hashtable::node_type;
+      using insert_return_type = typename _Hashtable::insert_return_type;
+
+
+
+
+
+      unordered_map() = default;
+# 150 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      explicit
+      unordered_map(size_type __n,
+      const hasher& __hf = hasher(),
+      const key_equal& __eql = key_equal(),
+      const allocator_type& __a = allocator_type())
+      : _M_h(__n, __hf, __eql, __a)
+      { }
+# 171 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      template<typename _InputIterator>
+ unordered_map(_InputIterator __first, _InputIterator __last,
+        size_type __n = 0,
+        const hasher& __hf = hasher(),
+        const key_equal& __eql = key_equal(),
+        const allocator_type& __a = allocator_type())
+ : _M_h(__first, __last, __n, __hf, __eql, __a)
+ { }
+
+
+      unordered_map(const unordered_map&) = default;
+
+
+      unordered_map(unordered_map&&) = default;
+
+
+
+
+
+      explicit
+      unordered_map(const allocator_type& __a)
+ : _M_h(__a)
+      { }
+
+
+
+
+
+
+      unordered_map(const unordered_map& __umap,
+      const allocator_type& __a)
+      : _M_h(__umap._M_h, __a)
+      { }
+
+
+
+
+
+
+      unordered_map(unordered_map&& __umap,
+      const allocator_type& __a)
+      : _M_h(std::move(__umap._M_h), __a)
+      { }
+# 226 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      unordered_map(initializer_list<value_type> __l,
+      size_type __n = 0,
+      const hasher& __hf = hasher(),
+      const key_equal& __eql = key_equal(),
+      const allocator_type& __a = allocator_type())
+      : _M_h(__l, __n, __hf, __eql, __a)
+      { }
+
+      unordered_map(size_type __n, const allocator_type& __a)
+      : unordered_map(__n, hasher(), key_equal(), __a)
+      { }
+
+      unordered_map(size_type __n, const hasher& __hf,
+      const allocator_type& __a)
+      : unordered_map(__n, __hf, key_equal(), __a)
+      { }
+
+      template<typename _InputIterator>
+ unordered_map(_InputIterator __first, _InputIterator __last,
+        size_type __n,
+        const allocator_type& __a)
+ : unordered_map(__first, __last, __n, hasher(), key_equal(), __a)
+ { }
+
+      template<typename _InputIterator>
+ unordered_map(_InputIterator __first, _InputIterator __last,
+        size_type __n, const hasher& __hf,
+        const allocator_type& __a)
+   : unordered_map(__first, __last, __n, __hf, key_equal(), __a)
+ { }
+
+      unordered_map(initializer_list<value_type> __l,
+      size_type __n,
+      const allocator_type& __a)
+      : unordered_map(__l, __n, hasher(), key_equal(), __a)
+      { }
+
+      unordered_map(initializer_list<value_type> __l,
+      size_type __n, const hasher& __hf,
+      const allocator_type& __a)
+      : unordered_map(__l, __n, __hf, key_equal(), __a)
+      { }
+
+
+      unordered_map&
+      operator=(const unordered_map&) = default;
+
+
+      unordered_map&
+      operator=(unordered_map&&) = default;
+# 288 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      unordered_map&
+      operator=(initializer_list<value_type> __l)
+      {
+ _M_h = __l;
+ return *this;
+      }
+
+
+      allocator_type
+      get_allocator() const noexcept
+      { return _M_h.get_allocator(); }
+
+
+
+
+      [[__nodiscard__]] bool
+      empty() const noexcept
+      { return _M_h.empty(); }
+
+
+      size_type
+      size() const noexcept
+      { return _M_h.size(); }
+
+
+      size_type
+      max_size() const noexcept
+      { return _M_h.max_size(); }
+
+
+
+
+
+
+
+      iterator
+      begin() noexcept
+      { return _M_h.begin(); }
+
+
+
+
+
+
+      const_iterator
+      begin() const noexcept
+      { return _M_h.begin(); }
+
+      const_iterator
+      cbegin() const noexcept
+      { return _M_h.begin(); }
+
+
+
+
+
+
+      iterator
+      end() noexcept
+      { return _M_h.end(); }
+
+
+
+
+
+
+      const_iterator
+      end() const noexcept
+      { return _M_h.end(); }
+
+      const_iterator
+      cend() const noexcept
+      { return _M_h.end(); }
+# 385 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      template<typename... _Args>
+ std::pair<iterator, bool>
+ emplace(_Args&&... __args)
+ { return _M_h.emplace(std::forward<_Args>(__args)...); }
+# 416 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      template<typename... _Args>
+ iterator
+ emplace_hint(const_iterator __pos, _Args&&... __args)
+ { return _M_h.emplace_hint(__pos, std::forward<_Args>(__args)...); }
+
+
+
+      node_type
+      extract(const_iterator __pos)
+      {
+ ;
+ return _M_h.extract(__pos);
+      }
+
+
+      node_type
+      extract(const key_type& __key)
+      { return _M_h.extract(__key); }
+
+
+      insert_return_type
+      insert(node_type&& __nh)
+      { return _M_h._M_reinsert_node(std::move(__nh)); }
+
+
+      iterator
+      insert(const_iterator, node_type&& __nh)
+      { return _M_h._M_reinsert_node(std::move(__nh)).position; }
+
+#define __cpp_lib_unordered_map_try_emplace 201411
+# 468 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      template <typename... _Args>
+        pair<iterator, bool>
+        try_emplace(const key_type& __k, _Args&&... __args)
+        {
+          iterator __i = find(__k);
+          if (__i == end())
+            {
+              __i = emplace(std::piecewise_construct,
+                            std::forward_as_tuple(__k),
+                            std::forward_as_tuple(
+                              std::forward<_Args>(__args)...))
+                .first;
+              return {__i, true};
+            }
+          return {__i, false};
+        }
+
+
+      template <typename... _Args>
+        pair<iterator, bool>
+        try_emplace(key_type&& __k, _Args&&... __args)
+        {
+          iterator __i = find(__k);
+          if (__i == end())
+            {
+              __i = emplace(std::piecewise_construct,
+                            std::forward_as_tuple(std::move(__k)),
+                            std::forward_as_tuple(
+                              std::forward<_Args>(__args)...))
+                .first;
+              return {__i, true};
+            }
+          return {__i, false};
+        }
+# 531 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      template <typename... _Args>
+        iterator
+        try_emplace(const_iterator __hint, const key_type& __k,
+                    _Args&&... __args)
+        {
+          iterator __i = find(__k);
+          if (__i == end())
+            __i = emplace_hint(__hint, std::piecewise_construct,
+                               std::forward_as_tuple(__k),
+                               std::forward_as_tuple(
+                                 std::forward<_Args>(__args)...));
+          return __i;
+        }
+
+
+      template <typename... _Args>
+        iterator
+        try_emplace(const_iterator __hint, key_type&& __k, _Args&&... __args)
+        {
+          iterator __i = find(__k);
+          if (__i == end())
+            __i = emplace_hint(__hint, std::piecewise_construct,
+                               std::forward_as_tuple(std::move(__k)),
+                               std::forward_as_tuple(
+                                 std::forward<_Args>(__args)...));
+          return __i;
+        }
+# 578 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      std::pair<iterator, bool>
+      insert(const value_type& __x)
+      { return _M_h.insert(__x); }
+
+
+
+      std::pair<iterator, bool>
+      insert(value_type&& __x)
+      { return _M_h.insert(std::move(__x)); }
+
+      template<typename _Pair>
+ __enable_if_t<is_constructible<value_type, _Pair&&>::value,
+        pair<iterator, bool>>
+ insert(_Pair&& __x)
+        { return _M_h.emplace(std::forward<_Pair>(__x)); }
+# 617 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      iterator
+      insert(const_iterator __hint, const value_type& __x)
+      { return _M_h.insert(__hint, __x); }
+
+
+
+      iterator
+      insert(const_iterator __hint, value_type&& __x)
+      { return _M_h.insert(__hint, std::move(__x)); }
+
+      template<typename _Pair>
+ __enable_if_t<is_constructible<value_type, _Pair&&>::value, iterator>
+ insert(const_iterator __hint, _Pair&& __x)
+ { return _M_h.emplace_hint(__hint, std::forward<_Pair>(__x)); }
+# 642 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      template<typename _InputIterator>
+ void
+ insert(_InputIterator __first, _InputIterator __last)
+ { _M_h.insert(__first, __last); }
+# 654 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      void
+      insert(initializer_list<value_type> __l)
+      { _M_h.insert(__l); }
+# 680 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      template <typename _Obj>
+        pair<iterator, bool>
+        insert_or_assign(const key_type& __k, _Obj&& __obj)
+        {
+          iterator __i = find(__k);
+          if (__i == end())
+            {
+              __i = emplace(std::piecewise_construct,
+                            std::forward_as_tuple(__k),
+                            std::forward_as_tuple(std::forward<_Obj>(__obj)))
+                .first;
+              return {__i, true};
+            }
+          (*__i).second = std::forward<_Obj>(__obj);
+          return {__i, false};
+        }
+
+
+      template <typename _Obj>
+        pair<iterator, bool>
+        insert_or_assign(key_type&& __k, _Obj&& __obj)
+        {
+          iterator __i = find(__k);
+          if (__i == end())
+            {
+              __i = emplace(std::piecewise_construct,
+                            std::forward_as_tuple(std::move(__k)),
+                            std::forward_as_tuple(std::forward<_Obj>(__obj)))
+                .first;
+              return {__i, true};
+            }
+          (*__i).second = std::forward<_Obj>(__obj);
+          return {__i, false};
+        }
+# 741 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      template <typename _Obj>
+        iterator
+        insert_or_assign(const_iterator __hint, const key_type& __k,
+                         _Obj&& __obj)
+        {
+          iterator __i = find(__k);
+          if (__i == end())
+            {
+              return emplace_hint(__hint, std::piecewise_construct,
+                                  std::forward_as_tuple(__k),
+                                  std::forward_as_tuple(
+                                    std::forward<_Obj>(__obj)));
+            }
+          (*__i).second = std::forward<_Obj>(__obj);
+          return __i;
+        }
+
+
+      template <typename _Obj>
+        iterator
+        insert_or_assign(const_iterator __hint, key_type&& __k, _Obj&& __obj)
+        {
+          iterator __i = find(__k);
+          if (__i == end())
+            {
+              return emplace_hint(__hint, std::piecewise_construct,
+                                  std::forward_as_tuple(std::move(__k)),
+                                  std::forward_as_tuple(
+                                    std::forward<_Obj>(__obj)));
+            }
+          (*__i).second = std::forward<_Obj>(__obj);
+          return __i;
+        }
+# 790 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      iterator
+      erase(const_iterator __position)
+      { return _M_h.erase(__position); }
+
+
+      iterator
+      erase(iterator __position)
+      { return _M_h.erase(__position); }
+# 812 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      size_type
+      erase(const key_type& __x)
+      { return _M_h.erase(__x); }
+# 830 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      iterator
+      erase(const_iterator __first, const_iterator __last)
+      { return _M_h.erase(__first, __last); }
+
+
+
+
+
+
+
+      void
+      clear() noexcept
+      { _M_h.clear(); }
+# 854 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      void
+      swap(unordered_map& __x)
+      noexcept( noexcept(_M_h.swap(__x._M_h)) )
+      { _M_h.swap(__x._M_h); }
+
+
+      template<typename, typename, typename>
+ friend class std::_Hash_merge_helper;
+
+      template<typename _H2, typename _P2>
+ void
+ merge(unordered_map<_Key, _Tp, _H2, _P2, _Alloc>& __source)
+ {
+   using _Merge_helper = _Hash_merge_helper<unordered_map, _H2, _P2>;
+   _M_h._M_merge_unique(_Merge_helper::_S_get_table(__source));
+ }
+
+      template<typename _H2, typename _P2>
+ void
+ merge(unordered_map<_Key, _Tp, _H2, _P2, _Alloc>&& __source)
+ { merge(__source); }
+
+      template<typename _H2, typename _P2>
+ void
+ merge(unordered_multimap<_Key, _Tp, _H2, _P2, _Alloc>& __source)
+ {
+   using _Merge_helper = _Hash_merge_helper<unordered_map, _H2, _P2>;
+   _M_h._M_merge_unique(_Merge_helper::_S_get_table(__source));
+ }
+
+      template<typename _H2, typename _P2>
+ void
+ merge(unordered_multimap<_Key, _Tp, _H2, _P2, _Alloc>&& __source)
+ { merge(__source); }
+
+
+
+
+
+
+      hasher
+      hash_function() const
+      { return _M_h.hash_function(); }
+
+
+
+      key_equal
+      key_eq() const
+      { return _M_h.key_eq(); }
+# 918 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      iterator
+      find(const key_type& __x)
+      { return _M_h.find(__x); }
+
+      const_iterator
+      find(const key_type& __x) const
+      { return _M_h.find(__x); }
+# 936 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      size_type
+      count(const key_type& __x) const
+      { return _M_h.count(__x); }
+# 960 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      std::pair<iterator, iterator>
+      equal_range(const key_type& __x)
+      { return _M_h.equal_range(__x); }
+
+      std::pair<const_iterator, const_iterator>
+      equal_range(const key_type& __x) const
+      { return _M_h.equal_range(__x); }
+# 982 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      mapped_type&
+      operator[](const key_type& __k)
+      { return _M_h[__k]; }
+
+      mapped_type&
+      operator[](key_type&& __k)
+      { return _M_h[std::move(__k)]; }
+# 999 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      mapped_type&
+      at(const key_type& __k)
+      { return _M_h.at(__k); }
+
+      const mapped_type&
+      at(const key_type& __k) const
+      { return _M_h.at(__k); }
+
+
+
+
+
+      size_type
+      bucket_count() const noexcept
+      { return _M_h.bucket_count(); }
+
+
+      size_type
+      max_bucket_count() const noexcept
+      { return _M_h.max_bucket_count(); }
+
+
+
+
+
+
+      size_type
+      bucket_size(size_type __n) const
+      { return _M_h.bucket_size(__n); }
+
+
+
+
+
+
+      size_type
+      bucket(const key_type& __key) const
+      { return _M_h.bucket(__key); }
+
+
+
+
+
+
+
+      local_iterator
+      begin(size_type __n)
+      { return _M_h.begin(__n); }
+# 1055 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      const_local_iterator
+      begin(size_type __n) const
+      { return _M_h.begin(__n); }
+
+      const_local_iterator
+      cbegin(size_type __n) const
+      { return _M_h.cbegin(__n); }
+# 1070 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      local_iterator
+      end(size_type __n)
+      { return _M_h.end(__n); }
+# 1081 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      const_local_iterator
+      end(size_type __n) const
+      { return _M_h.end(__n); }
+
+      const_local_iterator
+      cend(size_type __n) const
+      { return _M_h.cend(__n); }
+
+
+
+
+
+      float
+      load_factor() const noexcept
+      { return _M_h.load_factor(); }
+
+
+
+      float
+      max_load_factor() const noexcept
+      { return _M_h.max_load_factor(); }
+
+
+
+
+
+      void
+      max_load_factor(float __z)
+      { _M_h.max_load_factor(__z); }
+# 1118 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      void
+      rehash(size_type __n)
+      { _M_h.rehash(__n); }
+# 1129 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      void
+      reserve(size_type __n)
+      { _M_h.reserve(__n); }
+
+      template<typename _Key1, typename _Tp1, typename _Hash1, typename _Pred1,
+        typename _Alloc1>
+        friend bool
+ operator==(const unordered_map<_Key1, _Tp1, _Hash1, _Pred1, _Alloc1>&,
+     const unordered_map<_Key1, _Tp1, _Hash1, _Pred1, _Alloc1>&);
+    };
+
+
+
+  template<typename _InputIterator,
+    typename _Hash = hash<__iter_key_t<_InputIterator>>,
+    typename _Pred = equal_to<__iter_key_t<_InputIterator>>,
+    typename _Allocator = allocator<__iter_to_alloc_t<_InputIterator>>,
+    typename = _RequireInputIter<_InputIterator>,
+    typename = _RequireNotAllocatorOrIntegral<_Hash>,
+    typename = _RequireNotAllocator<_Pred>,
+    typename = _RequireAllocator<_Allocator>>
+    unordered_map(_InputIterator, _InputIterator,
+    typename unordered_map<int, int>::size_type = {},
+    _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator())
+    -> unordered_map<__iter_key_t<_InputIterator>,
+       __iter_val_t<_InputIterator>,
+       _Hash, _Pred, _Allocator>;
+
+  template<typename _Key, typename _Tp, typename _Hash = hash<_Key>,
+    typename _Pred = equal_to<_Key>,
+    typename _Allocator = allocator<pair<const _Key, _Tp>>,
+    typename = _RequireNotAllocatorOrIntegral<_Hash>,
+    typename = _RequireNotAllocator<_Pred>,
+    typename = _RequireAllocator<_Allocator>>
+    unordered_map(initializer_list<pair<_Key, _Tp>>,
+    typename unordered_map<int, int>::size_type = {},
+    _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator())
+    -> unordered_map<_Key, _Tp, _Hash, _Pred, _Allocator>;
+
+  template<typename _InputIterator, typename _Allocator,
+    typename = _RequireInputIter<_InputIterator>,
+    typename = _RequireAllocator<_Allocator>>
+    unordered_map(_InputIterator, _InputIterator,
+    typename unordered_map<int, int>::size_type, _Allocator)
+    -> unordered_map<__iter_key_t<_InputIterator>,
+       __iter_val_t<_InputIterator>,
+       hash<__iter_key_t<_InputIterator>>,
+       equal_to<__iter_key_t<_InputIterator>>,
+       _Allocator>;
+
+  template<typename _InputIterator, typename _Allocator,
+    typename = _RequireInputIter<_InputIterator>,
+    typename = _RequireAllocator<_Allocator>>
+    unordered_map(_InputIterator, _InputIterator, _Allocator)
+    -> unordered_map<__iter_key_t<_InputIterator>,
+       __iter_val_t<_InputIterator>,
+       hash<__iter_key_t<_InputIterator>>,
+       equal_to<__iter_key_t<_InputIterator>>,
+       _Allocator>;
+
+  template<typename _InputIterator, typename _Hash, typename _Allocator,
+    typename = _RequireInputIter<_InputIterator>,
+    typename = _RequireNotAllocatorOrIntegral<_Hash>,
+    typename = _RequireAllocator<_Allocator>>
+    unordered_map(_InputIterator, _InputIterator,
+    typename unordered_map<int, int>::size_type,
+    _Hash, _Allocator)
+    -> unordered_map<__iter_key_t<_InputIterator>,
+       __iter_val_t<_InputIterator>, _Hash,
+       equal_to<__iter_key_t<_InputIterator>>, _Allocator>;
+
+  template<typename _Key, typename _Tp, typename _Allocator,
+    typename = _RequireAllocator<_Allocator>>
+    unordered_map(initializer_list<pair<_Key, _Tp>>,
+    typename unordered_map<int, int>::size_type,
+    _Allocator)
+    -> unordered_map<_Key, _Tp, hash<_Key>, equal_to<_Key>, _Allocator>;
+
+  template<typename _Key, typename _Tp, typename _Allocator,
+    typename = _RequireAllocator<_Allocator>>
+    unordered_map(initializer_list<pair<_Key, _Tp>>, _Allocator)
+    -> unordered_map<_Key, _Tp, hash<_Key>, equal_to<_Key>, _Allocator>;
+
+  template<typename _Key, typename _Tp, typename _Hash, typename _Allocator,
+    typename = _RequireNotAllocatorOrIntegral<_Hash>,
+    typename = _RequireAllocator<_Allocator>>
+    unordered_map(initializer_list<pair<_Key, _Tp>>,
+    typename unordered_map<int, int>::size_type,
+    _Hash, _Allocator)
+    -> unordered_map<_Key, _Tp, _Hash, equal_to<_Key>, _Allocator>;
+# 1245 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+  template<typename _Key, typename _Tp,
+    typename _Hash = hash<_Key>,
+    typename _Pred = equal_to<_Key>,
+    typename _Alloc = allocator<std::pair<const _Key, _Tp>>>
+    class unordered_multimap
+    {
+      typedef __ummap_hashtable<_Key, _Tp, _Hash, _Pred, _Alloc> _Hashtable;
+      _Hashtable _M_h;
+
+    public:
+
+
+
+      typedef typename _Hashtable::key_type key_type;
+      typedef typename _Hashtable::value_type value_type;
+      typedef typename _Hashtable::mapped_type mapped_type;
+      typedef typename _Hashtable::hasher hasher;
+      typedef typename _Hashtable::key_equal key_equal;
+      typedef typename _Hashtable::allocator_type allocator_type;
+
+
+
+
+      typedef typename _Hashtable::pointer pointer;
+      typedef typename _Hashtable::const_pointer const_pointer;
+      typedef typename _Hashtable::reference reference;
+      typedef typename _Hashtable::const_reference const_reference;
+      typedef typename _Hashtable::iterator iterator;
+      typedef typename _Hashtable::const_iterator const_iterator;
+      typedef typename _Hashtable::local_iterator local_iterator;
+      typedef typename _Hashtable::const_local_iterator const_local_iterator;
+      typedef typename _Hashtable::size_type size_type;
+      typedef typename _Hashtable::difference_type difference_type;
+
+
+
+      using node_type = typename _Hashtable::node_type;
+
+
+
+
+
+      unordered_multimap() = default;
+# 1296 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      explicit
+      unordered_multimap(size_type __n,
+    const hasher& __hf = hasher(),
+    const key_equal& __eql = key_equal(),
+    const allocator_type& __a = allocator_type())
+      : _M_h(__n, __hf, __eql, __a)
+      { }
+# 1317 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      template<typename _InputIterator>
+ unordered_multimap(_InputIterator __first, _InputIterator __last,
+      size_type __n = 0,
+      const hasher& __hf = hasher(),
+      const key_equal& __eql = key_equal(),
+      const allocator_type& __a = allocator_type())
+ : _M_h(__first, __last, __n, __hf, __eql, __a)
+ { }
+
+
+      unordered_multimap(const unordered_multimap&) = default;
+
+
+      unordered_multimap(unordered_multimap&&) = default;
+
+
+
+
+
+      explicit
+      unordered_multimap(const allocator_type& __a)
+      : _M_h(__a)
+      { }
+
+
+
+
+
+
+      unordered_multimap(const unordered_multimap& __ummap,
+    const allocator_type& __a)
+      : _M_h(__ummap._M_h, __a)
+      { }
+
+
+
+
+
+
+      unordered_multimap(unordered_multimap&& __ummap,
+    const allocator_type& __a)
+      : _M_h(std::move(__ummap._M_h), __a)
+      { }
+# 1372 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      unordered_multimap(initializer_list<value_type> __l,
+    size_type __n = 0,
+    const hasher& __hf = hasher(),
+    const key_equal& __eql = key_equal(),
+    const allocator_type& __a = allocator_type())
+      : _M_h(__l, __n, __hf, __eql, __a)
+      { }
+
+      unordered_multimap(size_type __n, const allocator_type& __a)
+      : unordered_multimap(__n, hasher(), key_equal(), __a)
+      { }
+
+      unordered_multimap(size_type __n, const hasher& __hf,
+    const allocator_type& __a)
+      : unordered_multimap(__n, __hf, key_equal(), __a)
+      { }
+
+      template<typename _InputIterator>
+ unordered_multimap(_InputIterator __first, _InputIterator __last,
+      size_type __n,
+      const allocator_type& __a)
+ : unordered_multimap(__first, __last, __n, hasher(), key_equal(), __a)
+ { }
+
+      template<typename _InputIterator>
+ unordered_multimap(_InputIterator __first, _InputIterator __last,
+      size_type __n, const hasher& __hf,
+      const allocator_type& __a)
+ : unordered_multimap(__first, __last, __n, __hf, key_equal(), __a)
+ { }
+
+      unordered_multimap(initializer_list<value_type> __l,
+    size_type __n,
+    const allocator_type& __a)
+      : unordered_multimap(__l, __n, hasher(), key_equal(), __a)
+      { }
+
+      unordered_multimap(initializer_list<value_type> __l,
+    size_type __n, const hasher& __hf,
+    const allocator_type& __a)
+      : unordered_multimap(__l, __n, __hf, key_equal(), __a)
+      { }
+
+
+      unordered_multimap&
+      operator=(const unordered_multimap&) = default;
+
+
+      unordered_multimap&
+      operator=(unordered_multimap&&) = default;
+# 1434 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      unordered_multimap&
+      operator=(initializer_list<value_type> __l)
+      {
+ _M_h = __l;
+ return *this;
+      }
+
+
+      allocator_type
+      get_allocator() const noexcept
+      { return _M_h.get_allocator(); }
+
+
+
+
+      [[__nodiscard__]] bool
+      empty() const noexcept
+      { return _M_h.empty(); }
+
+
+      size_type
+      size() const noexcept
+      { return _M_h.size(); }
+
+
+      size_type
+      max_size() const noexcept
+      { return _M_h.max_size(); }
+
+
+
+
+
+
+
+      iterator
+      begin() noexcept
+      { return _M_h.begin(); }
+
+
+
+
+
+
+      const_iterator
+      begin() const noexcept
+      { return _M_h.begin(); }
+
+      const_iterator
+      cbegin() const noexcept
+      { return _M_h.begin(); }
+
+
+
+
+
+
+      iterator
+      end() noexcept
+      { return _M_h.end(); }
+
+
+
+
+
+
+      const_iterator
+      end() const noexcept
+      { return _M_h.end(); }
+
+      const_iterator
+      cend() const noexcept
+      { return _M_h.end(); }
+# 1526 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      template<typename... _Args>
+ iterator
+ emplace(_Args&&... __args)
+ { return _M_h.emplace(std::forward<_Args>(__args)...); }
+# 1553 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      template<typename... _Args>
+ iterator
+ emplace_hint(const_iterator __pos, _Args&&... __args)
+ { return _M_h.emplace_hint(__pos, std::forward<_Args>(__args)...); }
+# 1568 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      iterator
+      insert(const value_type& __x)
+      { return _M_h.insert(__x); }
+
+      iterator
+      insert(value_type&& __x)
+      { return _M_h.insert(std::move(__x)); }
+
+      template<typename _Pair>
+ __enable_if_t<is_constructible<value_type, _Pair&&>::value, iterator>
+ insert(_Pair&& __x)
+        { return _M_h.emplace(std::forward<_Pair>(__x)); }
+# 1602 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      iterator
+      insert(const_iterator __hint, const value_type& __x)
+      { return _M_h.insert(__hint, __x); }
+
+
+
+      iterator
+      insert(const_iterator __hint, value_type&& __x)
+      { return _M_h.insert(__hint, std::move(__x)); }
+
+      template<typename _Pair>
+ __enable_if_t<is_constructible<value_type, _Pair&&>::value, iterator>
+ insert(const_iterator __hint, _Pair&& __x)
+        { return _M_h.emplace_hint(__hint, std::forward<_Pair>(__x)); }
+# 1627 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      template<typename _InputIterator>
+ void
+ insert(_InputIterator __first, _InputIterator __last)
+ { _M_h.insert(__first, __last); }
+# 1640 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      void
+      insert(initializer_list<value_type> __l)
+      { _M_h.insert(__l); }
+
+
+
+      node_type
+      extract(const_iterator __pos)
+      {
+ ;
+ return _M_h.extract(__pos);
+      }
+
+
+      node_type
+      extract(const key_type& __key)
+      { return _M_h.extract(__key); }
+
+
+      iterator
+      insert(node_type&& __nh)
+      { return _M_h._M_reinsert_node_multi(cend(), std::move(__nh)); }
+
+
+      iterator
+      insert(const_iterator __hint, node_type&& __nh)
+      { return _M_h._M_reinsert_node_multi(__hint, std::move(__nh)); }
+# 1683 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      iterator
+      erase(const_iterator __position)
+      { return _M_h.erase(__position); }
+
+
+      iterator
+      erase(iterator __position)
+      { return _M_h.erase(__position); }
+# 1704 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      size_type
+      erase(const key_type& __x)
+      { return _M_h.erase(__x); }
+# 1723 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      iterator
+      erase(const_iterator __first, const_iterator __last)
+      { return _M_h.erase(__first, __last); }
+
+
+
+
+
+
+
+      void
+      clear() noexcept
+      { _M_h.clear(); }
+# 1747 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      void
+      swap(unordered_multimap& __x)
+      noexcept( noexcept(_M_h.swap(__x._M_h)) )
+      { _M_h.swap(__x._M_h); }
+
+
+      template<typename, typename, typename>
+ friend class std::_Hash_merge_helper;
+
+      template<typename _H2, typename _P2>
+ void
+ merge(unordered_multimap<_Key, _Tp, _H2, _P2, _Alloc>& __source)
+ {
+   using _Merge_helper
+     = _Hash_merge_helper<unordered_multimap, _H2, _P2>;
+   _M_h._M_merge_multi(_Merge_helper::_S_get_table(__source));
+ }
+
+      template<typename _H2, typename _P2>
+ void
+ merge(unordered_multimap<_Key, _Tp, _H2, _P2, _Alloc>&& __source)
+ { merge(__source); }
+
+      template<typename _H2, typename _P2>
+ void
+ merge(unordered_map<_Key, _Tp, _H2, _P2, _Alloc>& __source)
+ {
+   using _Merge_helper
+     = _Hash_merge_helper<unordered_multimap, _H2, _P2>;
+   _M_h._M_merge_multi(_Merge_helper::_S_get_table(__source));
+ }
+
+      template<typename _H2, typename _P2>
+ void
+ merge(unordered_map<_Key, _Tp, _H2, _P2, _Alloc>&& __source)
+ { merge(__source); }
+
+
+
+
+
+
+      hasher
+      hash_function() const
+      { return _M_h.hash_function(); }
+
+
+
+      key_equal
+      key_eq() const
+      { return _M_h.key_eq(); }
+# 1813 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      iterator
+      find(const key_type& __x)
+      { return _M_h.find(__x); }
+
+      const_iterator
+      find(const key_type& __x) const
+      { return _M_h.find(__x); }
+
+
+
+
+
+
+
+      size_type
+      count(const key_type& __x) const
+      { return _M_h.count(__x); }
+# 1849 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      std::pair<iterator, iterator>
+      equal_range(const key_type& __x)
+      { return _M_h.equal_range(__x); }
+
+      std::pair<const_iterator, const_iterator>
+      equal_range(const key_type& __x) const
+      { return _M_h.equal_range(__x); }
+
+
+
+
+
+      size_type
+      bucket_count() const noexcept
+      { return _M_h.bucket_count(); }
+
+
+      size_type
+      max_bucket_count() const noexcept
+      { return _M_h.max_bucket_count(); }
+
+
+
+
+
+
+      size_type
+      bucket_size(size_type __n) const
+      { return _M_h.bucket_size(__n); }
+
+
+
+
+
+
+      size_type
+      bucket(const key_type& __key) const
+      { return _M_h.bucket(__key); }
+
+
+
+
+
+
+
+      local_iterator
+      begin(size_type __n)
+      { return _M_h.begin(__n); }
+# 1905 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      const_local_iterator
+      begin(size_type __n) const
+      { return _M_h.begin(__n); }
+
+      const_local_iterator
+      cbegin(size_type __n) const
+      { return _M_h.cbegin(__n); }
+# 1920 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      local_iterator
+      end(size_type __n)
+      { return _M_h.end(__n); }
+# 1931 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      const_local_iterator
+      end(size_type __n) const
+      { return _M_h.end(__n); }
+
+      const_local_iterator
+      cend(size_type __n) const
+      { return _M_h.cend(__n); }
+
+
+
+
+
+      float
+      load_factor() const noexcept
+      { return _M_h.load_factor(); }
+
+
+
+      float
+      max_load_factor() const noexcept
+      { return _M_h.max_load_factor(); }
+
+
+
+
+
+      void
+      max_load_factor(float __z)
+      { _M_h.max_load_factor(__z); }
+# 1968 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      void
+      rehash(size_type __n)
+      { _M_h.rehash(__n); }
+# 1979 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      void
+      reserve(size_type __n)
+      { _M_h.reserve(__n); }
+
+      template<typename _Key1, typename _Tp1, typename _Hash1, typename _Pred1,
+        typename _Alloc1>
+        friend bool
+ operator==(const unordered_multimap<_Key1, _Tp1,
+         _Hash1, _Pred1, _Alloc1>&,
+     const unordered_multimap<_Key1, _Tp1,
+         _Hash1, _Pred1, _Alloc1>&);
+    };
+
+
+
+  template<typename _InputIterator,
+    typename _Hash = hash<__iter_key_t<_InputIterator>>,
+    typename _Pred = equal_to<__iter_key_t<_InputIterator>>,
+    typename _Allocator = allocator<__iter_to_alloc_t<_InputIterator>>,
+    typename = _RequireInputIter<_InputIterator>,
+    typename = _RequireNotAllocatorOrIntegral<_Hash>,
+    typename = _RequireNotAllocator<_Pred>,
+    typename = _RequireAllocator<_Allocator>>
+    unordered_multimap(_InputIterator, _InputIterator,
+         unordered_multimap<int, int>::size_type = {},
+         _Hash = _Hash(), _Pred = _Pred(),
+         _Allocator = _Allocator())
+    -> unordered_multimap<__iter_key_t<_InputIterator>,
+     __iter_val_t<_InputIterator>, _Hash, _Pred,
+     _Allocator>;
+
+  template<typename _Key, typename _Tp, typename _Hash = hash<_Key>,
+    typename _Pred = equal_to<_Key>,
+    typename _Allocator = allocator<pair<const _Key, _Tp>>,
+    typename = _RequireNotAllocatorOrIntegral<_Hash>,
+    typename = _RequireNotAllocator<_Pred>,
+    typename = _RequireAllocator<_Allocator>>
+    unordered_multimap(initializer_list<pair<_Key, _Tp>>,
+         unordered_multimap<int, int>::size_type = {},
+         _Hash = _Hash(), _Pred = _Pred(),
+         _Allocator = _Allocator())
+    -> unordered_multimap<_Key, _Tp, _Hash, _Pred, _Allocator>;
+
+  template<typename _InputIterator, typename _Allocator,
+    typename = _RequireInputIter<_InputIterator>,
+    typename = _RequireAllocator<_Allocator>>
+    unordered_multimap(_InputIterator, _InputIterator,
+         unordered_multimap<int, int>::size_type, _Allocator)
+    -> unordered_multimap<__iter_key_t<_InputIterator>,
+     __iter_val_t<_InputIterator>,
+     hash<__iter_key_t<_InputIterator>>,
+     equal_to<__iter_key_t<_InputIterator>>, _Allocator>;
+
+  template<typename _InputIterator, typename _Allocator,
+    typename = _RequireInputIter<_InputIterator>,
+    typename = _RequireAllocator<_Allocator>>
+    unordered_multimap(_InputIterator, _InputIterator, _Allocator)
+    -> unordered_multimap<__iter_key_t<_InputIterator>,
+     __iter_val_t<_InputIterator>,
+     hash<__iter_key_t<_InputIterator>>,
+     equal_to<__iter_key_t<_InputIterator>>, _Allocator>;
+
+  template<typename _InputIterator, typename _Hash, typename _Allocator,
+    typename = _RequireInputIter<_InputIterator>,
+    typename = _RequireNotAllocatorOrIntegral<_Hash>,
+    typename = _RequireAllocator<_Allocator>>
+    unordered_multimap(_InputIterator, _InputIterator,
+         unordered_multimap<int, int>::size_type, _Hash,
+         _Allocator)
+    -> unordered_multimap<__iter_key_t<_InputIterator>,
+     __iter_val_t<_InputIterator>, _Hash,
+     equal_to<__iter_key_t<_InputIterator>>, _Allocator>;
+
+  template<typename _Key, typename _Tp, typename _Allocator,
+    typename = _RequireAllocator<_Allocator>>
+    unordered_multimap(initializer_list<pair<_Key, _Tp>>,
+         unordered_multimap<int, int>::size_type,
+         _Allocator)
+    -> unordered_multimap<_Key, _Tp, hash<_Key>, equal_to<_Key>, _Allocator>;
+
+  template<typename _Key, typename _Tp, typename _Allocator,
+    typename = _RequireAllocator<_Allocator>>
+    unordered_multimap(initializer_list<pair<_Key, _Tp>>, _Allocator)
+    -> unordered_multimap<_Key, _Tp, hash<_Key>, equal_to<_Key>, _Allocator>;
+
+  template<typename _Key, typename _Tp, typename _Hash, typename _Allocator,
+    typename = _RequireNotAllocatorOrIntegral<_Hash>,
+    typename = _RequireAllocator<_Allocator>>
+    unordered_multimap(initializer_list<pair<_Key, _Tp>>,
+         unordered_multimap<int, int>::size_type,
+         _Hash, _Allocator)
+    -> unordered_multimap<_Key, _Tp, _Hash, equal_to<_Key>, _Allocator>;
+
+
+
+  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+    inline void
+    swap(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
+  unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
+    noexcept(noexcept(__x.swap(__y)))
+    { __x.swap(__y); }
+
+  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+    inline void
+    swap(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
+  unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
+    noexcept(noexcept(__x.swap(__y)))
+    { __x.swap(__y); }
+
+  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+    inline bool
+    operator==(const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
+        const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
+    { return __x._M_h._M_equal(__y._M_h); }
+
+
+  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+    inline bool
+    operator!=(const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
+        const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
+    { return !(__x == __y); }
+
+
+  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+    inline bool
+    operator==(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
+        const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
+    { return __x._M_h._M_equal(__y._M_h); }
+
+
+  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+    inline bool
+    operator!=(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
+        const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
+    { return !(__x == __y); }
+
+
+
+
+
+
+  template<typename _Key, typename _Val, typename _Hash1, typename _Eq1,
+    typename _Alloc, typename _Hash2, typename _Eq2>
+    struct _Hash_merge_helper<
+      std::unordered_map<_Key, _Val, _Hash1, _Eq1, _Alloc>,
+      _Hash2, _Eq2>
+    {
+    private:
+      template<typename... _Tp>
+ using unordered_map = std::unordered_map<_Tp...>;
+      template<typename... _Tp>
+ using unordered_multimap = std::unordered_multimap<_Tp...>;
+
+      friend unordered_map<_Key, _Val, _Hash1, _Eq1, _Alloc>;
+
+      static auto&
+      _S_get_table(unordered_map<_Key, _Val, _Hash2, _Eq2, _Alloc>& __map)
+      { return __map._M_h; }
+
+      static auto&
+      _S_get_table(unordered_multimap<_Key, _Val, _Hash2, _Eq2, _Alloc>& __map)
+      { return __map._M_h; }
+    };
+
+
+  template<typename _Key, typename _Val, typename _Hash1, typename _Eq1,
+    typename _Alloc, typename _Hash2, typename _Eq2>
+    struct _Hash_merge_helper<
+      std::unordered_multimap<_Key, _Val, _Hash1, _Eq1, _Alloc>,
+      _Hash2, _Eq2>
+    {
+    private:
+      template<typename... _Tp>
+ using unordered_map = std::unordered_map<_Tp...>;
+      template<typename... _Tp>
+ using unordered_multimap = std::unordered_multimap<_Tp...>;
+
+      friend unordered_multimap<_Key, _Val, _Hash1, _Eq1, _Alloc>;
+
+      static auto&
+      _S_get_table(unordered_map<_Key, _Val, _Hash2, _Eq2, _Alloc>& __map)
+      { return __map._M_h; }
+
+      static auto&
+      _S_get_table(unordered_multimap<_Key, _Val, _Hash2, _Eq2, _Alloc>& __map)
+      { return __map._M_h; }
+    };
+
+
+
+}
+# 48 "/usr/include/c++/10.2.0/unordered_map" 2 3
+
+# 1 "/usr/include/c++/10.2.0/bits/erase_if.h" 1 3
+# 31 "/usr/include/c++/10.2.0/bits/erase_if.h" 3
+#define _GLIBCXX_ERASE_IF_H 1
+
+       
+# 34 "/usr/include/c++/10.2.0/bits/erase_if.h" 3
+
+
+
+namespace std
+{
+
+
+
+
+
+
+  namespace __detail
+  {
+    template<typename _Container, typename _Predicate>
+      typename _Container::size_type
+      __erase_nodes_if(_Container& __cont, _Predicate __pred)
+      {
+ typename _Container::size_type __num = 0;
+ for (auto __iter = __cont.begin(), __last = __cont.end();
+      __iter != __last;)
+   {
+     if (__pred(*__iter))
+       {
+  __iter = __cont.erase(__iter);
+  ++__num;
+       }
+     else
+       ++__iter;
+   }
+ return __num;
+      }
+  }
+
+
+}
+# 50 "/usr/include/c++/10.2.0/unordered_map" 2 3
+
+
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  namespace pmr
+  {
+    template<typename _Tp> class polymorphic_allocator;
+    template<typename _Key, typename _Tp, typename _Hash = std::hash<_Key>,
+      typename _Pred = std::equal_to<_Key>>
+      using unordered_map
+ = std::unordered_map<_Key, _Tp, _Hash, _Pred,
+        polymorphic_allocator<pair<const _Key, _Tp>>>;
+    template<typename _Key, typename _Tp, typename _Hash = std::hash<_Key>,
+      typename _Pred = std::equal_to<_Key>>
+      using unordered_multimap
+ = std::unordered_multimap<_Key, _Tp, _Hash, _Pred,
+      polymorphic_allocator<pair<const _Key, _Tp>>>;
+  }
+
+}
+# 62 "/usr/include/c++/10.2.0/functional" 2 3
+# 1 "/usr/include/c++/10.2.0/vector" 1 3
+# 56 "/usr/include/c++/10.2.0/vector" 3
+#define _GLIBCXX_VECTOR 1
+
+       
+# 59 "/usr/include/c++/10.2.0/vector" 3
+# 67 "/usr/include/c++/10.2.0/vector" 3
+# 1 "/usr/include/c++/10.2.0/bits/stl_vector.h" 1 3
+# 57 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+#define _STL_VECTOR_H 1
+# 77 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+  template<typename _Tp, typename _Alloc>
+    struct _Vector_base
+    {
+      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
+ rebind<_Tp>::other _Tp_alloc_type;
+      typedef typename __gnu_cxx::__alloc_traits<_Tp_alloc_type>::pointer
+        pointer;
+
+      struct _Vector_impl_data
+      {
+ pointer _M_start;
+ pointer _M_finish;
+ pointer _M_end_of_storage;
+
+ _Vector_impl_data() noexcept
+ : _M_start(), _M_finish(), _M_end_of_storage()
+ { }
+
+
+ _Vector_impl_data(_Vector_impl_data&& __x) noexcept
+ : _M_start(__x._M_start), _M_finish(__x._M_finish),
+   _M_end_of_storage(__x._M_end_of_storage)
+ { __x._M_start = __x._M_finish = __x._M_end_of_storage = pointer(); }
+
+
+ void
+ _M_copy_data(_Vector_impl_data const& __x) noexcept
+ {
+   _M_start = __x._M_start;
+   _M_finish = __x._M_finish;
+   _M_end_of_storage = __x._M_end_of_storage;
+ }
+
+ void
+ _M_swap_data(_Vector_impl_data& __x) noexcept
+ {
+
+
+   _Vector_impl_data __tmp;
+   __tmp._M_copy_data(*this);
+   _M_copy_data(__x);
+   __x._M_copy_data(__tmp);
+ }
+      };
+
+      struct _Vector_impl
+ : public _Tp_alloc_type, public _Vector_impl_data
+      {
+ _Vector_impl() noexcept(is_nothrow_default_constructible<_Tp_alloc_type>::value)
+
+ : _Tp_alloc_type()
+ { }
+
+ _Vector_impl(_Tp_alloc_type const& __a) noexcept
+ : _Tp_alloc_type(__a)
+ { }
+
+
+
+
+ _Vector_impl(_Vector_impl&& __x) noexcept
+ : _Tp_alloc_type(std::move(__x)), _Vector_impl_data(std::move(__x))
+ { }
+
+ _Vector_impl(_Tp_alloc_type&& __a) noexcept
+ : _Tp_alloc_type(std::move(__a))
+ { }
+
+ _Vector_impl(_Tp_alloc_type&& __a, _Vector_impl&& __rv) noexcept
+ : _Tp_alloc_type(std::move(__a)), _Vector_impl_data(std::move(__rv))
+ { }
+# 264 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+#define _GLIBCXX_ASAN_ANNOTATE_REINIT 
+#define _GLIBCXX_ASAN_ANNOTATE_GROW(n) 
+#define _GLIBCXX_ASAN_ANNOTATE_GREW(n) 
+#define _GLIBCXX_ASAN_ANNOTATE_SHRINK(n) 
+#define _GLIBCXX_ASAN_ANNOTATE_BEFORE_DEALLOC 
+
+      };
+
+    public:
+      typedef _Alloc allocator_type;
+
+      _Tp_alloc_type&
+      _M_get_Tp_allocator() noexcept
+      { return this->_M_impl; }
+
+      const _Tp_alloc_type&
+      _M_get_Tp_allocator() const noexcept
+      { return this->_M_impl; }
+
+      allocator_type
+      get_allocator() const noexcept
+      { return allocator_type(_M_get_Tp_allocator()); }
+
+
+      _Vector_base() = default;
+
+
+
+
+      _Vector_base(const allocator_type& __a) noexcept
+      : _M_impl(__a) { }
+
+
+
+      _Vector_base(size_t __n)
+      : _M_impl()
+      { _M_create_storage(__n); }
+
+
+      _Vector_base(size_t __n, const allocator_type& __a)
+      : _M_impl(__a)
+      { _M_create_storage(__n); }
+
+
+      _Vector_base(_Vector_base&&) = default;
+
+
+
+      _Vector_base(_Tp_alloc_type&& __a) noexcept
+      : _M_impl(std::move(__a)) { }
+
+      _Vector_base(_Vector_base&& __x, const allocator_type& __a)
+      : _M_impl(__a)
+      {
+ if (__x.get_allocator() == __a)
+   this->_M_impl._M_swap_data(__x._M_impl);
+ else
+   {
+     size_t __n = __x._M_impl._M_finish - __x._M_impl._M_start;
+     _M_create_storage(__n);
+   }
+      }
+
+
+      _Vector_base(const allocator_type& __a, _Vector_base&& __x)
+      : _M_impl(_Tp_alloc_type(__a), std::move(__x._M_impl))
+      { }
+
+
+      ~_Vector_base() noexcept
+      {
+ _M_deallocate(_M_impl._M_start,
+        _M_impl._M_end_of_storage - _M_impl._M_start);
+      }
+
+    public:
+      _Vector_impl _M_impl;
+
+      pointer
+      _M_allocate(size_t __n)
+      {
+ typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tr;
+ return __n != 0 ? _Tr::allocate(_M_impl, __n) : pointer();
+      }
+
+      void
+      _M_deallocate(pointer __p, size_t __n)
+      {
+ typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tr;
+ if (__p)
+   _Tr::deallocate(_M_impl, __p, __n);
+      }
+
+    protected:
+      void
+      _M_create_storage(size_t __n)
+      {
+ this->_M_impl._M_start = this->_M_allocate(__n);
+ this->_M_impl._M_finish = this->_M_impl._M_start;
+ this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
+      }
+    };
+# 388 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+  template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
+    class vector : protected _Vector_base<_Tp, _Alloc>
+    {
+# 401 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      static_assert(is_same<typename remove_cv<_Tp>::type, _Tp>::value,
+   "std::vector must have a non-const, non-volatile value_type");
+
+      static_assert(is_same<typename _Alloc::value_type, _Tp>::value,
+   "std::vector must have the same value_type as its allocator");
+
+
+
+      typedef _Vector_base<_Tp, _Alloc> _Base;
+      typedef typename _Base::_Tp_alloc_type _Tp_alloc_type;
+      typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Alloc_traits;
+
+    public:
+      typedef _Tp value_type;
+      typedef typename _Base::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 __gnu_cxx::__normal_iterator<pointer, vector> iterator;
+      typedef __gnu_cxx::__normal_iterator<const_pointer, vector>
+      const_iterator;
+      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+      typedef std::reverse_iterator<iterator> reverse_iterator;
+      typedef size_t size_type;
+      typedef ptrdiff_t difference_type;
+      typedef _Alloc allocator_type;
+
+    private:
+
+      static constexpr bool
+      _S_nothrow_relocate(true_type)
+      {
+ return noexcept(std::__relocate_a(std::declval<pointer>(),
+       std::declval<pointer>(),
+       std::declval<pointer>(),
+       std::declval<_Tp_alloc_type&>()));
+      }
+
+      static constexpr bool
+      _S_nothrow_relocate(false_type)
+      { return false; }
+
+      static constexpr bool
+      _S_use_relocate()
+      {
+
+
+
+ return _S_nothrow_relocate(__is_move_insertable<_Tp_alloc_type>{});
+      }
+
+      static pointer
+      _S_do_relocate(pointer __first, pointer __last, pointer __result,
+       _Tp_alloc_type& __alloc, true_type) noexcept
+      {
+ return std::__relocate_a(__first, __last, __result, __alloc);
+      }
+
+      static pointer
+      _S_do_relocate(pointer, pointer, pointer __result,
+       _Tp_alloc_type&, false_type) noexcept
+      { return __result; }
+
+      static pointer
+      _S_relocate(pointer __first, pointer __last, pointer __result,
+    _Tp_alloc_type& __alloc) noexcept
+      {
+ using __do_it = __bool_constant<_S_use_relocate()>;
+ return _S_do_relocate(__first, __last, __result, __alloc, __do_it{});
+      }
+
+
+    protected:
+      using _Base::_M_allocate;
+      using _Base::_M_deallocate;
+      using _Base::_M_impl;
+      using _Base::_M_get_Tp_allocator;
+
+    public:
+
+
+
+
+
+
+
+      vector() = default;
+# 496 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      explicit
+      vector(const allocator_type& __a) noexcept
+      : _Base(__a) { }
+# 509 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      explicit
+      vector(size_type __n, const allocator_type& __a = allocator_type())
+      : _Base(_S_check_init_len(__n, __a), __a)
+      { _M_default_initialize(__n); }
+# 522 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      vector(size_type __n, const value_type& __value,
+      const allocator_type& __a = allocator_type())
+      : _Base(_S_check_init_len(__n, __a), __a)
+      { _M_fill_initialize(__n, __value); }
+# 553 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      vector(const vector& __x)
+      : _Base(__x.size(),
+ _Alloc_traits::_S_select_on_copy(__x._M_get_Tp_allocator()))
+      {
+ this->_M_impl._M_finish =
+   std::__uninitialized_copy_a(__x.begin(), __x.end(),
+          this->_M_impl._M_start,
+          _M_get_Tp_allocator());
+      }
+# 572 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      vector(vector&&) noexcept = default;
+
+
+      vector(const vector& __x, const allocator_type& __a)
+      : _Base(__x.size(), __a)
+      {
+ this->_M_impl._M_finish =
+   std::__uninitialized_copy_a(__x.begin(), __x.end(),
+          this->_M_impl._M_start,
+          _M_get_Tp_allocator());
+      }
+
+    private:
+      vector(vector&& __rv, const allocator_type& __m, true_type) noexcept
+      : _Base(__m, std::move(__rv))
+      { }
+
+      vector(vector&& __rv, const allocator_type& __m, false_type)
+      : _Base(__m)
+      {
+ if (__rv.get_allocator() == __m)
+   this->_M_impl._M_swap_data(__rv._M_impl);
+ else if (!__rv.empty())
+   {
+     this->_M_create_storage(__rv.size());
+     this->_M_impl._M_finish =
+       std::__uninitialized_move_a(__rv.begin(), __rv.end(),
+       this->_M_impl._M_start,
+       _M_get_Tp_allocator());
+     __rv.clear();
+   }
+      }
+
+    public:
+
+      vector(vector&& __rv, const allocator_type& __m)
+      noexcept( noexcept(
+ vector(std::declval<vector&&>(), std::declval<const allocator_type&>(),
+        std::declval<typename _Alloc_traits::is_always_equal>())) )
+      : vector(std::move(__rv), __m, typename _Alloc_traits::is_always_equal{})
+      { }
+# 625 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      vector(initializer_list<value_type> __l,
+      const allocator_type& __a = allocator_type())
+      : _Base(__a)
+      {
+ _M_range_initialize(__l.begin(), __l.end(),
+       random_access_iterator_tag());
+      }
+# 651 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      template<typename _InputIterator,
+        typename = std::_RequireInputIter<_InputIterator>>
+ vector(_InputIterator __first, _InputIterator __last,
+        const allocator_type& __a = allocator_type())
+ : _Base(__a)
+ {
+   _M_range_initialize(__first, __last,
+         std::__iterator_category(__first));
+ }
+# 678 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      ~vector() noexcept
+      {
+ std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
+        _M_get_Tp_allocator());
+ ;
+      }
+# 694 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      vector&
+      operator=(const vector& __x);
+# 708 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      vector&
+      operator=(vector&& __x) noexcept(_Alloc_traits::_S_nothrow_move())
+      {
+ constexpr bool __move_storage =
+   _Alloc_traits::_S_propagate_on_move_assign()
+   || _Alloc_traits::_S_always_equal();
+ _M_move_assign(std::move(__x), __bool_constant<__move_storage>());
+ return *this;
+      }
+# 729 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      vector&
+      operator=(initializer_list<value_type> __l)
+      {
+ this->_M_assign_aux(__l.begin(), __l.end(),
+       random_access_iterator_tag());
+ return *this;
+      }
+# 748 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      void
+      assign(size_type __n, const value_type& __val)
+      { _M_fill_assign(__n, __val); }
+# 765 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      template<typename _InputIterator,
+        typename = std::_RequireInputIter<_InputIterator>>
+ void
+ assign(_InputIterator __first, _InputIterator __last)
+ { _M_assign_dispatch(__first, __last, __false_type()); }
+# 793 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      void
+      assign(initializer_list<value_type> __l)
+      {
+ this->_M_assign_aux(__l.begin(), __l.end(),
+       random_access_iterator_tag());
+      }
+
+
+
+      using _Base::get_allocator;
+
+
+
+
+
+
+
+      iterator
+      begin() noexcept
+      { return iterator(this->_M_impl._M_start); }
+
+
+
+
+
+
+      const_iterator
+      begin() const noexcept
+      { return const_iterator(this->_M_impl._M_start); }
+
+
+
+
+
+
+      iterator
+      end() noexcept
+      { return iterator(this->_M_impl._M_finish); }
+
+
+
+
+
+
+      const_iterator
+      end() const noexcept
+      { return const_iterator(this->_M_impl._M_finish); }
+
+
+
+
+
+
+      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()); }
+
+
+
+
+
+
+
+      const_iterator
+      cbegin() const noexcept
+      { return const_iterator(this->_M_impl._M_start); }
+
+
+
+
+
+
+      const_iterator
+      cend() const noexcept
+      { return const_iterator(this->_M_impl._M_finish); }
+
+
+
+
+
+
+      const_reverse_iterator
+      crbegin() const noexcept
+      { return const_reverse_iterator(end()); }
+
+
+
+
+
+
+      const_reverse_iterator
+      crend() const noexcept
+      { return const_reverse_iterator(begin()); }
+
+
+
+
+      size_type
+      size() const noexcept
+      { return size_type(this->_M_impl._M_finish - this->_M_impl._M_start); }
+
+
+      size_type
+      max_size() const noexcept
+      { return _S_max_size(_M_get_Tp_allocator()); }
+# 936 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      void
+      resize(size_type __new_size)
+      {
+ if (__new_size > size())
+   _M_default_append(__new_size - size());
+ else if (__new_size < size())
+   _M_erase_at_end(this->_M_impl._M_start + __new_size);
+      }
+# 956 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      void
+      resize(size_type __new_size, const value_type& __x)
+      {
+ if (__new_size > size())
+   _M_fill_insert(end(), __new_size - size(), __x);
+ else if (__new_size < size())
+   _M_erase_at_end(this->_M_impl._M_start + __new_size);
+      }
+# 988 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      void
+      shrink_to_fit()
+      { _M_shrink_to_fit(); }
+
+
+
+
+
+
+      size_type
+      capacity() const noexcept
+      { return size_type(this->_M_impl._M_end_of_storage
+    - this->_M_impl._M_start); }
+
+
+
+
+
+      [[__nodiscard__]] bool
+      empty() const noexcept
+      { return begin() == end(); }
+# 1027 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      void
+      reserve(size_type __n);
+# 1042 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      reference
+      operator[](size_type __n) noexcept
+      {
+ ;
+ return *(this->_M_impl._M_start + __n);
+      }
+# 1060 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      const_reference
+      operator[](size_type __n) const noexcept
+      {
+ ;
+ return *(this->_M_impl._M_start + __n);
+      }
+
+    protected:
+
+      void
+      _M_range_check(size_type __n) const
+      {
+ if (__n >= this->size())
+   __throw_out_of_range_fmt(("vector::_M_range_check: __n " "(which is %zu) >= this->size() " "(which is %zu)")
+
+                            ,
+       __n, this->size());
+      }
+
+    public:
+# 1091 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      reference
+      at(size_type __n)
+      {
+ _M_range_check(__n);
+ return (*this)[__n];
+      }
+# 1109 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      const_reference
+      at(size_type __n) const
+      {
+ _M_range_check(__n);
+ return (*this)[__n];
+      }
+
+
+
+
+
+      reference
+      front() noexcept
+      {
+ ;
+ return *begin();
+      }
+
+
+
+
+
+      const_reference
+      front() const noexcept
+      {
+ ;
+ return *begin();
+      }
+
+
+
+
+
+      reference
+      back() noexcept
+      {
+ ;
+ return *(end() - 1);
+      }
+
+
+
+
+
+      const_reference
+      back() const noexcept
+      {
+ ;
+ return *(end() - 1);
+      }
+# 1167 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      _Tp*
+      data() noexcept
+      { return _M_data_ptr(this->_M_impl._M_start); }
+
+      const _Tp*
+      data() const noexcept
+      { return _M_data_ptr(this->_M_impl._M_start); }
+# 1186 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      void
+      push_back(const value_type& __x)
+      {
+ if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
+   {
+     ;
+     _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
+         __x);
+     ++this->_M_impl._M_finish;
+     ;
+   }
+ else
+   _M_realloc_insert(end(), __x);
+      }
+
+
+      void
+      push_back(value_type&& __x)
+      { emplace_back(std::move(__x)); }
+
+      template<typename... _Args>
+
+ reference
+
+
+
+ emplace_back(_Args&&... __args);
+# 1224 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      void
+      pop_back() noexcept
+      {
+ ;
+ --this->_M_impl._M_finish;
+ _Alloc_traits::destroy(this->_M_impl, this->_M_impl._M_finish);
+ ;
+      }
+# 1246 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      template<typename... _Args>
+ iterator
+ emplace(const_iterator __position, _Args&&... __args)
+ { return _M_emplace_aux(__position, std::forward<_Args>(__args)...); }
+# 1262 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      iterator
+      insert(const_iterator __position, const value_type& __x);
+# 1292 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      iterator
+      insert(const_iterator __position, value_type&& __x)
+      { return _M_insert_rval(__position, std::move(__x)); }
+# 1309 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      iterator
+      insert(const_iterator __position, initializer_list<value_type> __l)
+      {
+ auto __offset = __position - cbegin();
+ _M_range_insert(begin() + __offset, __l.begin(), __l.end(),
+   std::random_access_iterator_tag());
+ return begin() + __offset;
+      }
+# 1334 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      iterator
+      insert(const_iterator __position, size_type __n, const value_type& __x)
+      {
+ difference_type __offset = __position - cbegin();
+ _M_fill_insert(begin() + __offset, __n, __x);
+ return begin() + __offset;
+      }
+# 1376 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      template<typename _InputIterator,
+        typename = std::_RequireInputIter<_InputIterator>>
+ iterator
+ insert(const_iterator __position, _InputIterator __first,
+        _InputIterator __last)
+ {
+   difference_type __offset = __position - cbegin();
+   _M_insert_dispatch(begin() + __offset,
+        __first, __last, __false_type());
+   return begin() + __offset;
+ }
+# 1428 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      iterator
+
+      erase(const_iterator __position)
+      { return _M_erase(begin() + (__position - cbegin())); }
+# 1455 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      iterator
+
+      erase(const_iterator __first, const_iterator __last)
+      {
+ const auto __beg = begin();
+ const auto __cbeg = cbegin();
+ return _M_erase(__beg + (__first - __cbeg), __beg + (__last - __cbeg));
+      }
+# 1479 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      void
+      swap(vector& __x) noexcept
+      {
+
+
+                                                          ;
+
+ this->_M_impl._M_swap_data(__x._M_impl);
+ _Alloc_traits::_S_on_swap(_M_get_Tp_allocator(),
+      __x._M_get_Tp_allocator());
+      }
+
+
+
+
+
+
+
+      void
+      clear() noexcept
+      { _M_erase_at_end(this->_M_impl._M_start); }
+
+    protected:
+
+
+
+
+      template<typename _ForwardIterator>
+ pointer
+ _M_allocate_and_copy(size_type __n,
+        _ForwardIterator __first, _ForwardIterator __last)
+ {
+   pointer __result = this->_M_allocate(__n);
+   try
+     {
+       std::__uninitialized_copy_a(__first, __last, __result,
+       _M_get_Tp_allocator());
+       return __result;
+     }
+   catch(...)
+     {
+       _M_deallocate(__result, __n);
+       throw;
+     }
+ }
+# 1556 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      template<typename _InputIterator>
+ void
+ _M_range_initialize(_InputIterator __first, _InputIterator __last,
+       std::input_iterator_tag)
+ {
+   try {
+     for (; __first != __last; ++__first)
+
+       emplace_back(*__first);
+
+
+
+   } catch(...) {
+     clear();
+     throw;
+   }
+ }
+
+
+      template<typename _ForwardIterator>
+ void
+ _M_range_initialize(_ForwardIterator __first, _ForwardIterator __last,
+       std::forward_iterator_tag)
+ {
+   const size_type __n = std::distance(__first, __last);
+   this->_M_impl._M_start
+     = this->_M_allocate(_S_check_init_len(__n, _M_get_Tp_allocator()));
+   this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
+   this->_M_impl._M_finish =
+     std::__uninitialized_copy_a(__first, __last,
+     this->_M_impl._M_start,
+     _M_get_Tp_allocator());
+ }
+
+
+
+      void
+      _M_fill_initialize(size_type __n, const value_type& __value)
+      {
+ this->_M_impl._M_finish =
+   std::__uninitialized_fill_n_a(this->_M_impl._M_start, __n, __value,
+     _M_get_Tp_allocator());
+      }
+
+
+
+      void
+      _M_default_initialize(size_type __n)
+      {
+ this->_M_impl._M_finish =
+   std::__uninitialized_default_n_a(this->_M_impl._M_start, __n,
+        _M_get_Tp_allocator());
+      }
+# 1618 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      template<typename _Integer>
+ void
+ _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
+ { _M_fill_assign(__n, __val); }
+
+
+      template<typename _InputIterator>
+ void
+ _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
+      __false_type)
+ { _M_assign_aux(__first, __last, std::__iterator_category(__first)); }
+
+
+      template<typename _InputIterator>
+ void
+ _M_assign_aux(_InputIterator __first, _InputIterator __last,
+        std::input_iterator_tag);
+
+
+      template<typename _ForwardIterator>
+ void
+ _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
+        std::forward_iterator_tag);
+
+
+
+      void
+      _M_fill_assign(size_type __n, const value_type& __val);
+
+
+
+
+
+
+
+      template<typename _Integer>
+ void
+ _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __val,
+      __true_type)
+ { _M_fill_insert(__pos, __n, __val); }
+
+
+      template<typename _InputIterator>
+ void
+ _M_insert_dispatch(iterator __pos, _InputIterator __first,
+      _InputIterator __last, __false_type)
+ {
+   _M_range_insert(__pos, __first, __last,
+     std::__iterator_category(__first));
+ }
+
+
+      template<typename _InputIterator>
+ void
+ _M_range_insert(iterator __pos, _InputIterator __first,
+   _InputIterator __last, std::input_iterator_tag);
+
+
+      template<typename _ForwardIterator>
+ void
+ _M_range_insert(iterator __pos, _ForwardIterator __first,
+   _ForwardIterator __last, std::forward_iterator_tag);
+
+
+
+      void
+      _M_fill_insert(iterator __pos, size_type __n, const value_type& __x);
+
+
+
+      void
+      _M_default_append(size_type __n);
+
+      bool
+      _M_shrink_to_fit();
+# 1705 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      struct _Temporary_value
+      {
+ template<typename... _Args>
+   explicit
+   _Temporary_value(vector* __vec, _Args&&... __args) : _M_this(__vec)
+   {
+     _Alloc_traits::construct(_M_this->_M_impl, _M_ptr(),
+         std::forward<_Args>(__args)...);
+   }
+
+ ~_Temporary_value()
+ { _Alloc_traits::destroy(_M_this->_M_impl, _M_ptr()); }
+
+ value_type&
+ _M_val() { return *_M_ptr(); }
+
+      private:
+ _Tp*
+ _M_ptr() { return reinterpret_cast<_Tp*>(&__buf); }
+
+ vector* _M_this;
+ typename aligned_storage<sizeof(_Tp), alignof(_Tp)>::type __buf;
+      };
+
+
+
+      template<typename _Arg>
+ void
+ _M_insert_aux(iterator __position, _Arg&& __arg);
+
+      template<typename... _Args>
+ void
+ _M_realloc_insert(iterator __position, _Args&&... __args);
+
+
+      iterator
+      _M_insert_rval(const_iterator __position, value_type&& __v);
+
+
+      template<typename... _Args>
+ iterator
+ _M_emplace_aux(const_iterator __position, _Args&&... __args);
+
+
+      iterator
+      _M_emplace_aux(const_iterator __position, value_type&& __v)
+      { return _M_insert_rval(__position, std::move(__v)); }
+
+
+
+      size_type
+      _M_check_len(size_type __n, const char* __s) const
+      {
+ if (max_size() - size() < __n)
+   __throw_length_error((__s));
+
+ const size_type __len = size() + (std::max)(size(), __n);
+ return (__len < size() || __len > max_size()) ? max_size() : __len;
+      }
+
+
+      static size_type
+      _S_check_init_len(size_type __n, const allocator_type& __a)
+      {
+ if (__n > _S_max_size(_Tp_alloc_type(__a)))
+   __throw_length_error(
+       ("cannot create std::vector larger than max_size()"));
+ return __n;
+      }
+
+      static size_type
+      _S_max_size(const _Tp_alloc_type& __a) noexcept
+      {
+
+
+
+ const size_t __diffmax
+   = __gnu_cxx::__numeric_traits<ptrdiff_t>::__max / sizeof(_Tp);
+ const size_t __allocmax = _Alloc_traits::max_size(__a);
+ return (std::min)(__diffmax, __allocmax);
+      }
+
+
+
+
+
+      void
+      _M_erase_at_end(pointer __pos) noexcept
+      {
+ if (size_type __n = this->_M_impl._M_finish - __pos)
+   {
+     std::_Destroy(__pos, this->_M_impl._M_finish,
+     _M_get_Tp_allocator());
+     this->_M_impl._M_finish = __pos;
+     ;
+   }
+      }
+
+      iterator
+      _M_erase(iterator __position);
+
+      iterator
+      _M_erase(iterator __first, iterator __last);
+
+
+    private:
+
+
+
+      void
+      _M_move_assign(vector&& __x, true_type) noexcept
+      {
+ vector __tmp(get_allocator());
+ this->_M_impl._M_swap_data(__x._M_impl);
+ __tmp._M_impl._M_swap_data(__x._M_impl);
+ std::__alloc_on_move(_M_get_Tp_allocator(), __x._M_get_Tp_allocator());
+      }
+
+
+
+      void
+      _M_move_assign(vector&& __x, false_type)
+      {
+ if (__x._M_get_Tp_allocator() == this->_M_get_Tp_allocator())
+   _M_move_assign(std::move(__x), true_type());
+ else
+   {
+
+
+     this->_M_assign_aux(std::make_move_iterator(__x.begin()),
+           std::make_move_iterator(__x.end()),
+    std::random_access_iterator_tag());
+     __x.clear();
+   }
+      }
+
+
+      template<typename _Up>
+ _Up*
+ _M_data_ptr(_Up* __ptr) const noexcept
+ { return __ptr; }
+
+
+      template<typename _Ptr>
+ typename std::pointer_traits<_Ptr>::element_type*
+ _M_data_ptr(_Ptr __ptr) const
+ { return empty() ? nullptr : std::__to_address(__ptr); }
+# 1868 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+    };
+
+
+  template<typename _InputIterator, typename _ValT
+      = typename iterator_traits<_InputIterator>::value_type,
+    typename _Allocator = allocator<_ValT>,
+    typename = _RequireInputIter<_InputIterator>,
+    typename = _RequireAllocator<_Allocator>>
+    vector(_InputIterator, _InputIterator, _Allocator = _Allocator())
+      -> vector<_ValT, _Allocator>;
+# 1890 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator==(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
+    { return (__x.size() == __y.size()
+       && std::equal(__x.begin(), __x.end(), __y.begin())); }
+# 1928 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator<(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
+    { return std::lexicographical_compare(__x.begin(), __x.end(),
+       __y.begin(), __y.end()); }
+
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator!=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
+    { return !(__x == __y); }
+
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator>(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
+    { return __y < __x; }
+
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator<=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
+    { return !(__y < __x); }
+
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator>=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
+    { return !(__x < __y); }
+
+
+
+  template<typename _Tp, typename _Alloc>
+    inline void
+    swap(vector<_Tp, _Alloc>& __x, vector<_Tp, _Alloc>& __y)
+    noexcept(noexcept(__x.swap(__y)))
+    { __x.swap(__y); }
+
+
+
+
+  namespace __detail::__variant
+  {
+    template<typename> struct _Never_valueless_alt;
+
+
+
+    template<typename _Tp, typename _Alloc>
+      struct _Never_valueless_alt<std::vector<_Tp, _Alloc>>
+      : std::is_nothrow_move_assignable<std::vector<_Tp, _Alloc>>
+      { };
+  }
+
+
+
+}
+# 68 "/usr/include/c++/10.2.0/vector" 2 3
+# 1 "/usr/include/c++/10.2.0/bits/stl_bvector.h" 1 3
+# 57 "/usr/include/c++/10.2.0/bits/stl_bvector.h" 3
+#define _STL_BVECTOR_H 1
+
+
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+  typedef unsigned long _Bit_type;
+  enum { _S_word_bit = int(8 * sizeof(_Bit_type)) };
+
+  struct _Bit_reference
+  {
+    _Bit_type * _M_p;
+    _Bit_type _M_mask;
+
+    _Bit_reference(_Bit_type * __x, _Bit_type __y)
+    : _M_p(__x), _M_mask(__y) { }
+
+    _Bit_reference() noexcept : _M_p(0), _M_mask(0) { }
+
+
+    _Bit_reference(const _Bit_reference&) = default;
+
+
+    operator bool() const noexcept
+    { return !!(*_M_p & _M_mask); }
+
+    _Bit_reference&
+    operator=(bool __x) noexcept
+    {
+      if (__x)
+ *_M_p |= _M_mask;
+      else
+ *_M_p &= ~_M_mask;
+      return *this;
+    }
+
+    _Bit_reference&
+    operator=(const _Bit_reference& __x) noexcept
+    { return *this = bool(__x); }
+
+    bool
+    operator==(const _Bit_reference& __x) const
+    { return bool(*this) == bool(__x); }
+
+    bool
+    operator<(const _Bit_reference& __x) const
+    { return !bool(*this) && bool(__x); }
+
+    void
+    flip() noexcept
+    { *_M_p ^= _M_mask; }
+  };
+
+
+  inline void
+  swap(_Bit_reference __x, _Bit_reference __y) noexcept
+  {
+    bool __tmp = __x;
+    __x = __y;
+    __y = __tmp;
+  }
+
+  inline void
+  swap(_Bit_reference __x, bool& __y) noexcept
+  {
+    bool __tmp = __x;
+    __x = __y;
+    __y = __tmp;
+  }
+
+  inline void
+  swap(bool& __x, _Bit_reference __y) noexcept
+  {
+    bool __tmp = __x;
+    __x = __y;
+    __y = __tmp;
+  }
+
+
+  struct _Bit_iterator_base
+  : public std::iterator<std::random_access_iterator_tag, bool>
+  {
+    _Bit_type * _M_p;
+    unsigned int _M_offset;
+
+    _Bit_iterator_base(_Bit_type * __x, unsigned int __y)
+    : _M_p(__x), _M_offset(__y) { }
+
+    void
+    _M_bump_up()
+    {
+      if (_M_offset++ == int(_S_word_bit) - 1)
+ {
+   _M_offset = 0;
+   ++_M_p;
+ }
+    }
+
+    void
+    _M_bump_down()
+    {
+      if (_M_offset-- == 0)
+ {
+   _M_offset = int(_S_word_bit) - 1;
+   --_M_p;
+ }
+    }
+
+    void
+    _M_incr(ptrdiff_t __i)
+    {
+      difference_type __n = __i + _M_offset;
+      _M_p += __n / int(_S_word_bit);
+      __n = __n % int(_S_word_bit);
+      if (__n < 0)
+ {
+   __n += int(_S_word_bit);
+   --_M_p;
+ }
+      _M_offset = static_cast<unsigned int>(__n);
+    }
+
+    friend bool
+    operator==(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y)
+    { return __x._M_p == __y._M_p && __x._M_offset == __y._M_offset; }
+# 199 "/usr/include/c++/10.2.0/bits/stl_bvector.h" 3
+    friend bool
+    operator<(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y)
+    {
+      return __x._M_p < __y._M_p
+     || (__x._M_p == __y._M_p && __x._M_offset < __y._M_offset);
+    }
+
+    friend bool
+    operator!=(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y)
+    { return !(__x == __y); }
+
+    friend bool
+    operator>(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y)
+    { return __y < __x; }
+
+    friend bool
+    operator<=(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y)
+    { return !(__y < __x); }
+
+    friend bool
+    operator>=(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y)
+    { return !(__x < __y); }
+
+
+    friend ptrdiff_t
+    operator-(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y)
+    {
+      return (int(_S_word_bit) * (__x._M_p - __y._M_p)
+       + __x._M_offset - __y._M_offset);
+    }
+  };
+
+  struct _Bit_iterator : public _Bit_iterator_base
+  {
+    typedef _Bit_reference reference;
+
+
+
+    typedef _Bit_reference* pointer;
+
+    typedef _Bit_iterator iterator;
+
+    _Bit_iterator() : _Bit_iterator_base(0, 0) { }
+
+    _Bit_iterator(_Bit_type * __x, unsigned int __y)
+    : _Bit_iterator_base(__x, __y) { }
+
+    iterator
+    _M_const_cast() const
+    { return *this; }
+
+    reference
+    operator*() const
+    { return reference(_M_p, 1UL << _M_offset); }
+
+    iterator&
+    operator++()
+    {
+      _M_bump_up();
+      return *this;
+    }
+
+    iterator
+    operator++(int)
+    {
+      iterator __tmp = *this;
+      _M_bump_up();
+      return __tmp;
+    }
+
+    iterator&
+    operator--()
+    {
+      _M_bump_down();
+      return *this;
+    }
+
+    iterator
+    operator--(int)
+    {
+      iterator __tmp = *this;
+      _M_bump_down();
+      return __tmp;
+    }
+
+    iterator&
+    operator+=(difference_type __i)
+    {
+      _M_incr(__i);
+      return *this;
+    }
+
+    iterator&
+    operator-=(difference_type __i)
+    {
+      *this += -__i;
+      return *this;
+    }
+
+    reference
+    operator[](difference_type __i) const
+    { return *(*this + __i); }
+
+    friend iterator
+    operator+(const iterator& __x, difference_type __n)
+    {
+      iterator __tmp = __x;
+      __tmp += __n;
+      return __tmp;
+    }
+
+    friend iterator
+    operator+(difference_type __n, const iterator& __x)
+    { return __x + __n; }
+
+    friend iterator
+    operator-(const iterator& __x, difference_type __n)
+    {
+      iterator __tmp = __x;
+      __tmp -= __n;
+      return __tmp;
+    }
+  };
+
+  struct _Bit_const_iterator : public _Bit_iterator_base
+  {
+    typedef bool reference;
+    typedef bool const_reference;
+
+
+
+    typedef const bool* pointer;
+
+    typedef _Bit_const_iterator const_iterator;
+
+    _Bit_const_iterator() : _Bit_iterator_base(0, 0) { }
+
+    _Bit_const_iterator(_Bit_type * __x, unsigned int __y)
+    : _Bit_iterator_base(__x, __y) { }
+
+    _Bit_const_iterator(const _Bit_iterator& __x)
+    : _Bit_iterator_base(__x._M_p, __x._M_offset) { }
+
+    _Bit_iterator
+    _M_const_cast() const
+    { return _Bit_iterator(_M_p, _M_offset); }
+
+    const_reference
+    operator*() const
+    { return _Bit_reference(_M_p, 1UL << _M_offset); }
+
+    const_iterator&
+    operator++()
+    {
+      _M_bump_up();
+      return *this;
+    }
+
+    const_iterator
+    operator++(int)
+    {
+      const_iterator __tmp = *this;
+      _M_bump_up();
+      return __tmp;
+    }
+
+    const_iterator&
+    operator--()
+    {
+      _M_bump_down();
+      return *this;
+    }
+
+    const_iterator
+    operator--(int)
+    {
+      const_iterator __tmp = *this;
+      _M_bump_down();
+      return __tmp;
+    }
+
+    const_iterator&
+    operator+=(difference_type __i)
+    {
+      _M_incr(__i);
+      return *this;
+    }
+
+    const_iterator&
+    operator-=(difference_type __i)
+    {
+      *this += -__i;
+      return *this;
+    }
+
+    const_reference
+    operator[](difference_type __i) const
+    { return *(*this + __i); }
+
+    friend const_iterator
+    operator+(const const_iterator& __x, difference_type __n)
+    {
+      const_iterator __tmp = __x;
+      __tmp += __n;
+      return __tmp;
+    }
+
+    friend const_iterator
+    operator-(const const_iterator& __x, difference_type __n)
+    {
+      const_iterator __tmp = __x;
+      __tmp -= __n;
+      return __tmp;
+    }
+
+    friend const_iterator
+    operator+(difference_type __n, const const_iterator& __x)
+    { return __x + __n; }
+  };
+
+  inline void
+  __fill_bvector(_Bit_type * __v,
+   unsigned int __first, unsigned int __last, bool __x)
+  {
+    const _Bit_type __fmask = ~0ul << __first;
+    const _Bit_type __lmask = ~0ul >> (_S_word_bit - __last);
+    const _Bit_type __mask = __fmask & __lmask;
+
+    if (__x)
+      *__v |= __mask;
+    else
+      *__v &= ~__mask;
+  }
+
+  inline void
+  fill(_Bit_iterator __first, _Bit_iterator __last, const bool& __x)
+  {
+    if (__first._M_p != __last._M_p)
+      {
+ _Bit_type* __first_p = __first._M_p;
+ if (__first._M_offset != 0)
+   __fill_bvector(__first_p++, __first._M_offset, _S_word_bit, __x);
+
+ __builtin_memset(__first_p, __x ? ~0 : 0,
+    (__last._M_p - __first_p) * sizeof(_Bit_type));
+
+ if (__last._M_offset != 0)
+   __fill_bvector(__last._M_p, 0, __last._M_offset, __x);
+      }
+    else if (__first._M_offset != __last._M_offset)
+      __fill_bvector(__first._M_p, __first._M_offset, __last._M_offset, __x);
+  }
+
+  template<typename _Alloc>
+    struct _Bvector_base
+    {
+      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
+        rebind<_Bit_type>::other _Bit_alloc_type;
+      typedef typename __gnu_cxx::__alloc_traits<_Bit_alloc_type>
+ _Bit_alloc_traits;
+      typedef typename _Bit_alloc_traits::pointer _Bit_pointer;
+
+      struct _Bvector_impl_data
+      {
+ _Bit_iterator _M_start;
+ _Bit_iterator _M_finish;
+ _Bit_pointer _M_end_of_storage;
+
+ _Bvector_impl_data() noexcept
+ : _M_start(), _M_finish(), _M_end_of_storage()
+ { }
+
+
+ _Bvector_impl_data(_Bvector_impl_data&& __x) noexcept
+ : _M_start(__x._M_start), _M_finish(__x._M_finish)
+ , _M_end_of_storage(__x._M_end_of_storage)
+ { __x._M_reset(); }
+
+ void
+ _M_move_data(_Bvector_impl_data&& __x) noexcept
+ {
+   this->_M_start = __x._M_start;
+   this->_M_finish = __x._M_finish;
+   this->_M_end_of_storage = __x._M_end_of_storage;
+   __x._M_reset();
+ }
+
+
+ void
+ _M_reset() noexcept
+ {
+   _M_start = _M_finish = _Bit_iterator();
+   _M_end_of_storage = _Bit_pointer();
+ }
+      };
+
+      struct _Bvector_impl
+ : public _Bit_alloc_type, public _Bvector_impl_data
+ {
+ public:
+   _Bvector_impl() noexcept(is_nothrow_default_constructible<_Bit_alloc_type>::value)
+
+   : _Bit_alloc_type()
+   { }
+
+   _Bvector_impl(const _Bit_alloc_type& __a) noexcept
+   : _Bit_alloc_type(__a)
+   { }
+
+
+ _Bvector_impl(_Bvector_impl&&) = default;
+
+
+ _Bit_type*
+ _M_end_addr() const noexcept
+ {
+   if (this->_M_end_of_storage)
+     return std::__addressof(this->_M_end_of_storage[-1]) + 1;
+   return 0;
+ }
+      };
+
+    public:
+      typedef _Alloc allocator_type;
+
+      _Bit_alloc_type&
+      _M_get_Bit_allocator() noexcept
+      { return this->_M_impl; }
+
+      const _Bit_alloc_type&
+      _M_get_Bit_allocator() const noexcept
+      { return this->_M_impl; }
+
+      allocator_type
+      get_allocator() const noexcept
+      { return allocator_type(_M_get_Bit_allocator()); }
+
+
+      _Bvector_base() = default;
+
+
+
+
+      _Bvector_base(const allocator_type& __a)
+      : _M_impl(__a) { }
+
+
+      _Bvector_base(_Bvector_base&&) = default;
+
+
+      ~_Bvector_base()
+      { this->_M_deallocate(); }
+
+    protected:
+      _Bvector_impl _M_impl;
+
+      _Bit_pointer
+      _M_allocate(size_t __n)
+      { return _Bit_alloc_traits::allocate(_M_impl, _S_nword(__n)); }
+
+      void
+      _M_deallocate()
+      {
+ if (_M_impl._M_start._M_p)
+   {
+     const size_t __n = _M_impl._M_end_addr() - _M_impl._M_start._M_p;
+     _Bit_alloc_traits::deallocate(_M_impl,
+       _M_impl._M_end_of_storage - __n,
+       __n);
+     _M_impl._M_reset();
+   }
+      }
+
+
+      void
+      _M_move_data(_Bvector_base&& __x) noexcept
+      { _M_impl._M_move_data(std::move(__x._M_impl)); }
+
+
+      static size_t
+      _S_nword(size_t __n)
+      { return (__n + int(_S_word_bit) - 1) / int(_S_word_bit); }
+    };
+
+
+
+}
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+# 614 "/usr/include/c++/10.2.0/bits/stl_bvector.h" 3
+  template<typename _Alloc>
+    class vector<bool, _Alloc> : protected _Bvector_base<_Alloc>
+    {
+      typedef _Bvector_base<_Alloc> _Base;
+      typedef typename _Base::_Bit_pointer _Bit_pointer;
+      typedef typename _Base::_Bit_alloc_traits _Bit_alloc_traits;
+
+
+      friend struct std::hash<vector>;
+
+
+    public:
+      typedef bool value_type;
+      typedef size_t size_type;
+      typedef ptrdiff_t difference_type;
+      typedef _Bit_reference reference;
+      typedef bool const_reference;
+      typedef _Bit_reference* pointer;
+      typedef const bool* const_pointer;
+      typedef _Bit_iterator iterator;
+      typedef _Bit_const_iterator const_iterator;
+      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+      typedef std::reverse_iterator<iterator> reverse_iterator;
+      typedef _Alloc allocator_type;
+
+      allocator_type
+      get_allocator() const
+      { return _Base::get_allocator(); }
+
+    protected:
+      using _Base::_M_allocate;
+      using _Base::_M_deallocate;
+      using _Base::_S_nword;
+      using _Base::_M_get_Bit_allocator;
+
+    public:
+
+      vector() = default;
+
+
+
+
+      explicit
+      vector(const allocator_type& __a)
+      : _Base(__a) { }
+
+
+      explicit
+      vector(size_type __n, const allocator_type& __a = allocator_type())
+      : vector(__n, false, __a)
+      { }
+
+      vector(size_type __n, const bool& __value,
+      const allocator_type& __a = allocator_type())
+
+
+
+
+
+      : _Base(__a)
+      {
+ _M_initialize(__n);
+ _M_initialize_value(__value);
+      }
+
+      vector(const vector& __x)
+      : _Base(_Bit_alloc_traits::_S_select_on_copy(__x._M_get_Bit_allocator()))
+      {
+ _M_initialize(__x.size());
+ _M_copy_aligned(__x.begin(), __x.end(), this->_M_impl._M_start);
+      }
+
+
+      vector(vector&&) = default;
+
+      vector(vector&& __x, const allocator_type& __a)
+      noexcept(_Bit_alloc_traits::_S_always_equal())
+      : _Base(__a)
+      {
+ if (__x.get_allocator() == __a)
+   this->_M_move_data(std::move(__x));
+ else
+   {
+     _M_initialize(__x.size());
+     _M_copy_aligned(__x.begin(), __x.end(), begin());
+     __x.clear();
+   }
+      }
+
+      vector(const vector& __x, const allocator_type& __a)
+      : _Base(__a)
+      {
+ _M_initialize(__x.size());
+ _M_copy_aligned(__x.begin(), __x.end(), this->_M_impl._M_start);
+      }
+
+      vector(initializer_list<bool> __l,
+      const allocator_type& __a = allocator_type())
+      : _Base(__a)
+      {
+ _M_initialize_range(__l.begin(), __l.end(),
+       random_access_iterator_tag());
+      }
+
+
+
+      template<typename _InputIterator,
+        typename = std::_RequireInputIter<_InputIterator>>
+ vector(_InputIterator __first, _InputIterator __last,
+        const allocator_type& __a = allocator_type())
+ : _Base(__a)
+ { _M_initialize_dispatch(__first, __last, __false_type()); }
+# 737 "/usr/include/c++/10.2.0/bits/stl_bvector.h" 3
+      ~vector() noexcept { }
+
+      vector&
+      operator=(const vector& __x)
+      {
+ if (&__x == this)
+   return *this;
+
+ if (_Bit_alloc_traits::_S_propagate_on_copy_assign())
+   {
+     if (this->_M_get_Bit_allocator() != __x._M_get_Bit_allocator())
+       {
+  this->_M_deallocate();
+  std::__alloc_on_copy(_M_get_Bit_allocator(),
+         __x._M_get_Bit_allocator());
+  _M_initialize(__x.size());
+       }
+     else
+       std::__alloc_on_copy(_M_get_Bit_allocator(),
+       __x._M_get_Bit_allocator());
+   }
+
+ if (__x.size() > capacity())
+   {
+     this->_M_deallocate();
+     _M_initialize(__x.size());
+   }
+ this->_M_impl._M_finish = _M_copy_aligned(__x.begin(), __x.end(),
+        begin());
+ return *this;
+      }
+
+
+      vector&
+      operator=(vector&& __x) noexcept(_Bit_alloc_traits::_S_nothrow_move())
+      {
+ if (_Bit_alloc_traits::_S_propagate_on_move_assign()
+     || this->_M_get_Bit_allocator() == __x._M_get_Bit_allocator())
+   {
+     this->_M_deallocate();
+     this->_M_move_data(std::move(__x));
+     std::__alloc_on_move(_M_get_Bit_allocator(),
+     __x._M_get_Bit_allocator());
+   }
+ else
+   {
+     if (__x.size() > capacity())
+       {
+  this->_M_deallocate();
+  _M_initialize(__x.size());
+       }
+     this->_M_impl._M_finish = _M_copy_aligned(__x.begin(), __x.end(),
+            begin());
+     __x.clear();
+   }
+ return *this;
+      }
+
+      vector&
+      operator=(initializer_list<bool> __l)
+      {
+ this->assign (__l.begin(), __l.end());
+ return *this;
+      }
+
+
+
+
+
+
+      void
+      assign(size_type __n, const bool& __x)
+      { _M_fill_assign(__n, __x); }
+
+
+      template<typename _InputIterator,
+        typename = std::_RequireInputIter<_InputIterator>>
+ void
+ assign(_InputIterator __first, _InputIterator __last)
+ { _M_assign_aux(__first, __last, std::__iterator_category(__first)); }
+# 828 "/usr/include/c++/10.2.0/bits/stl_bvector.h" 3
+      void
+      assign(initializer_list<bool> __l)
+      { _M_assign_aux(__l.begin(), __l.end(), random_access_iterator_tag()); }
+
+
+      iterator
+      begin() noexcept
+      { return iterator(this->_M_impl._M_start._M_p, 0); }
+
+      const_iterator
+      begin() const noexcept
+      { return const_iterator(this->_M_impl._M_start._M_p, 0); }
+
+      iterator
+      end() noexcept
+      { return this->_M_impl._M_finish; }
+
+      const_iterator
+      end() const noexcept
+      { return this->_M_impl._M_finish; }
+
+      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()); }
+
+
+      const_iterator
+      cbegin() const noexcept
+      { return const_iterator(this->_M_impl._M_start._M_p, 0); }
+
+      const_iterator
+      cend() const noexcept
+      { return this->_M_impl._M_finish; }
+
+      const_reverse_iterator
+      crbegin() const noexcept
+      { return const_reverse_iterator(end()); }
+
+      const_reverse_iterator
+      crend() const noexcept
+      { return const_reverse_iterator(begin()); }
+
+
+      size_type
+      size() const noexcept
+      { return size_type(end() - begin()); }
+
+      size_type
+      max_size() const noexcept
+      {
+ const size_type __isize =
+   __gnu_cxx::__numeric_traits<difference_type>::__max
+   - int(_S_word_bit) + 1;
+ const size_type __asize
+   = _Bit_alloc_traits::max_size(_M_get_Bit_allocator());
+ return (__asize <= __isize / int(_S_word_bit)
+  ? __asize * int(_S_word_bit) : __isize);
+      }
+
+      size_type
+      capacity() const noexcept
+      { return size_type(const_iterator(this->_M_impl._M_end_addr(), 0)
+    - begin()); }
+
+      [[__nodiscard__]] bool
+      empty() const noexcept
+      { return begin() == end(); }
+
+      reference
+      operator[](size_type __n)
+      {
+ return *iterator(this->_M_impl._M_start._M_p
+    + __n / int(_S_word_bit), __n % int(_S_word_bit));
+      }
+
+      const_reference
+      operator[](size_type __n) const
+      {
+ return *const_iterator(this->_M_impl._M_start._M_p
+        + __n / int(_S_word_bit), __n % int(_S_word_bit));
+      }
+
+    protected:
+      void
+      _M_range_check(size_type __n) const
+      {
+ if (__n >= this->size())
+   __throw_out_of_range_fmt(("vector<bool>::_M_range_check: __n " "(which is %zu) >= this->size() " "(which is %zu)")
+
+                            ,
+       __n, this->size());
+      }
+
+    public:
+      reference
+      at(size_type __n)
+      { _M_range_check(__n); return (*this)[__n]; }
+
+      const_reference
+      at(size_type __n) const
+      { _M_range_check(__n); return (*this)[__n]; }
+
+      void
+      reserve(size_type __n)
+      {
+ if (__n > max_size())
+   __throw_length_error(("vector::reserve"));
+ if (capacity() < __n)
+   _M_reallocate(__n);
+      }
+
+      reference
+      front()
+      { return *begin(); }
+
+      const_reference
+      front() const
+      { return *begin(); }
+
+      reference
+      back()
+      { return *(end() - 1); }
+
+      const_reference
+      back() const
+      { return *(end() - 1); }
+
+
+
+
+
+
+      void
+      data() noexcept { }
+
+      void
+      push_back(bool __x)
+      {
+ if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_addr())
+   *this->_M_impl._M_finish++ = __x;
+ else
+   _M_insert_aux(end(), __x);
+      }
+
+      void
+      swap(vector& __x) noexcept
+      {
+ std::swap(this->_M_impl._M_start, __x._M_impl._M_start);
+ std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish);
+ std::swap(this->_M_impl._M_end_of_storage,
+    __x._M_impl._M_end_of_storage);
+ _Bit_alloc_traits::_S_on_swap(_M_get_Bit_allocator(),
+          __x._M_get_Bit_allocator());
+      }
+
+
+      static void
+      swap(reference __x, reference __y) noexcept
+      {
+ bool __tmp = __x;
+ __x = __y;
+ __y = __tmp;
+      }
+
+      iterator
+
+      insert(const_iterator __position, const bool& __x = bool())
+
+
+
+      {
+ const difference_type __n = __position - begin();
+ if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_addr()
+     && __position == end())
+   *this->_M_impl._M_finish++ = __x;
+ else
+   _M_insert_aux(__position._M_const_cast(), __x);
+ return begin() + __n;
+      }
+
+
+      template<typename _InputIterator,
+        typename = std::_RequireInputIter<_InputIterator>>
+ iterator
+ insert(const_iterator __position,
+        _InputIterator __first, _InputIterator __last)
+ {
+   difference_type __offset = __position - cbegin();
+   _M_insert_dispatch(__position._M_const_cast(),
+        __first, __last, __false_type());
+   return begin() + __offset;
+ }
+# 1044 "/usr/include/c++/10.2.0/bits/stl_bvector.h" 3
+      iterator
+      insert(const_iterator __position, size_type __n, const bool& __x)
+      {
+ difference_type __offset = __position - cbegin();
+ _M_fill_insert(__position._M_const_cast(), __n, __x);
+ return begin() + __offset;
+      }
+
+
+
+
+
+
+
+      iterator
+      insert(const_iterator __p, initializer_list<bool> __l)
+      { return this->insert(__p, __l.begin(), __l.end()); }
+
+
+      void
+      pop_back()
+      { --this->_M_impl._M_finish; }
+
+      iterator
+
+      erase(const_iterator __position)
+
+
+
+      { return _M_erase(__position._M_const_cast()); }
+
+      iterator
+
+      erase(const_iterator __first, const_iterator __last)
+
+
+
+      { return _M_erase(__first._M_const_cast(), __last._M_const_cast()); }
+
+      void
+      resize(size_type __new_size, bool __x = bool())
+      {
+ if (__new_size < size())
+   _M_erase_at_end(begin() + difference_type(__new_size));
+ else
+   insert(end(), __new_size - size(), __x);
+      }
+
+
+      void
+      shrink_to_fit()
+      { _M_shrink_to_fit(); }
+
+
+      void
+      flip() noexcept
+      {
+ _Bit_type * const __end = this->_M_impl._M_end_addr();
+ for (_Bit_type * __p = this->_M_impl._M_start._M_p; __p != __end; ++__p)
+   *__p = ~*__p;
+      }
+
+      void
+      clear() noexcept
+      { _M_erase_at_end(begin()); }
+
+
+      template<typename... _Args>
+
+ reference
+
+
+
+ emplace_back(_Args&&... __args)
+ {
+   push_back(bool(__args...));
+
+   return back();
+
+ }
+
+      template<typename... _Args>
+ iterator
+ emplace(const_iterator __pos, _Args&&... __args)
+ { return insert(__pos, bool(__args...)); }
+
+
+    protected:
+
+      iterator
+      _M_copy_aligned(const_iterator __first, const_iterator __last,
+        iterator __result)
+      {
+ _Bit_type* __q = std::copy(__first._M_p, __last._M_p, __result._M_p);
+ return std::copy(const_iterator(__last._M_p, 0), __last,
+    iterator(__q, 0));
+      }
+
+      void
+      _M_initialize(size_type __n)
+      {
+ if (__n)
+   {
+     _Bit_pointer __q = this->_M_allocate(__n);
+     this->_M_impl._M_end_of_storage = __q + _S_nword(__n);
+     this->_M_impl._M_start = iterator(std::__addressof(*__q), 0);
+   }
+ else
+   {
+     this->_M_impl._M_end_of_storage = _Bit_pointer();
+     this->_M_impl._M_start = iterator(0, 0);
+   }
+ this->_M_impl._M_finish = this->_M_impl._M_start + difference_type(__n);
+
+      }
+
+      void
+      _M_initialize_value(bool __x)
+      {
+ if (_Bit_type* __p = this->_M_impl._M_start._M_p)
+   __builtin_memset(__p, __x ? ~0 : 0,
+      (this->_M_impl._M_end_addr() - __p)
+      * sizeof(_Bit_type));
+      }
+
+      void
+      _M_reallocate(size_type __n);
+
+
+      bool
+      _M_shrink_to_fit();
+
+
+
+
+
+
+      template<typename _Integer>
+ void
+ _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type)
+ {
+   _M_initialize(static_cast<size_type>(__n));
+   _M_initialize_value(__x);
+ }
+
+      template<typename _InputIterator>
+ void
+ _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
+          __false_type)
+ { _M_initialize_range(__first, __last,
+         std::__iterator_category(__first)); }
+
+      template<typename _InputIterator>
+ void
+ _M_initialize_range(_InputIterator __first, _InputIterator __last,
+       std::input_iterator_tag)
+ {
+   for (; __first != __last; ++__first)
+     push_back(*__first);
+ }
+
+      template<typename _ForwardIterator>
+ void
+ _M_initialize_range(_ForwardIterator __first, _ForwardIterator __last,
+       std::forward_iterator_tag)
+ {
+   const size_type __n = std::distance(__first, __last);
+   _M_initialize(__n);
+   std::copy(__first, __last, this->_M_impl._M_start);
+ }
+# 1230 "/usr/include/c++/10.2.0/bits/stl_bvector.h" 3
+      void
+      _M_fill_assign(size_t __n, bool __x)
+      {
+ if (__n > size())
+   {
+     _M_initialize_value(__x);
+     insert(end(), __n - size(), __x);
+   }
+ else
+   {
+     _M_erase_at_end(begin() + __n);
+     _M_initialize_value(__x);
+   }
+      }
+
+      template<typename _InputIterator>
+ void
+ _M_assign_aux(_InputIterator __first, _InputIterator __last,
+        std::input_iterator_tag)
+ {
+   iterator __cur = begin();
+   for (; __first != __last && __cur != end(); ++__cur, (void)++__first)
+     *__cur = *__first;
+   if (__first == __last)
+     _M_erase_at_end(__cur);
+   else
+     insert(end(), __first, __last);
+ }
+
+      template<typename _ForwardIterator>
+ void
+ _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
+        std::forward_iterator_tag)
+ {
+   const size_type __len = std::distance(__first, __last);
+   if (__len < size())
+     _M_erase_at_end(std::copy(__first, __last, begin()));
+   else
+     {
+       _ForwardIterator __mid = __first;
+       std::advance(__mid, size());
+       std::copy(__first, __mid, begin());
+       insert(end(), __mid, __last);
+     }
+ }
+
+
+
+
+
+      template<typename _Integer>
+ void
+ _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __x,
+      __true_type)
+ { _M_fill_insert(__pos, __n, __x); }
+
+      template<typename _InputIterator>
+ void
+ _M_insert_dispatch(iterator __pos,
+      _InputIterator __first, _InputIterator __last,
+      __false_type)
+ { _M_insert_range(__pos, __first, __last,
+     std::__iterator_category(__first)); }
+
+      void
+      _M_fill_insert(iterator __position, size_type __n, bool __x);
+
+      template<typename _InputIterator>
+ void
+ _M_insert_range(iterator __pos, _InputIterator __first,
+   _InputIterator __last, std::input_iterator_tag)
+ {
+   for (; __first != __last; ++__first)
+     {
+       __pos = insert(__pos, *__first);
+       ++__pos;
+     }
+ }
+
+      template<typename _ForwardIterator>
+ void
+ _M_insert_range(iterator __position, _ForwardIterator __first,
+   _ForwardIterator __last, std::forward_iterator_tag);
+
+      void
+      _M_insert_aux(iterator __position, bool __x);
+
+      size_type
+      _M_check_len(size_type __n, const char* __s) const
+      {
+ if (max_size() - size() < __n)
+   __throw_length_error((__s));
+
+ const size_type __len = size() + std::max(size(), __n);
+ return (__len < size() || __len > max_size()) ? max_size() : __len;
+      }
+
+      void
+      _M_erase_at_end(iterator __pos)
+      { this->_M_impl._M_finish = __pos; }
+
+      iterator
+      _M_erase(iterator __pos);
+
+      iterator
+      _M_erase(iterator __first, iterator __last);
+  };
+
+
+
+}
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+  template<typename _Alloc>
+    struct hash<std::vector<bool, _Alloc>>
+    : public __hash_base<size_t, std::vector<bool, _Alloc>>
+    {
+      size_t
+      operator()(const std::vector<bool, _Alloc>&) const noexcept;
+    };
+
+
+}
+# 69 "/usr/include/c++/10.2.0/vector" 2 3
+
+
+
+# 1 "/usr/include/c++/10.2.0/bits/vector.tcc" 1 3
+# 57 "/usr/include/c++/10.2.0/bits/vector.tcc" 3
+#define _VECTOR_TCC 1
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+  template<typename _Tp, typename _Alloc>
+    void
+    vector<_Tp, _Alloc>::
+    reserve(size_type __n)
+    {
+      if (__n > this->max_size())
+ __throw_length_error(("vector::reserve"));
+      if (this->capacity() < __n)
+ {
+   const size_type __old_size = size();
+   pointer __tmp;
+
+   if constexpr (_S_use_relocate())
+     {
+       __tmp = this->_M_allocate(__n);
+       _S_relocate(this->_M_impl._M_start, this->_M_impl._M_finish,
+     __tmp, _M_get_Tp_allocator());
+     }
+   else
+
+     {
+       __tmp = _M_allocate_and_copy(__n,
+  std::__make_move_if_noexcept_iterator(this->_M_impl._M_start),
+  std::__make_move_if_noexcept_iterator(this->_M_impl._M_finish));
+       std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
+       _M_get_Tp_allocator());
+     }
+   ;
+   _M_deallocate(this->_M_impl._M_start,
+   this->_M_impl._M_end_of_storage
+   - this->_M_impl._M_start);
+   this->_M_impl._M_start = __tmp;
+   this->_M_impl._M_finish = __tmp + __old_size;
+   this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
+ }
+    }
+
+
+  template<typename _Tp, typename _Alloc>
+    template<typename... _Args>
+
+      typename vector<_Tp, _Alloc>::reference
+
+
+
+      vector<_Tp, _Alloc>::
+      emplace_back(_Args&&... __args)
+      {
+ if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
+   {
+     ;
+     _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
+         std::forward<_Args>(__args)...);
+     ++this->_M_impl._M_finish;
+     ;
+   }
+ else
+   _M_realloc_insert(end(), std::forward<_Args>(__args)...);
+
+ return back();
+
+      }
+
+
+  template<typename _Tp, typename _Alloc>
+    typename vector<_Tp, _Alloc>::iterator
+    vector<_Tp, _Alloc>::
+
+    insert(const_iterator __position, const value_type& __x)
+
+
+
+    {
+      const size_type __n = __position - begin();
+      if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
+ if (__position == end())
+   {
+     ;
+     _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
+         __x);
+     ++this->_M_impl._M_finish;
+     ;
+   }
+ else
+   {
+
+     const auto __pos = begin() + (__position - cbegin());
+
+
+     _Temporary_value __x_copy(this, __x);
+     _M_insert_aux(__pos, std::move(__x_copy._M_val()));
+
+
+
+   }
+      else
+
+ _M_realloc_insert(begin() + (__position - cbegin()), __x);
+
+
+
+
+      return iterator(this->_M_impl._M_start + __n);
+    }
+
+  template<typename _Tp, typename _Alloc>
+    typename vector<_Tp, _Alloc>::iterator
+    vector<_Tp, _Alloc>::
+    _M_erase(iterator __position)
+    {
+      if (__position + 1 != end())
+ std::move(__position + 1, end(), __position);
+      --this->_M_impl._M_finish;
+      _Alloc_traits::destroy(this->_M_impl, this->_M_impl._M_finish);
+      ;
+      return __position;
+    }
+
+  template<typename _Tp, typename _Alloc>
+    typename vector<_Tp, _Alloc>::iterator
+    vector<_Tp, _Alloc>::
+    _M_erase(iterator __first, iterator __last)
+    {
+      if (__first != __last)
+ {
+   if (__last != end())
+     std::move(__last, end(), __first);
+   _M_erase_at_end(__first.base() + (end() - __last));
+ }
+      return __first;
+    }
+
+  template<typename _Tp, typename _Alloc>
+    vector<_Tp, _Alloc>&
+    vector<_Tp, _Alloc>::
+    operator=(const vector<_Tp, _Alloc>& __x)
+    {
+      if (&__x != this)
+ {
+   ;
+
+   if (_Alloc_traits::_S_propagate_on_copy_assign())
+     {
+       if (!_Alloc_traits::_S_always_equal()
+           && _M_get_Tp_allocator() != __x._M_get_Tp_allocator())
+         {
+
+    this->clear();
+    _M_deallocate(this->_M_impl._M_start,
+    this->_M_impl._M_end_of_storage
+    - this->_M_impl._M_start);
+    this->_M_impl._M_start = nullptr;
+    this->_M_impl._M_finish = nullptr;
+    this->_M_impl._M_end_of_storage = nullptr;
+  }
+       std::__alloc_on_copy(_M_get_Tp_allocator(),
+       __x._M_get_Tp_allocator());
+     }
+
+   const size_type __xlen = __x.size();
+   if (__xlen > capacity())
+     {
+       pointer __tmp = _M_allocate_and_copy(__xlen, __x.begin(),
+         __x.end());
+       std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
+       _M_get_Tp_allocator());
+       _M_deallocate(this->_M_impl._M_start,
+       this->_M_impl._M_end_of_storage
+       - this->_M_impl._M_start);
+       this->_M_impl._M_start = __tmp;
+       this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __xlen;
+     }
+   else if (size() >= __xlen)
+     {
+       std::_Destroy(std::copy(__x.begin(), __x.end(), begin()),
+       end(), _M_get_Tp_allocator());
+     }
+   else
+     {
+       std::copy(__x._M_impl._M_start, __x._M_impl._M_start + size(),
+   this->_M_impl._M_start);
+       std::__uninitialized_copy_a(__x._M_impl._M_start + size(),
+       __x._M_impl._M_finish,
+       this->_M_impl._M_finish,
+       _M_get_Tp_allocator());
+     }
+   this->_M_impl._M_finish = this->_M_impl._M_start + __xlen;
+ }
+      return *this;
+    }
+
+  template<typename _Tp, typename _Alloc>
+    void
+    vector<_Tp, _Alloc>::
+    _M_fill_assign(size_t __n, const value_type& __val)
+    {
+      if (__n > capacity())
+ {
+   vector __tmp(__n, __val, _M_get_Tp_allocator());
+   __tmp._M_impl._M_swap_data(this->_M_impl);
+ }
+      else if (__n > size())
+ {
+   std::fill(begin(), end(), __val);
+   const size_type __add = __n - size();
+   ;
+   this->_M_impl._M_finish =
+     std::__uninitialized_fill_n_a(this->_M_impl._M_finish,
+       __add, __val, _M_get_Tp_allocator());
+   ;
+ }
+      else
+        _M_erase_at_end(std::fill_n(this->_M_impl._M_start, __n, __val));
+    }
+
+  template<typename _Tp, typename _Alloc>
+    template<typename _InputIterator>
+      void
+      vector<_Tp, _Alloc>::
+      _M_assign_aux(_InputIterator __first, _InputIterator __last,
+      std::input_iterator_tag)
+      {
+ pointer __cur(this->_M_impl._M_start);
+ for (; __first != __last && __cur != this->_M_impl._M_finish;
+      ++__cur, (void)++__first)
+   *__cur = *__first;
+ if (__first == __last)
+   _M_erase_at_end(__cur);
+ else
+   _M_range_insert(end(), __first, __last,
+     std::__iterator_category(__first));
+      }
+
+  template<typename _Tp, typename _Alloc>
+    template<typename _ForwardIterator>
+      void
+      vector<_Tp, _Alloc>::
+      _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
+      std::forward_iterator_tag)
+      {
+ const size_type __len = std::distance(__first, __last);
+
+ if (__len > capacity())
+   {
+     _S_check_init_len(__len, _M_get_Tp_allocator());
+     pointer __tmp(_M_allocate_and_copy(__len, __first, __last));
+     std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
+     _M_get_Tp_allocator());
+     ;
+     _M_deallocate(this->_M_impl._M_start,
+     this->_M_impl._M_end_of_storage
+     - this->_M_impl._M_start);
+     this->_M_impl._M_start = __tmp;
+     this->_M_impl._M_finish = this->_M_impl._M_start + __len;
+     this->_M_impl._M_end_of_storage = this->_M_impl._M_finish;
+   }
+ else if (size() >= __len)
+   _M_erase_at_end(std::copy(__first, __last, this->_M_impl._M_start));
+ else
+   {
+     _ForwardIterator __mid = __first;
+     std::advance(__mid, size());
+     std::copy(__first, __mid, this->_M_impl._M_start);
+     const size_type __attribute__((__unused__)) __n = __len - size();
+     ;
+     this->_M_impl._M_finish =
+       std::__uninitialized_copy_a(__mid, __last,
+       this->_M_impl._M_finish,
+       _M_get_Tp_allocator());
+     ;
+   }
+      }
+
+
+  template<typename _Tp, typename _Alloc>
+    auto
+    vector<_Tp, _Alloc>::
+    _M_insert_rval(const_iterator __position, value_type&& __v) -> iterator
+    {
+      const auto __n = __position - cbegin();
+      if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
+ if (__position == cend())
+   {
+     ;
+     _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
+         std::move(__v));
+     ++this->_M_impl._M_finish;
+     ;
+   }
+ else
+   _M_insert_aux(begin() + __n, std::move(__v));
+      else
+ _M_realloc_insert(begin() + __n, std::move(__v));
+
+      return iterator(this->_M_impl._M_start + __n);
+    }
+
+  template<typename _Tp, typename _Alloc>
+    template<typename... _Args>
+      auto
+      vector<_Tp, _Alloc>::
+      _M_emplace_aux(const_iterator __position, _Args&&... __args)
+      -> iterator
+      {
+ const auto __n = __position - cbegin();
+ if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
+   if (__position == cend())
+     {
+       ;
+       _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
+           std::forward<_Args>(__args)...);
+       ++this->_M_impl._M_finish;
+       ;
+     }
+   else
+     {
+
+
+
+       _Temporary_value __tmp(this, std::forward<_Args>(__args)...);
+       _M_insert_aux(begin() + __n, std::move(__tmp._M_val()));
+     }
+ else
+   _M_realloc_insert(begin() + __n, std::forward<_Args>(__args)...);
+
+ return iterator(this->_M_impl._M_start + __n);
+      }
+
+  template<typename _Tp, typename _Alloc>
+    template<typename _Arg>
+      void
+      vector<_Tp, _Alloc>::
+      _M_insert_aux(iterator __position, _Arg&& __arg)
+
+
+
+
+
+
+    {
+      ;
+      _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
+          std::move(*(this->_M_impl._M_finish - 1)));
+      ++this->_M_impl._M_finish;
+      ;
+
+
+
+      std::move_backward(__position.base(), this->_M_impl._M_finish - 2, this->_M_impl._M_finish - 1)
+
+                                     ;
+
+
+
+      *__position = std::forward<_Arg>(__arg);
+
+    }
+
+
+  template<typename _Tp, typename _Alloc>
+    template<typename... _Args>
+      void
+      vector<_Tp, _Alloc>::
+      _M_realloc_insert(iterator __position, _Args&&... __args)
+
+
+
+
+
+
+    {
+      const size_type __len =
+ _M_check_len(size_type(1), "vector::_M_realloc_insert");
+      pointer __old_start = this->_M_impl._M_start;
+      pointer __old_finish = this->_M_impl._M_finish;
+      const size_type __elems_before = __position - begin();
+      pointer __new_start(this->_M_allocate(__len));
+      pointer __new_finish(__new_start);
+      try
+ {
+
+
+
+
+
+   _Alloc_traits::construct(this->_M_impl,
+       __new_start + __elems_before,
+
+       std::forward<_Args>(__args)...);
+
+
+
+   __new_finish = pointer();
+
+
+   if constexpr (_S_use_relocate())
+     {
+       __new_finish = _S_relocate(__old_start, __position.base(),
+      __new_start, _M_get_Tp_allocator());
+
+       ++__new_finish;
+
+       __new_finish = _S_relocate(__position.base(), __old_finish,
+      __new_finish, _M_get_Tp_allocator());
+     }
+   else
+
+     {
+       __new_finish
+  = std::__uninitialized_move_if_noexcept_a
+  (__old_start, __position.base(),
+   __new_start, _M_get_Tp_allocator());
+
+       ++__new_finish;
+
+       __new_finish
+  = std::__uninitialized_move_if_noexcept_a
+  (__position.base(), __old_finish,
+   __new_finish, _M_get_Tp_allocator());
+     }
+ }
+      catch(...)
+ {
+   if (!__new_finish)
+     _Alloc_traits::destroy(this->_M_impl,
+       __new_start + __elems_before);
+   else
+     std::_Destroy(__new_start, __new_finish, _M_get_Tp_allocator());
+   _M_deallocate(__new_start, __len);
+   throw;
+ }
+
+      if constexpr (!_S_use_relocate())
+
+ std::_Destroy(__old_start, __old_finish, _M_get_Tp_allocator());
+      ;
+      _M_deallocate(__old_start,
+      this->_M_impl._M_end_of_storage - __old_start);
+      this->_M_impl._M_start = __new_start;
+      this->_M_impl._M_finish = __new_finish;
+      this->_M_impl._M_end_of_storage = __new_start + __len;
+    }
+
+  template<typename _Tp, typename _Alloc>
+    void
+    vector<_Tp, _Alloc>::
+    _M_fill_insert(iterator __position, size_type __n, const value_type& __x)
+    {
+      if (__n != 0)
+ {
+   if (size_type(this->_M_impl._M_end_of_storage
+   - this->_M_impl._M_finish) >= __n)
+     {
+
+
+
+       _Temporary_value __tmp(this, __x);
+       value_type& __x_copy = __tmp._M_val();
+
+       const size_type __elems_after = end() - __position;
+       pointer __old_finish(this->_M_impl._M_finish);
+       if (__elems_after > __n)
+  {
+    ;
+    std::__uninitialized_move_a(this->_M_impl._M_finish - __n,
+           this->_M_impl._M_finish,
+           this->_M_impl._M_finish,
+           _M_get_Tp_allocator());
+    this->_M_impl._M_finish += __n;
+    ;
+    std::move_backward(__position.base(), __old_finish - __n, __old_finish)
+                                        ;
+    std::fill(__position.base(), __position.base() + __n,
+       __x_copy);
+  }
+       else
+  {
+    ;
+    this->_M_impl._M_finish =
+      std::__uninitialized_fill_n_a(this->_M_impl._M_finish,
+        __n - __elems_after,
+        __x_copy,
+        _M_get_Tp_allocator());
+    ;
+    std::__uninitialized_move_a(__position.base(), __old_finish,
+           this->_M_impl._M_finish,
+           _M_get_Tp_allocator());
+    this->_M_impl._M_finish += __elems_after;
+    ;
+    std::fill(__position.base(), __old_finish, __x_copy);
+  }
+     }
+   else
+     {
+       const size_type __len =
+  _M_check_len(__n, "vector::_M_fill_insert");
+       const size_type __elems_before = __position - begin();
+       pointer __new_start(this->_M_allocate(__len));
+       pointer __new_finish(__new_start);
+       try
+  {
+
+    std::__uninitialized_fill_n_a(__new_start + __elems_before,
+      __n, __x,
+      _M_get_Tp_allocator());
+    __new_finish = pointer();
+
+    __new_finish
+      = std::__uninitialized_move_if_noexcept_a
+      (this->_M_impl._M_start, __position.base(),
+       __new_start, _M_get_Tp_allocator());
+
+    __new_finish += __n;
+
+    __new_finish
+      = std::__uninitialized_move_if_noexcept_a
+      (__position.base(), this->_M_impl._M_finish,
+       __new_finish, _M_get_Tp_allocator());
+  }
+       catch(...)
+  {
+    if (!__new_finish)
+      std::_Destroy(__new_start + __elems_before,
+      __new_start + __elems_before + __n,
+      _M_get_Tp_allocator());
+    else
+      std::_Destroy(__new_start, __new_finish,
+      _M_get_Tp_allocator());
+    _M_deallocate(__new_start, __len);
+    throw;
+  }
+       std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
+       _M_get_Tp_allocator());
+       ;
+       _M_deallocate(this->_M_impl._M_start,
+       this->_M_impl._M_end_of_storage
+       - this->_M_impl._M_start);
+       this->_M_impl._M_start = __new_start;
+       this->_M_impl._M_finish = __new_finish;
+       this->_M_impl._M_end_of_storage = __new_start + __len;
+     }
+ }
+    }
+
+
+  template<typename _Tp, typename _Alloc>
+    void
+    vector<_Tp, _Alloc>::
+    _M_default_append(size_type __n)
+    {
+      if (__n != 0)
+ {
+   const size_type __size = size();
+   size_type __navail = size_type(this->_M_impl._M_end_of_storage
+      - this->_M_impl._M_finish);
+
+   if (__size > max_size() || __navail > max_size() - __size)
+     __builtin_unreachable();
+
+   if (__navail >= __n)
+     {
+       ;
+       this->_M_impl._M_finish =
+  std::__uninitialized_default_n_a(this->_M_impl._M_finish,
+       __n, _M_get_Tp_allocator());
+       ;
+     }
+   else
+     {
+       const size_type __len =
+  _M_check_len(__n, "vector::_M_default_append");
+       pointer __new_start(this->_M_allocate(__len));
+       if constexpr (_S_use_relocate())
+  {
+    try
+      {
+        std::__uninitialized_default_n_a(__new_start + __size,
+         __n, _M_get_Tp_allocator());
+      }
+    catch(...)
+      {
+        _M_deallocate(__new_start, __len);
+        throw;
+      }
+    _S_relocate(this->_M_impl._M_start, this->_M_impl._M_finish,
+         __new_start, _M_get_Tp_allocator());
+  }
+       else
+  {
+    pointer __destroy_from = pointer();
+    try
+      {
+        std::__uninitialized_default_n_a(__new_start + __size,
+         __n, _M_get_Tp_allocator());
+        __destroy_from = __new_start + __size;
+        std::__uninitialized_move_if_noexcept_a(
+         this->_M_impl._M_start, this->_M_impl._M_finish,
+         __new_start, _M_get_Tp_allocator());
+      }
+    catch(...)
+      {
+        if (__destroy_from)
+   std::_Destroy(__destroy_from, __destroy_from + __n,
+          _M_get_Tp_allocator());
+        _M_deallocate(__new_start, __len);
+        throw;
+      }
+    std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
+    _M_get_Tp_allocator());
+  }
+       ;
+       _M_deallocate(this->_M_impl._M_start,
+       this->_M_impl._M_end_of_storage
+       - this->_M_impl._M_start);
+       this->_M_impl._M_start = __new_start;
+       this->_M_impl._M_finish = __new_start + __size + __n;
+       this->_M_impl._M_end_of_storage = __new_start + __len;
+     }
+ }
+    }
+
+  template<typename _Tp, typename _Alloc>
+    bool
+    vector<_Tp, _Alloc>::
+    _M_shrink_to_fit()
+    {
+      if (capacity() == size())
+ return false;
+      ;
+      return std::__shrink_to_fit_aux<vector>::_S_do_it(*this);
+    }
+
+
+  template<typename _Tp, typename _Alloc>
+    template<typename _InputIterator>
+      void
+      vector<_Tp, _Alloc>::
+      _M_range_insert(iterator __pos, _InputIterator __first,
+        _InputIterator __last, std::input_iterator_tag)
+      {
+ if (__pos == end())
+   {
+     for (; __first != __last; ++__first)
+       insert(end(), *__first);
+   }
+ else if (__first != __last)
+   {
+     vector __tmp(__first, __last, _M_get_Tp_allocator());
+     insert(__pos,
+     std::make_move_iterator(__tmp.begin()),
+     std::make_move_iterator(__tmp.end()));
+   }
+      }
+
+  template<typename _Tp, typename _Alloc>
+    template<typename _ForwardIterator>
+      void
+      vector<_Tp, _Alloc>::
+      _M_range_insert(iterator __position, _ForwardIterator __first,
+        _ForwardIterator __last, std::forward_iterator_tag)
+      {
+ if (__first != __last)
+   {
+     const size_type __n = std::distance(__first, __last);
+     if (size_type(this->_M_impl._M_end_of_storage
+     - this->_M_impl._M_finish) >= __n)
+       {
+  const size_type __elems_after = end() - __position;
+  pointer __old_finish(this->_M_impl._M_finish);
+  if (__elems_after > __n)
+    {
+      ;
+      std::__uninitialized_move_a(this->_M_impl._M_finish - __n,
+      this->_M_impl._M_finish,
+      this->_M_impl._M_finish,
+      _M_get_Tp_allocator());
+      this->_M_impl._M_finish += __n;
+      ;
+      std::move_backward(__position.base(), __old_finish - __n, __old_finish)
+                                          ;
+      std::copy(__first, __last, __position);
+    }
+  else
+    {
+      _ForwardIterator __mid = __first;
+      std::advance(__mid, __elems_after);
+      ;
+      std::__uninitialized_copy_a(__mid, __last,
+      this->_M_impl._M_finish,
+      _M_get_Tp_allocator());
+      this->_M_impl._M_finish += __n - __elems_after;
+      ;
+      std::__uninitialized_move_a(__position.base(),
+      __old_finish,
+      this->_M_impl._M_finish,
+      _M_get_Tp_allocator());
+      this->_M_impl._M_finish += __elems_after;
+      ;
+      std::copy(__first, __mid, __position);
+    }
+       }
+     else
+       {
+  const size_type __len =
+    _M_check_len(__n, "vector::_M_range_insert");
+  pointer __new_start(this->_M_allocate(__len));
+  pointer __new_finish(__new_start);
+  try
+    {
+      __new_finish
+        = std::__uninitialized_move_if_noexcept_a
+        (this->_M_impl._M_start, __position.base(),
+         __new_start, _M_get_Tp_allocator());
+      __new_finish
+        = std::__uninitialized_copy_a(__first, __last,
+          __new_finish,
+          _M_get_Tp_allocator());
+      __new_finish
+        = std::__uninitialized_move_if_noexcept_a
+        (__position.base(), this->_M_impl._M_finish,
+         __new_finish, _M_get_Tp_allocator());
+    }
+  catch(...)
+    {
+      std::_Destroy(__new_start, __new_finish,
+      _M_get_Tp_allocator());
+      _M_deallocate(__new_start, __len);
+      throw;
+    }
+  std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
+         _M_get_Tp_allocator());
+  ;
+  _M_deallocate(this->_M_impl._M_start,
+         this->_M_impl._M_end_of_storage
+         - this->_M_impl._M_start);
+  this->_M_impl._M_start = __new_start;
+  this->_M_impl._M_finish = __new_finish;
+  this->_M_impl._M_end_of_storage = __new_start + __len;
+       }
+   }
+      }
+
+
+
+  template<typename _Alloc>
+    void
+    vector<bool, _Alloc>::
+    _M_reallocate(size_type __n)
+    {
+      _Bit_pointer __q = this->_M_allocate(__n);
+      iterator __start(std::__addressof(*__q), 0);
+      iterator __finish(_M_copy_aligned(begin(), end(), __start));
+      this->_M_deallocate();
+      this->_M_impl._M_start = __start;
+      this->_M_impl._M_finish = __finish;
+      this->_M_impl._M_end_of_storage = __q + _S_nword(__n);
+    }
+
+  template<typename _Alloc>
+    void
+    vector<bool, _Alloc>::
+    _M_fill_insert(iterator __position, size_type __n, bool __x)
+    {
+      if (__n == 0)
+ return;
+      if (capacity() - size() >= __n)
+ {
+   std::copy_backward(__position, end(),
+        this->_M_impl._M_finish + difference_type(__n));
+   std::fill(__position, __position + difference_type(__n), __x);
+   this->_M_impl._M_finish += difference_type(__n);
+ }
+      else
+ {
+   const size_type __len =
+     _M_check_len(__n, "vector<bool>::_M_fill_insert");
+   _Bit_pointer __q = this->_M_allocate(__len);
+   iterator __start(std::__addressof(*__q), 0);
+   iterator __i = _M_copy_aligned(begin(), __position, __start);
+   std::fill(__i, __i + difference_type(__n), __x);
+   iterator __finish = std::copy(__position, end(),
+     __i + difference_type(__n));
+   this->_M_deallocate();
+   this->_M_impl._M_end_of_storage = __q + _S_nword(__len);
+   this->_M_impl._M_start = __start;
+   this->_M_impl._M_finish = __finish;
+ }
+    }
+
+  template<typename _Alloc>
+    template<typename _ForwardIterator>
+      void
+      vector<bool, _Alloc>::
+      _M_insert_range(iterator __position, _ForwardIterator __first,
+        _ForwardIterator __last, std::forward_iterator_tag)
+      {
+ if (__first != __last)
+   {
+     size_type __n = std::distance(__first, __last);
+     if (capacity() - size() >= __n)
+       {
+  std::copy_backward(__position, end(),
+       this->_M_impl._M_finish
+       + difference_type(__n));
+  std::copy(__first, __last, __position);
+  this->_M_impl._M_finish += difference_type(__n);
+       }
+     else
+       {
+  const size_type __len =
+    _M_check_len(__n, "vector<bool>::_M_insert_range");
+  _Bit_pointer __q = this->_M_allocate(__len);
+  iterator __start(std::__addressof(*__q), 0);
+  iterator __i = _M_copy_aligned(begin(), __position, __start);
+  __i = std::copy(__first, __last, __i);
+  iterator __finish = std::copy(__position, end(), __i);
+  this->_M_deallocate();
+  this->_M_impl._M_end_of_storage = __q + _S_nword(__len);
+  this->_M_impl._M_start = __start;
+  this->_M_impl._M_finish = __finish;
+       }
+   }
+      }
+
+  template<typename _Alloc>
+    void
+    vector<bool, _Alloc>::
+    _M_insert_aux(iterator __position, bool __x)
+    {
+      if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_addr())
+ {
+   std::copy_backward(__position, this->_M_impl._M_finish,
+        this->_M_impl._M_finish + 1);
+   *__position = __x;
+   ++this->_M_impl._M_finish;
+ }
+      else
+ {
+   const size_type __len =
+     _M_check_len(size_type(1), "vector<bool>::_M_insert_aux");
+   _Bit_pointer __q = this->_M_allocate(__len);
+   iterator __start(std::__addressof(*__q), 0);
+   iterator __i = _M_copy_aligned(begin(), __position, __start);
+   *__i++ = __x;
+   iterator __finish = std::copy(__position, end(), __i);
+   this->_M_deallocate();
+   this->_M_impl._M_end_of_storage = __q + _S_nword(__len);
+   this->_M_impl._M_start = __start;
+   this->_M_impl._M_finish = __finish;
+ }
+    }
+
+  template<typename _Alloc>
+    typename vector<bool, _Alloc>::iterator
+    vector<bool, _Alloc>::
+    _M_erase(iterator __position)
+    {
+      if (__position + 1 != end())
+        std::copy(__position + 1, end(), __position);
+      --this->_M_impl._M_finish;
+      return __position;
+    }
+
+  template<typename _Alloc>
+    typename vector<bool, _Alloc>::iterator
+    vector<bool, _Alloc>::
+    _M_erase(iterator __first, iterator __last)
+    {
+      if (__first != __last)
+ _M_erase_at_end(std::copy(__last, end(), __first));
+      return __first;
+    }
+
+
+  template<typename _Alloc>
+    bool
+    vector<bool, _Alloc>::
+    _M_shrink_to_fit()
+    {
+      if (capacity() - size() < int(_S_word_bit))
+ return false;
+      try
+ {
+   _M_reallocate(size());
+   return true;
+ }
+      catch(...)
+ { return false; }
+    }
+
+
+
+
+}
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  template<typename _Alloc>
+    size_t
+    hash<std::vector<bool, _Alloc>>::
+    operator()(const std::vector<bool, _Alloc>& __b) const noexcept
+    {
+      size_t __hash = 0;
+      using std::_S_word_bit;
+      using std::_Bit_type;
+
+      const size_t __words = __b.size() / _S_word_bit;
+      if (__words)
+ {
+   const size_t __clength = __words * sizeof(_Bit_type);
+   __hash = std::_Hash_impl::hash(__b._M_impl._M_start._M_p, __clength);
+ }
+
+      const size_t __extrabits = __b.size() % _S_word_bit;
+      if (__extrabits)
+ {
+   _Bit_type __hiword = *__b._M_impl._M_finish._M_p;
+   __hiword &= ~((~static_cast<_Bit_type>(0)) << __extrabits);
+
+   const size_t __clength
+     = (__extrabits + 8 - 1) / 8;
+   if (__words)
+     __hash = std::_Hash_impl::hash(&__hiword, __clength, __hash);
+   else
+     __hash = std::_Hash_impl::hash(&__hiword, __clength);
+ }
+
+      return __hash;
+    }
+
+
+}
+
+
+
+#undef _GLIBCXX_ASAN_ANNOTATE_REINIT
+#undef _GLIBCXX_ASAN_ANNOTATE_GROW
+#undef _GLIBCXX_ASAN_ANNOTATE_GREW
+#undef _GLIBCXX_ASAN_ANNOTATE_SHRINK
+# 73 "/usr/include/c++/10.2.0/vector" 2 3
+
+
+
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  namespace pmr {
+    template<typename _Tp> class polymorphic_allocator;
+    template<typename _Tp>
+      using vector = std::vector<_Tp, polymorphic_allocator<_Tp>>;
+  }
+
+
+
+
+
+
+
+
+}
+# 63 "/usr/include/c++/10.2.0/functional" 2 3
+
+
+# 1 "/usr/include/c++/10.2.0/bits/stl_algo.h" 1 3
+# 57 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+#define _STL_ALGO_H 1
+
+# 1 "/usr/include/c++/10.2.0/cstdlib" 1 3
+# 39 "/usr/include/c++/10.2.0/cstdlib" 3
+       
+# 40 "/usr/include/c++/10.2.0/cstdlib" 3
+# 60 "/usr/include/c++/10.2.0/bits/stl_algo.h" 2 3
+# 1 "/usr/include/c++/10.2.0/bits/algorithmfwd.h" 1 3
+# 31 "/usr/include/c++/10.2.0/bits/algorithmfwd.h" 3
+#define _GLIBCXX_ALGORITHMFWD_H 1
+
+       
+# 34 "/usr/include/c++/10.2.0/bits/algorithmfwd.h" 3
+# 42 "/usr/include/c++/10.2.0/bits/algorithmfwd.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 199 "/usr/include/c++/10.2.0/bits/algorithmfwd.h" 3
+  template<typename _IIter, typename _Predicate>
+   
+    bool
+    all_of(_IIter, _IIter, _Predicate);
+
+  template<typename _IIter, typename _Predicate>
+   
+    bool
+    any_of(_IIter, _IIter, _Predicate);
+
+
+  template<typename _FIter, typename _Tp>
+   
+    bool
+    binary_search(_FIter, _FIter, const _Tp&);
+
+  template<typename _FIter, typename _Tp, typename _Compare>
+   
+    bool
+    binary_search(_FIter, _FIter, const _Tp&, _Compare);
+
+
+  template<typename _Tp>
+    constexpr
+    const _Tp&
+    clamp(const _Tp&, const _Tp&, const _Tp&);
+
+  template<typename _Tp, typename _Compare>
+    constexpr
+    const _Tp&
+    clamp(const _Tp&, const _Tp&, const _Tp&, _Compare);
+
+
+  template<typename _IIter, typename _OIter>
+   
+    _OIter
+    copy(_IIter, _IIter, _OIter);
+
+  template<typename _BIter1, typename _BIter2>
+   
+    _BIter2
+    copy_backward(_BIter1, _BIter1, _BIter2);
+
+
+  template<typename _IIter, typename _OIter, typename _Predicate>
+   
+    _OIter
+    copy_if(_IIter, _IIter, _OIter, _Predicate);
+
+  template<typename _IIter, typename _Size, typename _OIter>
+   
+    _OIter
+    copy_n(_IIter, _Size, _OIter);
+
+
+
+
+
+  template<typename _FIter, typename _Tp>
+   
+    pair<_FIter, _FIter>
+    equal_range(_FIter, _FIter, const _Tp&);
+
+  template<typename _FIter, typename _Tp, typename _Compare>
+   
+    pair<_FIter, _FIter>
+    equal_range(_FIter, _FIter, const _Tp&, _Compare);
+
+  template<typename _FIter, typename _Tp>
+   
+    void
+    fill(_FIter, _FIter, const _Tp&);
+
+  template<typename _OIter, typename _Size, typename _Tp>
+   
+    _OIter
+    fill_n(_OIter, _Size, const _Tp&);
+
+
+
+  template<typename _FIter1, typename _FIter2>
+   
+    _FIter1
+    find_end(_FIter1, _FIter1, _FIter2, _FIter2);
+
+  template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
+   
+    _FIter1
+    find_end(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
+
+
+
+
+
+  template<typename _IIter, typename _Predicate>
+   
+    _IIter
+    find_if_not(_IIter, _IIter, _Predicate);
+
+
+
+
+
+
+  template<typename _IIter1, typename _IIter2>
+   
+    bool
+    includes(_IIter1, _IIter1, _IIter2, _IIter2);
+
+  template<typename _IIter1, typename _IIter2, typename _Compare>
+   
+    bool
+    includes(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
+
+  template<typename _BIter>
+    void
+    inplace_merge(_BIter, _BIter, _BIter);
+
+  template<typename _BIter, typename _Compare>
+    void
+    inplace_merge(_BIter, _BIter, _BIter, _Compare);
+
+
+  template<typename _RAIter>
+   
+    bool
+    is_heap(_RAIter, _RAIter);
+
+  template<typename _RAIter, typename _Compare>
+   
+    bool
+    is_heap(_RAIter, _RAIter, _Compare);
+
+  template<typename _RAIter>
+   
+    _RAIter
+    is_heap_until(_RAIter, _RAIter);
+
+  template<typename _RAIter, typename _Compare>
+   
+    _RAIter
+    is_heap_until(_RAIter, _RAIter, _Compare);
+
+  template<typename _IIter, typename _Predicate>
+   
+    bool
+    is_partitioned(_IIter, _IIter, _Predicate);
+
+  template<typename _FIter1, typename _FIter2>
+   
+    bool
+    is_permutation(_FIter1, _FIter1, _FIter2);
+
+  template<typename _FIter1, typename _FIter2,
+    typename _BinaryPredicate>
+   
+    bool
+    is_permutation(_FIter1, _FIter1, _FIter2, _BinaryPredicate);
+
+  template<typename _FIter>
+   
+    bool
+    is_sorted(_FIter, _FIter);
+
+  template<typename _FIter, typename _Compare>
+   
+    bool
+    is_sorted(_FIter, _FIter, _Compare);
+
+  template<typename _FIter>
+   
+    _FIter
+    is_sorted_until(_FIter, _FIter);
+
+  template<typename _FIter, typename _Compare>
+   
+    _FIter
+    is_sorted_until(_FIter, _FIter, _Compare);
+
+
+  template<typename _FIter1, typename _FIter2>
+   
+    void
+    iter_swap(_FIter1, _FIter2);
+
+  template<typename _FIter, typename _Tp>
+   
+    _FIter
+    lower_bound(_FIter, _FIter, const _Tp&);
+
+  template<typename _FIter, typename _Tp, typename _Compare>
+   
+    _FIter
+    lower_bound(_FIter, _FIter, const _Tp&, _Compare);
+
+  template<typename _RAIter>
+   
+    void
+    make_heap(_RAIter, _RAIter);
+
+  template<typename _RAIter, typename _Compare>
+   
+    void
+    make_heap(_RAIter, _RAIter, _Compare);
+
+  template<typename _Tp>
+    constexpr
+    const _Tp&
+    max(const _Tp&, const _Tp&);
+
+  template<typename _Tp, typename _Compare>
+    constexpr
+    const _Tp&
+    max(const _Tp&, const _Tp&, _Compare);
+
+
+
+
+  template<typename _Tp>
+    constexpr
+    const _Tp&
+    min(const _Tp&, const _Tp&);
+
+  template<typename _Tp, typename _Compare>
+    constexpr
+    const _Tp&
+    min(const _Tp&, const _Tp&, _Compare);
+
+
+
+
+  template<typename _Tp>
+    constexpr
+    pair<const _Tp&, const _Tp&>
+    minmax(const _Tp&, const _Tp&);
+
+  template<typename _Tp, typename _Compare>
+    constexpr
+    pair<const _Tp&, const _Tp&>
+    minmax(const _Tp&, const _Tp&, _Compare);
+
+  template<typename _FIter>
+    constexpr
+    pair<_FIter, _FIter>
+    minmax_element(_FIter, _FIter);
+
+  template<typename _FIter, typename _Compare>
+    constexpr
+    pair<_FIter, _FIter>
+    minmax_element(_FIter, _FIter, _Compare);
+
+  template<typename _Tp>
+    constexpr
+    _Tp
+    min(initializer_list<_Tp>);
+
+  template<typename _Tp, typename _Compare>
+    constexpr
+    _Tp
+    min(initializer_list<_Tp>, _Compare);
+
+  template<typename _Tp>
+    constexpr
+    _Tp
+    max(initializer_list<_Tp>);
+
+  template<typename _Tp, typename _Compare>
+    constexpr
+    _Tp
+    max(initializer_list<_Tp>, _Compare);
+
+  template<typename _Tp>
+    constexpr
+    pair<_Tp, _Tp>
+    minmax(initializer_list<_Tp>);
+
+  template<typename _Tp, typename _Compare>
+    constexpr
+    pair<_Tp, _Tp>
+    minmax(initializer_list<_Tp>, _Compare);
+
+
+
+
+  template<typename _BIter>
+   
+    bool
+    next_permutation(_BIter, _BIter);
+
+  template<typename _BIter, typename _Compare>
+   
+    bool
+    next_permutation(_BIter, _BIter, _Compare);
+
+
+  template<typename _IIter, typename _Predicate>
+   
+    bool
+    none_of(_IIter, _IIter, _Predicate);
+
+
+
+
+
+  template<typename _IIter, typename _RAIter>
+   
+    _RAIter
+    partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter);
+
+  template<typename _IIter, typename _RAIter, typename _Compare>
+   
+    _RAIter
+    partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter, _Compare);
+
+
+
+
+  template<typename _IIter, typename _OIter1,
+    typename _OIter2, typename _Predicate>
+   
+    pair<_OIter1, _OIter2>
+    partition_copy(_IIter, _IIter, _OIter1, _OIter2, _Predicate);
+
+  template<typename _FIter, typename _Predicate>
+   
+    _FIter
+    partition_point(_FIter, _FIter, _Predicate);
+
+
+  template<typename _RAIter>
+   
+    void
+    pop_heap(_RAIter, _RAIter);
+
+  template<typename _RAIter, typename _Compare>
+   
+    void
+    pop_heap(_RAIter, _RAIter, _Compare);
+
+  template<typename _BIter>
+   
+    bool
+    prev_permutation(_BIter, _BIter);
+
+  template<typename _BIter, typename _Compare>
+   
+    bool
+    prev_permutation(_BIter, _BIter, _Compare);
+
+  template<typename _RAIter>
+   
+    void
+    push_heap(_RAIter, _RAIter);
+
+  template<typename _RAIter, typename _Compare>
+   
+    void
+    push_heap(_RAIter, _RAIter, _Compare);
+
+
+
+  template<typename _FIter, typename _Tp>
+   
+    _FIter
+    remove(_FIter, _FIter, const _Tp&);
+
+  template<typename _FIter, typename _Predicate>
+   
+    _FIter
+    remove_if(_FIter, _FIter, _Predicate);
+
+  template<typename _IIter, typename _OIter, typename _Tp>
+   
+    _OIter
+    remove_copy(_IIter, _IIter, _OIter, const _Tp&);
+
+  template<typename _IIter, typename _OIter, typename _Predicate>
+   
+    _OIter
+    remove_copy_if(_IIter, _IIter, _OIter, _Predicate);
+
+
+
+  template<typename _IIter, typename _OIter, typename _Tp>
+   
+    _OIter
+    replace_copy(_IIter, _IIter, _OIter, const _Tp&, const _Tp&);
+
+  template<typename _Iter, typename _OIter, typename _Predicate, typename _Tp>
+   
+    _OIter
+    replace_copy_if(_Iter, _Iter, _OIter, _Predicate, const _Tp&);
+
+
+
+  template<typename _BIter>
+   
+    void
+    reverse(_BIter, _BIter);
+
+  template<typename _BIter, typename _OIter>
+   
+    _OIter
+    reverse_copy(_BIter, _BIter, _OIter);
+
+  inline namespace _V2
+  {
+    template<typename _FIter>
+     
+      _FIter
+      rotate(_FIter, _FIter, _FIter);
+  }
+
+  template<typename _FIter, typename _OIter>
+   
+    _OIter
+    rotate_copy(_FIter, _FIter, _FIter, _OIter);
+# 625 "/usr/include/c++/10.2.0/bits/algorithmfwd.h" 3
+  template<typename _RAIter, typename _UGenerator>
+    void
+    shuffle(_RAIter, _RAIter, _UGenerator&&);
+
+
+  template<typename _RAIter>
+   
+    void
+    sort_heap(_RAIter, _RAIter);
+
+  template<typename _RAIter, typename _Compare>
+   
+    void
+    sort_heap(_RAIter, _RAIter, _Compare);
+
+  template<typename _BIter, typename _Predicate>
+    _BIter
+    stable_partition(_BIter, _BIter, _Predicate);
+# 658 "/usr/include/c++/10.2.0/bits/algorithmfwd.h" 3
+  template<typename _FIter1, typename _FIter2>
+   
+    _FIter2
+    swap_ranges(_FIter1, _FIter1, _FIter2);
+
+
+
+  template<typename _FIter>
+   
+    _FIter
+    unique(_FIter, _FIter);
+
+  template<typename _FIter, typename _BinaryPredicate>
+   
+    _FIter
+    unique(_FIter, _FIter, _BinaryPredicate);
+
+
+
+  template<typename _FIter, typename _Tp>
+   
+    _FIter
+    upper_bound(_FIter, _FIter, const _Tp&);
+
+  template<typename _FIter, typename _Tp, typename _Compare>
+   
+    _FIter
+    upper_bound(_FIter, _FIter, const _Tp&, _Compare);
+
+
+
+  template<typename _FIter>
+   
+    _FIter
+    adjacent_find(_FIter, _FIter);
+
+  template<typename _FIter, typename _BinaryPredicate>
+   
+    _FIter
+    adjacent_find(_FIter, _FIter, _BinaryPredicate);
+
+  template<typename _IIter, typename _Tp>
+   
+    typename iterator_traits<_IIter>::difference_type
+    count(_IIter, _IIter, const _Tp&);
+
+  template<typename _IIter, typename _Predicate>
+   
+    typename iterator_traits<_IIter>::difference_type
+    count_if(_IIter, _IIter, _Predicate);
+
+  template<typename _IIter1, typename _IIter2>
+   
+    bool
+    equal(_IIter1, _IIter1, _IIter2);
+
+  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
+   
+    bool
+    equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
+
+  template<typename _IIter, typename _Tp>
+   
+    _IIter
+    find(_IIter, _IIter, const _Tp&);
+
+  template<typename _FIter1, typename _FIter2>
+   
+    _FIter1
+    find_first_of(_FIter1, _FIter1, _FIter2, _FIter2);
+
+  template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
+   
+    _FIter1
+    find_first_of(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
+
+  template<typename _IIter, typename _Predicate>
+   
+    _IIter
+    find_if(_IIter, _IIter, _Predicate);
+
+  template<typename _IIter, typename _Funct>
+   
+    _Funct
+    for_each(_IIter, _IIter, _Funct);
+
+  template<typename _FIter, typename _Generator>
+   
+    void
+    generate(_FIter, _FIter, _Generator);
+
+  template<typename _OIter, typename _Size, typename _Generator>
+   
+    _OIter
+    generate_n(_OIter, _Size, _Generator);
+
+  template<typename _IIter1, typename _IIter2>
+   
+    bool
+    lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2);
+
+  template<typename _IIter1, typename _IIter2, typename _Compare>
+   
+    bool
+    lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
+
+  template<typename _FIter>
+    constexpr
+    _FIter
+    max_element(_FIter, _FIter);
+
+  template<typename _FIter, typename _Compare>
+    constexpr
+    _FIter
+    max_element(_FIter, _FIter, _Compare);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter>
+   
+    _OIter
+    merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+    typename _Compare>
+   
+    _OIter
+    merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
+
+  template<typename _FIter>
+    constexpr
+    _FIter
+    min_element(_FIter, _FIter);
+
+  template<typename _FIter, typename _Compare>
+    constexpr
+    _FIter
+    min_element(_FIter, _FIter, _Compare);
+
+  template<typename _IIter1, typename _IIter2>
+   
+    pair<_IIter1, _IIter2>
+    mismatch(_IIter1, _IIter1, _IIter2);
+
+  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
+   
+    pair<_IIter1, _IIter2>
+    mismatch(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
+
+  template<typename _RAIter>
+   
+    void
+    nth_element(_RAIter, _RAIter, _RAIter);
+
+  template<typename _RAIter, typename _Compare>
+   
+    void
+    nth_element(_RAIter, _RAIter, _RAIter, _Compare);
+
+  template<typename _RAIter>
+   
+    void
+    partial_sort(_RAIter, _RAIter, _RAIter);
+
+  template<typename _RAIter, typename _Compare>
+   
+    void
+    partial_sort(_RAIter, _RAIter, _RAIter, _Compare);
+
+  template<typename _BIter, typename _Predicate>
+   
+    _BIter
+    partition(_BIter, _BIter, _Predicate);
+
+  template<typename _RAIter>
+    void
+    random_shuffle(_RAIter, _RAIter);
+
+  template<typename _RAIter, typename _Generator>
+    void
+    random_shuffle(_RAIter, _RAIter,
+
+     _Generator&&);
+
+
+
+
+  template<typename _FIter, typename _Tp>
+   
+    void
+    replace(_FIter, _FIter, const _Tp&, const _Tp&);
+
+  template<typename _FIter, typename _Predicate, typename _Tp>
+   
+    void
+    replace_if(_FIter, _FIter, _Predicate, const _Tp&);
+
+  template<typename _FIter1, typename _FIter2>
+   
+    _FIter1
+    search(_FIter1, _FIter1, _FIter2, _FIter2);
+
+  template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
+   
+    _FIter1
+    search(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
+
+  template<typename _FIter, typename _Size, typename _Tp>
+   
+    _FIter
+    search_n(_FIter, _FIter, _Size, const _Tp&);
+
+  template<typename _FIter, typename _Size, typename _Tp,
+    typename _BinaryPredicate>
+   
+    _FIter
+    search_n(_FIter, _FIter, _Size, const _Tp&, _BinaryPredicate);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter>
+   
+    _OIter
+    set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+    typename _Compare>
+   
+    _OIter
+    set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter>
+   
+    _OIter
+    set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+    typename _Compare>
+   
+    _OIter
+    set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter>
+   
+    _OIter
+    set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+    typename _Compare>
+   
+    _OIter
+    set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2,
+        _OIter, _Compare);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter>
+   
+    _OIter
+    set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+    typename _Compare>
+   
+    _OIter
+    set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
+
+  template<typename _RAIter>
+   
+    void
+    sort(_RAIter, _RAIter);
+
+  template<typename _RAIter, typename _Compare>
+   
+    void
+    sort(_RAIter, _RAIter, _Compare);
+
+  template<typename _RAIter>
+    void
+    stable_sort(_RAIter, _RAIter);
+
+  template<typename _RAIter, typename _Compare>
+    void
+    stable_sort(_RAIter, _RAIter, _Compare);
+
+  template<typename _IIter, typename _OIter, typename _UnaryOperation>
+   
+    _OIter
+    transform(_IIter, _IIter, _OIter, _UnaryOperation);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+    typename _BinaryOperation>
+   
+    _OIter
+    transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation);
+
+  template<typename _IIter, typename _OIter>
+   
+    _OIter
+    unique_copy(_IIter, _IIter, _OIter);
+
+  template<typename _IIter, typename _OIter, typename _BinaryPredicate>
+   
+    _OIter
+    unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate);
+
+
+
+}
+# 61 "/usr/include/c++/10.2.0/bits/stl_algo.h" 2 3
+# 1 "/usr/include/c++/10.2.0/bits/stl_heap.h" 1 3
+# 56 "/usr/include/c++/10.2.0/bits/stl_heap.h" 3
+#define _STL_HEAP_H 1
+
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+
+
+  template<typename _RandomAccessIterator, typename _Distance,
+    typename _Compare>
+   
+    _Distance
+    __is_heap_until(_RandomAccessIterator __first, _Distance __n,
+      _Compare& __comp)
+    {
+      _Distance __parent = 0;
+      for (_Distance __child = 1; __child < __n; ++__child)
+ {
+   if (__comp(__first + __parent, __first + __child))
+     return __child;
+   if ((__child & 1) == 0)
+     ++__parent;
+ }
+      return __n;
+    }
+
+
+
+  template<typename _RandomAccessIterator, typename _Distance>
+   
+    inline bool
+    __is_heap(_RandomAccessIterator __first, _Distance __n)
+    {
+      __gnu_cxx::__ops::_Iter_less_iter __comp;
+      return std::__is_heap_until(__first, __n, __comp) == __n;
+    }
+
+  template<typename _RandomAccessIterator, typename _Compare,
+    typename _Distance>
+   
+    inline bool
+    __is_heap(_RandomAccessIterator __first, _Compare __comp, _Distance __n)
+    {
+      typedef __decltype(__comp) _Cmp;
+      __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(std::move(__comp));
+      return std::__is_heap_until(__first, __n, __cmp) == __n;
+    }
+
+  template<typename _RandomAccessIterator>
+   
+    inline bool
+    __is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    { return std::__is_heap(__first, std::distance(__first, __last)); }
+
+  template<typename _RandomAccessIterator, typename _Compare>
+   
+    inline bool
+    __is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+       _Compare __comp)
+    {
+      return std::__is_heap(__first, std::move(__comp),
+       std::distance(__first, __last));
+    }
+
+
+
+
+  template<typename _RandomAccessIterator, typename _Distance, typename _Tp,
+    typename _Compare>
+   
+    void
+    __push_heap(_RandomAccessIterator __first,
+  _Distance __holeIndex, _Distance __topIndex, _Tp __value,
+  _Compare& __comp)
+    {
+      _Distance __parent = (__holeIndex - 1) / 2;
+      while (__holeIndex > __topIndex && __comp(__first + __parent, __value))
+ {
+   *(__first + __holeIndex) = std::move(*(__first + __parent));
+   __holeIndex = __parent;
+   __parent = (__holeIndex - 1) / 2;
+ }
+      *(__first + __holeIndex) = std::move(__value);
+    }
+# 158 "/usr/include/c++/10.2.0/bits/stl_heap.h" 3
+  template<typename _RandomAccessIterator>
+   
+    inline void
+    push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+   _ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+   _DistanceType;
+
+
+     
+
+     
+      ;
+      ;
+      ;
+
+      __gnu_cxx::__ops::_Iter_less_val __comp;
+      _ValueType __value = std::move(*(__last - 1));
+      std::__push_heap(__first, _DistanceType((__last - __first) - 1),
+         _DistanceType(0), std::move(__value), __comp);
+    }
+# 194 "/usr/include/c++/10.2.0/bits/stl_heap.h" 3
+  template<typename _RandomAccessIterator, typename _Compare>
+   
+    inline void
+    push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+       _Compare __comp)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+   _ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+   _DistanceType;
+
+
+     
+
+      ;
+      ;
+      ;
+
+      __decltype(__gnu_cxx::__ops::__iter_comp_val(std::move(__comp)))
+ __cmp(std::move(__comp));
+      _ValueType __value = std::move(*(__last - 1));
+      std::__push_heap(__first, _DistanceType((__last - __first) - 1),
+         _DistanceType(0), std::move(__value), __cmp);
+    }
+
+  template<typename _RandomAccessIterator, typename _Distance,
+    typename _Tp, typename _Compare>
+   
+    void
+    __adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
+    _Distance __len, _Tp __value, _Compare __comp)
+    {
+      const _Distance __topIndex = __holeIndex;
+      _Distance __secondChild = __holeIndex;
+      while (__secondChild < (__len - 1) / 2)
+ {
+   __secondChild = 2 * (__secondChild + 1);
+   if (__comp(__first + __secondChild,
+       __first + (__secondChild - 1)))
+     __secondChild--;
+   *(__first + __holeIndex) = std::move(*(__first + __secondChild));
+   __holeIndex = __secondChild;
+ }
+      if ((__len & 1) == 0 && __secondChild == (__len - 2) / 2)
+ {
+   __secondChild = 2 * (__secondChild + 1);
+   *(__first + __holeIndex) = std::move(*(__first + (__secondChild - 1)))
+                                  ;
+   __holeIndex = __secondChild - 1;
+ }
+      __decltype(__gnu_cxx::__ops::__iter_comp_val(std::move(__comp)))
+ __cmp(std::move(__comp));
+      std::__push_heap(__first, __holeIndex, __topIndex,
+         std::move(__value), __cmp);
+    }
+
+  template<typename _RandomAccessIterator, typename _Compare>
+   
+    inline void
+    __pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+        _RandomAccessIterator __result, _Compare& __comp)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+ _ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+ _DistanceType;
+
+      _ValueType __value = std::move(*__result);
+      *__result = std::move(*__first);
+      std::__adjust_heap(__first, _DistanceType(0),
+    _DistanceType(__last - __first),
+    std::move(__value), __comp);
+    }
+# 279 "/usr/include/c++/10.2.0/bits/stl_heap.h" 3
+  template<typename _RandomAccessIterator>
+   
+    inline void
+    pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    {
+
+     
+
+     
+
+      ;
+      ;
+      ;
+      ;
+
+      if (__last - __first > 1)
+ {
+   --__last;
+   __gnu_cxx::__ops::_Iter_less_iter __comp;
+   std::__pop_heap(__first, __last, __last, __comp);
+ }
+    }
+# 313 "/usr/include/c++/10.2.0/bits/stl_heap.h" 3
+  template<typename _RandomAccessIterator, typename _Compare>
+   
+    inline void
+    pop_heap(_RandomAccessIterator __first,
+      _RandomAccessIterator __last, _Compare __comp)
+    {
+
+     
+
+      ;
+      ;
+      ;
+      ;
+
+      if (__last - __first > 1)
+ {
+   typedef __decltype(__comp) _Cmp;
+   __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(std::move(__comp));
+   --__last;
+   std::__pop_heap(__first, __last, __last, __cmp);
+ }
+    }
+
+  template<typename _RandomAccessIterator, typename _Compare>
+   
+    void
+    __make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+  _Compare& __comp)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+   _ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+   _DistanceType;
+
+      if (__last - __first < 2)
+ return;
+
+      const _DistanceType __len = __last - __first;
+      _DistanceType __parent = (__len - 2) / 2;
+      while (true)
+ {
+   _ValueType __value = std::move(*(__first + __parent));
+   std::__adjust_heap(__first, __parent, __len, std::move(__value),
+        __comp);
+   if (__parent == 0)
+     return;
+   __parent--;
+ }
+    }
+# 371 "/usr/include/c++/10.2.0/bits/stl_heap.h" 3
+  template<typename _RandomAccessIterator>
+   
+    inline void
+    make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    {
+
+     
+
+     
+
+      ;
+      ;
+
+      __gnu_cxx::__ops::_Iter_less_iter __comp;
+      std::__make_heap(__first, __last, __comp);
+    }
+# 398 "/usr/include/c++/10.2.0/bits/stl_heap.h" 3
+  template<typename _RandomAccessIterator, typename _Compare>
+   
+    inline void
+    make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+       _Compare __comp)
+    {
+
+     
+
+      ;
+      ;
+
+      typedef __decltype(__comp) _Cmp;
+      __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(std::move(__comp));
+      std::__make_heap(__first, __last, __cmp);
+    }
+
+  template<typename _RandomAccessIterator, typename _Compare>
+   
+    void
+    __sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+  _Compare& __comp)
+    {
+      while (__last - __first > 1)
+ {
+   --__last;
+   std::__pop_heap(__first, __last, __last, __comp);
+ }
+    }
+# 436 "/usr/include/c++/10.2.0/bits/stl_heap.h" 3
+  template<typename _RandomAccessIterator>
+   
+    inline void
+    sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    {
+
+     
+
+     
+
+      ;
+      ;
+      ;
+
+      __gnu_cxx::__ops::_Iter_less_iter __comp;
+      std::__sort_heap(__first, __last, __comp);
+    }
+# 464 "/usr/include/c++/10.2.0/bits/stl_heap.h" 3
+  template<typename _RandomAccessIterator, typename _Compare>
+   
+    inline void
+    sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+       _Compare __comp)
+    {
+
+     
+
+      ;
+      ;
+      ;
+
+      typedef __decltype(__comp) _Cmp;
+      __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(std::move(__comp));
+      std::__sort_heap(__first, __last, __cmp);
+    }
+# 493 "/usr/include/c++/10.2.0/bits/stl_heap.h" 3
+  template<typename _RandomAccessIterator>
+   
+    inline _RandomAccessIterator
+    is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    {
+
+     
+
+     
+
+      ;
+      ;
+
+      __gnu_cxx::__ops::_Iter_less_iter __comp;
+      return __first +
+ std::__is_heap_until(__first, std::distance(__first, __last), __comp);
+    }
+# 522 "/usr/include/c++/10.2.0/bits/stl_heap.h" 3
+  template<typename _RandomAccessIterator, typename _Compare>
+   
+    inline _RandomAccessIterator
+    is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last,
+    _Compare __comp)
+    {
+
+     
+
+      ;
+      ;
+
+      typedef __decltype(__comp) _Cmp;
+      __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(std::move(__comp));
+      return __first
+ + std::__is_heap_until(__first, std::distance(__first, __last), __cmp);
+    }
+# 547 "/usr/include/c++/10.2.0/bits/stl_heap.h" 3
+  template<typename _RandomAccessIterator>
+   
+    inline bool
+    is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    { return std::is_heap_until(__first, __last) == __last; }
+# 561 "/usr/include/c++/10.2.0/bits/stl_heap.h" 3
+  template<typename _RandomAccessIterator, typename _Compare>
+   
+    inline bool
+    is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+     _Compare __comp)
+    {
+
+     
+
+      ;
+      ;
+
+      const auto __dist = std::distance(__first, __last);
+      typedef __decltype(__comp) _Cmp;
+      __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(std::move(__comp));
+      return std::__is_heap_until(__first, __dist, __cmp) == __dist;
+    }
+
+
+
+}
+# 62 "/usr/include/c++/10.2.0/bits/stl_algo.h" 2 3
+
+
+
+
+# 1 "/usr/include/c++/10.2.0/bits/uniform_int_dist.h" 1 3
+# 32 "/usr/include/c++/10.2.0/bits/uniform_int_dist.h" 3
+#define _GLIBCXX_BITS_UNIFORM_INT_DIST_H 
+
+
+
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 57 "/usr/include/c++/10.2.0/bits/uniform_int_dist.h" 3
+  namespace __detail
+  {
+
+    template<typename _Tp>
+      inline bool
+      _Power_of_2(_Tp __x)
+      {
+ return ((__x - 1) & __x) == 0;
+      }
+  }
+
+
+
+
+
+
+  template<typename _IntType = int>
+    class uniform_int_distribution
+    {
+      static_assert(std::is_integral<_IntType>::value,
+      "template argument must be an integral type");
+
+    public:
+
+      typedef _IntType result_type;
+
+      struct param_type
+      {
+ typedef uniform_int_distribution<_IntType> distribution_type;
+
+ param_type() : param_type(0) { }
+
+ explicit
+ param_type(_IntType __a,
+     _IntType __b = numeric_limits<_IntType>::max())
+ : _M_a(__a), _M_b(__b)
+ {
+   ;
+ }
+
+ result_type
+ a() const
+ { return _M_a; }
+
+ result_type
+ b() const
+ { return _M_b; }
+
+ friend bool
+ operator==(const param_type& __p1, const param_type& __p2)
+ { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
+
+ friend bool
+ operator!=(const param_type& __p1, const param_type& __p2)
+ { return !(__p1 == __p2); }
+
+      private:
+ _IntType _M_a;
+ _IntType _M_b;
+      };
+
+    public:
+
+
+
+      uniform_int_distribution() : uniform_int_distribution(0) { }
+
+
+
+
+      explicit
+      uniform_int_distribution(_IntType __a,
+          _IntType __b = numeric_limits<_IntType>::max())
+      : _M_param(__a, __b)
+      { }
+
+      explicit
+      uniform_int_distribution(const param_type& __p)
+      : _M_param(__p)
+      { }
+
+
+
+
+
+
+      void
+      reset() { }
+
+      result_type
+      a() const
+      { return _M_param.a(); }
+
+      result_type
+      b() const
+      { return _M_param.b(); }
+
+
+
+
+      param_type
+      param() const
+      { return _M_param; }
+
+
+
+
+
+      void
+      param(const param_type& __param)
+      { _M_param = __param; }
+
+
+
+
+      result_type
+      min() const
+      { return this->a(); }
+
+
+
+
+      result_type
+      max() const
+      { return this->b(); }
+
+
+
+
+      template<typename _UniformRandomNumberGenerator>
+ result_type
+ operator()(_UniformRandomNumberGenerator& __urng)
+        { return this->operator()(__urng, _M_param); }
+
+      template<typename _UniformRandomNumberGenerator>
+ result_type
+ operator()(_UniformRandomNumberGenerator& __urng,
+     const param_type& __p);
+
+      template<typename _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate(_ForwardIterator __f, _ForwardIterator __t,
+     _UniformRandomNumberGenerator& __urng)
+ { this->__generate(__f, __t, __urng, _M_param); }
+
+      template<typename _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate(_ForwardIterator __f, _ForwardIterator __t,
+     _UniformRandomNumberGenerator& __urng,
+     const param_type& __p)
+ { this->__generate_impl(__f, __t, __urng, __p); }
+
+      template<typename _UniformRandomNumberGenerator>
+ void
+ __generate(result_type* __f, result_type* __t,
+     _UniformRandomNumberGenerator& __urng,
+     const param_type& __p)
+ { this->__generate_impl(__f, __t, __urng, __p); }
+
+
+
+
+
+      friend bool
+      operator==(const uniform_int_distribution& __d1,
+   const uniform_int_distribution& __d2)
+      { return __d1._M_param == __d2._M_param; }
+
+    private:
+      template<typename _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+   _UniformRandomNumberGenerator& __urng,
+   const param_type& __p);
+
+      param_type _M_param;
+    };
+
+  template<typename _IntType>
+    template<typename _UniformRandomNumberGenerator>
+      typename uniform_int_distribution<_IntType>::result_type
+      uniform_int_distribution<_IntType>::
+      operator()(_UniformRandomNumberGenerator& __urng,
+   const param_type& __param)
+      {
+ typedef typename _UniformRandomNumberGenerator::result_type
+   _Gresult_type;
+ typedef typename std::make_unsigned<result_type>::type __utype;
+ typedef typename std::common_type<_Gresult_type, __utype>::type
+   __uctype;
+
+ const __uctype __urngmin = __urng.min();
+ const __uctype __urngmax = __urng.max();
+ const __uctype __urngrange = __urngmax - __urngmin;
+ const __uctype __urange
+   = __uctype(__param.b()) - __uctype(__param.a());
+
+ __uctype __ret;
+
+ if (__urngrange > __urange)
+   {
+
+     const __uctype __uerange = __urange + 1;
+     const __uctype __scaling = __urngrange / __uerange;
+     const __uctype __past = __uerange * __scaling;
+     do
+       __ret = __uctype(__urng()) - __urngmin;
+     while (__ret >= __past);
+     __ret /= __scaling;
+   }
+ else if (__urngrange < __urange)
+   {
+# 287 "/usr/include/c++/10.2.0/bits/uniform_int_dist.h" 3
+     __uctype __tmp;
+     do
+       {
+  const __uctype __uerngrange = __urngrange + 1;
+  __tmp = (__uerngrange * operator()
+    (__urng, param_type(0, __urange / __uerngrange)));
+  __ret = __tmp + (__uctype(__urng()) - __urngmin);
+       }
+     while (__ret > __urange || __ret < __tmp);
+   }
+ else
+   __ret = __uctype(__urng()) - __urngmin;
+
+ return __ret + __param.a();
+      }
+
+
+  template<typename _IntType>
+    template<typename _ForwardIterator,
+      typename _UniformRandomNumberGenerator>
+      void
+      uniform_int_distribution<_IntType>::
+      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+        _UniformRandomNumberGenerator& __urng,
+        const param_type& __param)
+      {
+
+ typedef typename _UniformRandomNumberGenerator::result_type
+   _Gresult_type;
+ typedef typename std::make_unsigned<result_type>::type __utype;
+ typedef typename std::common_type<_Gresult_type, __utype>::type
+   __uctype;
+
+ const __uctype __urngmin = __urng.min();
+ const __uctype __urngmax = __urng.max();
+ const __uctype __urngrange = __urngmax - __urngmin;
+ const __uctype __urange
+   = __uctype(__param.b()) - __uctype(__param.a());
+
+ __uctype __ret;
+
+ if (__urngrange > __urange)
+   {
+     if (__detail::_Power_of_2(__urngrange + 1)
+  && __detail::_Power_of_2(__urange + 1))
+       {
+  while (__f != __t)
+    {
+      __ret = __uctype(__urng()) - __urngmin;
+      *__f++ = (__ret & __urange) + __param.a();
+    }
+       }
+     else
+       {
+
+  const __uctype __uerange = __urange + 1;
+  const __uctype __scaling = __urngrange / __uerange;
+  const __uctype __past = __uerange * __scaling;
+  while (__f != __t)
+    {
+      do
+        __ret = __uctype(__urng()) - __urngmin;
+      while (__ret >= __past);
+      *__f++ = __ret / __scaling + __param.a();
+    }
+       }
+   }
+ else if (__urngrange < __urange)
+   {
+# 371 "/usr/include/c++/10.2.0/bits/uniform_int_dist.h" 3
+     __uctype __tmp;
+     while (__f != __t)
+       {
+  do
+    {
+      const __uctype __uerngrange = __urngrange + 1;
+      __tmp = (__uerngrange * operator()
+        (__urng, param_type(0, __urange / __uerngrange)));
+      __ret = __tmp + (__uctype(__urng()) - __urngmin);
+    }
+  while (__ret > __urange || __ret < __tmp);
+  *__f++ = __ret;
+       }
+   }
+ else
+   while (__f != __t)
+     *__f++ = __uctype(__urng()) - __urngmin + __param.a();
+      }
+
+
+
+
+}
+# 67 "/usr/include/c++/10.2.0/bits/stl_algo.h" 2 3
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+  template<typename _Iterator, typename _Compare>
+   
+    void
+    __move_median_to_first(_Iterator __result,_Iterator __a, _Iterator __b,
+      _Iterator __c, _Compare __comp)
+    {
+      if (__comp(__a, __b))
+ {
+   if (__comp(__b, __c))
+     std::iter_swap(__result, __b);
+   else if (__comp(__a, __c))
+     std::iter_swap(__result, __c);
+   else
+     std::iter_swap(__result, __a);
+ }
+      else if (__comp(__a, __c))
+ std::iter_swap(__result, __a);
+      else if (__comp(__b, __c))
+ std::iter_swap(__result, __c);
+      else
+ std::iter_swap(__result, __b);
+    }
+
+
+  template<typename _InputIterator, typename _Predicate>
+   
+    inline _InputIterator
+    __find_if_not(_InputIterator __first, _InputIterator __last,
+    _Predicate __pred)
+    {
+      return std::__find_if(__first, __last,
+       __gnu_cxx::__ops::__negate(__pred),
+       std::__iterator_category(__first));
+    }
+
+
+
+
+  template<typename _InputIterator, typename _Predicate, typename _Distance>
+   
+    _InputIterator
+    __find_if_not_n(_InputIterator __first, _Distance& __len, _Predicate __pred)
+    {
+      for (; __len; --__len, (void) ++__first)
+ if (!__pred(__first))
+   break;
+      return __first;
+    }
+# 138 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _ForwardIterator1, typename _ForwardIterator2,
+    typename _BinaryPredicate>
+   
+    _ForwardIterator1
+    __search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+      _ForwardIterator2 __first2, _ForwardIterator2 __last2,
+      _BinaryPredicate __predicate)
+    {
+
+      if (__first1 == __last1 || __first2 == __last2)
+ return __first1;
+
+
+      _ForwardIterator2 __p1(__first2);
+      if (++__p1 == __last2)
+ return std::__find_if(__first1, __last1,
+  __gnu_cxx::__ops::__iter_comp_iter(__predicate, __first2));
+
+
+      _ForwardIterator1 __current = __first1;
+
+      for (;;)
+ {
+   __first1 =
+     std::__find_if(__first1, __last1,
+  __gnu_cxx::__ops::__iter_comp_iter(__predicate, __first2));
+
+   if (__first1 == __last1)
+     return __last1;
+
+   _ForwardIterator2 __p = __p1;
+   __current = __first1;
+   if (++__current == __last1)
+     return __last1;
+
+   while (__predicate(__current, __p))
+     {
+       if (++__p == __last2)
+  return __first1;
+       if (++__current == __last1)
+  return __last1;
+     }
+   ++__first1;
+ }
+      return __first1;
+    }
+
+
+
+
+
+
+  template<typename _ForwardIterator, typename _Integer,
+    typename _UnaryPredicate>
+   
+    _ForwardIterator
+    __search_n_aux(_ForwardIterator __first, _ForwardIterator __last,
+     _Integer __count, _UnaryPredicate __unary_pred,
+     std::forward_iterator_tag)
+    {
+      __first = std::__find_if(__first, __last, __unary_pred);
+      while (__first != __last)
+ {
+   typename iterator_traits<_ForwardIterator>::difference_type
+     __n = __count;
+   _ForwardIterator __i = __first;
+   ++__i;
+   while (__i != __last && __n != 1 && __unary_pred(__i))
+     {
+       ++__i;
+       --__n;
+     }
+   if (__n == 1)
+     return __first;
+   if (__i == __last)
+     return __last;
+   __first = std::__find_if(++__i, __last, __unary_pred);
+ }
+      return __last;
+    }
+
+
+
+
+
+  template<typename _RandomAccessIter, typename _Integer,
+    typename _UnaryPredicate>
+   
+    _RandomAccessIter
+    __search_n_aux(_RandomAccessIter __first, _RandomAccessIter __last,
+     _Integer __count, _UnaryPredicate __unary_pred,
+     std::random_access_iterator_tag)
+    {
+      typedef typename std::iterator_traits<_RandomAccessIter>::difference_type
+ _DistanceType;
+
+      _DistanceType __tailSize = __last - __first;
+      _DistanceType __remainder = __count;
+
+      while (__remainder <= __tailSize)
+ {
+   __first += __remainder;
+   __tailSize -= __remainder;
+
+
+   _RandomAccessIter __backTrack = __first;
+   while (__unary_pred(--__backTrack))
+     {
+       if (--__remainder == 0)
+  return (__first - __count);
+     }
+   __remainder = __count + 1 - (__first - __backTrack);
+ }
+      return __last;
+    }
+
+  template<typename _ForwardIterator, typename _Integer,
+    typename _UnaryPredicate>
+   
+    _ForwardIterator
+    __search_n(_ForwardIterator __first, _ForwardIterator __last,
+        _Integer __count,
+        _UnaryPredicate __unary_pred)
+    {
+      if (__count <= 0)
+ return __first;
+
+      if (__count == 1)
+ return std::__find_if(__first, __last, __unary_pred);
+
+      return std::__search_n_aux(__first, __last, __count, __unary_pred,
+     std::__iterator_category(__first));
+    }
+
+
+  template<typename _ForwardIterator1, typename _ForwardIterator2,
+    typename _BinaryPredicate>
+   
+    _ForwardIterator1
+    __find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+        _ForwardIterator2 __first2, _ForwardIterator2 __last2,
+        forward_iterator_tag, forward_iterator_tag,
+        _BinaryPredicate __comp)
+    {
+      if (__first2 == __last2)
+ return __last1;
+
+      _ForwardIterator1 __result = __last1;
+      while (1)
+ {
+   _ForwardIterator1 __new_result
+     = std::__search(__first1, __last1, __first2, __last2, __comp);
+   if (__new_result == __last1)
+     return __result;
+   else
+     {
+       __result = __new_result;
+       __first1 = __new_result;
+       ++__first1;
+     }
+ }
+    }
+
+
+  template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
+    typename _BinaryPredicate>
+   
+    _BidirectionalIterator1
+    __find_end(_BidirectionalIterator1 __first1,
+        _BidirectionalIterator1 __last1,
+        _BidirectionalIterator2 __first2,
+        _BidirectionalIterator2 __last2,
+        bidirectional_iterator_tag, bidirectional_iterator_tag,
+        _BinaryPredicate __comp)
+    {
+
+     
+
+     
+
+
+      typedef reverse_iterator<_BidirectionalIterator1> _RevIterator1;
+      typedef reverse_iterator<_BidirectionalIterator2> _RevIterator2;
+
+      _RevIterator1 __rlast1(__first1);
+      _RevIterator2 __rlast2(__first2);
+      _RevIterator1 __rresult = std::__search(_RevIterator1(__last1), __rlast1,
+           _RevIterator2(__last2), __rlast2,
+           __comp);
+
+      if (__rresult == __rlast1)
+ return __last1;
+      else
+ {
+   _BidirectionalIterator1 __result = __rresult.base();
+   std::advance(__result, -std::distance(__first2, __last2));
+   return __result;
+ }
+    }
+# 364 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _ForwardIterator1, typename _ForwardIterator2>
+   
+    inline _ForwardIterator1
+    find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+      _ForwardIterator2 __first2, _ForwardIterator2 __last2)
+    {
+
+     
+     
+     
+
+
+      ;
+      ;
+
+      return std::__find_end(__first1, __last1, __first2, __last2,
+        std::__iterator_category(__first1),
+        std::__iterator_category(__first2),
+        __gnu_cxx::__ops::__iter_equal_to_iter());
+    }
+# 413 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _ForwardIterator1, typename _ForwardIterator2,
+    typename _BinaryPredicate>
+   
+    inline _ForwardIterator1
+    find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+      _ForwardIterator2 __first2, _ForwardIterator2 __last2,
+      _BinaryPredicate __comp)
+    {
+
+     
+     
+     
+
+
+      ;
+      ;
+
+      return std::__find_end(__first1, __last1, __first2, __last2,
+        std::__iterator_category(__first1),
+        std::__iterator_category(__first2),
+        __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+# 449 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _Predicate>
+   
+    inline bool
+    all_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
+    { return __last == std::find_if_not(__first, __last, __pred); }
+# 467 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _Predicate>
+   
+    inline bool
+    none_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
+    { return __last == std::find_if(__first, __last, __pred); }
+# 486 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _Predicate>
+   
+    inline bool
+    any_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
+    { return !std::none_of(__first, __last, __pred); }
+# 502 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _Predicate>
+   
+    inline _InputIterator
+    find_if_not(_InputIterator __first, _InputIterator __last,
+  _Predicate __pred)
+    {
+
+     
+     
+
+      ;
+      return std::__find_if_not(__first, __last,
+    __gnu_cxx::__ops::__pred_iter(__pred));
+    }
+# 527 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _Predicate>
+   
+    inline bool
+    is_partitioned(_InputIterator __first, _InputIterator __last,
+     _Predicate __pred)
+    {
+      __first = std::find_if_not(__first, __last, __pred);
+      if (__first == __last)
+ return true;
+      ++__first;
+      return std::none_of(__first, __last, __pred);
+    }
+# 549 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Predicate>
+   
+    _ForwardIterator
+    partition_point(_ForwardIterator __first, _ForwardIterator __last,
+      _Predicate __pred)
+    {
+
+     
+     
+
+
+
+      ;
+
+      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 (__pred(*__middle))
+     {
+       __first = __middle;
+       ++__first;
+       __len = __len - __half - 1;
+     }
+   else
+     __len = __half;
+ }
+      return __first;
+    }
+
+
+  template<typename _InputIterator, typename _OutputIterator,
+    typename _Predicate>
+   
+    _OutputIterator
+    __remove_copy_if(_InputIterator __first, _InputIterator __last,
+       _OutputIterator __result, _Predicate __pred)
+    {
+      for (; __first != __last; ++__first)
+ if (!__pred(__first))
+   {
+     *__result = *__first;
+     ++__result;
+   }
+      return __result;
+    }
+# 616 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _OutputIterator, typename _Tp>
+   
+    inline _OutputIterator
+    remove_copy(_InputIterator __first, _InputIterator __last,
+  _OutputIterator __result, const _Tp& __value)
+    {
+
+     
+     
+
+     
+
+      ;
+
+      return std::__remove_copy_if(__first, __last, __result,
+ __gnu_cxx::__ops::__iter_equals_val(__value));
+    }
+# 649 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _OutputIterator,
+    typename _Predicate>
+   
+    inline _OutputIterator
+    remove_copy_if(_InputIterator __first, _InputIterator __last,
+     _OutputIterator __result, _Predicate __pred)
+    {
+
+     
+     
+
+     
+
+      ;
+
+      return std::__remove_copy_if(__first, __last, __result,
+       __gnu_cxx::__ops::__pred_iter(__pred));
+    }
+# 684 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _OutputIterator,
+    typename _Predicate>
+   
+    _OutputIterator
+    copy_if(_InputIterator __first, _InputIterator __last,
+     _OutputIterator __result, _Predicate __pred)
+    {
+
+     
+     
+
+     
+
+      ;
+
+      for (; __first != __last; ++__first)
+ if (__pred(*__first))
+   {
+     *__result = *__first;
+     ++__result;
+   }
+      return __result;
+    }
+
+  template<typename _InputIterator, typename _Size, typename _OutputIterator>
+   
+    _OutputIterator
+    __copy_n_a(_InputIterator __first, _Size __n, _OutputIterator __result)
+    {
+      if (__n > 0)
+ {
+   while (true)
+     {
+       *__result = *__first;
+       ++__result;
+       if (--__n > 0)
+  ++__first;
+       else
+  break;
+     }
+ }
+      return __result;
+    }
+
+  template<typename _CharT, typename _Size>
+    __enable_if_t<__is_char<_CharT>::__value, _CharT*>
+    __copy_n_a(istreambuf_iterator<_CharT, char_traits<_CharT>>,
+        _Size, _CharT*);
+
+  template<typename _InputIterator, typename _Size, typename _OutputIterator>
+   
+    _OutputIterator
+    __copy_n(_InputIterator __first, _Size __n,
+      _OutputIterator __result, input_iterator_tag)
+    {
+      return std::__niter_wrap(__result,
+          __copy_n_a(__first, __n,
+       std::__niter_base(__result)));
+    }
+
+  template<typename _RandomAccessIterator, typename _Size,
+    typename _OutputIterator>
+   
+    inline _OutputIterator
+    __copy_n(_RandomAccessIterator __first, _Size __n,
+      _OutputIterator __result, random_access_iterator_tag)
+    { return std::copy(__first, __first + __n, __result); }
+# 765 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _Size, typename _OutputIterator>
+   
+    inline _OutputIterator
+    copy_n(_InputIterator __first, _Size __n, _OutputIterator __result)
+    {
+
+     
+     
+
+      ;
+      ;
+
+      return std::__copy_n(__first, __n, __result,
+      std::__iterator_category(__first));
+    }
+# 796 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _OutputIterator1,
+    typename _OutputIterator2, typename _Predicate>
+   
+    pair<_OutputIterator1, _OutputIterator2>
+    partition_copy(_InputIterator __first, _InputIterator __last,
+     _OutputIterator1 __out_true, _OutputIterator2 __out_false,
+     _Predicate __pred)
+    {
+
+     
+     
+
+     
+
+     
+
+      ;
+
+      for (; __first != __last; ++__first)
+ if (__pred(*__first))
+   {
+     *__out_true = *__first;
+     ++__out_true;
+   }
+ else
+   {
+     *__out_false = *__first;
+     ++__out_false;
+   }
+
+      return pair<_OutputIterator1, _OutputIterator2>(__out_true, __out_false);
+    }
+
+
+  template<typename _ForwardIterator, typename _Predicate>
+   
+    _ForwardIterator
+    __remove_if(_ForwardIterator __first, _ForwardIterator __last,
+  _Predicate __pred)
+    {
+      __first = std::__find_if(__first, __last, __pred);
+      if (__first == __last)
+ return __first;
+      _ForwardIterator __result = __first;
+      ++__first;
+      for (; __first != __last; ++__first)
+ if (!__pred(__first))
+   {
+     *__result = std::move(*__first);
+     ++__result;
+   }
+      return __result;
+    }
+# 867 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Tp>
+   
+    inline _ForwardIterator
+    remove(_ForwardIterator __first, _ForwardIterator __last,
+    const _Tp& __value)
+    {
+
+     
+
+     
+
+      ;
+
+      return std::__remove_if(__first, __last,
+  __gnu_cxx::__ops::__iter_equals_val(__value));
+    }
+# 901 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Predicate>
+   
+    inline _ForwardIterator
+    remove_if(_ForwardIterator __first, _ForwardIterator __last,
+       _Predicate __pred)
+    {
+
+     
+
+     
+
+      ;
+
+      return std::__remove_if(__first, __last,
+         __gnu_cxx::__ops::__pred_iter(__pred));
+    }
+
+  template<typename _ForwardIterator, typename _BinaryPredicate>
+   
+    _ForwardIterator
+    __adjacent_find(_ForwardIterator __first, _ForwardIterator __last,
+      _BinaryPredicate __binary_pred)
+    {
+      if (__first == __last)
+ return __last;
+      _ForwardIterator __next = __first;
+      while (++__next != __last)
+ {
+   if (__binary_pred(__first, __next))
+     return __first;
+   __first = __next;
+ }
+      return __last;
+    }
+
+  template<typename _ForwardIterator, typename _BinaryPredicate>
+   
+    _ForwardIterator
+    __unique(_ForwardIterator __first, _ForwardIterator __last,
+      _BinaryPredicate __binary_pred)
+    {
+
+      __first = std::__adjacent_find(__first, __last, __binary_pred);
+      if (__first == __last)
+ return __last;
+
+
+      _ForwardIterator __dest = __first;
+      ++__first;
+      while (++__first != __last)
+ if (!__binary_pred(__dest, __first))
+   *++__dest = std::move(*__first);
+      return ++__dest;
+    }
+# 970 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _ForwardIterator>
+   
+    inline _ForwardIterator
+    unique(_ForwardIterator __first, _ForwardIterator __last)
+    {
+
+     
+
+     
+
+      ;
+
+      return std::__unique(__first, __last,
+      __gnu_cxx::__ops::__iter_equal_to_iter());
+    }
+# 1001 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _BinaryPredicate>
+   
+    inline _ForwardIterator
+    unique(_ForwardIterator __first, _ForwardIterator __last,
+    _BinaryPredicate __binary_pred)
+    {
+
+     
+
+     
+
+
+      ;
+
+      return std::__unique(__first, __last,
+      __gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
+    }
+
+
+
+
+
+
+
+  template<typename _ForwardIterator, typename _OutputIterator,
+    typename _BinaryPredicate>
+   
+    _OutputIterator
+    __unique_copy(_ForwardIterator __first, _ForwardIterator __last,
+    _OutputIterator __result, _BinaryPredicate __binary_pred,
+    forward_iterator_tag, output_iterator_tag)
+    {
+
+     
+
+
+
+      _ForwardIterator __next = __first;
+      *__result = *__first;
+      while (++__next != __last)
+ if (!__binary_pred(__first, __next))
+   {
+     __first = __next;
+     *++__result = *__first;
+   }
+      return ++__result;
+    }
+
+
+
+
+
+
+
+  template<typename _InputIterator, typename _OutputIterator,
+    typename _BinaryPredicate>
+   
+    _OutputIterator
+    __unique_copy(_InputIterator __first, _InputIterator __last,
+    _OutputIterator __result, _BinaryPredicate __binary_pred,
+    input_iterator_tag, output_iterator_tag)
+    {
+
+     
+
+
+
+      typename iterator_traits<_InputIterator>::value_type __value = *__first;
+      __decltype(__gnu_cxx::__ops::__iter_comp_val(__binary_pred))
+ __rebound_pred
+ = __gnu_cxx::__ops::__iter_comp_val(__binary_pred);
+      *__result = __value;
+      while (++__first != __last)
+ if (!__rebound_pred(__first, __value))
+   {
+     __value = *__first;
+     *++__result = __value;
+   }
+      return ++__result;
+    }
+
+
+
+
+
+
+
+  template<typename _InputIterator, typename _ForwardIterator,
+    typename _BinaryPredicate>
+   
+    _ForwardIterator
+    __unique_copy(_InputIterator __first, _InputIterator __last,
+    _ForwardIterator __result, _BinaryPredicate __binary_pred,
+    input_iterator_tag, forward_iterator_tag)
+    {
+
+     
+
+
+      *__result = *__first;
+      while (++__first != __last)
+ if (!__binary_pred(__result, __first))
+   *++__result = *__first;
+      return ++__result;
+    }
+
+
+
+
+
+
+  template<typename _BidirectionalIterator>
+   
+    void
+    __reverse(_BidirectionalIterator __first, _BidirectionalIterator __last,
+       bidirectional_iterator_tag)
+    {
+      while (true)
+ if (__first == __last || __first == --__last)
+   return;
+ else
+   {
+     std::iter_swap(__first, __last);
+     ++__first;
+   }
+    }
+
+
+
+
+
+
+  template<typename _RandomAccessIterator>
+   
+    void
+    __reverse(_RandomAccessIterator __first, _RandomAccessIterator __last,
+       random_access_iterator_tag)
+    {
+      if (__first == __last)
+ return;
+      --__last;
+      while (__first < __last)
+ {
+   std::iter_swap(__first, __last);
+   ++__first;
+   --__last;
+ }
+    }
+# 1162 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _BidirectionalIterator>
+   
+    inline void
+    reverse(_BidirectionalIterator __first, _BidirectionalIterator __last)
+    {
+
+     
+
+      ;
+      std::__reverse(__first, __last, std::__iterator_category(__first));
+    }
+# 1190 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _BidirectionalIterator, typename _OutputIterator>
+   
+    _OutputIterator
+    reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last,
+   _OutputIterator __result)
+    {
+
+     
+
+     
+
+      ;
+
+      while (__first != __last)
+ {
+   --__last;
+   *__result = *__last;
+   ++__result;
+ }
+      return __result;
+    }
+
+
+
+
+
+  template<typename _EuclideanRingElement>
+   
+    _EuclideanRingElement
+    __gcd(_EuclideanRingElement __m, _EuclideanRingElement __n)
+    {
+      while (__n != 0)
+ {
+   _EuclideanRingElement __t = __m % __n;
+   __m = __n;
+   __n = __t;
+ }
+      return __m;
+    }
+
+  inline namespace _V2
+  {
+
+
+  template<typename _ForwardIterator>
+   
+    _ForwardIterator
+    __rotate(_ForwardIterator __first,
+      _ForwardIterator __middle,
+      _ForwardIterator __last,
+      forward_iterator_tag)
+    {
+      if (__first == __middle)
+ return __last;
+      else if (__last == __middle)
+ return __first;
+
+      _ForwardIterator __first2 = __middle;
+      do
+ {
+   std::iter_swap(__first, __first2);
+   ++__first;
+   ++__first2;
+   if (__first == __middle)
+     __middle = __first2;
+ }
+      while (__first2 != __last);
+
+      _ForwardIterator __ret = __first;
+
+      __first2 = __middle;
+
+      while (__first2 != __last)
+ {
+   std::iter_swap(__first, __first2);
+   ++__first;
+   ++__first2;
+   if (__first == __middle)
+     __middle = __first2;
+   else if (__first2 == __last)
+     __first2 = __middle;
+ }
+      return __ret;
+    }
+
+
+  template<typename _BidirectionalIterator>
+   
+    _BidirectionalIterator
+    __rotate(_BidirectionalIterator __first,
+      _BidirectionalIterator __middle,
+      _BidirectionalIterator __last,
+       bidirectional_iterator_tag)
+    {
+
+     
+
+
+      if (__first == __middle)
+ return __last;
+      else if (__last == __middle)
+ return __first;
+
+      std::__reverse(__first, __middle, bidirectional_iterator_tag());
+      std::__reverse(__middle, __last, bidirectional_iterator_tag());
+
+      while (__first != __middle && __middle != __last)
+ {
+   std::iter_swap(__first, --__last);
+   ++__first;
+ }
+
+      if (__first == __middle)
+ {
+   std::__reverse(__middle, __last, bidirectional_iterator_tag());
+   return __last;
+ }
+      else
+ {
+   std::__reverse(__first, __middle, bidirectional_iterator_tag());
+   return __first;
+ }
+    }
+
+
+  template<typename _RandomAccessIterator>
+   
+    _RandomAccessIterator
+    __rotate(_RandomAccessIterator __first,
+      _RandomAccessIterator __middle,
+      _RandomAccessIterator __last,
+      random_access_iterator_tag)
+    {
+
+     
+
+
+      if (__first == __middle)
+ return __last;
+      else if (__last == __middle)
+ return __first;
+
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+ _Distance;
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+ _ValueType;
+
+      _Distance __n = __last - __first;
+      _Distance __k = __middle - __first;
+
+      if (__k == __n - __k)
+ {
+   std::swap_ranges(__first, __middle, __middle);
+   return __middle;
+ }
+
+      _RandomAccessIterator __p = __first;
+      _RandomAccessIterator __ret = __first + (__last - __middle);
+
+      for (;;)
+ {
+   if (__k < __n - __k)
+     {
+       if (__is_pod(_ValueType) && __k == 1)
+  {
+    _ValueType __t = std::move(*__p);
+    std::move(__p + 1, __p + __n, __p);
+    *(__p + __n - 1) = std::move(__t);
+    return __ret;
+  }
+       _RandomAccessIterator __q = __p + __k;
+       for (_Distance __i = 0; __i < __n - __k; ++ __i)
+  {
+    std::iter_swap(__p, __q);
+    ++__p;
+    ++__q;
+  }
+       __n %= __k;
+       if (__n == 0)
+  return __ret;
+       std::swap(__n, __k);
+       __k = __n - __k;
+     }
+   else
+     {
+       __k = __n - __k;
+       if (__is_pod(_ValueType) && __k == 1)
+  {
+    _ValueType __t = std::move(*(__p + __n - 1));
+    std::move_backward(__p, __p + __n - 1, __p + __n);
+    *__p = std::move(__t);
+    return __ret;
+  }
+       _RandomAccessIterator __q = __p + __n;
+       __p = __q - __k;
+       for (_Distance __i = 0; __i < __n - __k; ++ __i)
+  {
+    --__p;
+    --__q;
+    std::iter_swap(__p, __q);
+  }
+       __n %= __k;
+       if (__n == 0)
+  return __ret;
+       std::swap(__n, __k);
+     }
+ }
+    }
+# 1422 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _ForwardIterator>
+   
+    inline _ForwardIterator
+    rotate(_ForwardIterator __first, _ForwardIterator __middle,
+    _ForwardIterator __last)
+    {
+
+     
+
+      ;
+      ;
+
+      return std::__rotate(__first, __middle, __last,
+      std::__iterator_category(__first));
+    }
+
+  }
+# 1460 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _OutputIterator>
+   
+    inline _OutputIterator
+    rotate_copy(_ForwardIterator __first, _ForwardIterator __middle,
+  _ForwardIterator __last, _OutputIterator __result)
+    {
+
+     
+     
+
+      ;
+      ;
+
+      return std::copy(__first, __middle,
+         std::copy(__middle, __last, __result));
+    }
+
+
+  template<typename _ForwardIterator, typename _Predicate>
+   
+    _ForwardIterator
+    __partition(_ForwardIterator __first, _ForwardIterator __last,
+  _Predicate __pred, forward_iterator_tag)
+    {
+      if (__first == __last)
+ return __first;
+
+      while (__pred(*__first))
+ if (++__first == __last)
+   return __first;
+
+      _ForwardIterator __next = __first;
+
+      while (++__next != __last)
+ if (__pred(*__next))
+   {
+     std::iter_swap(__first, __next);
+     ++__first;
+   }
+
+      return __first;
+    }
+
+
+  template<typename _BidirectionalIterator, typename _Predicate>
+   
+    _BidirectionalIterator
+    __partition(_BidirectionalIterator __first, _BidirectionalIterator __last,
+  _Predicate __pred, bidirectional_iterator_tag)
+    {
+      while (true)
+ {
+   while (true)
+     if (__first == __last)
+       return __first;
+     else if (__pred(*__first))
+       ++__first;
+     else
+       break;
+   --__last;
+   while (true)
+     if (__first == __last)
+       return __first;
+     else if (!bool(__pred(*__last)))
+       --__last;
+     else
+       break;
+   std::iter_swap(__first, __last);
+   ++__first;
+ }
+    }
+# 1540 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Pointer, typename _Predicate,
+    typename _Distance>
+    _ForwardIterator
+    __stable_partition_adaptive(_ForwardIterator __first,
+    _ForwardIterator __last,
+    _Predicate __pred, _Distance __len,
+    _Pointer __buffer,
+    _Distance __buffer_size)
+    {
+      if (__len == 1)
+ return __first;
+
+      if (__len <= __buffer_size)
+ {
+   _ForwardIterator __result1 = __first;
+   _Pointer __result2 = __buffer;
+
+
+
+
+   *__result2 = std::move(*__first);
+   ++__result2;
+   ++__first;
+   for (; __first != __last; ++__first)
+     if (__pred(__first))
+       {
+  *__result1 = std::move(*__first);
+  ++__result1;
+       }
+     else
+       {
+  *__result2 = std::move(*__first);
+  ++__result2;
+       }
+
+   std::move(__buffer, __result2, __result1);
+   return __result1;
+ }
+
+      _ForwardIterator __middle = __first;
+      std::advance(__middle, __len / 2);
+      _ForwardIterator __left_split =
+ std::__stable_partition_adaptive(__first, __middle, __pred,
+      __len / 2, __buffer,
+      __buffer_size);
+
+
+
+      _Distance __right_len = __len - __len / 2;
+      _ForwardIterator __right_split =
+ std::__find_if_not_n(__middle, __right_len, __pred);
+
+      if (__right_len)
+ __right_split =
+   std::__stable_partition_adaptive(__right_split, __last, __pred,
+        __right_len,
+        __buffer, __buffer_size);
+
+      return std::rotate(__left_split, __middle, __right_split);
+    }
+
+  template<typename _ForwardIterator, typename _Predicate>
+    _ForwardIterator
+    __stable_partition(_ForwardIterator __first, _ForwardIterator __last,
+         _Predicate __pred)
+    {
+      __first = std::__find_if_not(__first, __last, __pred);
+
+      if (__first == __last)
+ return __first;
+
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+ _ValueType;
+      typedef typename iterator_traits<_ForwardIterator>::difference_type
+ _DistanceType;
+
+      _Temporary_buffer<_ForwardIterator, _ValueType>
+ __buf(__first, std::distance(__first, __last));
+      return
+ std::__stable_partition_adaptive(__first, __last, __pred,
+      _DistanceType(__buf.requested_size()),
+      __buf.begin(),
+      _DistanceType(__buf.size()));
+    }
+# 1642 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Predicate>
+    inline _ForwardIterator
+    stable_partition(_ForwardIterator __first, _ForwardIterator __last,
+       _Predicate __pred)
+    {
+
+     
+
+     
+
+      ;
+
+      return std::__stable_partition(__first, __last,
+         __gnu_cxx::__ops::__pred_iter(__pred));
+    }
+
+
+  template<typename _RandomAccessIterator, typename _Compare>
+   
+    void
+    __heap_select(_RandomAccessIterator __first,
+    _RandomAccessIterator __middle,
+    _RandomAccessIterator __last, _Compare __comp)
+    {
+      std::__make_heap(__first, __middle, __comp);
+      for (_RandomAccessIterator __i = __middle; __i < __last; ++__i)
+ if (__comp(__i, __first))
+   std::__pop_heap(__first, __middle, __i, __comp);
+    }
+
+
+
+  template<typename _InputIterator, typename _RandomAccessIterator,
+    typename _Compare>
+   
+    _RandomAccessIterator
+    __partial_sort_copy(_InputIterator __first, _InputIterator __last,
+   _RandomAccessIterator __result_first,
+   _RandomAccessIterator __result_last,
+   _Compare __comp)
+    {
+      typedef typename iterator_traits<_InputIterator>::value_type
+ _InputValueType;
+      typedef iterator_traits<_RandomAccessIterator> _RItTraits;
+      typedef typename _RItTraits::difference_type _DistanceType;
+
+      if (__result_first == __result_last)
+ return __result_last;
+      _RandomAccessIterator __result_real_last = __result_first;
+      while (__first != __last && __result_real_last != __result_last)
+ {
+   *__result_real_last = *__first;
+   ++__result_real_last;
+   ++__first;
+ }
+
+      std::__make_heap(__result_first, __result_real_last, __comp);
+      while (__first != __last)
+ {
+   if (__comp(__first, __result_first))
+     std::__adjust_heap(__result_first, _DistanceType(0),
+          _DistanceType(__result_real_last
+          - __result_first),
+          _InputValueType(*__first), __comp);
+   ++__first;
+ }
+      std::__sort_heap(__result_first, __result_real_last, __comp);
+      return __result_real_last;
+    }
+# 1730 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _RandomAccessIterator>
+   
+    inline _RandomAccessIterator
+    partial_sort_copy(_InputIterator __first, _InputIterator __last,
+        _RandomAccessIterator __result_first,
+        _RandomAccessIterator __result_last)
+    {
+# 1745 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+     
+     
+
+     
+
+     
+      ;
+      ;
+      ;
+
+      return std::__partial_sort_copy(__first, __last,
+          __result_first, __result_last,
+          __gnu_cxx::__ops::__iter_less_iter());
+    }
+# 1780 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _RandomAccessIterator,
+    typename _Compare>
+   
+    inline _RandomAccessIterator
+    partial_sort_copy(_InputIterator __first, _InputIterator __last,
+        _RandomAccessIterator __result_first,
+        _RandomAccessIterator __result_last,
+        _Compare __comp)
+    {
+# 1797 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+     
+     
+
+     
+
+     
+
+     
+
+      ;
+      ;
+      ;
+
+      return std::__partial_sort_copy(__first, __last,
+          __result_first, __result_last,
+    __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+
+  template<typename _RandomAccessIterator, typename _Compare>
+   
+    void
+    __unguarded_linear_insert(_RandomAccessIterator __last,
+         _Compare __comp)
+    {
+      typename iterator_traits<_RandomAccessIterator>::value_type
+ __val = std::move(*__last);
+      _RandomAccessIterator __next = __last;
+      --__next;
+      while (__comp(__val, __next))
+ {
+   *__last = std::move(*__next);
+   __last = __next;
+   --__next;
+ }
+      *__last = std::move(__val);
+    }
+
+
+  template<typename _RandomAccessIterator, typename _Compare>
+   
+    void
+    __insertion_sort(_RandomAccessIterator __first,
+       _RandomAccessIterator __last, _Compare __comp)
+    {
+      if (__first == __last) return;
+
+      for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
+ {
+   if (__comp(__i, __first))
+     {
+       typename iterator_traits<_RandomAccessIterator>::value_type
+  __val = std::move(*__i);
+       std::move_backward(__first, __i, __i + 1);
+       *__first = std::move(__val);
+     }
+   else
+     std::__unguarded_linear_insert(__i,
+    __gnu_cxx::__ops::__val_comp_iter(__comp));
+ }
+    }
+
+
+  template<typename _RandomAccessIterator, typename _Compare>
+   
+    inline void
+    __unguarded_insertion_sort(_RandomAccessIterator __first,
+          _RandomAccessIterator __last, _Compare __comp)
+    {
+      for (_RandomAccessIterator __i = __first; __i != __last; ++__i)
+ std::__unguarded_linear_insert(__i,
+    __gnu_cxx::__ops::__val_comp_iter(__comp));
+    }
+
+
+
+
+
+  enum { _S_threshold = 16 };
+
+
+  template<typename _RandomAccessIterator, typename _Compare>
+   
+    void
+    __final_insertion_sort(_RandomAccessIterator __first,
+      _RandomAccessIterator __last, _Compare __comp)
+    {
+      if (__last - __first > int(_S_threshold))
+ {
+   std::__insertion_sort(__first, __first + int(_S_threshold), __comp);
+   std::__unguarded_insertion_sort(__first + int(_S_threshold), __last,
+       __comp);
+ }
+      else
+ std::__insertion_sort(__first, __last, __comp);
+    }
+
+
+  template<typename _RandomAccessIterator, typename _Compare>
+   
+    _RandomAccessIterator
+    __unguarded_partition(_RandomAccessIterator __first,
+     _RandomAccessIterator __last,
+     _RandomAccessIterator __pivot, _Compare __comp)
+    {
+      while (true)
+ {
+   while (__comp(__first, __pivot))
+     ++__first;
+   --__last;
+   while (__comp(__pivot, __last))
+     --__last;
+   if (!(__first < __last))
+     return __first;
+   std::iter_swap(__first, __last);
+   ++__first;
+ }
+    }
+
+
+  template<typename _RandomAccessIterator, typename _Compare>
+   
+    inline _RandomAccessIterator
+    __unguarded_partition_pivot(_RandomAccessIterator __first,
+    _RandomAccessIterator __last, _Compare __comp)
+    {
+      _RandomAccessIterator __mid = __first + (__last - __first) / 2;
+      std::__move_median_to_first(__first, __first + 1, __mid, __last - 1,
+      __comp);
+      return std::__unguarded_partition(__first + 1, __last, __first, __comp);
+    }
+
+  template<typename _RandomAccessIterator, typename _Compare>
+   
+    inline void
+    __partial_sort(_RandomAccessIterator __first,
+     _RandomAccessIterator __middle,
+     _RandomAccessIterator __last,
+     _Compare __comp)
+    {
+      std::__heap_select(__first, __middle, __last, __comp);
+      std::__sort_heap(__first, __middle, __comp);
+    }
+
+
+  template<typename _RandomAccessIterator, typename _Size, typename _Compare>
+   
+    void
+    __introsort_loop(_RandomAccessIterator __first,
+       _RandomAccessIterator __last,
+       _Size __depth_limit, _Compare __comp)
+    {
+      while (__last - __first > int(_S_threshold))
+ {
+   if (__depth_limit == 0)
+     {
+       std::__partial_sort(__first, __last, __last, __comp);
+       return;
+     }
+   --__depth_limit;
+   _RandomAccessIterator __cut =
+     std::__unguarded_partition_pivot(__first, __last, __comp);
+   std::__introsort_loop(__cut, __last, __depth_limit, __comp);
+   __last = __cut;
+ }
+    }
+
+
+
+  template<typename _RandomAccessIterator, typename _Compare>
+   
+    inline void
+    __sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
+    _Compare __comp)
+    {
+      if (__first != __last)
+ {
+   std::__introsort_loop(__first, __last,
+    std::__lg(__last - __first) * 2,
+    __comp);
+   std::__final_insertion_sort(__first, __last, __comp);
+ }
+    }
+
+  template<typename _RandomAccessIterator, typename _Size, typename _Compare>
+   
+    void
+    __introselect(_RandomAccessIterator __first, _RandomAccessIterator __nth,
+    _RandomAccessIterator __last, _Size __depth_limit,
+    _Compare __comp)
+    {
+      while (__last - __first > 3)
+ {
+   if (__depth_limit == 0)
+     {
+       std::__heap_select(__first, __nth + 1, __last, __comp);
+
+       std::iter_swap(__first, __nth);
+       return;
+     }
+   --__depth_limit;
+   _RandomAccessIterator __cut =
+     std::__unguarded_partition_pivot(__first, __last, __comp);
+   if (__cut <= __nth)
+     __first = __cut;
+   else
+     __last = __cut;
+ }
+      std::__insertion_sort(__first, __last, __comp);
+    }
+# 2028 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Tp, typename _Compare>
+   
+    inline _ForwardIterator
+    lower_bound(_ForwardIterator __first, _ForwardIterator __last,
+  const _Tp& __val, _Compare __comp)
+    {
+
+     
+     
+
+     
+                    ;
+
+      return std::__lower_bound(__first, __last, __val,
+    __gnu_cxx::__ops::__iter_comp_val(__comp));
+    }
+
+  template<typename _ForwardIterator, typename _Tp, typename _Compare>
+   
+    _ForwardIterator
+    __upper_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(__val, __middle))
+     __len = __half;
+   else
+     {
+       __first = __middle;
+       ++__first;
+       __len = __len - __half - 1;
+     }
+ }
+      return __first;
+    }
+# 2084 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Tp>
+   
+    inline _ForwardIterator
+    upper_bound(_ForwardIterator __first, _ForwardIterator __last,
+  const _Tp& __val)
+    {
+
+     
+     
+
+      ;
+
+      return std::__upper_bound(__first, __last, __val,
+    __gnu_cxx::__ops::__val_less_iter());
+    }
+# 2115 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Tp, typename _Compare>
+   
+    inline _ForwardIterator
+    upper_bound(_ForwardIterator __first, _ForwardIterator __last,
+  const _Tp& __val, _Compare __comp)
+    {
+
+     
+     
+
+     
+                    ;
+
+      return std::__upper_bound(__first, __last, __val,
+    __gnu_cxx::__ops::__val_comp_iter(__comp));
+    }
+
+  template<typename _ForwardIterator, typename _Tp,
+    typename _CompareItTp, typename _CompareTpIt>
+   
+    pair<_ForwardIterator, _ForwardIterator>
+    __equal_range(_ForwardIterator __first, _ForwardIterator __last,
+    const _Tp& __val,
+    _CompareItTp __comp_it_val, _CompareTpIt __comp_val_it)
+    {
+      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_it_val(__middle, __val))
+     {
+       __first = __middle;
+       ++__first;
+       __len = __len - __half - 1;
+     }
+   else if (__comp_val_it(__val, __middle))
+     __len = __half;
+   else
+     {
+       _ForwardIterator __left
+  = std::__lower_bound(__first, __middle, __val, __comp_it_val);
+       std::advance(__first, __len);
+       _ForwardIterator __right
+  = std::__upper_bound(++__middle, __first, __val, __comp_val_it);
+       return pair<_ForwardIterator, _ForwardIterator>(__left, __right);
+     }
+ }
+      return pair<_ForwardIterator, _ForwardIterator>(__first, __first);
+    }
+# 2188 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Tp>
+   
+    inline pair<_ForwardIterator, _ForwardIterator>
+    equal_range(_ForwardIterator __first, _ForwardIterator __last,
+  const _Tp& __val)
+    {
+
+     
+     
+
+     
+
+      ;
+      ;
+
+      return std::__equal_range(__first, __last, __val,
+    __gnu_cxx::__ops::__iter_less_val(),
+    __gnu_cxx::__ops::__val_less_iter());
+    }
+# 2225 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Tp, typename _Compare>
+   
+    inline pair<_ForwardIterator, _ForwardIterator>
+    equal_range(_ForwardIterator __first, _ForwardIterator __last,
+  const _Tp& __val, _Compare __comp)
+    {
+
+     
+     
+
+     
+
+     
+                    ;
+     
+                    ;
+
+      return std::__equal_range(__first, __last, __val,
+    __gnu_cxx::__ops::__iter_comp_val(__comp),
+    __gnu_cxx::__ops::__val_comp_iter(__comp));
+    }
+# 2259 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Tp>
+   
+    bool
+    binary_search(_ForwardIterator __first, _ForwardIterator __last,
+    const _Tp& __val)
+    {
+
+     
+     
+
+      ;
+      ;
+
+      _ForwardIterator __i
+ = std::__lower_bound(__first, __last, __val,
+        __gnu_cxx::__ops::__iter_less_val());
+      return __i != __last && !(__val < *__i);
+    }
+# 2293 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Tp, typename _Compare>
+   
+    bool
+    binary_search(_ForwardIterator __first, _ForwardIterator __last,
+    const _Tp& __val, _Compare __comp)
+    {
+
+     
+     
+
+     
+                    ;
+     
+                    ;
+
+      _ForwardIterator __i
+ = std::__lower_bound(__first, __last, __val,
+        __gnu_cxx::__ops::__iter_comp_val(__comp));
+      return __i != __last && !bool(__comp(__val, *__i));
+    }
+
+
+
+
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator, typename _Compare>
+    void
+    __move_merge_adaptive(_InputIterator1 __first1, _InputIterator1 __last1,
+     _InputIterator2 __first2, _InputIterator2 __last2,
+     _OutputIterator __result, _Compare __comp)
+    {
+      while (__first1 != __last1 && __first2 != __last2)
+ {
+   if (__comp(__first2, __first1))
+     {
+       *__result = std::move(*__first2);
+       ++__first2;
+     }
+   else
+     {
+       *__result = std::move(*__first1);
+       ++__first1;
+     }
+   ++__result;
+ }
+      if (__first1 != __last1)
+ std::move(__first1, __last1, __result);
+    }
+
+
+  template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
+    typename _BidirectionalIterator3, typename _Compare>
+    void
+    __move_merge_adaptive_backward(_BidirectionalIterator1 __first1,
+       _BidirectionalIterator1 __last1,
+       _BidirectionalIterator2 __first2,
+       _BidirectionalIterator2 __last2,
+       _BidirectionalIterator3 __result,
+       _Compare __comp)
+    {
+      if (__first1 == __last1)
+ {
+   std::move_backward(__first2, __last2, __result);
+   return;
+ }
+      else if (__first2 == __last2)
+ return;
+
+      --__last1;
+      --__last2;
+      while (true)
+ {
+   if (__comp(__last2, __last1))
+     {
+       *--__result = std::move(*__last1);
+       if (__first1 == __last1)
+  {
+    std::move_backward(__first2, ++__last2, __result);
+    return;
+  }
+       --__last1;
+     }
+   else
+     {
+       *--__result = std::move(*__last2);
+       if (__first2 == __last2)
+  return;
+       --__last2;
+     }
+ }
+    }
+
+
+  template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
+    typename _Distance>
+    _BidirectionalIterator1
+    __rotate_adaptive(_BidirectionalIterator1 __first,
+        _BidirectionalIterator1 __middle,
+        _BidirectionalIterator1 __last,
+        _Distance __len1, _Distance __len2,
+        _BidirectionalIterator2 __buffer,
+        _Distance __buffer_size)
+    {
+      _BidirectionalIterator2 __buffer_end;
+      if (__len1 > __len2 && __len2 <= __buffer_size)
+ {
+   if (__len2)
+     {
+       __buffer_end = std::move(__middle, __last, __buffer);
+       std::move_backward(__first, __middle, __last);
+       return std::move(__buffer, __buffer_end, __first);
+     }
+   else
+     return __first;
+ }
+      else if (__len1 <= __buffer_size)
+ {
+   if (__len1)
+     {
+       __buffer_end = std::move(__first, __middle, __buffer);
+       std::move(__middle, __last, __first);
+       return std::move_backward(__buffer, __buffer_end, __last);
+     }
+   else
+     return __last;
+ }
+      else
+ return std::rotate(__first, __middle, __last);
+    }
+
+
+  template<typename _BidirectionalIterator, typename _Distance,
+    typename _Pointer, typename _Compare>
+    void
+    __merge_adaptive(_BidirectionalIterator __first,
+       _BidirectionalIterator __middle,
+       _BidirectionalIterator __last,
+       _Distance __len1, _Distance __len2,
+       _Pointer __buffer, _Distance __buffer_size,
+       _Compare __comp)
+    {
+      if (__len1 <= __len2 && __len1 <= __buffer_size)
+ {
+   _Pointer __buffer_end = std::move(__first, __middle, __buffer);
+   std::__move_merge_adaptive(__buffer, __buffer_end, __middle, __last,
+         __first, __comp);
+ }
+      else if (__len2 <= __buffer_size)
+ {
+   _Pointer __buffer_end = std::move(__middle, __last, __buffer);
+   std::__move_merge_adaptive_backward(__first, __middle, __buffer,
+           __buffer_end, __last, __comp);
+ }
+      else
+ {
+   _BidirectionalIterator __first_cut = __first;
+   _BidirectionalIterator __second_cut = __middle;
+   _Distance __len11 = 0;
+   _Distance __len22 = 0;
+   if (__len1 > __len2)
+     {
+       __len11 = __len1 / 2;
+       std::advance(__first_cut, __len11);
+       __second_cut
+  = std::__lower_bound(__middle, __last, *__first_cut,
+         __gnu_cxx::__ops::__iter_comp_val(__comp));
+       __len22 = std::distance(__middle, __second_cut);
+     }
+   else
+     {
+       __len22 = __len2 / 2;
+       std::advance(__second_cut, __len22);
+       __first_cut
+  = std::__upper_bound(__first, __middle, *__second_cut,
+         __gnu_cxx::__ops::__val_comp_iter(__comp));
+       __len11 = std::distance(__first, __first_cut);
+     }
+
+   _BidirectionalIterator __new_middle
+     = std::__rotate_adaptive(__first_cut, __middle, __second_cut,
+         __len1 - __len11, __len22, __buffer,
+         __buffer_size);
+   std::__merge_adaptive(__first, __first_cut, __new_middle, __len11,
+    __len22, __buffer, __buffer_size, __comp);
+   std::__merge_adaptive(__new_middle, __second_cut, __last,
+    __len1 - __len11,
+    __len2 - __len22, __buffer,
+    __buffer_size, __comp);
+ }
+    }
+
+
+  template<typename _BidirectionalIterator, typename _Distance,
+    typename _Compare>
+    void
+    __merge_without_buffer(_BidirectionalIterator __first,
+      _BidirectionalIterator __middle,
+      _BidirectionalIterator __last,
+      _Distance __len1, _Distance __len2,
+      _Compare __comp)
+    {
+      if (__len1 == 0 || __len2 == 0)
+ return;
+
+      if (__len1 + __len2 == 2)
+ {
+   if (__comp(__middle, __first))
+     std::iter_swap(__first, __middle);
+   return;
+ }
+
+      _BidirectionalIterator __first_cut = __first;
+      _BidirectionalIterator __second_cut = __middle;
+      _Distance __len11 = 0;
+      _Distance __len22 = 0;
+      if (__len1 > __len2)
+ {
+   __len11 = __len1 / 2;
+   std::advance(__first_cut, __len11);
+   __second_cut
+     = std::__lower_bound(__middle, __last, *__first_cut,
+     __gnu_cxx::__ops::__iter_comp_val(__comp));
+   __len22 = std::distance(__middle, __second_cut);
+ }
+      else
+ {
+   __len22 = __len2 / 2;
+   std::advance(__second_cut, __len22);
+   __first_cut
+     = std::__upper_bound(__first, __middle, *__second_cut,
+     __gnu_cxx::__ops::__val_comp_iter(__comp));
+   __len11 = std::distance(__first, __first_cut);
+ }
+
+      _BidirectionalIterator __new_middle
+ = std::rotate(__first_cut, __middle, __second_cut);
+      std::__merge_without_buffer(__first, __first_cut, __new_middle,
+      __len11, __len22, __comp);
+      std::__merge_without_buffer(__new_middle, __second_cut, __last,
+      __len1 - __len11, __len2 - __len22, __comp);
+    }
+
+  template<typename _BidirectionalIterator, typename _Compare>
+    void
+    __inplace_merge(_BidirectionalIterator __first,
+      _BidirectionalIterator __middle,
+      _BidirectionalIterator __last,
+      _Compare __comp)
+    {
+      typedef typename iterator_traits<_BidirectionalIterator>::value_type
+   _ValueType;
+      typedef typename iterator_traits<_BidirectionalIterator>::difference_type
+   _DistanceType;
+
+      if (__first == __middle || __middle == __last)
+ return;
+
+      const _DistanceType __len1 = std::distance(__first, __middle);
+      const _DistanceType __len2 = std::distance(__middle, __last);
+
+      typedef _Temporary_buffer<_BidirectionalIterator, _ValueType> _TmpBuf;
+      _TmpBuf __buf(__first, __len1 + __len2);
+
+      if (__buf.begin() == 0)
+ std::__merge_without_buffer
+   (__first, __middle, __last, __len1, __len2, __comp);
+      else
+ std::__merge_adaptive
+   (__first, __middle, __last, __len1, __len2, __buf.begin(),
+    _DistanceType(__buf.size()), __comp);
+    }
+# 2583 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _BidirectionalIterator>
+    inline void
+    inplace_merge(_BidirectionalIterator __first,
+    _BidirectionalIterator __middle,
+    _BidirectionalIterator __last)
+    {
+
+     
+
+     
+
+      ;
+      ;
+      ;
+
+      std::__inplace_merge(__first, __middle, __last,
+      __gnu_cxx::__ops::__iter_less_iter());
+    }
+# 2624 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _BidirectionalIterator, typename _Compare>
+    inline void
+    inplace_merge(_BidirectionalIterator __first,
+    _BidirectionalIterator __middle,
+    _BidirectionalIterator __last,
+    _Compare __comp)
+    {
+
+     
+
+     
+
+
+      ;
+      ;
+      ;
+
+      std::__inplace_merge(__first, __middle, __last,
+      __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+
+
+  template<typename _InputIterator, typename _OutputIterator,
+    typename _Compare>
+    _OutputIterator
+    __move_merge(_InputIterator __first1, _InputIterator __last1,
+   _InputIterator __first2, _InputIterator __last2,
+   _OutputIterator __result, _Compare __comp)
+    {
+      while (__first1 != __last1 && __first2 != __last2)
+ {
+   if (__comp(__first2, __first1))
+     {
+       *__result = std::move(*__first2);
+       ++__first2;
+     }
+   else
+     {
+       *__result = std::move(*__first1);
+       ++__first1;
+     }
+   ++__result;
+ }
+      return std::move(__first2, __last2, std::move(__first1, __last1, __result))
+
+                  ;
+    }
+
+  template<typename _RandomAccessIterator1, typename _RandomAccessIterator2,
+    typename _Distance, typename _Compare>
+    void
+    __merge_sort_loop(_RandomAccessIterator1 __first,
+        _RandomAccessIterator1 __last,
+        _RandomAccessIterator2 __result, _Distance __step_size,
+        _Compare __comp)
+    {
+      const _Distance __two_step = 2 * __step_size;
+
+      while (__last - __first >= __two_step)
+ {
+   __result = std::__move_merge(__first, __first + __step_size,
+           __first + __step_size,
+           __first + __two_step,
+           __result, __comp);
+   __first += __two_step;
+ }
+      __step_size = std::min(_Distance(__last - __first), __step_size);
+
+      std::__move_merge(__first, __first + __step_size,
+   __first + __step_size, __last, __result, __comp);
+    }
+
+  template<typename _RandomAccessIterator, typename _Distance,
+    typename _Compare>
+   
+    void
+    __chunk_insertion_sort(_RandomAccessIterator __first,
+      _RandomAccessIterator __last,
+      _Distance __chunk_size, _Compare __comp)
+    {
+      while (__last - __first >= __chunk_size)
+ {
+   std::__insertion_sort(__first, __first + __chunk_size, __comp);
+   __first += __chunk_size;
+ }
+      std::__insertion_sort(__first, __last, __comp);
+    }
+
+  enum { _S_chunk_size = 7 };
+
+  template<typename _RandomAccessIterator, typename _Pointer, typename _Compare>
+    void
+    __merge_sort_with_buffer(_RandomAccessIterator __first,
+        _RandomAccessIterator __last,
+        _Pointer __buffer, _Compare __comp)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+ _Distance;
+
+      const _Distance __len = __last - __first;
+      const _Pointer __buffer_last = __buffer + __len;
+
+      _Distance __step_size = _S_chunk_size;
+      std::__chunk_insertion_sort(__first, __last, __step_size, __comp);
+
+      while (__step_size < __len)
+ {
+   std::__merge_sort_loop(__first, __last, __buffer,
+     __step_size, __comp);
+   __step_size *= 2;
+   std::__merge_sort_loop(__buffer, __buffer_last, __first,
+     __step_size, __comp);
+   __step_size *= 2;
+ }
+    }
+
+  template<typename _RandomAccessIterator, typename _Pointer,
+    typename _Distance, typename _Compare>
+    void
+    __stable_sort_adaptive(_RandomAccessIterator __first,
+      _RandomAccessIterator __last,
+      _Pointer __buffer, _Distance __buffer_size,
+      _Compare __comp)
+    {
+      const _Distance __len = (__last - __first + 1) / 2;
+      const _RandomAccessIterator __middle = __first + __len;
+      if (__len > __buffer_size)
+ {
+   std::__stable_sort_adaptive(__first, __middle, __buffer,
+          __buffer_size, __comp);
+   std::__stable_sort_adaptive(__middle, __last, __buffer,
+          __buffer_size, __comp);
+ }
+      else
+ {
+   std::__merge_sort_with_buffer(__first, __middle, __buffer, __comp);
+   std::__merge_sort_with_buffer(__middle, __last, __buffer, __comp);
+ }
+      std::__merge_adaptive(__first, __middle, __last,
+       _Distance(__middle - __first),
+       _Distance(__last - __middle),
+       __buffer, __buffer_size,
+       __comp);
+    }
+
+
+  template<typename _RandomAccessIterator, typename _Compare>
+    void
+    __inplace_stable_sort(_RandomAccessIterator __first,
+     _RandomAccessIterator __last, _Compare __comp)
+    {
+      if (__last - __first < 15)
+ {
+   std::__insertion_sort(__first, __last, __comp);
+   return;
+ }
+      _RandomAccessIterator __middle = __first + (__last - __first) / 2;
+      std::__inplace_stable_sort(__first, __middle, __comp);
+      std::__inplace_stable_sort(__middle, __last, __comp);
+      std::__merge_without_buffer(__first, __middle, __last,
+      __middle - __first,
+      __last - __middle,
+      __comp);
+    }
+# 2797 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _Compare>
+   
+    bool
+    __includes(_InputIterator1 __first1, _InputIterator1 __last1,
+        _InputIterator2 __first2, _InputIterator2 __last2,
+        _Compare __comp)
+    {
+      while (__first1 != __last1 && __first2 != __last2)
+ if (__comp(__first2, __first1))
+   return false;
+ else if (__comp(__first1, __first2))
+   ++__first1;
+ else
+   {
+     ++__first1;
+     ++__first2;
+   }
+
+      return __first2 == __last2;
+    }
+# 2837 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _InputIterator1, typename _InputIterator2>
+   
+    inline bool
+    includes(_InputIterator1 __first1, _InputIterator1 __last1,
+      _InputIterator2 __first2, _InputIterator2 __last2)
+    {
+
+     
+     
+     
+
+
+     
+
+
+      ;
+      ;
+      ;
+      ;
+
+      return std::__includes(__first1, __last1, __first2, __last2,
+        __gnu_cxx::__ops::__iter_less_iter());
+    }
+# 2882 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _Compare>
+   
+    inline bool
+    includes(_InputIterator1 __first1, _InputIterator1 __last1,
+      _InputIterator2 __first2, _InputIterator2 __last2,
+      _Compare __comp)
+    {
+
+     
+     
+     
+
+
+     
+
+
+      ;
+      ;
+      ;
+      ;
+
+      return std::__includes(__first1, __last1, __first2, __last2,
+        __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+# 2918 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _BidirectionalIterator, typename _Compare>
+   
+    bool
+    __next_permutation(_BidirectionalIterator __first,
+         _BidirectionalIterator __last, _Compare __comp)
+    {
+      if (__first == __last)
+ return false;
+      _BidirectionalIterator __i = __first;
+      ++__i;
+      if (__i == __last)
+ return false;
+      __i = __last;
+      --__i;
+
+      for(;;)
+ {
+   _BidirectionalIterator __ii = __i;
+   --__i;
+   if (__comp(__i, __ii))
+     {
+       _BidirectionalIterator __j = __last;
+       while (!__comp(__i, --__j))
+  {}
+       std::iter_swap(__i, __j);
+       std::__reverse(__ii, __last,
+        std::__iterator_category(__first));
+       return true;
+     }
+   if (__i == __first)
+     {
+       std::__reverse(__first, __last,
+        std::__iterator_category(__first));
+       return false;
+     }
+ }
+    }
+# 2968 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _BidirectionalIterator>
+   
+    inline bool
+    next_permutation(_BidirectionalIterator __first,
+       _BidirectionalIterator __last)
+    {
+
+     
+
+     
+
+      ;
+      ;
+
+      return std::__next_permutation
+ (__first, __last, __gnu_cxx::__ops::__iter_less_iter());
+    }
+# 3001 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _BidirectionalIterator, typename _Compare>
+   
+    inline bool
+    next_permutation(_BidirectionalIterator __first,
+       _BidirectionalIterator __last, _Compare __comp)
+    {
+
+     
+
+     
+
+
+      ;
+      ;
+
+      return std::__next_permutation
+ (__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+  template<typename _BidirectionalIterator, typename _Compare>
+   
+    bool
+    __prev_permutation(_BidirectionalIterator __first,
+         _BidirectionalIterator __last, _Compare __comp)
+    {
+      if (__first == __last)
+ return false;
+      _BidirectionalIterator __i = __first;
+      ++__i;
+      if (__i == __last)
+ return false;
+      __i = __last;
+      --__i;
+
+      for(;;)
+ {
+   _BidirectionalIterator __ii = __i;
+   --__i;
+   if (__comp(__ii, __i))
+     {
+       _BidirectionalIterator __j = __last;
+       while (!__comp(--__j, __i))
+  {}
+       std::iter_swap(__i, __j);
+       std::__reverse(__ii, __last,
+        std::__iterator_category(__first));
+       return true;
+     }
+   if (__i == __first)
+     {
+       std::__reverse(__first, __last,
+        std::__iterator_category(__first));
+       return false;
+     }
+ }
+    }
+# 3071 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _BidirectionalIterator>
+   
+    inline bool
+    prev_permutation(_BidirectionalIterator __first,
+       _BidirectionalIterator __last)
+    {
+
+     
+
+     
+
+      ;
+      ;
+
+      return std::__prev_permutation(__first, __last,
+         __gnu_cxx::__ops::__iter_less_iter());
+    }
+# 3104 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _BidirectionalIterator, typename _Compare>
+   
+    inline bool
+    prev_permutation(_BidirectionalIterator __first,
+       _BidirectionalIterator __last, _Compare __comp)
+    {
+
+     
+
+     
+
+
+      ;
+      ;
+
+      return std::__prev_permutation(__first, __last,
+    __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+
+
+
+  template<typename _InputIterator, typename _OutputIterator,
+    typename _Predicate, typename _Tp>
+   
+    _OutputIterator
+    __replace_copy_if(_InputIterator __first, _InputIterator __last,
+        _OutputIterator __result,
+        _Predicate __pred, const _Tp& __new_value)
+    {
+      for (; __first != __last; ++__first, (void)++__result)
+ if (__pred(__first))
+   *__result = __new_value;
+ else
+   *__result = *__first;
+      return __result;
+    }
+# 3156 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _OutputIterator, typename _Tp>
+   
+    inline _OutputIterator
+    replace_copy(_InputIterator __first, _InputIterator __last,
+   _OutputIterator __result,
+   const _Tp& __old_value, const _Tp& __new_value)
+    {
+
+     
+     
+
+     
+
+      ;
+
+      return std::__replace_copy_if(__first, __last, __result,
+   __gnu_cxx::__ops::__iter_equals_val(__old_value),
+           __new_value);
+    }
+# 3191 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _OutputIterator,
+    typename _Predicate, typename _Tp>
+   
+    inline _OutputIterator
+    replace_copy_if(_InputIterator __first, _InputIterator __last,
+      _OutputIterator __result,
+      _Predicate __pred, const _Tp& __new_value)
+    {
+
+     
+     
+
+     
+
+      ;
+
+      return std::__replace_copy_if(__first, __last, __result,
+    __gnu_cxx::__ops::__pred_iter(__pred),
+           __new_value);
+    }
+# 3220 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _ForwardIterator>
+   
+    inline bool
+    is_sorted(_ForwardIterator __first, _ForwardIterator __last)
+    { return std::is_sorted_until(__first, __last) == __last; }
+# 3235 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Compare>
+   
+    inline bool
+    is_sorted(_ForwardIterator __first, _ForwardIterator __last,
+       _Compare __comp)
+    { return std::is_sorted_until(__first, __last, __comp) == __last; }
+
+  template<typename _ForwardIterator, typename _Compare>
+   
+    _ForwardIterator
+    __is_sorted_until(_ForwardIterator __first, _ForwardIterator __last,
+        _Compare __comp)
+    {
+      if (__first == __last)
+ return __last;
+
+      _ForwardIterator __next = __first;
+      for (++__next; __next != __last; __first = __next, (void)++__next)
+ if (__comp(__next, __first))
+   return __next;
+      return __next;
+    }
+# 3266 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _ForwardIterator>
+   
+    inline _ForwardIterator
+    is_sorted_until(_ForwardIterator __first, _ForwardIterator __last)
+    {
+
+     
+     
+
+      ;
+      ;
+
+      return std::__is_sorted_until(__first, __last,
+        __gnu_cxx::__ops::__iter_less_iter());
+    }
+# 3291 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Compare>
+   
+    inline _ForwardIterator
+    is_sorted_until(_ForwardIterator __first, _ForwardIterator __last,
+      _Compare __comp)
+    {
+
+     
+     
+
+
+      ;
+      ;
+
+      return std::__is_sorted_until(__first, __last,
+        __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+# 3317 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _Tp>
+    constexpr
+    inline pair<const _Tp&, const _Tp&>
+    minmax(const _Tp& __a, const _Tp& __b)
+    {
+
+     
+
+      return __b < __a ? pair<const _Tp&, const _Tp&>(__b, __a)
+         : pair<const _Tp&, const _Tp&>(__a, __b);
+    }
+# 3338 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _Tp, typename _Compare>
+    constexpr
+    inline pair<const _Tp&, const _Tp&>
+    minmax(const _Tp& __a, const _Tp& __b, _Compare __comp)
+    {
+      return __comp(__b, __a) ? pair<const _Tp&, const _Tp&>(__b, __a)
+         : pair<const _Tp&, const _Tp&>(__a, __b);
+    }
+
+  template<typename _ForwardIterator, typename _Compare>
+    constexpr
+    pair<_ForwardIterator, _ForwardIterator>
+    __minmax_element(_ForwardIterator __first, _ForwardIterator __last,
+       _Compare __comp)
+    {
+      _ForwardIterator __next = __first;
+      if (__first == __last
+   || ++__next == __last)
+ return std::make_pair(__first, __first);
+
+      _ForwardIterator __min{}, __max{};
+      if (__comp(__next, __first))
+ {
+   __min = __next;
+   __max = __first;
+ }
+      else
+ {
+   __min = __first;
+   __max = __next;
+ }
+
+      __first = __next;
+      ++__first;
+
+      while (__first != __last)
+ {
+   __next = __first;
+   if (++__next == __last)
+     {
+       if (__comp(__first, __min))
+  __min = __first;
+       else if (!__comp(__first, __max))
+  __max = __first;
+       break;
+     }
+
+   if (__comp(__next, __first))
+     {
+       if (__comp(__next, __min))
+  __min = __next;
+       if (!__comp(__first, __max))
+  __max = __first;
+     }
+   else
+     {
+       if (__comp(__first, __min))
+  __min = __first;
+       if (!__comp(__next, __max))
+  __max = __next;
+     }
+
+   __first = __next;
+   ++__first;
+ }
+
+      return std::make_pair(__min, __max);
+    }
+# 3418 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _ForwardIterator>
+    constexpr
+    inline pair<_ForwardIterator, _ForwardIterator>
+    minmax_element(_ForwardIterator __first, _ForwardIterator __last)
+    {
+
+     
+     
+
+      ;
+      ;
+
+      return std::__minmax_element(__first, __last,
+       __gnu_cxx::__ops::__iter_less_iter());
+    }
+# 3446 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Compare>
+    constexpr
+    inline pair<_ForwardIterator, _ForwardIterator>
+    minmax_element(_ForwardIterator __first, _ForwardIterator __last,
+     _Compare __comp)
+    {
+
+     
+     
+
+
+      ;
+      ;
+
+      return std::__minmax_element(__first, __last,
+       __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+
+  template<typename _Tp>
+    constexpr
+    inline _Tp
+    min(initializer_list<_Tp> __l)
+    { return *std::min_element(__l.begin(), __l.end()); }
+
+  template<typename _Tp, typename _Compare>
+    constexpr
+    inline _Tp
+    min(initializer_list<_Tp> __l, _Compare __comp)
+    { return *std::min_element(__l.begin(), __l.end(), __comp); }
+
+  template<typename _Tp>
+    constexpr
+    inline _Tp
+    max(initializer_list<_Tp> __l)
+    { return *std::max_element(__l.begin(), __l.end()); }
+
+  template<typename _Tp, typename _Compare>
+    constexpr
+    inline _Tp
+    max(initializer_list<_Tp> __l, _Compare __comp)
+    { return *std::max_element(__l.begin(), __l.end(), __comp); }
+
+  template<typename _Tp>
+    constexpr
+    inline pair<_Tp, _Tp>
+    minmax(initializer_list<_Tp> __l)
+    {
+      pair<const _Tp*, const _Tp*> __p =
+ std::minmax_element(__l.begin(), __l.end());
+      return std::make_pair(*__p.first, *__p.second);
+    }
+
+  template<typename _Tp, typename _Compare>
+    constexpr
+    inline pair<_Tp, _Tp>
+    minmax(initializer_list<_Tp> __l, _Compare __comp)
+    {
+      pair<const _Tp*, const _Tp*> __p =
+ std::minmax_element(__l.begin(), __l.end(), __comp);
+      return std::make_pair(*__p.first, *__p.second);
+    }
+# 3523 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _ForwardIterator1, typename _ForwardIterator2,
+    typename _BinaryPredicate>
+   
+    inline bool
+    is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+     _ForwardIterator2 __first2, _BinaryPredicate __pred)
+    {
+
+     
+     
+     
+
+
+      ;
+
+      return std::__is_permutation(__first1, __last1, __first2,
+       __gnu_cxx::__ops::__iter_comp_iter(__pred));
+    }
+
+
+  template<typename _ForwardIterator1, typename _ForwardIterator2,
+    typename _BinaryPredicate>
+   
+    bool
+    __is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+       _ForwardIterator2 __first2, _ForwardIterator2 __last2,
+       _BinaryPredicate __pred)
+    {
+      using _Cat1
+ = typename iterator_traits<_ForwardIterator1>::iterator_category;
+      using _Cat2
+ = typename iterator_traits<_ForwardIterator2>::iterator_category;
+      using _It1_is_RA = is_same<_Cat1, random_access_iterator_tag>;
+      using _It2_is_RA = is_same<_Cat2, random_access_iterator_tag>;
+      constexpr bool __ra_iters = _It1_is_RA() && _It2_is_RA();
+      if (__ra_iters)
+ {
+   auto __d1 = std::distance(__first1, __last1);
+   auto __d2 = std::distance(__first2, __last2);
+   if (__d1 != __d2)
+     return false;
+ }
+
+
+
+      for (; __first1 != __last1 && __first2 != __last2;
+   ++__first1, (void)++__first2)
+ if (!__pred(__first1, __first2))
+   break;
+
+      if (__ra_iters)
+ {
+   if (__first1 == __last1)
+     return true;
+ }
+      else
+ {
+   auto __d1 = std::distance(__first1, __last1);
+   auto __d2 = std::distance(__first2, __last2);
+   if (__d1 == 0 && __d2 == 0)
+     return true;
+   if (__d1 != __d2)
+     return false;
+ }
+
+      for (_ForwardIterator1 __scan = __first1; __scan != __last1; ++__scan)
+ {
+   if (__scan != std::__find_if(__first1, __scan,
+   __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)))
+     continue;
+
+   auto __matches = std::__count_if(__first2, __last2,
+  __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan));
+   if (0 == __matches
+       || std::__count_if(__scan, __last1,
+   __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan))
+       != __matches)
+     return false;
+ }
+      return true;
+    }
+# 3618 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _ForwardIterator1, typename _ForwardIterator2>
+   
+    inline bool
+    is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+     _ForwardIterator2 __first2, _ForwardIterator2 __last2)
+    {
+      ;
+      ;
+
+      return
+ std::__is_permutation(__first1, __last1, __first2, __last2,
+         __gnu_cxx::__ops::__iter_equal_to_iter());
+    }
+# 3646 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _ForwardIterator1, typename _ForwardIterator2,
+    typename _BinaryPredicate>
+   
+    inline bool
+    is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+     _ForwardIterator2 __first2, _ForwardIterator2 __last2,
+     _BinaryPredicate __pred)
+    {
+      ;
+      ;
+
+      return std::__is_permutation(__first1, __last1, __first2, __last2,
+       __gnu_cxx::__ops::__iter_comp_iter(__pred));
+    }
+
+
+
+#define __cpp_lib_clamp 201603
+# 3673 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _Tp>
+    constexpr const _Tp&
+    clamp(const _Tp& __val, const _Tp& __lo, const _Tp& __hi)
+    {
+      ;
+      return (__val < __lo) ? __lo : (__hi < __val) ? __hi : __val;
+    }
+# 3691 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _Tp, typename _Compare>
+    constexpr const _Tp&
+    clamp(const _Tp& __val, const _Tp& __lo, const _Tp& __hi, _Compare __comp)
+    {
+      ;
+      return __comp(__val, __lo) ? __lo : __comp(__hi, __val) ? __hi : __val;
+    }
+# 3723 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _IntType, typename _UniformRandomBitGenerator>
+    pair<_IntType, _IntType>
+    __gen_two_uniform_ints(_IntType __b0, _IntType __b1,
+      _UniformRandomBitGenerator&& __g)
+    {
+      _IntType __x
+ = uniform_int_distribution<_IntType>{0, (__b0 * __b1) - 1}(__g);
+      return std::make_pair(__x / __b1, __x % __b1);
+    }
+# 3745 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _RandomAccessIterator,
+    typename _UniformRandomNumberGenerator>
+    void
+    shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
+     _UniformRandomNumberGenerator&& __g)
+    {
+
+     
+
+      ;
+
+      if (__first == __last)
+ return;
+
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+ _DistanceType;
+
+      typedef typename std::make_unsigned<_DistanceType>::type __ud_type;
+      typedef typename std::uniform_int_distribution<__ud_type> __distr_type;
+      typedef typename __distr_type::param_type __p_type;
+
+      typedef typename remove_reference<_UniformRandomNumberGenerator>::type
+ _Gen;
+      typedef typename common_type<typename _Gen::result_type, __ud_type>::type
+ __uc_type;
+
+      const __uc_type __urngrange = __g.max() - __g.min();
+      const __uc_type __urange = __uc_type(__last - __first);
+
+      if (__urngrange / __urange >= __urange)
+
+      {
+ _RandomAccessIterator __i = __first + 1;
+
+
+
+
+
+ if ((__urange % 2) == 0)
+ {
+   __distr_type __d{0, 1};
+   std::iter_swap(__i++, __first + __d(__g));
+ }
+
+
+
+
+
+ while (__i != __last)
+ {
+   const __uc_type __swap_range = __uc_type(__i - __first) + 1;
+
+   const pair<__uc_type, __uc_type> __pospos =
+     __gen_two_uniform_ints(__swap_range, __swap_range + 1, __g);
+
+   std::iter_swap(__i++, __first + __pospos.first);
+   std::iter_swap(__i++, __first + __pospos.second);
+ }
+
+ return;
+      }
+
+      __distr_type __d;
+
+      for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
+ std::iter_swap(__i, __first + __d(__g, __p_type(0, __i - __first)));
+    }
+
+
+
+
+
+# 3830 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _Function>
+   
+    _Function
+    for_each(_InputIterator __first, _InputIterator __last, _Function __f)
+    {
+
+     
+      ;
+      for (; __first != __last; ++__first)
+ __f(*__first);
+      return __f;
+    }
+# 3856 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _Size, typename _Function>
+    _InputIterator
+    for_each_n(_InputIterator __first, _Size __n, _Function __f)
+    {
+      auto __n2 = std::__size_to_integer(__n);
+      using _Cat = typename iterator_traits<_InputIterator>::iterator_category;
+      if constexpr (is_base_of_v<random_access_iterator_tag, _Cat>)
+ {
+   if (__n2 <= 0)
+     return __first;
+   auto __last = __first + __n2;
+   std::for_each(__first, __last, std::move(__f));
+   return __last;
+ }
+      else
+ {
+   while (__n2-->0)
+     {
+       __f(*__first);
+       ++__first;
+     }
+   return __first;
+ }
+    }
+# 3891 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _Tp>
+   
+    inline _InputIterator
+    find(_InputIterator __first, _InputIterator __last,
+  const _Tp& __val)
+    {
+
+     
+     
+
+      ;
+      return std::__find_if(__first, __last,
+       __gnu_cxx::__ops::__iter_equals_val(__val));
+    }
+# 3916 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _Predicate>
+   
+    inline _InputIterator
+    find_if(_InputIterator __first, _InputIterator __last,
+     _Predicate __pred)
+    {
+
+     
+     
+
+      ;
+
+      return std::__find_if(__first, __last,
+       __gnu_cxx::__ops::__pred_iter(__pred));
+    }
+# 3948 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _ForwardIterator>
+   
+    _InputIterator
+    find_first_of(_InputIterator __first1, _InputIterator __last1,
+    _ForwardIterator __first2, _ForwardIterator __last2)
+    {
+
+     
+     
+     
+
+
+      ;
+      ;
+
+      for (; __first1 != __last1; ++__first1)
+ for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter)
+   if (*__first1 == *__iter)
+     return __first1;
+      return __last1;
+    }
+# 3989 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _ForwardIterator,
+    typename _BinaryPredicate>
+   
+    _InputIterator
+    find_first_of(_InputIterator __first1, _InputIterator __last1,
+    _ForwardIterator __first2, _ForwardIterator __last2,
+    _BinaryPredicate __comp)
+    {
+
+     
+     
+     
+
+
+      ;
+      ;
+
+      for (; __first1 != __last1; ++__first1)
+ for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter)
+   if (__comp(*__first1, *__iter))
+     return __first1;
+      return __last1;
+    }
+# 4022 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _ForwardIterator>
+   
+    inline _ForwardIterator
+    adjacent_find(_ForwardIterator __first, _ForwardIterator __last)
+    {
+
+     
+     
+
+      ;
+
+      return std::__adjacent_find(__first, __last,
+      __gnu_cxx::__ops::__iter_equal_to_iter());
+    }
+# 4048 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _BinaryPredicate>
+   
+    inline _ForwardIterator
+    adjacent_find(_ForwardIterator __first, _ForwardIterator __last,
+    _BinaryPredicate __binary_pred)
+    {
+
+     
+     
+
+
+      ;
+
+      return std::__adjacent_find(__first, __last,
+   __gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
+    }
+# 4074 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _Tp>
+   
+    inline typename iterator_traits<_InputIterator>::difference_type
+    count(_InputIterator __first, _InputIterator __last, const _Tp& __value)
+    {
+
+     
+     
+
+      ;
+
+      return std::__count_if(__first, __last,
+        __gnu_cxx::__ops::__iter_equals_val(__value));
+    }
+# 4098 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _Predicate>
+   
+    inline typename iterator_traits<_InputIterator>::difference_type
+    count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred)
+    {
+
+     
+     
+
+      ;
+
+      return std::__count_if(__first, __last,
+        __gnu_cxx::__ops::__pred_iter(__pred));
+    }
+# 4139 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _ForwardIterator1, typename _ForwardIterator2>
+   
+    inline _ForwardIterator1
+    search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+    _ForwardIterator2 __first2, _ForwardIterator2 __last2)
+    {
+
+     
+     
+     
+
+
+      ;
+      ;
+
+      return std::__search(__first1, __last1, __first2, __last2,
+      __gnu_cxx::__ops::__iter_equal_to_iter());
+    }
+# 4179 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _ForwardIterator1, typename _ForwardIterator2,
+    typename _BinaryPredicate>
+   
+    inline _ForwardIterator1
+    search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+    _ForwardIterator2 __first2, _ForwardIterator2 __last2,
+    _BinaryPredicate __predicate)
+    {
+
+     
+     
+     
+
+
+      ;
+      ;
+
+      return std::__search(__first1, __last1, __first2, __last2,
+      __gnu_cxx::__ops::__iter_comp_iter(__predicate));
+    }
+# 4215 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Integer, typename _Tp>
+   
+    inline _ForwardIterator
+    search_n(_ForwardIterator __first, _ForwardIterator __last,
+      _Integer __count, const _Tp& __val)
+    {
+
+     
+     
+
+      ;
+
+      return std::__search_n(__first, __last, __count,
+        __gnu_cxx::__ops::__iter_equals_val(__val));
+    }
+# 4249 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Integer, typename _Tp,
+    typename _BinaryPredicate>
+   
+    inline _ForwardIterator
+    search_n(_ForwardIterator __first, _ForwardIterator __last,
+      _Integer __count, const _Tp& __val,
+      _BinaryPredicate __binary_pred)
+    {
+
+     
+     
+
+      ;
+
+      return std::__search_n(__first, __last, __count,
+  __gnu_cxx::__ops::__iter_comp_val(__binary_pred, __val));
+    }
+# 4275 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Searcher>
+    inline _ForwardIterator
+    search(_ForwardIterator __first, _ForwardIterator __last,
+    const _Searcher& __searcher)
+    { return __searcher(__first, __last).first; }
+# 4298 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _OutputIterator,
+    typename _UnaryOperation>
+   
+    _OutputIterator
+    transform(_InputIterator __first, _InputIterator __last,
+       _OutputIterator __result, _UnaryOperation __unary_op)
+    {
+
+     
+     
+
+
+      ;
+
+      for (; __first != __last; ++__first, (void)++__result)
+ *__result = __unary_op(*__first);
+      return __result;
+    }
+# 4336 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator, typename _BinaryOperation>
+   
+    _OutputIterator
+    transform(_InputIterator1 __first1, _InputIterator1 __last1,
+       _InputIterator2 __first2, _OutputIterator __result,
+       _BinaryOperation __binary_op)
+    {
+
+     
+     
+     
+
+
+      ;
+
+      for (; __first1 != __last1; ++__first1, (void)++__first2, ++__result)
+ *__result = __binary_op(*__first1, *__first2);
+      return __result;
+    }
+# 4370 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Tp>
+   
+    void
+    replace(_ForwardIterator __first, _ForwardIterator __last,
+     const _Tp& __old_value, const _Tp& __new_value)
+    {
+
+     
+
+     
+
+     
+
+      ;
+
+      for (; __first != __last; ++__first)
+ if (*__first == __old_value)
+   *__first = __new_value;
+    }
+# 4403 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Predicate, typename _Tp>
+   
+    void
+    replace_if(_ForwardIterator __first, _ForwardIterator __last,
+        _Predicate __pred, const _Tp& __new_value)
+    {
+
+     
+
+     
+
+     
+
+      ;
+
+      for (; __first != __last; ++__first)
+ if (__pred(*__first))
+   *__first = __new_value;
+    }
+# 4436 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Generator>
+   
+    void
+    generate(_ForwardIterator __first, _ForwardIterator __last,
+      _Generator __gen)
+    {
+
+     
+     
+
+      ;
+
+      for (; __first != __last; ++__first)
+ *__first = __gen();
+    }
+# 4470 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _OutputIterator, typename _Size, typename _Generator>
+   
+    _OutputIterator
+    generate_n(_OutputIterator __first, _Size __n, _Generator __gen)
+    {
+
+     
+
+
+
+      typedef __decltype(std::__size_to_integer(__n)) _IntSize;
+      for (_IntSize __niter = std::__size_to_integer(__n);
+    __niter > 0; --__niter, (void) ++__first)
+ *__first = __gen();
+      return __first;
+    }
+# 4508 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _OutputIterator>
+   
+    inline _OutputIterator
+    unique_copy(_InputIterator __first, _InputIterator __last,
+  _OutputIterator __result)
+    {
+
+     
+     
+
+     
+
+      ;
+
+      if (__first == __last)
+ return __result;
+      return std::__unique_copy(__first, __last, __result,
+    __gnu_cxx::__ops::__iter_equal_to_iter(),
+    std::__iterator_category(__first),
+    std::__iterator_category(__result));
+    }
+# 4549 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _OutputIterator,
+    typename _BinaryPredicate>
+   
+    inline _OutputIterator
+    unique_copy(_InputIterator __first, _InputIterator __last,
+  _OutputIterator __result,
+  _BinaryPredicate __binary_pred)
+    {
+
+     
+     
+
+      ;
+
+      if (__first == __last)
+ return __result;
+      return std::__unique_copy(__first, __last, __result,
+   __gnu_cxx::__ops::__iter_comp_iter(__binary_pred),
+    std::__iterator_category(__first),
+    std::__iterator_category(__result));
+    }
+# 4583 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _RandomAccessIterator>
+    inline void
+    random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    {
+
+     
+
+      ;
+
+      if (__first != __last)
+ for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
+   {
+
+     _RandomAccessIterator __j = __first
+     + std::rand() % ((__i - __first) + 1);
+     if (__i != __j)
+       std::iter_swap(__i, __j);
+   }
+    }
+# 4618 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _RandomAccessIterator, typename _RandomNumberGenerator>
+    void
+    random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
+
+     _RandomNumberGenerator&& __rand)
+
+
+
+    {
+
+     
+
+      ;
+
+      if (__first == __last)
+ return;
+      for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
+ {
+   _RandomAccessIterator __j = __first + __rand((__i - __first) + 1);
+   if (__i != __j)
+     std::iter_swap(__i, __j);
+ }
+    }
+# 4658 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Predicate>
+   
+    inline _ForwardIterator
+    partition(_ForwardIterator __first, _ForwardIterator __last,
+       _Predicate __pred)
+    {
+
+     
+
+     
+
+      ;
+
+      return std::__partition(__first, __last, __pred,
+         std::__iterator_category(__first));
+    }
+# 4692 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _RandomAccessIterator>
+   
+    inline void
+    partial_sort(_RandomAccessIterator __first,
+   _RandomAccessIterator __middle,
+   _RandomAccessIterator __last)
+    {
+
+     
+
+     
+
+      ;
+      ;
+      ;
+
+      std::__partial_sort(__first, __middle, __last,
+     __gnu_cxx::__ops::__iter_less_iter());
+    }
+# 4731 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _RandomAccessIterator, typename _Compare>
+   
+    inline void
+    partial_sort(_RandomAccessIterator __first,
+   _RandomAccessIterator __middle,
+   _RandomAccessIterator __last,
+   _Compare __comp)
+    {
+
+     
+
+     
+
+
+      ;
+      ;
+      ;
+
+      std::__partial_sort(__first, __middle, __last,
+     __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+# 4768 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _RandomAccessIterator>
+   
+    inline void
+    nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth,
+  _RandomAccessIterator __last)
+    {
+
+     
+
+     
+
+      ;
+      ;
+      ;
+
+      if (__first == __last || __nth == __last)
+ return;
+
+      std::__introselect(__first, __nth, __last,
+    std::__lg(__last - __first) * 2,
+    __gnu_cxx::__ops::__iter_less_iter());
+    }
+# 4808 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _RandomAccessIterator, typename _Compare>
+   
+    inline void
+    nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth,
+  _RandomAccessIterator __last, _Compare __comp)
+    {
+
+     
+
+     
+
+
+      ;
+      ;
+      ;
+
+      if (__first == __last || __nth == __last)
+ return;
+
+      std::__introselect(__first, __nth, __last,
+    std::__lg(__last - __first) * 2,
+    __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+# 4846 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _RandomAccessIterator>
+   
+    inline void
+    sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    {
+
+     
+
+     
+
+      ;
+      ;
+
+      std::__sort(__first, __last, __gnu_cxx::__ops::__iter_less_iter());
+    }
+# 4877 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _RandomAccessIterator, typename _Compare>
+   
+    inline void
+    sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
+  _Compare __comp)
+    {
+
+     
+
+     
+
+
+      ;
+      ;
+
+      std::__sort(__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator, typename _Compare>
+   
+    _OutputIterator
+    __merge(_InputIterator1 __first1, _InputIterator1 __last1,
+     _InputIterator2 __first2, _InputIterator2 __last2,
+     _OutputIterator __result, _Compare __comp)
+    {
+      while (__first1 != __last1 && __first2 != __last2)
+ {
+   if (__comp(__first2, __first1))
+     {
+       *__result = *__first2;
+       ++__first2;
+     }
+   else
+     {
+       *__result = *__first1;
+       ++__first1;
+     }
+   ++__result;
+ }
+      return std::copy(__first2, __last2,
+         std::copy(__first1, __last1, __result));
+    }
+# 4940 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator>
+   
+    inline _OutputIterator
+    merge(_InputIterator1 __first1, _InputIterator1 __last1,
+   _InputIterator2 __first2, _InputIterator2 __last2,
+   _OutputIterator __result)
+    {
+
+     
+     
+     
+
+     
+
+     
+
+
+      ;
+      ;
+      ;
+      ;
+
+      return std::__merge(__first1, __last1,
+         __first2, __last2, __result,
+         __gnu_cxx::__ops::__iter_less_iter());
+    }
+# 4991 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator, typename _Compare>
+   
+    inline _OutputIterator
+    merge(_InputIterator1 __first1, _InputIterator1 __last1,
+   _InputIterator2 __first2, _InputIterator2 __last2,
+   _OutputIterator __result, _Compare __comp)
+    {
+
+     
+     
+     
+
+     
+
+     
+
+
+      ;
+      ;
+      ;
+      ;
+
+      return std::__merge(__first1, __last1,
+    __first2, __last2, __result,
+    __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    __stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
+    _Compare __comp)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+ _ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+ _DistanceType;
+
+      typedef _Temporary_buffer<_RandomAccessIterator, _ValueType> _TmpBuf;
+      _TmpBuf __buf(__first, std::distance(__first, __last));
+
+      if (__buf.begin() == 0)
+ std::__inplace_stable_sort(__first, __last, __comp);
+      else
+ std::__stable_sort_adaptive(__first, __last, __buf.begin(),
+        _DistanceType(__buf.size()), __comp);
+    }
+# 5056 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _RandomAccessIterator>
+    inline void
+    stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    {
+
+     
+
+     
+
+      ;
+      ;
+
+      std::__stable_sort(__first, __last,
+        __gnu_cxx::__ops::__iter_less_iter());
+    }
+# 5090 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
+  _Compare __comp)
+    {
+
+     
+
+     
+
+
+      ;
+      ;
+
+      std::__stable_sort(__first, __last,
+        __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator,
+    typename _Compare>
+   
+    _OutputIterator
+    __set_union(_InputIterator1 __first1, _InputIterator1 __last1,
+  _InputIterator2 __first2, _InputIterator2 __last2,
+  _OutputIterator __result, _Compare __comp)
+    {
+      while (__first1 != __last1 && __first2 != __last2)
+ {
+   if (__comp(__first1, __first2))
+     {
+       *__result = *__first1;
+       ++__first1;
+     }
+   else if (__comp(__first2, __first1))
+     {
+       *__result = *__first2;
+       ++__first2;
+     }
+   else
+     {
+       *__result = *__first1;
+       ++__first1;
+       ++__first2;
+     }
+   ++__result;
+ }
+      return std::copy(__first2, __last2,
+         std::copy(__first1, __last1, __result));
+    }
+# 5160 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator>
+   
+    inline _OutputIterator
+    set_union(_InputIterator1 __first1, _InputIterator1 __last1,
+       _InputIterator2 __first2, _InputIterator2 __last2,
+       _OutputIterator __result)
+    {
+
+     
+     
+     
+
+     
+
+     
+
+
+     
+
+
+      ;
+      ;
+      ;
+      ;
+
+      return std::__set_union(__first1, __last1,
+    __first2, __last2, __result,
+    __gnu_cxx::__ops::__iter_less_iter());
+    }
+# 5211 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator, typename _Compare>
+   
+    inline _OutputIterator
+    set_union(_InputIterator1 __first1, _InputIterator1 __last1,
+       _InputIterator2 __first2, _InputIterator2 __last2,
+       _OutputIterator __result, _Compare __comp)
+    {
+
+     
+     
+     
+
+     
+
+     
+
+
+     
+
+
+      ;
+      ;
+      ;
+      ;
+
+      return std::__set_union(__first1, __last1,
+    __first2, __last2, __result,
+    __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator,
+    typename _Compare>
+   
+    _OutputIterator
+    __set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
+         _InputIterator2 __first2, _InputIterator2 __last2,
+         _OutputIterator __result, _Compare __comp)
+    {
+      while (__first1 != __last1 && __first2 != __last2)
+ if (__comp(__first1, __first2))
+   ++__first1;
+ else if (__comp(__first2, __first1))
+   ++__first2;
+ else
+   {
+     *__result = *__first1;
+     ++__first1;
+     ++__first2;
+     ++__result;
+   }
+      return __result;
+    }
+# 5284 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator>
+   
+    inline _OutputIterator
+    set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
+       _InputIterator2 __first2, _InputIterator2 __last2,
+       _OutputIterator __result)
+    {
+
+     
+     
+     
+
+     
+
+
+     
+
+
+      ;
+      ;
+      ;
+      ;
+
+      return std::__set_intersection(__first1, __last1,
+         __first2, __last2, __result,
+         __gnu_cxx::__ops::__iter_less_iter());
+    }
+# 5334 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator, typename _Compare>
+   
+    inline _OutputIterator
+    set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
+       _InputIterator2 __first2, _InputIterator2 __last2,
+       _OutputIterator __result, _Compare __comp)
+    {
+
+     
+     
+     
+
+     
+
+
+     
+
+
+      ;
+      ;
+      ;
+      ;
+
+      return std::__set_intersection(__first1, __last1,
+    __first2, __last2, __result,
+    __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator,
+    typename _Compare>
+   
+    _OutputIterator
+    __set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
+       _InputIterator2 __first2, _InputIterator2 __last2,
+       _OutputIterator __result, _Compare __comp)
+    {
+      while (__first1 != __last1 && __first2 != __last2)
+ if (__comp(__first1, __first2))
+   {
+     *__result = *__first1;
+     ++__first1;
+     ++__result;
+   }
+ else if (__comp(__first2, __first1))
+   ++__first2;
+ else
+   {
+     ++__first1;
+     ++__first2;
+   }
+      return std::copy(__first1, __last1, __result);
+    }
+# 5409 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator>
+   
+    inline _OutputIterator
+    set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
+     _InputIterator2 __first2, _InputIterator2 __last2,
+     _OutputIterator __result)
+    {
+
+     
+     
+     
+
+     
+
+
+     
+
+
+      ;
+      ;
+      ;
+      ;
+
+      return std::__set_difference(__first1, __last1,
+       __first2, __last2, __result,
+       __gnu_cxx::__ops::__iter_less_iter());
+    }
+# 5461 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator, typename _Compare>
+   
+    inline _OutputIterator
+    set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
+     _InputIterator2 __first2, _InputIterator2 __last2,
+     _OutputIterator __result, _Compare __comp)
+    {
+
+     
+     
+     
+
+     
+
+
+     
+
+
+      ;
+      ;
+      ;
+      ;
+
+      return std::__set_difference(__first1, __last1,
+       __first2, __last2, __result,
+       __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator,
+    typename _Compare>
+   
+    _OutputIterator
+    __set_symmetric_difference(_InputIterator1 __first1,
+          _InputIterator1 __last1,
+          _InputIterator2 __first2,
+          _InputIterator2 __last2,
+          _OutputIterator __result,
+          _Compare __comp)
+    {
+      while (__first1 != __last1 && __first2 != __last2)
+ if (__comp(__first1, __first2))
+   {
+     *__result = *__first1;
+     ++__first1;
+     ++__result;
+   }
+ else if (__comp(__first2, __first1))
+   {
+     *__result = *__first2;
+     ++__first2;
+     ++__result;
+   }
+ else
+   {
+     ++__first1;
+     ++__first2;
+   }
+      return std::copy(__first2, __last2,
+         std::copy(__first1, __last1, __result));
+    }
+# 5542 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator>
+   
+    inline _OutputIterator
+    set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
+        _InputIterator2 __first2, _InputIterator2 __last2,
+        _OutputIterator __result)
+    {
+
+     
+     
+     
+
+     
+
+     
+
+
+     
+
+
+      ;
+      ;
+      ;
+      ;
+
+      return std::__set_symmetric_difference(__first1, __last1,
+     __first2, __last2, __result,
+     __gnu_cxx::__ops::__iter_less_iter());
+    }
+# 5594 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator, typename _Compare>
+   
+    inline _OutputIterator
+    set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
+        _InputIterator2 __first2, _InputIterator2 __last2,
+        _OutputIterator __result,
+        _Compare __comp)
+    {
+
+     
+     
+     
+
+     
+
+     
+
+
+     
+
+
+      ;
+      ;
+      ;
+      ;
+
+      return std::__set_symmetric_difference(__first1, __last1,
+    __first2, __last2, __result,
+    __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+  template<typename _ForwardIterator, typename _Compare>
+    constexpr
+    _ForwardIterator
+    __min_element(_ForwardIterator __first, _ForwardIterator __last,
+    _Compare __comp)
+    {
+      if (__first == __last)
+ return __first;
+      _ForwardIterator __result = __first;
+      while (++__first != __last)
+ if (__comp(__first, __result))
+   __result = __first;
+      return __result;
+    }
+# 5648 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _ForwardIterator>
+    constexpr
+    _ForwardIterator
+    inline min_element(_ForwardIterator __first, _ForwardIterator __last)
+    {
+
+     
+     
+
+      ;
+      ;
+
+      return std::__min_element(__first, __last,
+    __gnu_cxx::__ops::__iter_less_iter());
+    }
+# 5673 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Compare>
+    constexpr
+    inline _ForwardIterator
+    min_element(_ForwardIterator __first, _ForwardIterator __last,
+  _Compare __comp)
+    {
+
+     
+     
+
+
+      ;
+      ;
+
+      return std::__min_element(__first, __last,
+    __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+  template<typename _ForwardIterator, typename _Compare>
+    constexpr
+    _ForwardIterator
+    __max_element(_ForwardIterator __first, _ForwardIterator __last,
+    _Compare __comp)
+    {
+      if (__first == __last) return __first;
+      _ForwardIterator __result = __first;
+      while (++__first != __last)
+ if (__comp(__result, __first))
+   __result = __first;
+      return __result;
+    }
+# 5712 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _ForwardIterator>
+    constexpr
+    inline _ForwardIterator
+    max_element(_ForwardIterator __first, _ForwardIterator __last)
+    {
+
+     
+     
+
+      ;
+      ;
+
+      return std::__max_element(__first, __last,
+    __gnu_cxx::__ops::__iter_less_iter());
+    }
+# 5737 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Compare>
+    constexpr
+    inline _ForwardIterator
+    max_element(_ForwardIterator __first, _ForwardIterator __last,
+  _Compare __comp)
+    {
+
+     
+     
+
+
+      ;
+      ;
+
+      return std::__max_element(__first, __last,
+    __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+
+
+  template<typename _InputIterator, typename _RandomAccessIterator,
+           typename _Size, typename _UniformRandomBitGenerator>
+    _RandomAccessIterator
+    __sample(_InputIterator __first, _InputIterator __last, input_iterator_tag,
+      _RandomAccessIterator __out, random_access_iterator_tag,
+      _Size __n, _UniformRandomBitGenerator&& __g)
+    {
+      using __distrib_type = uniform_int_distribution<_Size>;
+      using __param_type = typename __distrib_type::param_type;
+      __distrib_type __d{};
+      _Size __sample_sz = 0;
+      while (__first != __last && __sample_sz != __n)
+ {
+   __out[__sample_sz++] = *__first;
+   ++__first;
+ }
+      for (auto __pop_sz = __sample_sz; __first != __last;
+   ++__first, (void) ++__pop_sz)
+ {
+   const auto __k = __d(__g, __param_type{0, __pop_sz});
+   if (__k < __n)
+     __out[__k] = *__first;
+ }
+      return __out + __sample_sz;
+    }
+
+
+  template<typename _ForwardIterator, typename _OutputIterator, typename _Cat,
+           typename _Size, typename _UniformRandomBitGenerator>
+    _OutputIterator
+    __sample(_ForwardIterator __first, _ForwardIterator __last,
+      forward_iterator_tag,
+      _OutputIterator __out, _Cat,
+      _Size __n, _UniformRandomBitGenerator&& __g)
+    {
+      using __distrib_type = uniform_int_distribution<_Size>;
+      using __param_type = typename __distrib_type::param_type;
+      using _USize = make_unsigned_t<_Size>;
+      using _Gen = remove_reference_t<_UniformRandomBitGenerator>;
+      using __uc_type = common_type_t<typename _Gen::result_type, _USize>;
+
+      __distrib_type __d{};
+      _Size __unsampled_sz = std::distance(__first, __last);
+      __n = std::min(__n, __unsampled_sz);
+
+
+
+
+      const __uc_type __urngrange = __g.max() - __g.min();
+      if (__urngrange / __uc_type(__unsampled_sz) >= __uc_type(__unsampled_sz))
+
+
+        {
+   while (__n != 0 && __unsampled_sz >= 2)
+     {
+       const pair<_Size, _Size> __p =
+  __gen_two_uniform_ints(__unsampled_sz, __unsampled_sz - 1, __g);
+
+       --__unsampled_sz;
+       if (__p.first < __n)
+  {
+    *__out++ = *__first;
+    --__n;
+  }
+
+       ++__first;
+
+       if (__n == 0) break;
+
+       --__unsampled_sz;
+       if (__p.second < __n)
+  {
+    *__out++ = *__first;
+    --__n;
+  }
+
+       ++__first;
+     }
+        }
+
+
+
+      for (; __n != 0; ++__first)
+ if (__d(__g, __param_type{0, --__unsampled_sz}) < __n)
+   {
+     *__out++ = *__first;
+     --__n;
+   }
+      return __out;
+    }
+
+
+#define __cpp_lib_sample 201603
+
+  template<typename _PopulationIterator, typename _SampleIterator,
+           typename _Distance, typename _UniformRandomBitGenerator>
+    _SampleIterator
+    sample(_PopulationIterator __first, _PopulationIterator __last,
+    _SampleIterator __out, _Distance __n,
+    _UniformRandomBitGenerator&& __g)
+    {
+      using __pop_cat = typename
+ std::iterator_traits<_PopulationIterator>::iterator_category;
+      using __samp_cat = typename
+ std::iterator_traits<_SampleIterator>::iterator_category;
+
+      static_assert(
+   __or_<is_convertible<__pop_cat, forward_iterator_tag>,
+  is_convertible<__samp_cat, random_access_iterator_tag>>::value,
+   "output range must use a RandomAccessIterator when input range"
+   " does not meet the ForwardIterator requirements");
+
+      static_assert(is_integral<_Distance>::value,
+      "sample size must be an integer type");
+
+      typename iterator_traits<_PopulationIterator>::difference_type __d = __n;
+      return std::
+ __sample(__first, __last, __pop_cat{}, __out, __samp_cat{}, __d,
+   std::forward<_UniformRandomBitGenerator>(__g));
+    }
+
+
+
+
+
+}
+# 66 "/usr/include/c++/10.2.0/functional" 2 3
+
+
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+#define __cpp_lib_invoke 201411L
+
+
+
+
+
+  template<typename _Callable, typename... _Args>
+    inline invoke_result_t<_Callable, _Args...>
+    invoke(_Callable&& __fn, _Args&&... __args)
+    noexcept(is_nothrow_invocable_v<_Callable, _Args...>)
+    {
+      return std::__invoke(std::forward<_Callable>(__fn),
+      std::forward<_Args>(__args)...);
+    }
+
+
+  template<typename _MemFunPtr,
+    bool __is_mem_fn = is_member_function_pointer<_MemFunPtr>::value>
+    class _Mem_fn_base
+    : public _Mem_fn_traits<_MemFunPtr>::__maybe_type
+    {
+      using _Traits = _Mem_fn_traits<_MemFunPtr>;
+
+      using _Arity = typename _Traits::__arity;
+      using _Varargs = typename _Traits::__vararg;
+
+      template<typename _Func, typename... _BoundArgs>
+ friend struct _Bind_check_arity;
+
+      _MemFunPtr _M_pmf;
+
+    public:
+
+      using result_type = typename _Traits::__result_type;
+
+      explicit constexpr
+      _Mem_fn_base(_MemFunPtr __pmf) noexcept : _M_pmf(__pmf) { }
+
+      template<typename... _Args>
+
+ auto
+ operator()(_Args&&... __args) const
+ noexcept(noexcept(
+       std::__invoke(_M_pmf, std::forward<_Args>(__args)...)))
+ -> decltype(std::__invoke(_M_pmf, std::forward<_Args>(__args)...))
+ { return std::__invoke(_M_pmf, std::forward<_Args>(__args)...); }
+    };
+
+
+  template<typename _MemObjPtr>
+    class _Mem_fn_base<_MemObjPtr, false>
+    {
+      using _Arity = integral_constant<size_t, 0>;
+      using _Varargs = false_type;
+
+      template<typename _Func, typename... _BoundArgs>
+ friend struct _Bind_check_arity;
+
+      _MemObjPtr _M_pm;
+
+    public:
+      explicit constexpr
+      _Mem_fn_base(_MemObjPtr __pm) noexcept : _M_pm(__pm) { }
+
+      template<typename _Tp>
+
+ auto
+ operator()(_Tp&& __obj) const
+ noexcept(noexcept(std::__invoke(_M_pm, std::forward<_Tp>(__obj))))
+ -> decltype(std::__invoke(_M_pm, std::forward<_Tp>(__obj)))
+ { return std::__invoke(_M_pm, std::forward<_Tp>(__obj)); }
+    };
+
+  template<typename _MemberPointer>
+    struct _Mem_fn;
+
+  template<typename _Res, typename _Class>
+    struct _Mem_fn<_Res _Class::*>
+    : _Mem_fn_base<_Res _Class::*>
+    {
+      using _Mem_fn_base<_Res _Class::*>::_Mem_fn_base;
+    };
+# 167 "/usr/include/c++/10.2.0/functional" 3
+  template<typename _Tp, typename _Class>
+   
+    inline _Mem_fn<_Tp _Class::*>
+    mem_fn(_Tp _Class::* __pm) noexcept
+    {
+      return _Mem_fn<_Tp _Class::*>(__pm);
+    }
+# 183 "/usr/include/c++/10.2.0/functional" 3
+  template<typename _Tp>
+    struct is_bind_expression
+    : public false_type { };
+# 194 "/usr/include/c++/10.2.0/functional" 3
+  template<typename _Tp>
+    struct is_placeholder
+    : public integral_constant<int, 0>
+    { };
+
+
+  template <typename _Tp> inline constexpr bool is_bind_expression_v
+    = is_bind_expression<_Tp>::value;
+  template <typename _Tp> inline constexpr int is_placeholder_v
+    = is_placeholder<_Tp>::value;
+
+
+
+
+
+  template<int _Num> struct _Placeholder { };
+
+
+
+
+
+  namespace placeholders
+  {
+
+
+
+
+    extern const _Placeholder<1> _1;
+    extern const _Placeholder<2> _2;
+    extern const _Placeholder<3> _3;
+    extern const _Placeholder<4> _4;
+    extern const _Placeholder<5> _5;
+    extern const _Placeholder<6> _6;
+    extern const _Placeholder<7> _7;
+    extern const _Placeholder<8> _8;
+    extern const _Placeholder<9> _9;
+    extern const _Placeholder<10> _10;
+    extern const _Placeholder<11> _11;
+    extern const _Placeholder<12> _12;
+    extern const _Placeholder<13> _13;
+    extern const _Placeholder<14> _14;
+    extern const _Placeholder<15> _15;
+    extern const _Placeholder<16> _16;
+    extern const _Placeholder<17> _17;
+    extern const _Placeholder<18> _18;
+    extern const _Placeholder<19> _19;
+    extern const _Placeholder<20> _20;
+    extern const _Placeholder<21> _21;
+    extern const _Placeholder<22> _22;
+    extern const _Placeholder<23> _23;
+    extern const _Placeholder<24> _24;
+    extern const _Placeholder<25> _25;
+    extern const _Placeholder<26> _26;
+    extern const _Placeholder<27> _27;
+    extern const _Placeholder<28> _28;
+    extern const _Placeholder<29> _29;
+  }
+
+
+
+
+
+
+  template<int _Num>
+    struct is_placeholder<_Placeholder<_Num> >
+    : public integral_constant<int, _Num>
+    { };
+
+  template<int _Num>
+    struct is_placeholder<const _Placeholder<_Num> >
+    : public integral_constant<int, _Num>
+    { };
+
+
+
+  template<std::size_t __i, typename _Tuple>
+    using _Safe_tuple_element_t
+      = typename enable_if<(__i < tuple_size<_Tuple>::value),
+      tuple_element<__i, _Tuple>>::type::type;
+# 285 "/usr/include/c++/10.2.0/functional" 3
+  template<typename _Arg,
+    bool _IsBindExp = is_bind_expression<_Arg>::value,
+    bool _IsPlaceholder = (is_placeholder<_Arg>::value > 0)>
+    class _Mu;
+
+
+
+
+
+
+  template<typename _Tp>
+    class _Mu<reference_wrapper<_Tp>, false, false>
+    {
+    public:
+
+
+
+
+      template<typename _CVRef, typename _Tuple>
+
+ _Tp&
+ operator()(_CVRef& __arg, _Tuple&) const volatile
+ { return __arg.get(); }
+    };
+
+
+
+
+
+
+
+  template<typename _Arg>
+    class _Mu<_Arg, true, false>
+    {
+    public:
+      template<typename _CVArg, typename... _Args>
+
+ auto
+ operator()(_CVArg& __arg,
+     tuple<_Args...>& __tuple) const volatile
+ -> decltype(__arg(declval<_Args>()...))
+ {
+
+   typedef typename _Build_index_tuple<sizeof...(_Args)>::__type
+     _Indexes;
+   return this->__call(__arg, __tuple, _Indexes());
+ }
+
+    private:
+
+
+      template<typename _CVArg, typename... _Args, std::size_t... _Indexes>
+
+ auto
+ __call(_CVArg& __arg, tuple<_Args...>& __tuple,
+        const _Index_tuple<_Indexes...>&) const volatile
+ -> decltype(__arg(declval<_Args>()...))
+ {
+   return __arg(std::get<_Indexes>(std::move(__tuple))...);
+ }
+    };
+
+
+
+
+
+
+  template<typename _Arg>
+    class _Mu<_Arg, false, true>
+    {
+    public:
+      template<typename _Tuple>
+
+ _Safe_tuple_element_t<(is_placeholder<_Arg>::value - 1), _Tuple>&&
+ operator()(const volatile _Arg&, _Tuple& __tuple) const volatile
+ {
+   return
+     ::std::get<(is_placeholder<_Arg>::value - 1)>(std::move(__tuple));
+ }
+    };
+
+
+
+
+
+
+  template<typename _Arg>
+    class _Mu<_Arg, false, false>
+    {
+    public:
+      template<typename _CVArg, typename _Tuple>
+
+ _CVArg&&
+ operator()(_CVArg&& __arg, _Tuple&) const volatile
+ { return std::forward<_CVArg>(__arg); }
+    };
+
+
+  template<std::size_t _Ind, typename... _Tp>
+    inline auto
+    __volget(volatile tuple<_Tp...>& __tuple)
+    -> __tuple_element_t<_Ind, tuple<_Tp...>> volatile&
+    { return std::get<_Ind>(const_cast<tuple<_Tp...>&>(__tuple)); }
+
+
+  template<std::size_t _Ind, typename... _Tp>
+    inline auto
+    __volget(const volatile tuple<_Tp...>& __tuple)
+    -> __tuple_element_t<_Ind, tuple<_Tp...>> const volatile&
+    { return std::get<_Ind>(const_cast<const tuple<_Tp...>&>(__tuple)); }
+
+
+  template<typename _Signature>
+    struct _Bind;
+
+   template<typename _Functor, typename... _Bound_args>
+    class _Bind<_Functor(_Bound_args...)>
+    : public _Weak_result_type<_Functor>
+    {
+      typedef typename _Build_index_tuple<sizeof...(_Bound_args)>::__type
+ _Bound_indexes;
+
+      _Functor _M_f;
+      tuple<_Bound_args...> _M_bound_args;
+
+
+      template<typename _Result, typename... _Args, std::size_t... _Indexes>
+
+ _Result
+ __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>)
+ {
+   return std::__invoke(_M_f,
+       _Mu<_Bound_args>()(std::get<_Indexes>(_M_bound_args), __args)...
+       );
+ }
+
+
+      template<typename _Result, typename... _Args, std::size_t... _Indexes>
+
+ _Result
+ __call_c(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) const
+ {
+   return std::__invoke(_M_f,
+       _Mu<_Bound_args>()(std::get<_Indexes>(_M_bound_args), __args)...
+       );
+ }
+
+
+      template<typename _Result, typename... _Args, std::size_t... _Indexes>
+ _Result
+ __call_v(tuple<_Args...>&& __args,
+   _Index_tuple<_Indexes...>) volatile
+ {
+   return std::__invoke(_M_f,
+       _Mu<_Bound_args>()(__volget<_Indexes>(_M_bound_args), __args)...
+       );
+ }
+
+
+      template<typename _Result, typename... _Args, std::size_t... _Indexes>
+ _Result
+ __call_c_v(tuple<_Args...>&& __args,
+     _Index_tuple<_Indexes...>) const volatile
+ {
+   return std::__invoke(_M_f,
+       _Mu<_Bound_args>()(__volget<_Indexes>(_M_bound_args), __args)...
+       );
+ }
+
+      template<typename _BoundArg, typename _CallArgs>
+ using _Mu_type = decltype(
+     _Mu<typename remove_cv<_BoundArg>::type>()(
+       std::declval<_BoundArg&>(), std::declval<_CallArgs&>()) );
+
+      template<typename _Fn, typename _CallArgs, typename... _BArgs>
+ using _Res_type_impl
+   = typename result_of< _Fn&(_Mu_type<_BArgs, _CallArgs>&&...) >::type;
+
+      template<typename _CallArgs>
+ using _Res_type = _Res_type_impl<_Functor, _CallArgs, _Bound_args...>;
+
+      template<typename _CallArgs>
+ using __dependent = typename
+   enable_if<bool(tuple_size<_CallArgs>::value+1), _Functor>::type;
+
+      template<typename _CallArgs, template<class> class __cv_quals>
+ using _Res_type_cv = _Res_type_impl<
+   typename __cv_quals<__dependent<_CallArgs>>::type,
+   _CallArgs,
+   typename __cv_quals<_Bound_args>::type...>;
+
+     public:
+      template<typename... _Args>
+ explicit
+ _Bind(const _Functor& __f, _Args&&... __args)
+ : _M_f(__f), _M_bound_args(std::forward<_Args>(__args)...)
+ { }
+
+      template<typename... _Args>
+ explicit
+ _Bind(_Functor&& __f, _Args&&... __args)
+ : _M_f(std::move(__f)), _M_bound_args(std::forward<_Args>(__args)...)
+ { }
+
+      _Bind(const _Bind&) = default;
+      _Bind(_Bind&&) = default;
+
+
+      template<typename... _Args,
+        typename _Result = _Res_type<tuple<_Args...>>>
+
+ _Result
+ operator()(_Args&&... __args)
+ {
+   return this->__call<_Result>(
+       std::forward_as_tuple(std::forward<_Args>(__args)...),
+       _Bound_indexes());
+ }
+
+
+      template<typename... _Args,
+        typename _Result = _Res_type_cv<tuple<_Args...>, add_const>>
+
+ _Result
+ operator()(_Args&&... __args) const
+ {
+   return this->__call_c<_Result>(
+       std::forward_as_tuple(std::forward<_Args>(__args)...),
+       _Bound_indexes());
+ }
+
+
+#define _GLIBCXX_DEPR_BIND [[deprecated("std::bind does not support volatile in C++17")]]
+
+
+
+
+
+      template<typename... _Args,
+        typename _Result = _Res_type_cv<tuple<_Args...>, add_volatile>>
+ [[deprecated("std::bind does not support volatile in C++17")]]
+ _Result
+ operator()(_Args&&... __args) volatile
+ {
+   return this->__call_v<_Result>(
+       std::forward_as_tuple(std::forward<_Args>(__args)...),
+       _Bound_indexes());
+ }
+
+
+      template<typename... _Args,
+        typename _Result = _Res_type_cv<tuple<_Args...>, add_cv>>
+ [[deprecated("std::bind does not support volatile in C++17")]]
+ _Result
+ operator()(_Args&&... __args) const volatile
+ {
+   return this->__call_c_v<_Result>(
+       std::forward_as_tuple(std::forward<_Args>(__args)...),
+       _Bound_indexes());
+ }
+    };
+
+
+  template<typename _Result, typename _Signature>
+    struct _Bind_result;
+
+  template<typename _Result, typename _Functor, typename... _Bound_args>
+    class _Bind_result<_Result, _Functor(_Bound_args...)>
+    {
+      typedef typename _Build_index_tuple<sizeof...(_Bound_args)>::__type
+ _Bound_indexes;
+
+      _Functor _M_f;
+      tuple<_Bound_args...> _M_bound_args;
+
+
+      template<typename _Res, typename... _Args, std::size_t... _Indexes>
+
+ _Res
+ __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>)
+ {
+   return std::__invoke_r<_Res>(_M_f, _Mu<_Bound_args>()
+        (std::get<_Indexes>(_M_bound_args), __args)...);
+ }
+
+
+      template<typename _Res, typename... _Args, std::size_t... _Indexes>
+
+ _Res
+ __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) const
+ {
+   return std::__invoke_r<_Res>(_M_f, _Mu<_Bound_args>()
+        (std::get<_Indexes>(_M_bound_args), __args)...);
+ }
+
+
+      template<typename _Res, typename... _Args, std::size_t... _Indexes>
+
+ _Res
+ __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) volatile
+ {
+   return std::__invoke_r<_Res>(_M_f, _Mu<_Bound_args>()
+        (__volget<_Indexes>(_M_bound_args), __args)...);
+ }
+
+
+      template<typename _Res, typename... _Args, std::size_t... _Indexes>
+
+ _Res
+ __call(tuple<_Args...>&& __args,
+        _Index_tuple<_Indexes...>) const volatile
+ {
+   return std::__invoke_r<_Res>(_M_f, _Mu<_Bound_args>()
+        (__volget<_Indexes>(_M_bound_args), __args)...);
+ }
+
+    public:
+      typedef _Result result_type;
+
+      template<typename... _Args>
+ explicit
+ _Bind_result(const _Functor& __f, _Args&&... __args)
+ : _M_f(__f), _M_bound_args(std::forward<_Args>(__args)...)
+ { }
+
+      template<typename... _Args>
+ explicit
+ _Bind_result(_Functor&& __f, _Args&&... __args)
+ : _M_f(std::move(__f)), _M_bound_args(std::forward<_Args>(__args)...)
+ { }
+
+      _Bind_result(const _Bind_result&) = default;
+      _Bind_result(_Bind_result&&) = default;
+
+
+      template<typename... _Args>
+
+ result_type
+ operator()(_Args&&... __args)
+ {
+   return this->__call<_Result>(
+       std::forward_as_tuple(std::forward<_Args>(__args)...),
+       _Bound_indexes());
+ }
+
+
+      template<typename... _Args>
+
+ result_type
+ operator()(_Args&&... __args) const
+ {
+   return this->__call<_Result>(
+       std::forward_as_tuple(std::forward<_Args>(__args)...),
+       _Bound_indexes());
+ }
+
+
+      template<typename... _Args>
+ [[deprecated("std::bind does not support volatile in C++17")]]
+ result_type
+ operator()(_Args&&... __args) volatile
+ {
+   return this->__call<_Result>(
+       std::forward_as_tuple(std::forward<_Args>(__args)...),
+       _Bound_indexes());
+ }
+
+
+      template<typename... _Args>
+ [[deprecated("std::bind does not support volatile in C++17")]]
+ result_type
+ operator()(_Args&&... __args) const volatile
+ {
+   return this->__call<_Result>(
+       std::forward_as_tuple(std::forward<_Args>(__args)...),
+       _Bound_indexes());
+ }
+    };
+#undef _GLIBCXX_DEPR_BIND
+
+
+
+
+
+  template<typename _Signature>
+    struct is_bind_expression<_Bind<_Signature> >
+    : public true_type { };
+
+
+
+
+
+  template<typename _Signature>
+    struct is_bind_expression<const _Bind<_Signature> >
+    : public true_type { };
+
+
+
+
+
+  template<typename _Signature>
+    struct is_bind_expression<volatile _Bind<_Signature> >
+    : public true_type { };
+
+
+
+
+
+  template<typename _Signature>
+    struct is_bind_expression<const volatile _Bind<_Signature>>
+    : public true_type { };
+
+
+
+
+
+  template<typename _Result, typename _Signature>
+    struct is_bind_expression<_Bind_result<_Result, _Signature>>
+    : public true_type { };
+
+
+
+
+
+  template<typename _Result, typename _Signature>
+    struct is_bind_expression<const _Bind_result<_Result, _Signature>>
+    : public true_type { };
+
+
+
+
+
+  template<typename _Result, typename _Signature>
+    struct is_bind_expression<volatile _Bind_result<_Result, _Signature>>
+    : public true_type { };
+
+
+
+
+
+  template<typename _Result, typename _Signature>
+    struct is_bind_expression<const volatile _Bind_result<_Result, _Signature>>
+    : public true_type { };
+
+  template<typename _Func, typename... _BoundArgs>
+    struct _Bind_check_arity { };
+
+  template<typename _Ret, typename... _Args, typename... _BoundArgs>
+    struct _Bind_check_arity<_Ret (*)(_Args...), _BoundArgs...>
+    {
+      static_assert(sizeof...(_BoundArgs) == sizeof...(_Args),
+                   "Wrong number of arguments for function");
+    };
+
+  template<typename _Ret, typename... _Args, typename... _BoundArgs>
+    struct _Bind_check_arity<_Ret (*)(_Args......), _BoundArgs...>
+    {
+      static_assert(sizeof...(_BoundArgs) >= sizeof...(_Args),
+                   "Wrong number of arguments for function");
+    };
+
+  template<typename _Tp, typename _Class, typename... _BoundArgs>
+    struct _Bind_check_arity<_Tp _Class::*, _BoundArgs...>
+    {
+      using _Arity = typename _Mem_fn<_Tp _Class::*>::_Arity;
+      using _Varargs = typename _Mem_fn<_Tp _Class::*>::_Varargs;
+      static_assert(_Varargs::value
+      ? sizeof...(_BoundArgs) >= _Arity::value + 1
+      : sizeof...(_BoundArgs) == _Arity::value + 1,
+      "Wrong number of arguments for pointer-to-member");
+    };
+
+
+
+
+  template<typename _Tp, typename _Tp2 = typename decay<_Tp>::type>
+    using __is_socketlike = __or_<is_integral<_Tp2>, is_enum<_Tp2>>;
+
+  template<bool _SocketLike, typename _Func, typename... _BoundArgs>
+    struct _Bind_helper
+    : _Bind_check_arity<typename decay<_Func>::type, _BoundArgs...>
+    {
+      typedef typename decay<_Func>::type __func_type;
+      typedef _Bind<__func_type(typename decay<_BoundArgs>::type...)> type;
+    };
+
+
+
+
+  template<typename _Func, typename... _BoundArgs>
+    struct _Bind_helper<true, _Func, _BoundArgs...>
+    { };
+
+
+
+
+
+  template<typename _Func, typename... _BoundArgs>
+    inline typename
+    _Bind_helper<__is_socketlike<_Func>::value, _Func, _BoundArgs...>::type
+    bind(_Func&& __f, _BoundArgs&&... __args)
+    {
+      typedef _Bind_helper<false, _Func, _BoundArgs...> __helper_type;
+      return typename __helper_type::type(std::forward<_Func>(__f),
+       std::forward<_BoundArgs>(__args)...);
+    }
+
+  template<typename _Result, typename _Func, typename... _BoundArgs>
+    struct _Bindres_helper
+    : _Bind_check_arity<typename decay<_Func>::type, _BoundArgs...>
+    {
+      typedef typename decay<_Func>::type __functor_type;
+      typedef _Bind_result<_Result,
+      __functor_type(typename decay<_BoundArgs>::type...)>
+ type;
+    };
+
+
+
+
+
+  template<typename _Result, typename _Func, typename... _BoundArgs>
+    inline
+    typename _Bindres_helper<_Result, _Func, _BoundArgs...>::type
+    bind(_Func&& __f, _BoundArgs&&... __args)
+    {
+      typedef _Bindres_helper<_Result, _Func, _BoundArgs...> __helper_type;
+      return typename __helper_type::type(std::forward<_Func>(__f),
+       std::forward<_BoundArgs>(__args)...);
+    }
+# 918 "/usr/include/c++/10.2.0/functional" 3
+  template<typename _Fn>
+    class _Not_fn
+    {
+      template<typename _Fn2, typename... _Args>
+ using __inv_res_t = typename __invoke_result<_Fn2, _Args...>::type;
+
+      template<typename _Tp>
+ static decltype(!std::declval<_Tp>())
+ _S_not() noexcept(noexcept(!std::declval<_Tp>()));
+
+    public:
+      template<typename _Fn2>
+ constexpr
+ _Not_fn(_Fn2&& __fn, int)
+ : _M_fn(std::forward<_Fn2>(__fn)) { }
+
+      _Not_fn(const _Not_fn& __fn) = default;
+      _Not_fn(_Not_fn&& __fn) = default;
+      ~_Not_fn() = default;
+
+
+
+
+#define _GLIBCXX_NOT_FN_CALL_OP(_QUALS) template<typename... _Args> _GLIBCXX20_CONSTEXPR decltype(_S_not<__inv_res_t<_Fn _QUALS, _Args...>>()) operator()(_Args&&... __args) _QUALS noexcept(__is_nothrow_invocable<_Fn _QUALS, _Args...>::value && noexcept(_S_not<__inv_res_t<_Fn _QUALS, _Args...>>())) { return !std::__invoke(std::forward< _Fn _QUALS >(_M_fn), std::forward<_Args>(__args)...); }
+# 952 "/usr/include/c++/10.2.0/functional" 3
+      template<typename... _Args> decltype(_S_not<__inv_res_t<_Fn &, _Args...>>()) operator()(_Args&&... __args) & noexcept(__is_nothrow_invocable<_Fn &, _Args...>::value && noexcept(_S_not<__inv_res_t<_Fn &, _Args...>>())) { return !std::__invoke(std::forward< _Fn & >(_M_fn), std::forward<_Args>(__args)...); }
+      template<typename... _Args> decltype(_S_not<__inv_res_t<_Fn const &, _Args...>>()) operator()(_Args&&... __args) const & noexcept(__is_nothrow_invocable<_Fn const &, _Args...>::value && noexcept(_S_not<__inv_res_t<_Fn const &, _Args...>>())) { return !std::__invoke(std::forward< _Fn const & >(_M_fn), std::forward<_Args>(__args)...); }
+      template<typename... _Args> decltype(_S_not<__inv_res_t<_Fn &&, _Args...>>()) operator()(_Args&&... __args) && noexcept(__is_nothrow_invocable<_Fn &&, _Args...>::value && noexcept(_S_not<__inv_res_t<_Fn &&, _Args...>>())) { return !std::__invoke(std::forward< _Fn && >(_M_fn), std::forward<_Args>(__args)...); }
+      template<typename... _Args> decltype(_S_not<__inv_res_t<_Fn const &&, _Args...>>()) operator()(_Args&&... __args) const && noexcept(__is_nothrow_invocable<_Fn const &&, _Args...>::value && noexcept(_S_not<__inv_res_t<_Fn const &&, _Args...>>())) { return !std::__invoke(std::forward< _Fn const && >(_M_fn), std::forward<_Args>(__args)...); }
+#undef _GLIBCXX_NOT_FN_CALL_OP
+
+    private:
+      _Fn _M_fn;
+    };
+
+  template<typename _Tp, typename _Pred>
+    struct __is_byte_like : false_type { };
+
+  template<typename _Tp>
+    struct __is_byte_like<_Tp, equal_to<_Tp>>
+    : __bool_constant<sizeof(_Tp) == 1 && is_integral<_Tp>::value> { };
+
+  template<typename _Tp>
+    struct __is_byte_like<_Tp, equal_to<void>>
+    : __bool_constant<sizeof(_Tp) == 1 && is_integral<_Tp>::value> { };
+
+
+
+  enum class byte : unsigned char;
+
+  template<>
+    struct __is_byte_like<byte, equal_to<byte>>
+    : true_type { };
+
+  template<>
+    struct __is_byte_like<byte, equal_to<void>>
+    : true_type { };
+
+#define __cpp_lib_not_fn 201603
+
+  template<typename _Fn>
+   
+    inline auto
+    not_fn(_Fn&& __fn)
+    noexcept(std::is_nothrow_constructible<std::decay_t<_Fn>, _Fn&&>::value)
+    {
+      return _Not_fn<std::decay_t<_Fn>>{std::forward<_Fn>(__fn), 0};
+    }
+
+
+#define __cpp_lib_boyer_moore_searcher 201603
+
+  template<typename _ForwardIterator1, typename _BinaryPredicate = equal_to<>>
+    class default_searcher
+    {
+    public:
+     
+      default_searcher(_ForwardIterator1 __pat_first,
+         _ForwardIterator1 __pat_last,
+         _BinaryPredicate __pred = _BinaryPredicate())
+      : _M_m(__pat_first, __pat_last, std::move(__pred))
+      { }
+
+      template<typename _ForwardIterator2>
+
+ pair<_ForwardIterator2, _ForwardIterator2>
+ operator()(_ForwardIterator2 __first, _ForwardIterator2 __last) const
+ {
+   _ForwardIterator2 __first_ret =
+     std::search(__first, __last, std::get<0>(_M_m), std::get<1>(_M_m),
+   std::get<2>(_M_m));
+   auto __ret = std::make_pair(__first_ret, __first_ret);
+   if (__ret.first != __last)
+     std::advance(__ret.second, std::distance(std::get<0>(_M_m),
+           std::get<1>(_M_m)));
+   return __ret;
+ }
+
+    private:
+      tuple<_ForwardIterator1, _ForwardIterator1, _BinaryPredicate> _M_m;
+    };
+
+  template<typename _Key, typename _Tp, typename _Hash, typename _Pred>
+    struct __boyer_moore_map_base
+    {
+      template<typename _RAIter>
+ __boyer_moore_map_base(_RAIter __pat, size_t __patlen,
+          _Hash&& __hf, _Pred&& __pred)
+ : _M_bad_char{ __patlen, std::move(__hf), std::move(__pred) }
+ {
+   if (__patlen > 0)
+     for (__diff_type __i = 0; __i < __patlen - 1; ++__i)
+       _M_bad_char[__pat[__i]] = __patlen - 1 - __i;
+ }
+
+      using __diff_type = _Tp;
+
+      __diff_type
+      _M_lookup(_Key __key, __diff_type __not_found) const
+      {
+ auto __iter = _M_bad_char.find(__key);
+ if (__iter == _M_bad_char.end())
+   return __not_found;
+ return __iter->second;
+      }
+
+      _Pred
+      _M_pred() const { return _M_bad_char.key_eq(); }
+
+      std::unordered_map<_Key, _Tp, _Hash, _Pred> _M_bad_char;
+    };
+
+  template<typename _Tp, size_t _Len, typename _Pred>
+    struct __boyer_moore_array_base
+    {
+      template<typename _RAIter, typename _Unused>
+ __boyer_moore_array_base(_RAIter __pat, size_t __patlen,
+     _Unused&&, _Pred&& __pred)
+ : _M_bad_char{ std::array<_Tp, _Len>{}, std::move(__pred) }
+ {
+   std::get<0>(_M_bad_char).fill(__patlen);
+   if (__patlen > 0)
+     for (__diff_type __i = 0; __i < __patlen - 1; ++__i)
+       {
+  auto __ch = __pat[__i];
+  using _UCh = make_unsigned_t<decltype(__ch)>;
+  auto __uch = static_cast<_UCh>(__ch);
+  std::get<0>(_M_bad_char)[__uch] = __patlen - 1 - __i;
+       }
+ }
+
+      using __diff_type = _Tp;
+
+      template<typename _Key>
+ __diff_type
+ _M_lookup(_Key __key, __diff_type __not_found) const
+ {
+   auto __ukey = static_cast<make_unsigned_t<_Key>>(__key);
+   if (__ukey >= _Len)
+     return __not_found;
+   return std::get<0>(_M_bad_char)[__ukey];
+ }
+
+      const _Pred&
+      _M_pred() const { return std::get<1>(_M_bad_char); }
+
+      tuple<std::array<_Tp, _Len>, _Pred> _M_bad_char;
+    };
+
+
+
+  template<typename _RAIter, typename _Hash, typename _Pred,
+           typename _Val = typename iterator_traits<_RAIter>::value_type,
+    typename _Diff = typename iterator_traits<_RAIter>::difference_type>
+    using __boyer_moore_base_t
+      = conditional_t<__is_byte_like<_Val, _Pred>::value,
+        __boyer_moore_array_base<_Diff, 256, _Pred>,
+        __boyer_moore_map_base<_Val, _Diff, _Hash, _Pred>>;
+
+  template<typename _RAIter, typename _Hash
+      = hash<typename iterator_traits<_RAIter>::value_type>,
+    typename _BinaryPredicate = equal_to<>>
+    class boyer_moore_searcher
+    : __boyer_moore_base_t<_RAIter, _Hash, _BinaryPredicate>
+    {
+      using _Base = __boyer_moore_base_t<_RAIter, _Hash, _BinaryPredicate>;
+      using typename _Base::__diff_type;
+
+    public:
+      boyer_moore_searcher(_RAIter __pat_first, _RAIter __pat_last,
+      _Hash __hf = _Hash(),
+      _BinaryPredicate __pred = _BinaryPredicate());
+
+      template<typename _RandomAccessIterator2>
+        pair<_RandomAccessIterator2, _RandomAccessIterator2>
+ operator()(_RandomAccessIterator2 __first,
+     _RandomAccessIterator2 __last) const;
+
+    private:
+      bool
+      _M_is_prefix(_RAIter __word, __diff_type __len,
+     __diff_type __pos)
+      {
+ const auto& __pred = this->_M_pred();
+ __diff_type __suffixlen = __len - __pos;
+ for (__diff_type __i = 0; __i < __suffixlen; ++__i)
+   if (!__pred(__word[__i], __word[__pos + __i]))
+     return false;
+ return true;
+      }
+
+      __diff_type
+      _M_suffix_length(_RAIter __word, __diff_type __len,
+         __diff_type __pos)
+      {
+ const auto& __pred = this->_M_pred();
+ __diff_type __i = 0;
+ while (__pred(__word[__pos - __i], __word[__len - 1 - __i])
+        && __i < __pos)
+   {
+     ++__i;
+   }
+ return __i;
+      }
+
+      template<typename _Tp>
+ __diff_type
+ _M_bad_char_shift(_Tp __c) const
+ { return this->_M_lookup(__c, _M_pat_end - _M_pat); }
+
+      _RAIter _M_pat;
+      _RAIter _M_pat_end;
+      std::vector<__diff_type> _M_good_suffix;
+    };
+
+  template<typename _RAIter, typename _Hash
+      = hash<typename iterator_traits<_RAIter>::value_type>,
+    typename _BinaryPredicate = equal_to<>>
+    class boyer_moore_horspool_searcher
+    : __boyer_moore_base_t<_RAIter, _Hash, _BinaryPredicate>
+    {
+      using _Base = __boyer_moore_base_t<_RAIter, _Hash, _BinaryPredicate>;
+      using typename _Base::__diff_type;
+
+    public:
+      boyer_moore_horspool_searcher(_RAIter __pat,
+        _RAIter __pat_end,
+        _Hash __hf = _Hash(),
+        _BinaryPredicate __pred
+        = _BinaryPredicate())
+      : _Base(__pat, __pat_end - __pat, std::move(__hf), std::move(__pred)),
+ _M_pat(__pat), _M_pat_end(__pat_end)
+      { }
+
+      template<typename _RandomAccessIterator2>
+        pair<_RandomAccessIterator2, _RandomAccessIterator2>
+ operator()(_RandomAccessIterator2 __first,
+     _RandomAccessIterator2 __last) const
+ {
+   const auto& __pred = this->_M_pred();
+   auto __patlen = _M_pat_end - _M_pat;
+   if (__patlen == 0)
+     return std::make_pair(__first, __first);
+   auto __len = __last - __first;
+   while (__len >= __patlen)
+     {
+       for (auto __scan = __patlen - 1;
+     __pred(__first[__scan], _M_pat[__scan]); --__scan)
+  if (__scan == 0)
+    return std::make_pair(__first, __first + __patlen);
+       auto __shift = _M_bad_char_shift(__first[__patlen - 1]);
+       __len -= __shift;
+       __first += __shift;
+     }
+   return std::make_pair(__last, __last);
+ }
+
+    private:
+      template<typename _Tp>
+ __diff_type
+ _M_bad_char_shift(_Tp __c) const
+ { return this->_M_lookup(__c, _M_pat_end - _M_pat); }
+
+      _RAIter _M_pat;
+      _RAIter _M_pat_end;
+    };
+
+  template<typename _RAIter, typename _Hash, typename _BinaryPredicate>
+    boyer_moore_searcher<_RAIter, _Hash, _BinaryPredicate>::
+    boyer_moore_searcher(_RAIter __pat, _RAIter __pat_end,
+    _Hash __hf, _BinaryPredicate __pred)
+    : _Base(__pat, __pat_end - __pat, std::move(__hf), std::move(__pred)),
+      _M_pat(__pat), _M_pat_end(__pat_end), _M_good_suffix(__pat_end - __pat)
+    {
+      auto __patlen = __pat_end - __pat;
+      if (__patlen == 0)
+ return;
+      __diff_type __last_prefix = __patlen - 1;
+      for (__diff_type __p = __patlen - 1; __p >= 0; --__p)
+ {
+   if (_M_is_prefix(__pat, __patlen, __p + 1))
+     __last_prefix = __p + 1;
+   _M_good_suffix[__p] = __last_prefix + (__patlen - 1 - __p);
+ }
+      for (__diff_type __p = 0; __p < __patlen - 1; ++__p)
+ {
+   auto __slen = _M_suffix_length(__pat, __patlen, __p);
+   auto __pos = __patlen - 1 - __slen;
+   if (!__pred(__pat[__p - __slen], __pat[__pos]))
+     _M_good_suffix[__pos] = __patlen - 1 - __p + __slen;
+ }
+    }
+
+  template<typename _RAIter, typename _Hash, typename _BinaryPredicate>
+  template<typename _RandomAccessIterator2>
+    pair<_RandomAccessIterator2, _RandomAccessIterator2>
+    boyer_moore_searcher<_RAIter, _Hash, _BinaryPredicate>::
+    operator()(_RandomAccessIterator2 __first,
+        _RandomAccessIterator2 __last) const
+    {
+      auto __patlen = _M_pat_end - _M_pat;
+      if (__patlen == 0)
+ return std::make_pair(__first, __first);
+      const auto& __pred = this->_M_pred();
+      __diff_type __i = __patlen - 1;
+      auto __stringlen = __last - __first;
+      while (__i < __stringlen)
+ {
+   __diff_type __j = __patlen - 1;
+   while (__j >= 0 && __pred(__first[__i], _M_pat[__j]))
+     {
+       --__i;
+       --__j;
+     }
+   if (__j < 0)
+     {
+       const auto __match = __first + __i + 1;
+       return std::make_pair(__match, __match + __patlen);
+     }
+   __i += std::max(_M_bad_char_shift(__first[__i]),
+     _M_good_suffix[__j]);
+ }
+      return std::make_pair(__last, __last);
+    }
+
+
+
+
+
+}
+# 40 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 2 3 4
+# 48 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+
+namespace boost
+{
+
+namespace movelib
+{
+
+template< class T, class D > class unique_ptr;
+
+}
+
+namespace detail
+{
+# 72 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 3 4
+struct sp_nothrow_tag {};
+
+template< class D > struct sp_inplace_tag
+{
+};
+
+template< class T > class sp_reference_wrapper
+{
+public:
+
+    explicit sp_reference_wrapper( T & t): t_( boost::addressof( t ) )
+    {
+    }
+
+    template< class Y > void operator()( Y * p ) const
+    {
+        (*t_)( p );
+    }
+
+private:
+
+    T * t_;
+};
+
+template< class D > struct sp_convert_reference
+{
+    typedef D type;
+};
+
+template< class D > struct sp_convert_reference< D& >
+{
+    typedef sp_reference_wrapper< D > type;
+};
+
+class weak_count;
+
+class shared_count
+{
+private:
+
+    sp_counted_base * pi_;
+
+
+
+
+
+    friend class weak_count;
+
+public:
+
+    constexpr shared_count() noexcept: pi_(0)
+
+
+
+    {
+    }
+
+    constexpr explicit shared_count( sp_counted_base * pi ) noexcept: pi_( pi )
+
+
+
+    {
+    }
+
+    template<class Y> explicit shared_count( Y * p ): pi_( 0 )
+
+
+
+    {
+
+
+        try
+        {
+            pi_ = new sp_counted_impl_p<Y>( p );
+        }
+        catch(...)
+        {
+            boost::checked_delete( p );
+            throw;
+        }
+# 164 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 3 4
+    }
+
+
+
+
+    template<class P, class D> shared_count( P p, D d ): pi_(0)
+
+
+
+
+    {
+
+
+
+
+
+        try
+        {
+            pi_ = new sp_counted_impl_pd<P, D>(p, d);
+        }
+        catch(...)
+        {
+            d(p);
+            throw;
+        }
+# 201 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 3 4
+    }
+
+
+
+    template< class P, class D > shared_count( P p, sp_inplace_tag<D> ): pi_( 0 )
+
+
+
+    {
+
+
+        try
+        {
+            pi_ = new sp_counted_impl_pd< P, D >( p );
+        }
+        catch( ... )
+        {
+            D::operator_fn( p );
+            throw;
+        }
+# 233 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 3 4
+    }
+
+
+
+    template<class P, class D, class A> shared_count( P p, D d, A a ): pi_( 0 )
+
+
+
+    {
+        typedef sp_counted_impl_pda<P, D, A> impl_type;
+
+
+
+        typedef typename std::allocator_traits<A>::template rebind_alloc< impl_type > A2;
+
+
+
+
+
+
+
+        A2 a2( a );
+
+
+
+        try
+        {
+            pi_ = a2.allocate( 1 );
+            ::new( static_cast< void* >( pi_ ) ) impl_type( p, d, a );
+        }
+        catch(...)
+        {
+            d( p );
+
+            if( pi_ != 0 )
+            {
+                a2.deallocate( static_cast< impl_type* >( pi_ ), 1 );
+            }
+
+            throw;
+        }
+# 290 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 3 4
+    }
+
+
+
+    template< class P, class D, class A > shared_count( P p, sp_inplace_tag< D >, A a ): pi_( 0 )
+
+
+
+    {
+        typedef sp_counted_impl_pda< P, D, A > impl_type;
+
+
+
+        typedef typename std::allocator_traits<A>::template rebind_alloc< impl_type > A2;
+
+
+
+
+
+
+
+        A2 a2( a );
+
+
+
+        try
+        {
+            pi_ = a2.allocate( 1 );
+            ::new( static_cast< void* >( pi_ ) ) impl_type( p, a );
+        }
+        catch(...)
+        {
+            D::operator_fn( p );
+
+            if( pi_ != 0 )
+            {
+                a2.deallocate( static_cast< impl_type* >( pi_ ), 1 );
+            }
+
+            throw;
+        }
+# 347 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 3 4
+    }
+
+
+
+
+
+
+
+    template<class Y>
+    explicit shared_count( std::auto_ptr<Y> & r ): pi_( new sp_counted_impl_p<Y>( r.get() ) )
+
+
+
+    {
+# 370 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 3 4
+        r.release();
+    }
+
+
+
+
+
+    template<class Y, class D>
+    explicit shared_count( std::unique_ptr<Y, D> & r ): pi_( 0 )
+
+
+
+    {
+        typedef typename sp_convert_reference<D>::type D2;
+
+        D2 d2( r.get_deleter() );
+        pi_ = new sp_counted_impl_pd< typename std::unique_ptr<Y, D>::pointer, D2 >( r.get(), d2 );
+# 397 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 3 4
+        r.release();
+    }
+
+
+
+    template<class Y, class D>
+    explicit shared_count( boost::movelib::unique_ptr<Y, D> & r ): pi_( 0 )
+
+
+
+    {
+        typedef typename sp_convert_reference<D>::type D2;
+
+        D2 d2( r.get_deleter() );
+        pi_ = new sp_counted_impl_pd< typename boost::movelib::unique_ptr<Y, D>::pointer, D2 >( r.get(), d2 );
+# 422 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 3 4
+        r.release();
+    }
+
+    ~shared_count()
+    {
+        if( pi_ != 0 ) pi_->release();
+
+
+
+    }
+
+    shared_count(shared_count const & r) noexcept: pi_(r.pi_)
+
+
+
+    {
+        if( pi_ != 0 ) pi_->add_ref_copy();
+    }
+
+
+
+    shared_count(shared_count && r) noexcept: pi_(r.pi_)
+
+
+
+    {
+        r.pi_ = 0;
+    }
+
+
+
+    explicit shared_count(weak_count const & r);
+    shared_count( weak_count const & r, sp_nothrow_tag ) noexcept;
+
+    shared_count & operator= (shared_count const & r) noexcept
+    {
+        sp_counted_base * tmp = r.pi_;
+
+        if( tmp != pi_ )
+        {
+            if( tmp != 0 ) tmp->add_ref_copy();
+            if( pi_ != 0 ) pi_->release();
+            pi_ = tmp;
+        }
+
+        return *this;
+    }
+
+    void swap(shared_count & r) noexcept
+    {
+        sp_counted_base * tmp = r.pi_;
+        r.pi_ = pi_;
+        pi_ = tmp;
+    }
+
+    long use_count() const noexcept
+    {
+        return pi_ != 0? pi_->use_count(): 0;
+    }
+
+    bool unique() const noexcept
+    {
+        return use_count() == 1;
+    }
+
+    bool empty() const noexcept
+    {
+        return pi_ == 0;
+    }
+
+    friend inline bool operator==(shared_count const & a, shared_count const & b) noexcept
+    {
+        return a.pi_ == b.pi_;
+    }
+
+    friend inline bool operator<(shared_count const & a, shared_count const & b) noexcept
+    {
+        return std::less<sp_counted_base *>()( a.pi_, b.pi_ );
+    }
+
+    void * get_deleter( sp_typeinfo_ const & ti ) const noexcept
+    {
+        return pi_? pi_->get_deleter( ti ): 0;
+    }
+
+    void * get_local_deleter( sp_typeinfo_ const & ti ) const noexcept
+    {
+        return pi_? pi_->get_local_deleter( ti ): 0;
+    }
+
+    void * get_untyped_deleter() const noexcept
+    {
+        return pi_? pi_->get_untyped_deleter(): 0;
+    }
+};
+
+
+class weak_count
+{
+private:
+
+    sp_counted_base * pi_;
+
+
+
+
+
+    friend class shared_count;
+
+public:
+
+    constexpr weak_count() noexcept: pi_(0)
+
+
+
+    {
+    }
+
+    weak_count(shared_count const & r) noexcept: pi_(r.pi_)
+
+
+
+    {
+        if(pi_ != 0) pi_->weak_add_ref();
+    }
+
+    weak_count(weak_count const & r) noexcept: pi_(r.pi_)
+
+
+
+    {
+        if(pi_ != 0) pi_->weak_add_ref();
+    }
+
+
+
+
+
+    weak_count(weak_count && r) noexcept: pi_(r.pi_)
+
+
+
+    {
+        r.pi_ = 0;
+    }
+
+
+
+    ~weak_count()
+    {
+        if(pi_ != 0) pi_->weak_release();
+
+
+
+    }
+
+    weak_count & operator= (shared_count const & r) noexcept
+    {
+        sp_counted_base * tmp = r.pi_;
+
+        if( tmp != pi_ )
+        {
+            if(tmp != 0) tmp->weak_add_ref();
+            if(pi_ != 0) pi_->weak_release();
+            pi_ = tmp;
+        }
+
+        return *this;
+    }
+
+    weak_count & operator= (weak_count const & r) noexcept
+    {
+        sp_counted_base * tmp = r.pi_;
+
+        if( tmp != pi_ )
+        {
+            if(tmp != 0) tmp->weak_add_ref();
+            if(pi_ != 0) pi_->weak_release();
+            pi_ = tmp;
+        }
+
+        return *this;
+    }
+
+    void swap(weak_count & r) noexcept
+    {
+        sp_counted_base * tmp = r.pi_;
+        r.pi_ = pi_;
+        pi_ = tmp;
+    }
+
+    long use_count() const noexcept
+    {
+        return pi_ != 0? pi_->use_count(): 0;
+    }
+
+    bool empty() const noexcept
+    {
+        return pi_ == 0;
+    }
+
+    friend inline bool operator==(weak_count const & a, weak_count const & b) noexcept
+    {
+        return a.pi_ == b.pi_;
+    }
+
+    friend inline bool operator<(weak_count const & a, weak_count const & b) noexcept
+    {
+        return std::less<sp_counted_base *>()(a.pi_, b.pi_);
+    }
+};
+
+inline shared_count::shared_count( weak_count const & r ): pi_( r.pi_ )
+
+
+
+{
+    if( pi_ == 0 || !pi_->add_ref_lock() )
+    {
+        boost::throw_exception( boost::bad_weak_ptr() );
+    }
+}
+
+inline shared_count::shared_count( weak_count const & r, sp_nothrow_tag ) noexcept: pi_( r.pi_ )
+
+
+
+{
+    if( pi_ != 0 && !pi_->add_ref_lock() )
+    {
+        pi_ = 0;
+    }
+}
+
+}
+
+}
+
+
+#pragma GCC diagnostic pop
+# 29 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 2 3 4
+
+# 1 "/usr/include/boost/smart_ptr/detail/sp_convertible.hpp" 1 3 4
+
+#define BOOST_SMART_PTR_DETAIL_SP_CONVERTIBLE_HPP_INCLUDED 
+# 35 "/usr/include/boost/smart_ptr/detail/sp_convertible.hpp" 3 4
+namespace boost
+{
+
+namespace detail
+{
+
+template< class Y, class T > struct sp_convertible
+{
+    typedef char (&yes) [1];
+    typedef char (&no) [2];
+
+    static yes f( T* );
+    static no f( ... );
+
+    enum _vt { value = sizeof( (f)( static_cast<Y*>(0) ) ) == sizeof(yes) };
+};
+
+template< class Y, class T > struct sp_convertible< Y, T[] >
+{
+    enum _vt { value = false };
+};
+
+template< class Y, class T > struct sp_convertible< Y[], T[] >
+{
+    enum _vt { value = sp_convertible< Y[1], T[1] >::value };
+};
+
+template< class Y, std::size_t N, class T > struct sp_convertible< Y[N], T[] >
+{
+    enum _vt { value = sp_convertible< Y[1], T[1] >::value };
+};
+
+struct sp_empty
+{
+};
+
+template< bool > struct sp_enable_if_convertible_impl;
+
+template<> struct sp_enable_if_convertible_impl<true>
+{
+    typedef sp_empty type;
+};
+
+template<> struct sp_enable_if_convertible_impl<false>
+{
+};
+
+template< class Y, class T > struct sp_enable_if_convertible: public sp_enable_if_convertible_impl< sp_convertible< Y, T >::value >
+{
+};
+
+}
+
+}
+# 31 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 2 3 4
+# 1 "/usr/include/boost/smart_ptr/detail/sp_nullptr_t.hpp" 1 3 4
+
+#define BOOST_SMART_PTR_DETAIL_SP_NULLPTR_T_HPP_INCLUDED 
+# 23 "/usr/include/boost/smart_ptr/detail/sp_nullptr_t.hpp" 3 4
+namespace boost
+{
+
+namespace detail
+{
+
+
+
+
+
+
+
+    typedef std::nullptr_t sp_nullptr_t;
+
+
+
+}
+
+}
+# 32 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 2 3 4
+
+
+
+
+# 1 "/usr/include/boost/smart_ptr/detail/spinlock_pool.hpp" 1 3 4
+
+#define BOOST_SMART_PTR_DETAIL_SPINLOCK_POOL_HPP_INCLUDED 
+# 25 "/usr/include/boost/smart_ptr/detail/spinlock_pool.hpp" 3 4
+# 1 "/usr/include/boost/smart_ptr/detail/spinlock.hpp" 1 3 4
+
+#define BOOST_SMART_PTR_DETAIL_SPINLOCK_HPP_INCLUDED 
+# 47 "/usr/include/boost/smart_ptr/detail/spinlock.hpp" 3 4
+# 1 "/usr/include/boost/smart_ptr/detail/spinlock_std_atomic.hpp" 1 3 4
+
+#define BOOST_SMART_PTR_DETAIL_SPINLOCK_STD_ATOMIC_HPP_INCLUDED 
+# 18 "/usr/include/boost/smart_ptr/detail/spinlock_std_atomic.hpp" 3 4
+# 1 "/usr/include/boost/smart_ptr/detail/yield_k.hpp" 1 3 4
+
+#define BOOST_SMART_PTR_DETAIL_YIELD_K_HPP_INCLUDED 
+# 28 "/usr/include/boost/smart_ptr/detail/yield_k.hpp" 3 4
+# 1 "/usr/include/boost/predef/platform/windows_runtime.h" 1 3 4
+# 10 "/usr/include/boost/predef/platform/windows_runtime.h" 3 4
+#define BOOST_PREDEF_PLAT_WINDOWS_RUNTIME_H 
+
+# 1 "/usr/include/boost/predef/make.h" 1 3 4
+
+
+
+
+
+
+# 1 "/usr/include/boost/predef/detail/test.h" 1 3 4
+# 9 "/usr/include/boost/predef/detail/test.h" 3 4
+#define BOOST_PREDEF_DETAIL_TEST_H 
+
+
+
+#define BOOST_PREDEF_DECLARE_TEST(x,s) 
+# 8 "/usr/include/boost/predef/make.h" 2 3 4
+
+
+#define BOOST_PREDEF_MAKE_H 
+# 32 "/usr/include/boost/predef/make.h" 3 4
+#define BOOST_PREDEF_MAKE_0X_VRP(V) BOOST_VERSION_NUMBER((V&0xF00)>>8,(V&0xF0)>>4,(V&0xF))
+
+#define BOOST_PREDEF_MAKE_0X_VVRP(V) BOOST_VERSION_NUMBER((V&0xFF00)>>8,(V&0xF0)>>4,(V&0xF))
+
+#define BOOST_PREDEF_MAKE_0X_VRPP(V) BOOST_VERSION_NUMBER((V&0xF000)>>12,(V&0xF00)>>8,(V&0xFF))
+
+#define BOOST_PREDEF_MAKE_0X_VVRR(V) BOOST_VERSION_NUMBER((V&0xFF00)>>8,(V&0xFF),0)
+
+#define BOOST_PREDEF_MAKE_0X_VRRPPPP(V) BOOST_VERSION_NUMBER((V&0xF000000)>>24,(V&0xFF0000)>>16,(V&0xFFFF))
+
+#define BOOST_PREDEF_MAKE_0X_VVRRP(V) BOOST_VERSION_NUMBER((V&0xFF000)>>12,(V&0xFF0)>>4,(V&0xF))
+
+#define BOOST_PREDEF_MAKE_0X_VRRPP000(V) BOOST_VERSION_NUMBER((V&0xF0000000)>>28,(V&0xFF00000)>>20,(V&0xFF000)>>12)
+
+#define BOOST_PREDEF_MAKE_0X_VVRRPP(V) BOOST_VERSION_NUMBER((V&0xFF0000)>>16,(V&0xFF00)>>8,(V&0xFF))
+
+#define BOOST_PREDEF_MAKE_10_VPPP(V) BOOST_VERSION_NUMBER(((V)/1000)%10,0,(V)%1000)
+
+#define BOOST_PREDEF_MAKE_10_VR0(V) BOOST_VERSION_NUMBER(((V)/100)%10,((V)/10)%10,0)
+
+#define BOOST_PREDEF_MAKE_10_VRP(V) BOOST_VERSION_NUMBER(((V)/100)%10,((V)/10)%10,(V)%10)
+
+#define BOOST_PREDEF_MAKE_10_VRP000(V) BOOST_VERSION_NUMBER(((V)/100000)%10,((V)/10000)%10,((V)/1000)%10)
+
+#define BOOST_PREDEF_MAKE_10_VRPPPP(V) BOOST_VERSION_NUMBER(((V)/100000)%10,((V)/10000)%10,(V)%10000)
+
+#define BOOST_PREDEF_MAKE_10_VRPP(V) BOOST_VERSION_NUMBER(((V)/1000)%10,((V)/100)%10,(V)%100)
+
+#define BOOST_PREDEF_MAKE_10_VRR(V) BOOST_VERSION_NUMBER(((V)/100)%10,(V)%100,0)
+
+#define BOOST_PREDEF_MAKE_10_VRRPP(V) BOOST_VERSION_NUMBER(((V)/10000)%10,((V)/100)%100,(V)%100)
+
+#define BOOST_PREDEF_MAKE_10_VRR000(V) BOOST_VERSION_NUMBER(((V)/100000)%10,((V)/1000)%100,0)
+
+#define BOOST_PREDEF_MAKE_10_VV00(V) BOOST_VERSION_NUMBER(((V)/100)%100,0,0)
+
+#define BOOST_PREDEF_MAKE_10_VVRR(V) BOOST_VERSION_NUMBER(((V)/100)%100,(V)%100,0)
+
+#define BOOST_PREDEF_MAKE_10_VVRRP(V) BOOST_VERSION_NUMBER(((V)/1000)%100,((V)/10)%100,(V)%10)
+
+#define BOOST_PREDEF_MAKE_10_VVRRPP(V) BOOST_VERSION_NUMBER(((V)/10000)%100,((V)/100)%100,(V)%100)
+
+#define BOOST_PREDEF_MAKE_10_VVRRPPP(V) BOOST_VERSION_NUMBER(((V)/100000)%100,((V)/1000)%100,(V)%1000)
+
+#define BOOST_PREDEF_MAKE_10_VVRR0PP00(V) BOOST_VERSION_NUMBER(((V)/10000000)%100,((V)/100000)%100,((V)/100)%100)
+
+#define BOOST_PREDEF_MAKE_10_VVRR0PPPP(V) BOOST_VERSION_NUMBER(((V)/10000000)%100,((V)/100000)%100,(V)%10000)
+
+#define BOOST_PREDEF_MAKE_10_VVRR00PP00(V) BOOST_VERSION_NUMBER(((V)/100000000)%100,((V)/1000000)%100,((V)/100)%100)
+# 89 "/usr/include/boost/predef/make.h" 3 4
+#define BOOST_PREDEF_MAKE_DATE(Y,M,D) BOOST_VERSION_NUMBER((Y)%10000-1970,(M)%100,(D)%100)
+
+#define BOOST_PREDEF_MAKE_YYYYMMDD(V) BOOST_PREDEF_MAKE_DATE(((V)/10000)%10000,((V)/100)%100,(V)%100)
+
+#define BOOST_PREDEF_MAKE_YYYY(V) BOOST_PREDEF_MAKE_DATE(V,1,1)
+
+#define BOOST_PREDEF_MAKE_YYYYMM(V) BOOST_PREDEF_MAKE_DATE((V)/100,(V)%100,1)
+# 13 "/usr/include/boost/predef/platform/windows_runtime.h" 2 3 4
+# 1 "/usr/include/boost/predef/os/windows.h" 1 3 4
+# 9 "/usr/include/boost/predef/os/windows.h" 3 4
+#define BOOST_PREDEF_OS_WINDOWS_H 
+
+# 1 "/usr/include/boost/predef/version_number.h" 1 3 4
+# 9 "/usr/include/boost/predef/version_number.h" 3 4
+#define BOOST_PREDEF_VERSION_NUMBER_H 
+# 35 "/usr/include/boost/predef/version_number.h" 3 4
+#define BOOST_VERSION_NUMBER(major,minor,patch) ( (((major)%100)*10000000) + (((minor)%100)*100000) + ((patch)%100000) )
+
+
+#define BOOST_VERSION_NUMBER_MAX BOOST_VERSION_NUMBER(99,99,99999)
+
+
+#define BOOST_VERSION_NUMBER_ZERO BOOST_VERSION_NUMBER(0,0,0)
+
+
+#define BOOST_VERSION_NUMBER_MIN BOOST_VERSION_NUMBER(0,0,1)
+
+
+#define BOOST_VERSION_NUMBER_AVAILABLE BOOST_VERSION_NUMBER_MIN
+
+
+#define BOOST_VERSION_NUMBER_NOT_AVAILABLE BOOST_VERSION_NUMBER_ZERO
+# 63 "/usr/include/boost/predef/version_number.h" 3 4
+#define BOOST_VERSION_NUMBER_MAJOR(N) ( ((N)/10000000)%100 )
+
+
+#define BOOST_VERSION_NUMBER_MINOR(N) ( ((N)/100000)%100 )
+
+
+#define BOOST_VERSION_NUMBER_PATCH(N) ( (N)%100000 )
+# 12 "/usr/include/boost/predef/os/windows.h" 2 3 4
+# 1 "/usr/include/boost/predef/make.h" 1 3 4
+# 13 "/usr/include/boost/predef/os/windows.h" 2 3 4
+# 30 "/usr/include/boost/predef/os/windows.h" 3 4
+#define BOOST_OS_WINDOWS BOOST_VERSION_NUMBER_NOT_AVAILABLE
+# 46 "/usr/include/boost/predef/os/windows.h" 3 4
+#define BOOST_OS_WINDOWS_NAME "Microsoft Windows"
+
+
+
+
+
+# 14 "/usr/include/boost/predef/platform/windows_runtime.h" 2 3 4
+# 1 "/usr/include/boost/predef/platform/windows_phone.h" 1 3 4
+# 10 "/usr/include/boost/predef/platform/windows_phone.h" 3 4
+#define BOOST_PREDEF_PLAT_WINDOWS_PHONE_H 
+
+# 1 "/usr/include/boost/predef/make.h" 1 3 4
+# 13 "/usr/include/boost/predef/platform/windows_phone.h" 2 3 4
+# 1 "/usr/include/boost/predef/os/windows.h" 1 3 4
+# 51 "/usr/include/boost/predef/os/windows.h" 3 4
+
+# 14 "/usr/include/boost/predef/platform/windows_phone.h" 2 3 4
+# 1 "/usr/include/boost/predef/platform/windows_uwp.h" 1 3 4
+# 9 "/usr/include/boost/predef/platform/windows_uwp.h" 3 4
+#define BOOST_PREDEF_PLAT_WINDOWS_UWP_H 
+
+# 1 "/usr/include/boost/predef/make.h" 1 3 4
+# 12 "/usr/include/boost/predef/platform/windows_uwp.h" 2 3 4
+# 1 "/usr/include/boost/predef/os/windows.h" 1 3 4
+# 51 "/usr/include/boost/predef/os/windows.h" 3 4
+
+# 13 "/usr/include/boost/predef/platform/windows_uwp.h" 2 3 4
+# 30 "/usr/include/boost/predef/platform/windows_uwp.h" 3 4
+#define BOOST_PLAT_WINDOWS_UWP BOOST_VERSION_NUMBER_NOT_AVAILABLE
+#define BOOST_PLAT_WINDOWS_SDK_VERSION BOOST_VERSION_NUMBER_NOT_AVAILABLE
+# 55 "/usr/include/boost/predef/platform/windows_uwp.h" 3 4
+#define BOOST_PLAT_WINDOWS_UWP_NAME "Universal Windows Platform"
+
+
+
+
+
+# 15 "/usr/include/boost/predef/platform/windows_phone.h" 2 3 4
+# 30 "/usr/include/boost/predef/platform/windows_phone.h" 3 4
+#define BOOST_PLAT_WINDOWS_PHONE BOOST_VERSION_NUMBER_NOT_AVAILABLE
+# 43 "/usr/include/boost/predef/platform/windows_phone.h" 3 4
+#define BOOST_PLAT_WINDOWS_PHONE_NAME "Windows Phone"
+
+
+
+
+
+# 15 "/usr/include/boost/predef/platform/windows_runtime.h" 2 3 4
+# 1 "/usr/include/boost/predef/platform/windows_store.h" 1 3 4
+# 10 "/usr/include/boost/predef/platform/windows_store.h" 3 4
+#define BOOST_PREDEF_PLAT_WINDOWS_STORE_H 
+
+# 1 "/usr/include/boost/predef/make.h" 1 3 4
+# 13 "/usr/include/boost/predef/platform/windows_store.h" 2 3 4
+# 1 "/usr/include/boost/predef/os/windows.h" 1 3 4
+# 51 "/usr/include/boost/predef/os/windows.h" 3 4
+
+# 14 "/usr/include/boost/predef/platform/windows_store.h" 2 3 4
+# 1 "/usr/include/boost/predef/platform/windows_uwp.h" 1 3 4
+# 60 "/usr/include/boost/predef/platform/windows_uwp.h" 3 4
+
+# 15 "/usr/include/boost/predef/platform/windows_store.h" 2 3 4
+# 31 "/usr/include/boost/predef/platform/windows_store.h" 3 4
+#define BOOST_PLAT_WINDOWS_STORE BOOST_VERSION_NUMBER_NOT_AVAILABLE
+# 45 "/usr/include/boost/predef/platform/windows_store.h" 3 4
+#define BOOST_PLAT_WINDOWS_STORE_NAME "Windows Store"
+
+
+
+
+
+# 16 "/usr/include/boost/predef/platform/windows_runtime.h" 2 3 4
+# 35 "/usr/include/boost/predef/platform/windows_runtime.h" 3 4
+#define BOOST_PLAT_WINDOWS_RUNTIME BOOST_VERSION_NUMBER_NOT_AVAILABLE
+# 48 "/usr/include/boost/predef/platform/windows_runtime.h" 3 4
+#define BOOST_PLAT_WINDOWS_RUNTIME_NAME "Windows Runtime"
+
+
+
+
+
+# 29 "/usr/include/boost/smart_ptr/detail/yield_k.hpp" 2 3 4
+# 44 "/usr/include/boost/smart_ptr/detail/yield_k.hpp" 3 4
+#define BOOST_SMT_PAUSE __asm__ __volatile__( "rep; nop" : : : "memory" );
+# 125 "/usr/include/boost/smart_ptr/detail/yield_k.hpp" 3 4
+namespace boost
+{
+
+namespace detail
+{
+
+inline void yield( unsigned k )
+{
+    if( k < 4 )
+    {
+    }
+
+    else if( k < 16 )
+    {
+        __asm__ __volatile__( "rep; nop" : : : "memory" );
+    }
+
+    else if( k < 32 || k & 1 )
+    {
+        sched_yield();
+    }
+    else
+    {
+
+        struct timespec rqtp = { 0, 0 };
+
+
+
+
+        rqtp.tv_sec = 0;
+        rqtp.tv_nsec = 1000;
+
+        nanosleep( &rqtp, 0 );
+    }
+}
+
+}
+
+}
+# 19 "/usr/include/boost/smart_ptr/detail/spinlock_std_atomic.hpp" 2 3 4
+
+
+
+namespace boost
+{
+
+namespace detail
+{
+
+class spinlock
+{
+public:
+
+    std::atomic_flag v_;
+
+public:
+
+    bool try_lock() noexcept
+    {
+        return !v_.test_and_set( std::memory_order_acquire );
+    }
+
+    void lock() noexcept
+    {
+        for( unsigned k = 0; !try_lock(); ++k )
+        {
+            boost::detail::yield( k );
+        }
+    }
+
+    void unlock() noexcept
+    {
+        v_ .clear( std::memory_order_release );
+    }
+
+public:
+
+    class scoped_lock
+    {
+    private:
+
+        spinlock & sp_;
+
+        scoped_lock( scoped_lock const & );
+        scoped_lock & operator=( scoped_lock const & );
+
+    public:
+
+        explicit scoped_lock( spinlock & sp ) noexcept: sp_( sp )
+        {
+            sp.lock();
+        }
+
+        ~scoped_lock()
+        {
+            sp_.unlock();
+        }
+    };
+};
+
+}
+}
+
+#define BOOST_DETAIL_SPINLOCK_INIT { ATOMIC_FLAG_INIT }
+# 48 "/usr/include/boost/smart_ptr/detail/spinlock.hpp" 2 3 4
+# 26 "/usr/include/boost/smart_ptr/detail/spinlock_pool.hpp" 2 3 4
+
+
+namespace boost
+{
+
+namespace detail
+{
+
+template< int M > class spinlock_pool
+{
+private:
+
+    static spinlock pool_[ 41 ];
+
+public:
+
+    static spinlock & spinlock_for( void const * pv )
+    {
+
+
+
+        std::size_t i = reinterpret_cast< std::size_t >( pv ) % 41;
+
+        return pool_[ i ];
+    }
+
+    class scoped_lock
+    {
+    private:
+
+        spinlock & sp_;
+
+        scoped_lock( scoped_lock const & );
+        scoped_lock & operator=( scoped_lock const & );
+
+    public:
+
+        explicit scoped_lock( void const * pv ): sp_( spinlock_for( pv ) )
+        {
+            sp_.lock();
+        }
+
+        ~scoped_lock()
+        {
+            sp_.unlock();
+        }
+    };
+};
+
+template< int M > spinlock spinlock_pool< M >::pool_[ 41 ] =
+{
+    { { 0 } }, { { 0 } }, { { 0 } }, { { 0 } }, { { 0 } },
+    { { 0 } }, { { 0 } }, { { 0 } }, { { 0 } }, { { 0 } },
+    { { 0 } }, { { 0 } }, { { 0 } }, { { 0 } }, { { 0 } },
+    { { 0 } }, { { 0 } }, { { 0 } }, { { 0 } }, { { 0 } },
+    { { 0 } }, { { 0 } }, { { 0 } }, { { 0 } }, { { 0 } },
+    { { 0 } }, { { 0 } }, { { 0 } }, { { 0 } }, { { 0 } },
+    { { 0 } }, { { 0 } }, { { 0 } }, { { 0 } }, { { 0 } },
+    { { 0 } }, { { 0 } }, { { 0 } }, { { 0 } }, { { 0 } },
+    { { 0 } }
+};
+
+}
+}
+# 37 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 2 3 4
+
+
+# 1 "/usr/include/c++/10.2.0/algorithm" 1 3 4
+# 56 "/usr/include/c++/10.2.0/algorithm" 3 4
+#define _GLIBCXX_ALGORITHM 1
+
+       
+# 59 "/usr/include/c++/10.2.0/algorithm" 3
+# 74 "/usr/include/c++/10.2.0/algorithm" 3
+# 1 "/usr/include/c++/10.2.0/pstl/glue_algorithm_defs.h" 1 3
+# 11 "/usr/include/c++/10.2.0/pstl/glue_algorithm_defs.h" 3
+#define _PSTL_GLUE_ALGORITHM_DEFS_H 
+
+
+
+
+
+namespace std
+{
+
+
+
+template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
+any_of(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred);
+
+
+
+template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
+all_of(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred);
+
+
+
+template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
+none_of(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred);
+
+
+
+template <class _ExecutionPolicy, class _ForwardIterator, class _Function>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
+for_each(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Function __f);
+
+template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Function>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+for_each_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n, _Function __f);
+
+
+
+template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+find_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred);
+
+template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+find_if_not(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred);
+
+template <class _ExecutionPolicy, class _ForwardIterator, class _Tp>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+find(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value);
+
+
+
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1>
+find_end(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first,
+         _ForwardIterator2 __s_last, _BinaryPredicate __pred);
+
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1>
+find_end(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first,
+         _ForwardIterator2 __s_last);
+
+
+
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1>
+find_first_of(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
+              _ForwardIterator2 __s_first, _ForwardIterator2 __s_last, _BinaryPredicate __pred);
+
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1>
+find_first_of(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
+              _ForwardIterator2 __s_first, _ForwardIterator2 __s_last);
+
+
+
+template <class _ExecutionPolicy, class _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+adjacent_find(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last);
+
+template <class _ExecutionPolicy, class _ForwardIterator, class _BinaryPredicate>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+adjacent_find(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred);
+
+
+
+template <class _ExecutionPolicy, class _ForwardIterator, class _Tp>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy,
+                                                 typename iterator_traits<_ForwardIterator>::difference_type>
+count(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value);
+
+template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy,
+                                                 typename iterator_traits<_ForwardIterator>::difference_type>
+count_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred);
+
+
+
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1>
+search(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first,
+       _ForwardIterator2 __s_last, _BinaryPredicate __pred);
+
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1>
+search(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first,
+       _ForwardIterator2 __s_last);
+
+template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Tp, class _BinaryPredicate>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+search_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Size __count,
+         const _Tp& __value, _BinaryPredicate __pred);
+
+template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Tp>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+search_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Size __count,
+         const _Tp& __value);
+
+
+
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result);
+
+template <class _ExecutionPolicy, class _ForwardIterator1, class _Size, class _ForwardIterator2>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+copy_n(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _Size __n, _ForwardIterator2 __result);
+
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Predicate>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+copy_if(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 result,
+        _Predicate __pred);
+
+
+
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+swap_ranges(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
+            _ForwardIterator2 __first2);
+
+
+
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _UnaryOperation>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+transform(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result,
+          _UnaryOperation __op);
+
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator,
+          class _BinaryOperation>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+transform(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
+          _ForwardIterator __result, _BinaryOperation __op);
+
+
+
+template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _Tp>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
+replace_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred,
+           const _Tp& __new_value);
+
+template <class _ExecutionPolicy, class _ForwardIterator, class _Tp>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
+replace(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __old_value,
+        const _Tp& __new_value);
+
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _UnaryPredicate, class _Tp>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+replace_copy_if(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
+                _ForwardIterator2 __result, _UnaryPredicate __pred, const _Tp& __new_value);
+
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Tp>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+replace_copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result,
+             const _Tp& __old_value, const _Tp& __new_value);
+
+
+
+template <class _ExecutionPolicy, class _ForwardIterator, class _Tp>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
+fill(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value);
+
+template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Tp>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+fill_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __count, const _Tp& __value);
+
+
+template <class _ExecutionPolicy, class _ForwardIterator, class _Generator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
+generate(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Generator __g);
+
+template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Generator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+generate_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size count, _Generator __g);
+
+
+
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Predicate>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+remove_copy_if(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
+               _ForwardIterator2 __result, _Predicate __pred);
+
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Tp>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+remove_copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result,
+            const _Tp& __value);
+
+template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+remove_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred);
+
+template <class _ExecutionPolicy, class _ForwardIterator, class _Tp>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+remove(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value);
+
+
+
+template <class _ExecutionPolicy, class _ForwardIterator, class _BinaryPredicate>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+unique(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred);
+
+template <class _ExecutionPolicy, class _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+unique(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last);
+
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+unique_copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result,
+            _BinaryPredicate __pred);
+
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+unique_copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result);
+
+
+
+template <class _ExecutionPolicy, class _BidirectionalIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
+reverse(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last);
+
+template <class _ExecutionPolicy, class _BidirectionalIterator, class _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+reverse_copy(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last,
+             _ForwardIterator __d_first);
+
+
+
+template <class _ExecutionPolicy, class _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+rotate(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last);
+
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+rotate_copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __middle, _ForwardIterator1 __last,
+            _ForwardIterator2 __result);
+
+
+
+template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
+is_partitioned(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred);
+
+template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+partition(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred);
+
+template <class _ExecutionPolicy, class _BidirectionalIterator, class _UnaryPredicate>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _BidirectionalIterator>
+stable_partition(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last,
+                 _UnaryPredicate __pred);
+
+template <class _ExecutionPolicy, class _ForwardIterator, class _ForwardIterator1, class _ForwardIterator2,
+          class _UnaryPredicate>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>>
+partition_copy(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last,
+               _ForwardIterator1 __out_true, _ForwardIterator2 __out_false, _UnaryPredicate __pred);
+
+
+
+template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
+sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp);
+
+template <class _ExecutionPolicy, class _RandomAccessIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
+sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last);
+
+
+
+template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
+stable_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp);
+
+template <class _ExecutionPolicy, class _RandomAccessIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
+stable_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last);
+
+
+
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>>
+mismatch(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
+         _ForwardIterator2 __last2, _BinaryPredicate __pred);
+
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>>
+mismatch(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
+         _BinaryPredicate __pred);
+
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>>
+mismatch(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
+         _ForwardIterator2 __last2);
+
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>>
+mismatch(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2);
+
+
+
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
+equal(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
+      _BinaryPredicate __p);
+
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
+equal(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2);
+
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
+equal(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
+      _ForwardIterator2 __last2, _BinaryPredicate __p);
+
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
+equal(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
+      _ForwardIterator2 __last2);
+
+
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+move(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __d_first);
+
+
+
+template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
+partial_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __middle,
+             _RandomAccessIterator __last, _Compare __comp);
+
+template <class _ExecutionPolicy, class _RandomAccessIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
+partial_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __middle,
+             _RandomAccessIterator __last);
+
+
+
+template <class _ExecutionPolicy, class _ForwardIterator, class _RandomAccessIterator, class _Compare>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _RandomAccessIterator>
+partial_sort_copy(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last,
+                  _RandomAccessIterator __d_first, _RandomAccessIterator __d_last, _Compare __comp);
+
+template <class _ExecutionPolicy, class _ForwardIterator, class _RandomAccessIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _RandomAccessIterator>
+partial_sort_copy(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last,
+                  _RandomAccessIterator __d_first, _RandomAccessIterator __d_last);
+
+
+template <class _ExecutionPolicy, class _ForwardIterator, class _Compare>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+is_sorted_until(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp);
+
+template <class _ExecutionPolicy, class _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+is_sorted_until(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last);
+
+template <class _ExecutionPolicy, class _ForwardIterator, class _Compare>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
+is_sorted(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp);
+
+template <class _ExecutionPolicy, class _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
+is_sorted(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last);
+
+
+
+template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
+nth_element(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __nth,
+            _RandomAccessIterator __last, _Compare __comp);
+
+template <class _ExecutionPolicy, class _RandomAccessIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
+nth_element(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __nth,
+            _RandomAccessIterator __last);
+
+
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator,
+          class _Compare>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+merge(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
+      _ForwardIterator2 __last2, _ForwardIterator __d_first, _Compare __comp);
+
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+merge(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
+      _ForwardIterator2 __last2, _ForwardIterator __d_first);
+
+template <class _ExecutionPolicy, class _BidirectionalIterator, class _Compare>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
+inplace_merge(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __middle,
+              _BidirectionalIterator __last, _Compare __comp);
+
+template <class _ExecutionPolicy, class _BidirectionalIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
+inplace_merge(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __middle,
+              _BidirectionalIterator __last);
+
+
+
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Compare>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
+includes(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
+         _ForwardIterator2 __last2, _Compare __comp);
+
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
+includes(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
+         _ForwardIterator2 __last2);
+
+
+
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator,
+          class _Compare>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+set_union(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
+          _ForwardIterator2 __last2, _ForwardIterator __result, _Compare __comp);
+
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+set_union(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
+          _ForwardIterator2 __last2, _ForwardIterator __result);
+
+
+
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator,
+          class _Compare>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+set_intersection(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
+                 _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result, _Compare __comp);
+
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+set_intersection(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
+                 _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result);
+
+
+
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator,
+          class _Compare>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+set_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
+               _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result, _Compare __comp);
+
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+set_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
+               _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result);
+
+
+
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator,
+          class _Compare>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+set_symmetric_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
+                         _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator result,
+                         _Compare __comp);
+
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+set_symmetric_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
+                         _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result);
+
+
+template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _RandomAccessIterator>
+is_heap_until(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp);
+
+template <class _ExecutionPolicy, class _RandomAccessIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _RandomAccessIterator>
+is_heap_until(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last);
+
+template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
+is_heap(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp);
+
+template <class _ExecutionPolicy, class _RandomAccessIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
+is_heap(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last);
+
+
+
+template <class _ExecutionPolicy, class _ForwardIterator, class _Compare>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+min_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp);
+
+template <class _ExecutionPolicy, class _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+min_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last);
+
+template <class _ExecutionPolicy, class _ForwardIterator, class _Compare>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+max_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp);
+
+template <class _ExecutionPolicy, class _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+max_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last);
+
+template <class _ExecutionPolicy, class _ForwardIterator, class _Compare>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator, _ForwardIterator>>
+minmax_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp);
+
+template <class _ExecutionPolicy, class _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator, _ForwardIterator>>
+minmax_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last);
+
+
+
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Compare>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
+lexicographical_compare(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
+                        _ForwardIterator2 __first2, _ForwardIterator2 __last2, _Compare __comp);
+
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
+lexicographical_compare(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
+                        _ForwardIterator2 __first2, _ForwardIterator2 __last2);
+
+}
+# 75 "/usr/include/c++/10.2.0/algorithm" 2 3
+#define _PSTL_ALGORITHM_FORWARD_DECLARED 1
+
+
+
+#define __cpp_lib_parallel_algorithm 201603L
+# 40 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 2 3 4
+# 53 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+
+namespace boost
+{
+
+template<class T> class shared_ptr;
+template<class T> class weak_ptr;
+template<class T> class enable_shared_from_this;
+class enable_shared_from_raw;
+
+namespace movelib
+{
+
+    template< class T, class D > class unique_ptr;
+
+}
+
+namespace detail
+{
+
+
+
+template< class T > struct sp_element
+{
+    typedef T type;
+};
+
+
+
+template< class T > struct sp_element< T[] >
+{
+    typedef T type;
+};
+
+
+
+template< class T, std::size_t N > struct sp_element< T[N] >
+{
+    typedef T type;
+};
+
+
+
+
+
+
+
+template< class T > struct sp_dereference
+{
+    typedef T & type;
+};
+
+template<> struct sp_dereference< void >
+{
+    typedef void type;
+};
+
+
+
+template<> struct sp_dereference< void const >
+{
+    typedef void type;
+};
+
+template<> struct sp_dereference< void volatile >
+{
+    typedef void type;
+};
+
+template<> struct sp_dereference< void const volatile >
+{
+    typedef void type;
+};
+
+
+
+
+
+template< class T > struct sp_dereference< T[] >
+{
+    typedef void type;
+};
+
+
+
+template< class T, std::size_t N > struct sp_dereference< T[N] >
+{
+    typedef void type;
+};
+
+
+
+
+
+
+
+template< class T > struct sp_member_access
+{
+    typedef T * type;
+};
+
+
+
+template< class T > struct sp_member_access< T[] >
+{
+    typedef void type;
+};
+
+
+
+template< class T, std::size_t N > struct sp_member_access< T[N] >
+{
+    typedef void type;
+};
+
+
+
+
+
+
+
+template< class T > struct sp_array_access
+{
+    typedef void type;
+};
+
+
+
+template< class T > struct sp_array_access< T[] >
+{
+    typedef T & type;
+};
+
+
+
+template< class T, std::size_t N > struct sp_array_access< T[N] >
+{
+    typedef T & type;
+};
+
+
+
+
+
+
+
+template< class T > struct sp_extent
+{
+    enum _vt { value = 0 };
+};
+
+
+
+template< class T, std::size_t N > struct sp_extent< T[N] >
+{
+    enum _vt { value = N };
+};
+
+
+
+
+
+template< class X, class Y, class T > inline void sp_enable_shared_from_this( boost::shared_ptr<X> const * ppx, Y const * py, boost::enable_shared_from_this< T > const * pe )
+{
+    if( pe != 0 )
+    {
+        pe->_internal_accept_owner( ppx, const_cast< Y* >( py ) );
+    }
+}
+
+template< class X, class Y > inline void sp_enable_shared_from_this( boost::shared_ptr<X> * ppx, Y const * py, boost::enable_shared_from_raw const * pe );
+# 242 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 3 4
+inline void sp_enable_shared_from_this( ... )
+{
+}
+
+
+
+
+
+
+
+template< class T, class R > struct sp_enable_if_auto_ptr
+{
+};
+
+template< class T, class R > struct sp_enable_if_auto_ptr< std::auto_ptr< T >, R >
+{
+    typedef R type;
+};
+
+
+
+
+
+template< class Y, class T > inline void sp_assert_convertible() noexcept
+{
+
+
+
+    typedef char tmp[ sp_convertible< Y, T >::value? 1: -1 ];
+    (void)sizeof( tmp );
+
+
+
+
+
+
+
+}
+
+
+
+template< class T, class Y > inline void sp_pointer_construct( boost::shared_ptr< T > * ppx, Y * p, boost::detail::shared_count & pn )
+{
+    boost::detail::shared_count( p ).swap( pn );
+    boost::detail::sp_enable_shared_from_this( ppx, p, p );
+}
+
+
+
+template< class T, class Y > inline void sp_pointer_construct( boost::shared_ptr< T[] > * , Y * p, boost::detail::shared_count & pn )
+{
+    sp_assert_convertible< Y[], T[] >();
+    boost::detail::shared_count( p, boost::checked_array_deleter< T >() ).swap( pn );
+}
+
+template< class T, std::size_t N, class Y > inline void sp_pointer_construct( boost::shared_ptr< T[N] > * , Y * p, boost::detail::shared_count & pn )
+{
+    sp_assert_convertible< Y[N], T[N] >();
+    boost::detail::shared_count( p, boost::checked_array_deleter< T >() ).swap( pn );
+}
+
+
+
+
+
+template< class T, class Y > inline void sp_deleter_construct( boost::shared_ptr< T > * ppx, Y * p )
+{
+    boost::detail::sp_enable_shared_from_this( ppx, p, p );
+}
+
+
+
+template< class T, class Y > inline void sp_deleter_construct( boost::shared_ptr< T[] > * , Y * )
+{
+    sp_assert_convertible< Y[], T[] >();
+}
+
+template< class T, std::size_t N, class Y > inline void sp_deleter_construct( boost::shared_ptr< T[N] > * , Y * )
+{
+    sp_assert_convertible< Y[N], T[N] >();
+}
+
+
+
+struct sp_internal_constructor_tag
+{
+};
+
+}
+# 341 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 3 4
+template<class T> class shared_ptr
+{
+private:
+
+
+    typedef shared_ptr<T> this_type;
+
+public:
+
+    typedef typename boost::detail::sp_element< T >::type element_type;
+
+    constexpr shared_ptr() noexcept : px( 0 ), pn()
+    {
+    }
+
+
+
+    constexpr shared_ptr( boost::detail::sp_nullptr_t ) noexcept : px( 0 ), pn()
+    {
+    }
+
+
+
+    constexpr shared_ptr( boost::detail::sp_internal_constructor_tag, element_type * px_, boost::detail::shared_count const & pn_ ) noexcept : px( px_ ), pn( pn_ )
+    {
+    }
+
+
+
+    constexpr shared_ptr( boost::detail::sp_internal_constructor_tag, element_type * px_, boost::detail::shared_count && pn_ ) noexcept : px( px_ ), pn( std::move( pn_ ) )
+    {
+    }
+
+
+
+    template<class Y>
+    explicit shared_ptr( Y * p ): px( p ), pn()
+    {
+        boost::detail::sp_pointer_construct( this, p, pn );
+    }
+
+
+
+
+
+
+
+    template<class Y, class D> shared_ptr( Y * p, D d ): px( p ), pn( p, d )
+    {
+        boost::detail::sp_deleter_construct( this, p );
+    }
+
+
+
+    template<class D> shared_ptr( boost::detail::sp_nullptr_t p, D d ): px( p ), pn( p, d )
+    {
+    }
+
+
+
+
+
+    template<class Y, class D, class A> shared_ptr( Y * p, D d, A a ): px( p ), pn( p, d, a )
+    {
+        boost::detail::sp_deleter_construct( this, p );
+    }
+
+
+
+    template<class D, class A> shared_ptr( boost::detail::sp_nullptr_t p, D d, A a ): px( p ), pn( p, d, a )
+    {
+    }
+# 422 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 3 4
+    shared_ptr( shared_ptr const & r ) noexcept : px( r.px ), pn( r.pn )
+    {
+    }
+
+
+
+    template<class Y>
+    explicit shared_ptr( weak_ptr<Y> const & r ): pn( r.pn )
+    {
+        boost::detail::sp_assert_convertible< Y, T >();
+
+
+        px = r.px;
+    }
+
+    template<class Y>
+    shared_ptr( weak_ptr<Y> const & r, boost::detail::sp_nothrow_tag )
+    noexcept : px( 0 ), pn( r.pn, boost::detail::sp_nothrow_tag() )
+    {
+        if( !pn.empty() )
+        {
+            px = r.px;
+        }
+    }
+
+    template<class Y>
+
+
+    shared_ptr( shared_ptr<Y> const & r, typename boost::detail::sp_enable_if_convertible<Y,T>::type = boost::detail::sp_empty() )
+
+
+
+
+
+
+    noexcept : px( r.px ), pn( r.pn )
+    {
+        boost::detail::sp_assert_convertible< Y, T >();
+    }
+
+
+    template< class Y >
+    shared_ptr( shared_ptr<Y> const & r, element_type * p ) noexcept : px( p ), pn( r.pn )
+    {
+    }
+
+
+
+    template<class Y>
+    explicit shared_ptr( std::auto_ptr<Y> & r ): px(r.get()), pn()
+    {
+        boost::detail::sp_assert_convertible< Y, T >();
+
+        Y * tmp = r.get();
+        pn = boost::detail::shared_count( r );
+
+        boost::detail::sp_deleter_construct( this, tmp );
+    }
+
+
+
+    template<class Y>
+    shared_ptr( std::auto_ptr<Y> && r ): px(r.get()), pn()
+    {
+        boost::detail::sp_assert_convertible< Y, T >();
+
+        Y * tmp = r.get();
+        pn = boost::detail::shared_count( r );
+
+        boost::detail::sp_deleter_construct( this, tmp );
+    }
+# 515 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 3 4
+    template< class Y, class D >
+    shared_ptr( std::unique_ptr< Y, D > && r ): px( r.get() ), pn()
+    {
+        boost::detail::sp_assert_convertible< Y, T >();
+
+        typename std::unique_ptr< Y, D >::pointer tmp = r.get();
+
+        if( tmp != 0 )
+        {
+            pn = boost::detail::shared_count( r );
+            boost::detail::sp_deleter_construct( this, tmp );
+        }
+    }
+
+
+
+    template< class Y, class D >
+    shared_ptr( boost::movelib::unique_ptr< Y, D > r ): px( r.get() ), pn()
+    {
+        boost::detail::sp_assert_convertible< Y, T >();
+
+        typename boost::movelib::unique_ptr< Y, D >::pointer tmp = r.get();
+
+        if( tmp != 0 )
+        {
+            pn = boost::detail::shared_count( r );
+            boost::detail::sp_deleter_construct( this, tmp );
+        }
+    }
+
+
+
+    shared_ptr & operator=( shared_ptr const & r ) noexcept
+    {
+        this_type(r).swap(*this);
+        return *this;
+    }
+
+
+
+    template<class Y>
+    shared_ptr & operator=(shared_ptr<Y> const & r) noexcept
+    {
+        this_type(r).swap(*this);
+        return *this;
+    }
+
+
+
+
+
+    template<class Y>
+    shared_ptr & operator=( std::auto_ptr<Y> & r )
+    {
+        this_type( r ).swap( *this );
+        return *this;
+    }
+
+
+
+    template<class Y>
+    shared_ptr & operator=( std::auto_ptr<Y> && r )
+    {
+        this_type( static_cast< std::auto_ptr<Y> && >( r ) ).swap( *this );
+        return *this;
+    }
+# 597 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 3 4
+    template<class Y, class D>
+    shared_ptr & operator=( std::unique_ptr<Y, D> && r )
+    {
+        this_type( static_cast< std::unique_ptr<Y, D> && >( r ) ).swap(*this);
+        return *this;
+    }
+
+
+
+    template<class Y, class D>
+    shared_ptr & operator=( boost::movelib::unique_ptr<Y, D> r )
+    {
+
+
+        boost::detail::sp_assert_convertible< Y, T >();
+
+        typename boost::movelib::unique_ptr< Y, D >::pointer p = r.get();
+
+        shared_ptr tmp;
+
+        if( p != 0 )
+        {
+            tmp.px = p;
+            tmp.pn = boost::detail::shared_count( r );
+
+            boost::detail::sp_deleter_construct( &tmp, p );
+        }
+
+        tmp.swap( *this );
+
+        return *this;
+    }
+
+
+
+
+
+    shared_ptr( shared_ptr && r ) noexcept : px( r.px ), pn()
+    {
+        pn.swap( r.pn );
+        r.px = 0;
+    }
+
+    template<class Y>
+
+
+    shared_ptr( shared_ptr<Y> && r, typename boost::detail::sp_enable_if_convertible<Y,T>::type = boost::detail::sp_empty() )
+
+
+
+
+
+
+    noexcept : px( r.px ), pn()
+    {
+        boost::detail::sp_assert_convertible< Y, T >();
+
+        pn.swap( r.pn );
+        r.px = 0;
+    }
+
+    shared_ptr & operator=( shared_ptr && r ) noexcept
+    {
+        this_type( static_cast< shared_ptr && >( r ) ).swap( *this );
+        return *this;
+    }
+
+    template<class Y>
+    shared_ptr & operator=( shared_ptr<Y> && r ) noexcept
+    {
+        this_type( static_cast< shared_ptr<Y> && >( r ) ).swap( *this );
+        return *this;
+    }
+
+
+    template<class Y>
+    shared_ptr( shared_ptr<Y> && r, element_type * p ) noexcept : px( p ), pn()
+    {
+        pn.swap( r.pn );
+        r.px = 0;
+    }
+
+
+
+
+
+    shared_ptr & operator=( boost::detail::sp_nullptr_t ) noexcept
+    {
+        this_type().swap(*this);
+        return *this;
+    }
+
+
+
+    void reset() noexcept
+    {
+        this_type().swap(*this);
+    }
+
+    template<class Y> void reset( Y * p )
+    {
+        (static_cast <bool> (p == 0 || p != px) ? void (0) : __assert_fail ("p == 0 || p != px", "/usr/include/boost/smart_ptr/shared_ptr.hpp", 698, __extension__ __PRETTY_FUNCTION__));
+        this_type( p ).swap( *this );
+    }
+
+    template<class Y, class D> void reset( Y * p, D d )
+    {
+        this_type( p, d ).swap( *this );
+    }
+
+    template<class Y, class D, class A> void reset( Y * p, D d, A a )
+    {
+        this_type( p, d, a ).swap( *this );
+    }
+
+    template<class Y> void reset( shared_ptr<Y> const & r, element_type * p ) noexcept
+    {
+        this_type( r, p ).swap( *this );
+    }
+
+
+
+    template<class Y> void reset( shared_ptr<Y> && r, element_type * p ) noexcept
+    {
+        this_type( static_cast< shared_ptr<Y> && >( r ), p ).swap( *this );
+    }
+
+
+
+    typename boost::detail::sp_dereference< T >::type operator* () const noexcept
+    {
+        (static_cast <bool> (px != 0) ? void (0) : __assert_fail ("px != 0", "/usr/include/boost/smart_ptr/shared_ptr.hpp", 728, __extension__ __PRETTY_FUNCTION__));
+        return *px;
+    }
+
+    typename boost::detail::sp_member_access< T >::type operator-> () const noexcept
+    {
+        (static_cast <bool> (px != 0) ? void (0) : __assert_fail ("px != 0", "/usr/include/boost/smart_ptr/shared_ptr.hpp", 734, __extension__ __PRETTY_FUNCTION__));
+        return px;
+    }
+
+    typename boost::detail::sp_array_access< T >::type operator[] ( std::ptrdiff_t i ) const noexcept
+    {
+        (static_cast <bool> (px != 0) ? void (0) : __assert_fail ("px != 0", "/usr/include/boost/smart_ptr/shared_ptr.hpp", 740, __extension__ __PRETTY_FUNCTION__));
+        (static_cast <bool> (i >= 0 && ( i < boost::detail::sp_extent< T >::value || boost::detail::sp_extent< T >::value == 0 )) ? void (0) : __assert_fail ("i >= 0 && ( i < boost::detail::sp_extent< T >::value || boost::detail::sp_extent< T >::value == 0 )", "/usr/include/boost/smart_ptr/shared_ptr.hpp", 741, __extension__ __PRETTY_FUNCTION__));
+
+        return static_cast< typename boost::detail::sp_array_access< T >::type >( px[ i ] );
+    }
+
+    element_type * get() const noexcept
+    {
+        return px;
+    }
+
+
+# 1 "/usr/include/boost/smart_ptr/detail/operator_bool.hpp" 1 3 4
+# 12 "/usr/include/boost/smart_ptr/detail/operator_bool.hpp" 3 4
+    explicit operator bool () const noexcept
+    {
+        return px != 0;
+    }
+# 61 "/usr/include/boost/smart_ptr/detail/operator_bool.hpp" 3 4
+    bool operator! () const noexcept
+    {
+        return px == 0;
+    }
+# 753 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 2 3 4
+
+    bool unique() const noexcept
+    {
+        return pn.unique();
+    }
+
+    long use_count() const noexcept
+    {
+        return pn.use_count();
+    }
+
+    void swap( shared_ptr & other ) noexcept
+    {
+        std::swap(px, other.px);
+        pn.swap(other.pn);
+    }
+
+    template<class Y> bool owner_before( shared_ptr<Y> const & rhs ) const noexcept
+    {
+        return pn < rhs.pn;
+    }
+
+    template<class Y> bool owner_before( weak_ptr<Y> const & rhs ) const noexcept
+    {
+        return pn < rhs.pn;
+    }
+
+    void * _internal_get_deleter( boost::detail::sp_typeinfo_ const & ti ) const noexcept
+    {
+        return pn.get_deleter( ti );
+    }
+
+    void * _internal_get_local_deleter( boost::detail::sp_typeinfo_ const & ti ) const noexcept
+    {
+        return pn.get_local_deleter( ti );
+    }
+
+    void * _internal_get_untyped_deleter() const noexcept
+    {
+        return pn.get_untyped_deleter();
+    }
+
+    bool _internal_equiv( shared_ptr const & r ) const noexcept
+    {
+        return px == r.px && pn == r.pn;
+    }
+
+    boost::detail::shared_count _internal_count() const noexcept
+    {
+        return pn;
+    }
+
+
+
+
+
+
+private:
+
+    template<class Y> friend class shared_ptr;
+    template<class Y> friend class weak_ptr;
+
+
+
+
+    element_type * px;
+    boost::detail::shared_count pn;
+
+};
+
+template<class T, class U> inline bool operator==(shared_ptr<T> const & a, shared_ptr<U> const & b) noexcept
+{
+    return a.get() == b.get();
+}
+
+template<class T, class U> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<U> const & b) noexcept
+{
+    return a.get() != b.get();
+}
+# 846 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 3 4
+template<class T> inline bool operator==( shared_ptr<T> const & p, boost::detail::sp_nullptr_t ) noexcept
+{
+    return p.get() == 0;
+}
+
+template<class T> inline bool operator==( boost::detail::sp_nullptr_t, shared_ptr<T> const & p ) noexcept
+{
+    return p.get() == 0;
+}
+
+template<class T> inline bool operator!=( shared_ptr<T> const & p, boost::detail::sp_nullptr_t ) noexcept
+{
+    return p.get() != 0;
+}
+
+template<class T> inline bool operator!=( boost::detail::sp_nullptr_t, shared_ptr<T> const & p ) noexcept
+{
+    return p.get() != 0;
+}
+
+
+
+template<class T, class U> inline bool operator<(shared_ptr<T> const & a, shared_ptr<U> const & b) noexcept
+{
+    return a.owner_before( b );
+}
+
+template<class T> inline void swap(shared_ptr<T> & a, shared_ptr<T> & b) noexcept
+{
+    a.swap(b);
+}
+
+template<class T, class U> shared_ptr<T> static_pointer_cast( shared_ptr<U> const & r ) noexcept
+{
+    (void) static_cast< T* >( static_cast< U* >( 0 ) );
+
+    typedef typename shared_ptr<T>::element_type E;
+
+    E * p = static_cast< E* >( r.get() );
+    return shared_ptr<T>( r, p );
+}
+
+template<class T, class U> shared_ptr<T> const_pointer_cast( shared_ptr<U> const & r ) noexcept
+{
+    (void) const_cast< T* >( static_cast< U* >( 0 ) );
+
+    typedef typename shared_ptr<T>::element_type E;
+
+    E * p = const_cast< E* >( r.get() );
+    return shared_ptr<T>( r, p );
+}
+
+template<class T, class U> shared_ptr<T> dynamic_pointer_cast( shared_ptr<U> const & r ) noexcept
+{
+    (void) dynamic_cast< T* >( static_cast< U* >( 0 ) );
+
+    typedef typename shared_ptr<T>::element_type E;
+
+    E * p = dynamic_cast< E* >( r.get() );
+    return p? shared_ptr<T>( r, p ): shared_ptr<T>();
+}
+
+template<class T, class U> shared_ptr<T> reinterpret_pointer_cast( shared_ptr<U> const & r ) noexcept
+{
+    (void) reinterpret_cast< T* >( static_cast< U* >( 0 ) );
+
+    typedef typename shared_ptr<T>::element_type E;
+
+    E * p = reinterpret_cast< E* >( r.get() );
+    return shared_ptr<T>( r, p );
+}
+
+
+
+template<class T, class U> shared_ptr<T> static_pointer_cast( shared_ptr<U> && r ) noexcept
+{
+    (void) static_cast< T* >( static_cast< U* >( 0 ) );
+
+    typedef typename shared_ptr<T>::element_type E;
+
+    E * p = static_cast< E* >( r.get() );
+    return shared_ptr<T>( std::move(r), p );
+}
+
+template<class T, class U> shared_ptr<T> const_pointer_cast( shared_ptr<U> && r ) noexcept
+{
+    (void) const_cast< T* >( static_cast< U* >( 0 ) );
+
+    typedef typename shared_ptr<T>::element_type E;
+
+    E * p = const_cast< E* >( r.get() );
+    return shared_ptr<T>( std::move(r), p );
+}
+
+template<class T, class U> shared_ptr<T> dynamic_pointer_cast( shared_ptr<U> && r ) noexcept
+{
+    (void) dynamic_cast< T* >( static_cast< U* >( 0 ) );
+
+    typedef typename shared_ptr<T>::element_type E;
+
+    E * p = dynamic_cast< E* >( r.get() );
+    return p? shared_ptr<T>( std::move(r), p ): shared_ptr<T>();
+}
+
+template<class T, class U> shared_ptr<T> reinterpret_pointer_cast( shared_ptr<U> && r ) noexcept
+{
+    (void) reinterpret_cast< T* >( static_cast< U* >( 0 ) );
+
+    typedef typename shared_ptr<T>::element_type E;
+
+    E * p = reinterpret_cast< E* >( r.get() );
+    return shared_ptr<T>( std::move(r), p );
+}
+
+
+
+
+
+template<class T> inline typename shared_ptr<T>::element_type * get_pointer(shared_ptr<T> const & p) noexcept
+{
+    return p.get();
+}
+# 991 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 3 4
+template<class E, class T, class Y> std::basic_ostream<E, T> & operator<< (std::basic_ostream<E, T> & os, shared_ptr<Y> const & p)
+
+{
+    os << p.get();
+    return os;
+}
+# 1006 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 3 4
+namespace detail
+{
+
+template<class D, class T> D * basic_get_deleter( shared_ptr<T> const & p ) noexcept
+{
+    return static_cast<D *>( p._internal_get_deleter(typeid(D)) );
+}
+
+template<class D, class T> D * basic_get_local_deleter( D *, shared_ptr<T> const & p ) noexcept;
+template<class D, class T> D const * basic_get_local_deleter( D const *, shared_ptr<T> const & p ) noexcept;
+
+class esft2_deleter_wrapper
+{
+private:
+
+    shared_ptr<void const volatile> deleter_;
+
+public:
+
+    esft2_deleter_wrapper() noexcept
+    {
+    }
+
+    template< class T > void set_deleter( shared_ptr<T> const & deleter ) noexcept
+    {
+        deleter_ = deleter;
+    }
+
+    template<typename D> D* get_deleter() const noexcept
+    {
+        return boost::detail::basic_get_deleter<D>( deleter_ );
+    }
+
+    template< class T> void operator()( T* ) noexcept
+    {
+        (static_cast <bool> (deleter_.use_count() <= 1) ? void (0) : __assert_fail ("deleter_.use_count() <= 1", "/usr/include/boost/smart_ptr/shared_ptr.hpp", 1041, __extension__ __PRETTY_FUNCTION__));
+        deleter_.reset();
+    }
+};
+
+}
+
+template<class D, class T> D * get_deleter( shared_ptr<T> const & p ) noexcept
+{
+    D * d = boost::detail::basic_get_deleter<D>( p );
+
+    if( d == 0 )
+    {
+        d = boost::detail::basic_get_local_deleter( d, p );
+    }
+
+    if( d == 0 )
+    {
+        boost::detail::esft2_deleter_wrapper *del_wrapper = boost::detail::basic_get_deleter<boost::detail::esft2_deleter_wrapper>(p);
+
+
+        if(del_wrapper) d = del_wrapper->::boost::detail::esft2_deleter_wrapper::get_deleter<D>();
+    }
+
+    return d;
+}
+
+
+
+
+
+template<class T> inline bool atomic_is_lock_free( shared_ptr<T> const * ) noexcept
+{
+    return false;
+}
+
+template<class T> shared_ptr<T> atomic_load( shared_ptr<T> const * p ) noexcept
+{
+    boost::detail::spinlock_pool<2>::scoped_lock lock( p );
+    return *p;
+}
+
+template<class T, class M> inline shared_ptr<T> atomic_load_explicit( shared_ptr<T> const * p, M ) noexcept
+{
+    return atomic_load( p );
+}
+
+template<class T> void atomic_store( shared_ptr<T> * p, shared_ptr<T> r ) noexcept
+{
+    boost::detail::spinlock_pool<2>::scoped_lock lock( p );
+    p->swap( r );
+}
+
+template<class T, class M> inline void atomic_store_explicit( shared_ptr<T> * p, shared_ptr<T> r, M ) noexcept
+{
+    atomic_store( p, r );
+}
+
+template<class T> shared_ptr<T> atomic_exchange( shared_ptr<T> * p, shared_ptr<T> r ) noexcept
+{
+    boost::detail::spinlock & sp = boost::detail::spinlock_pool<2>::spinlock_for( p );
+
+    sp.lock();
+    p->swap( r );
+    sp.unlock();
+
+    return r;
+}
+
+template<class T, class M> shared_ptr<T> inline atomic_exchange_explicit( shared_ptr<T> * p, shared_ptr<T> r, M ) noexcept
+{
+    return atomic_exchange( p, r );
+}
+
+template<class T> bool atomic_compare_exchange( shared_ptr<T> * p, shared_ptr<T> * v, shared_ptr<T> w ) noexcept
+{
+    boost::detail::spinlock & sp = boost::detail::spinlock_pool<2>::spinlock_for( p );
+
+    sp.lock();
+
+    if( p->_internal_equiv( *v ) )
+    {
+        p->swap( w );
+
+        sp.unlock();
+
+        return true;
+    }
+    else
+    {
+        shared_ptr<T> tmp( *p );
+
+        sp.unlock();
+
+        tmp.swap( *v );
+        return false;
+    }
+}
+
+template<class T, class M> inline bool atomic_compare_exchange_explicit( shared_ptr<T> * p, shared_ptr<T> * v, shared_ptr<T> w, M, M ) noexcept
+{
+    return atomic_compare_exchange( p, v, w );
+}
+
+
+
+
+
+template< class T > struct hash;
+
+template< class T > std::size_t hash_value( boost::shared_ptr<T> const & p ) noexcept
+{
+    return boost::hash< typename boost::shared_ptr<T>::element_type* >()( p.get() );
+}
+
+}
+
+# 1 "/usr/include/boost/smart_ptr/detail/local_sp_deleter.hpp" 1 3 4
+
+#define BOOST_SMART_PTR_DETAIL_LOCAL_SP_DELETER_HPP_INCLUDED 
+# 20 "/usr/include/boost/smart_ptr/detail/local_sp_deleter.hpp" 3 4
+# 1 "/usr/include/boost/smart_ptr/detail/local_counted_base.hpp" 1 3 4
+
+#define BOOST_SMART_PTR_DETAIL_LOCAL_COUNTED_BASE_HPP_INCLUDED 
+# 24 "/usr/include/boost/smart_ptr/detail/local_counted_base.hpp" 3 4
+namespace boost
+{
+
+namespace detail
+{
+
+class __attribute__((__visibility__("default"))) local_counted_base
+{
+private:
+
+    local_counted_base & operator= ( local_counted_base const & );
+
+private:
+
+
+    enum count_type { min_ = 0, initial_ = 1, max_ = 2147483647 };
+
+    count_type local_use_count_;
+
+public:
+
+    constexpr local_counted_base() noexcept: local_use_count_( initial_ )
+    {
+    }
+
+    constexpr local_counted_base( local_counted_base const & ) noexcept: local_use_count_( initial_ )
+    {
+    }
+
+    virtual ~local_counted_base()
+    {
+    }
+
+    virtual void local_cb_destroy() noexcept = 0;
+
+    virtual boost::detail::shared_count local_cb_get_shared_count() const noexcept = 0;
+
+    void add_ref() noexcept
+    {
+# 73 "/usr/include/boost/smart_ptr/detail/local_counted_base.hpp" 3 4
+        local_use_count_ = static_cast<count_type>( local_use_count_ + 1 );
+    }
+
+    void release() noexcept
+    {
+        local_use_count_ = static_cast<count_type>( local_use_count_ - 1 );
+
+        if( local_use_count_ == 0 )
+        {
+            local_cb_destroy();
+        }
+    }
+
+    long local_use_count() const noexcept
+    {
+        return local_use_count_;
+    }
+};
+
+class __attribute__((__visibility__("default"))) local_counted_impl: public local_counted_base
+{
+private:
+
+    local_counted_impl( local_counted_impl const & );
+
+private:
+
+    shared_count pn_;
+
+public:
+
+    explicit local_counted_impl( shared_count const& pn ) noexcept: pn_( pn )
+    {
+    }
+
+
+
+    explicit local_counted_impl( shared_count && pn ) noexcept: pn_( std::move(pn) )
+    {
+    }
+
+
+
+    virtual void local_cb_destroy() noexcept
+    {
+        delete this;
+    }
+
+    virtual boost::detail::shared_count local_cb_get_shared_count() const noexcept
+    {
+        return pn_;
+    }
+};
+
+class __attribute__((__visibility__("default"))) local_counted_impl_em: public local_counted_base
+{
+public:
+
+    shared_count pn_;
+
+    virtual void local_cb_destroy() noexcept
+    {
+        shared_count().swap( pn_ );
+    }
+
+    virtual boost::detail::shared_count local_cb_get_shared_count() const noexcept
+    {
+        return pn_;
+    }
+};
+
+}
+
+}
+# 21 "/usr/include/boost/smart_ptr/detail/local_sp_deleter.hpp" 2 3 4
+
+
+namespace boost
+{
+
+namespace detail
+{
+
+template<class D> class local_sp_deleter: public local_counted_impl_em
+{
+private:
+
+    D d_;
+
+public:
+
+    local_sp_deleter(): d_()
+    {
+    }
+
+    explicit local_sp_deleter( D const& d ) noexcept: d_( d )
+    {
+    }
+
+
+
+    explicit local_sp_deleter( D&& d ) noexcept: d_( std::move(d) )
+    {
+    }
+
+
+
+    D& deleter() noexcept
+    {
+        return d_;
+    }
+
+    template<class Y> void operator()( Y* p ) noexcept
+    {
+        d_( p );
+    }
+
+
+
+    void operator()( boost::detail::sp_nullptr_t p ) noexcept
+    {
+        d_( p );
+    }
+
+
+};
+
+template<> class local_sp_deleter<void>
+{
+};
+
+template<class D> D * get_local_deleter( local_sp_deleter<D> * p ) noexcept
+{
+    return &p->deleter();
+}
+
+inline void * get_local_deleter( local_sp_deleter<void> * ) noexcept
+{
+    return 0;
+}
+
+}
+
+}
+# 1159 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 2 3 4
+
+namespace boost
+{
+
+namespace detail
+{
+
+template<class D, class T> D * basic_get_local_deleter( D *, shared_ptr<T> const & p ) noexcept
+{
+    return static_cast<D *>( p._internal_get_local_deleter( typeid(local_sp_deleter<D>) ) );
+}
+
+template<class D, class T> D const * basic_get_local_deleter( D const *, shared_ptr<T> const & p ) noexcept
+{
+    return static_cast<D *>( p._internal_get_local_deleter( typeid(local_sp_deleter<D>) ) );
+}
+
+}
+
+}
+
+
+#pragma GCC diagnostic pop
+# 18 "/usr/include/boost/shared_ptr.hpp" 2 3 4
+# 25 "/usr/include/boost/test/execution_monitor.hpp" 2 3 4
+# 1 "/usr/include/boost/scoped_array.hpp" 1 3 4
+
+#define BOOST_SCOPED_ARRAY_HPP_INCLUDED 
+# 13 "/usr/include/boost/scoped_array.hpp" 3 4
+# 1 "/usr/include/boost/smart_ptr/scoped_array.hpp" 1 3 4
+
+#define BOOST_SMART_PTR_SCOPED_ARRAY_HPP_INCLUDED 
+# 14 "/usr/include/boost/smart_ptr/scoped_array.hpp" 3 4
+# 1 "/usr/include/boost/assert.hpp" 1 3 4
+# 32 "/usr/include/boost/assert.hpp" 3 4
+#undef BOOST_ASSERT
+#undef BOOST_ASSERT_MSG
+#undef BOOST_ASSERT_IS_VOID
+# 58 "/usr/include/boost/assert.hpp" 3 4
+# 1 "/usr/include/assert.h" 1 3 4
+# 24 "/usr/include/assert.h" 3 4
+#undef _ASSERT_H
+#undef assert
+#undef __ASSERT_VOID_CAST
+
+
+#undef assert_perror
+
+
+
+
+#define _ASSERT_H 1
+
+
+
+#define __ASSERT_VOID_CAST static_cast<void>
+# 64 "/usr/include/assert.h" 3 4
+extern "C" {
+
+
+extern void __assert_fail (const char *__assertion, const char *__file,
+      unsigned int __line, const char *__function)
+     throw () __attribute__ ((__noreturn__));
+
+
+extern void __assert_perror_fail (int __errnum, const char *__file,
+      unsigned int __line, const char *__function)
+     throw () __attribute__ ((__noreturn__));
+
+
+
+
+extern void __assert (const char *__assertion, const char *__file, int __line)
+     throw () __attribute__ ((__noreturn__));
+
+
+}
+
+
+
+
+
+#define assert(expr) (static_cast <bool> (expr) ? void (0) : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
+# 114 "/usr/include/assert.h" 3 4
+#define assert_perror(errnum) (!(errnum) ? __ASSERT_VOID_CAST (0) : __assert_perror_fail ((errnum), __FILE__, __LINE__, __ASSERT_FUNCTION))
+# 126 "/usr/include/assert.h" 3 4
+#define __ASSERT_FUNCTION __extension__ __PRETTY_FUNCTION__
+# 59 "/usr/include/boost/assert.hpp" 2 3 4
+
+#define BOOST_ASSERT(expr) assert(expr)
+#define BOOST_ASSERT_MSG(expr,msg) assert((expr)&&(msg))
+# 72 "/usr/include/boost/assert.hpp" 3 4
+#undef BOOST_VERIFY
+#undef BOOST_VERIFY_MSG
+# 82 "/usr/include/boost/assert.hpp" 3 4
+#define BOOST_VERIFY(expr) BOOST_ASSERT(expr)
+#define BOOST_VERIFY_MSG(expr,msg) BOOST_ASSERT_MSG(expr,msg)
+# 15 "/usr/include/boost/smart_ptr/scoped_array.hpp" 2 3 4
+# 23 "/usr/include/boost/smart_ptr/scoped_array.hpp" 3 4
+namespace boost
+{
+# 39 "/usr/include/boost/smart_ptr/scoped_array.hpp" 3 4
+template<class T> class scoped_array
+{
+private:
+
+    T * px;
+
+    scoped_array(scoped_array const &);
+    scoped_array & operator=(scoped_array const &);
+
+    typedef scoped_array<T> this_type;
+
+    void operator==( scoped_array const& ) const;
+    void operator!=( scoped_array const& ) const;
+
+public:
+
+    typedef T element_type;
+
+    explicit scoped_array( T * p = 0 ) noexcept : px( p )
+    {
+
+
+
+    }
+
+    ~scoped_array() noexcept
+    {
+
+
+
+        boost::checked_array_delete( px );
+    }
+
+    void reset(T * p = 0) noexcept
+    {
+        (static_cast <bool> (p == 0 || p != px) ? void (0) : __assert_fail ("p == 0 || p != px", "/usr/include/boost/smart_ptr/scoped_array.hpp", 74, __extension__ __PRETTY_FUNCTION__));
+        this_type(p).swap(*this);
+    }
+
+    T & operator[](std::ptrdiff_t i) const noexcept
+    {
+        (static_cast <bool> (px != 0) ? void (0) : __assert_fail ("px != 0", "/usr/include/boost/smart_ptr/scoped_array.hpp", 80, __extension__ __PRETTY_FUNCTION__));
+        (static_cast <bool> (i >= 0) ? void (0) : __assert_fail ("i >= 0", "/usr/include/boost/smart_ptr/scoped_array.hpp", 81, __extension__ __PRETTY_FUNCTION__));
+        return px[i];
+    }
+
+    T * get() const noexcept
+    {
+        return px;
+    }
+
+
+# 1 "/usr/include/boost/smart_ptr/detail/operator_bool.hpp" 1 3 4
+# 12 "/usr/include/boost/smart_ptr/detail/operator_bool.hpp" 3 4
+    explicit operator bool () const noexcept
+    {
+        return px != 0;
+    }
+# 61 "/usr/include/boost/smart_ptr/detail/operator_bool.hpp" 3 4
+    bool operator! () const noexcept
+    {
+        return px == 0;
+    }
+# 92 "/usr/include/boost/smart_ptr/scoped_array.hpp" 2 3 4
+
+    void swap(scoped_array & b) noexcept
+    {
+        T * tmp = b.px;
+        b.px = px;
+        px = tmp;
+    }
+};
+
+
+
+template<class T> inline bool operator==( scoped_array<T> const & p, boost::detail::sp_nullptr_t ) noexcept
+{
+    return p.get() == 0;
+}
+
+template<class T> inline bool operator==( boost::detail::sp_nullptr_t, scoped_array<T> const & p ) noexcept
+{
+    return p.get() == 0;
+}
+
+template<class T> inline bool operator!=( scoped_array<T> const & p, boost::detail::sp_nullptr_t ) noexcept
+{
+    return p.get() != 0;
+}
+
+template<class T> inline bool operator!=( boost::detail::sp_nullptr_t, scoped_array<T> const & p ) noexcept
+{
+    return p.get() != 0;
+}
+
+
+
+template<class T> inline void swap(scoped_array<T> & a, scoped_array<T> & b) noexcept
+{
+    a.swap(b);
+}
+
+}
+# 14 "/usr/include/boost/scoped_array.hpp" 2 3 4
+# 26 "/usr/include/boost/test/execution_monitor.hpp" 2 3 4
+# 1 "/usr/include/boost/type.hpp" 1 3 4
+
+
+
+
+
+
+#define BOOST_TYPE_DWA20010120_HPP 
+
+namespace boost {
+
+
+
+  template <class T>
+  struct type {};
+
+}
+# 27 "/usr/include/boost/test/execution_monitor.hpp" 2 3 4
+# 1 "/usr/include/boost/cstdlib.hpp" 1 3 4
+# 13 "/usr/include/boost/cstdlib.hpp" 3 4
+#define BOOST_CSTDLIB_HPP 
+
+# 1 "/usr/include/c++/10.2.0/cstdlib" 1 3 4
+# 39 "/usr/include/c++/10.2.0/cstdlib" 3 4
+       
+# 40 "/usr/include/c++/10.2.0/cstdlib" 3
+# 16 "/usr/include/boost/cstdlib.hpp" 2 3 4
+
+namespace boost
+{
+# 33 "/usr/include/boost/cstdlib.hpp" 3 4
+   const int exit_success = 0;
+   const int exit_failure = 1;
+   const int exit_exception_failure = 200;
+   const int exit_test_failure = 201;
+
+}
+# 28 "/usr/include/boost/test/execution_monitor.hpp" 2 3 4
+# 1 "/usr/include/boost/function/function0.hpp" 1 3 4
+# 10 "/usr/include/boost/function/function0.hpp" 3 4
+#define BOOST_FUNCTION_NUM_ARGS 0
+# 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
+# 11 "/usr/include/boost/function/detail/maybe_include.hpp" 3 4
+#undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#define BOOST_FUNCTION_MAX_ARGS_DEFINED 0
+
+#define BOOST_FUNCTION_0 
+# 1 "/usr/include/boost/function/function_template.hpp" 1 3 4
+# 13 "/usr/include/boost/function/function_template.hpp" 3 4
+# 1 "/usr/include/boost/function/detail/prologue.hpp" 1 3 4
+# 11 "/usr/include/boost/function/detail/prologue.hpp" 3 4
+#define BOOST_FUNCTION_PROLOGUE_HPP 
+# 1 "/usr/include/c++/10.2.0/cassert" 1 3 4
+# 41 "/usr/include/c++/10.2.0/cassert" 3 4
+       
+# 42 "/usr/include/c++/10.2.0/cassert" 3
+
+
+# 1 "/usr/include/assert.h" 1 3 4
+# 24 "/usr/include/assert.h" 3 4
+#undef _ASSERT_H
+#undef assert
+#undef __ASSERT_VOID_CAST
+
+
+#undef assert_perror
+
+
+
+
+#define _ASSERT_H 1
+
+
+
+#define __ASSERT_VOID_CAST static_cast<void>
+# 64 "/usr/include/assert.h" 3 4
+extern "C" {
+
+
+extern void __assert_fail (const char *__assertion, const char *__file,
+      unsigned int __line, const char *__function)
+     throw () __attribute__ ((__noreturn__));
+
+
+extern void __assert_perror_fail (int __errnum, const char *__file,
+      unsigned int __line, const char *__function)
+     throw () __attribute__ ((__noreturn__));
+
+
+
+
+extern void __assert (const char *__assertion, const char *__file, int __line)
+     throw () __attribute__ ((__noreturn__));
+
+
+}
+
+
+
+
+
+#define assert(expr) (static_cast <bool> (expr) ? void (0) : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
+# 114 "/usr/include/assert.h" 3 4
+#define assert_perror(errnum) (!(errnum) ? __ASSERT_VOID_CAST (0) : __assert_perror_fail ((errnum), __FILE__, __LINE__, __ASSERT_FUNCTION))
+# 126 "/usr/include/assert.h" 3 4
+#define __ASSERT_FUNCTION __extension__ __PRETTY_FUNCTION__
+# 45 "/usr/include/c++/10.2.0/cassert" 2 3
+# 13 "/usr/include/boost/function/detail/prologue.hpp" 2 3 4
+
+# 1 "/usr/include/boost/config/no_tr1/functional.hpp" 1 3 4
+# 14 "/usr/include/boost/config/no_tr1/functional.hpp" 3 4
+#define BOOST_CONFIG_FUNCTIONAL 
+
+
+#define BOOST_TR1_NO_RECURSION 
+#define BOOST_CONFIG_NO_FUNCTIONAL_RECURSION 
+
+
+
+
+
+#undef BOOST_TR1_NO_RECURSION
+#undef BOOST_CONFIG_NO_FUNCTIONAL_RECURSION
+# 15 "/usr/include/boost/function/detail/prologue.hpp" 2 3 4
+
+
+# 1 "/usr/include/boost/function/function_base.hpp" 1 3 4
+# 12 "/usr/include/boost/function/function_base.hpp" 3 4
+#define BOOST_FUNCTION_BASE_HEADER 
+
+
+
+
+
+
+# 1 "/usr/include/boost/assert.hpp" 1 3 4
+# 32 "/usr/include/boost/assert.hpp" 3 4
+#undef BOOST_ASSERT
+#undef BOOST_ASSERT_MSG
+#undef BOOST_ASSERT_IS_VOID
+# 58 "/usr/include/boost/assert.hpp" 3 4
+# 1 "/usr/include/assert.h" 1 3 4
+# 24 "/usr/include/assert.h" 3 4
+#undef _ASSERT_H
+#undef assert
+#undef __ASSERT_VOID_CAST
+
+
+#undef assert_perror
+
+
+
+
+#define _ASSERT_H 1
+
+
+
+#define __ASSERT_VOID_CAST static_cast<void>
+# 64 "/usr/include/assert.h" 3 4
+extern "C" {
+
+
+extern void __assert_fail (const char *__assertion, const char *__file,
+      unsigned int __line, const char *__function)
+     throw () __attribute__ ((__noreturn__));
+
+
+extern void __assert_perror_fail (int __errnum, const char *__file,
+      unsigned int __line, const char *__function)
+     throw () __attribute__ ((__noreturn__));
+
+
+
+
+extern void __assert (const char *__assertion, const char *__file, int __line)
+     throw () __attribute__ ((__noreturn__));
+
+
+}
+
+
+
+
+
+#define assert(expr) (static_cast <bool> (expr) ? void (0) : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
+# 114 "/usr/include/assert.h" 3 4
+#define assert_perror(errnum) (!(errnum) ? __ASSERT_VOID_CAST (0) : __assert_perror_fail ((errnum), __FILE__, __LINE__, __ASSERT_FUNCTION))
+# 126 "/usr/include/assert.h" 3 4
+#define __ASSERT_FUNCTION __extension__ __PRETTY_FUNCTION__
+# 59 "/usr/include/boost/assert.hpp" 2 3 4
+
+#define BOOST_ASSERT(expr) assert(expr)
+#define BOOST_ASSERT_MSG(expr,msg) assert((expr)&&(msg))
+# 72 "/usr/include/boost/assert.hpp" 3 4
+#undef BOOST_VERIFY
+#undef BOOST_VERIFY_MSG
+# 82 "/usr/include/boost/assert.hpp" 3 4
+#define BOOST_VERIFY(expr) BOOST_ASSERT(expr)
+#define BOOST_VERIFY_MSG(expr,msg) BOOST_ASSERT_MSG(expr,msg)
+# 20 "/usr/include/boost/function/function_base.hpp" 2 3 4
+# 1 "/usr/include/boost/integer.hpp" 1 3 4
+# 16 "/usr/include/boost/integer.hpp" 3 4
+#define BOOST_INTEGER_HPP 
+
+# 1 "/usr/include/boost/integer_fwd.hpp" 1 3 4
+# 10 "/usr/include/boost/integer_fwd.hpp" 3 4
+#define BOOST_INTEGER_FWD_HPP 
+
+# 1 "/usr/include/c++/10.2.0/climits" 1 3 4
+# 39 "/usr/include/c++/10.2.0/climits" 3 4
+       
+# 40 "/usr/include/c++/10.2.0/climits" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include-fixed/limits.h" 1 3 4
+# 30 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include-fixed/limits.h" 3 4
+#define _GCC_LIMITS_H_ 
+
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include-fixed/syslimits.h" 1 3 4
+
+
+
+
+
+#define _GCC_NEXT_LIMITS_H 
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include-fixed/limits.h" 1 3 4
+# 195 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include-fixed/limits.h" 3 4
+# 1 "/usr/include/limits.h" 1 3 4
+# 23 "/usr/include/limits.h" 3 4
+#define _LIBC_LIMITS_H_ 1
+
+#define __GLIBC_INTERNAL_STARTING_HEADER_IMPLEMENTATION 
+# 1 "/usr/include/bits/libc-header-start.h" 1 3 4
+# 31 "/usr/include/bits/libc-header-start.h" 3 4
+#undef __GLIBC_INTERNAL_STARTING_HEADER_IMPLEMENTATION
+
+
+
+
+
+#undef __GLIBC_USE_LIB_EXT2
+
+
+#define __GLIBC_USE_LIB_EXT2 1
+# 49 "/usr/include/bits/libc-header-start.h" 3 4
+#undef __GLIBC_USE_IEC_60559_BFP_EXT
+
+#define __GLIBC_USE_IEC_60559_BFP_EXT 1
+
+
+
+#undef __GLIBC_USE_IEC_60559_BFP_EXT_C2X
+
+#define __GLIBC_USE_IEC_60559_BFP_EXT_C2X 1
+# 66 "/usr/include/bits/libc-header-start.h" 3 4
+#undef __GLIBC_USE_IEC_60559_FUNCS_EXT
+
+#define __GLIBC_USE_IEC_60559_FUNCS_EXT 1
+
+
+
+#undef __GLIBC_USE_IEC_60559_FUNCS_EXT_C2X
+
+#define __GLIBC_USE_IEC_60559_FUNCS_EXT_C2X 1
+
+
+
+
+
+
+#undef __GLIBC_USE_IEC_60559_TYPES_EXT
+
+#define __GLIBC_USE_IEC_60559_TYPES_EXT 1
+# 27 "/usr/include/limits.h" 2 3 4
+
+
+
+
+
+#define MB_LEN_MAX 16
+# 132 "/usr/include/limits.h" 3 4
+#define LLONG_MIN (-LLONG_MAX-1)
+
+
+#define LLONG_MAX __LONG_LONG_MAX__
+
+
+#define ULLONG_MAX (LLONG_MAX * 2ULL + 1)
+# 147 "/usr/include/limits.h" 3 4
+#define CHAR_WIDTH 8
+
+
+#define SCHAR_WIDTH 8
+
+
+#define UCHAR_WIDTH 8
+
+
+#define SHRT_WIDTH 16
+
+
+#define USHRT_WIDTH 16
+
+
+#define INT_WIDTH 32
+
+
+#define UINT_WIDTH 32
+
+
+#define LONG_WIDTH __WORDSIZE
+
+
+#define ULONG_WIDTH __WORDSIZE
+
+
+#define LLONG_WIDTH 64
+
+
+#define ULLONG_WIDTH 64
+
+
+
+
+
+# 1 "/usr/include/bits/posix1_lim.h" 1 3 4
+# 25 "/usr/include/bits/posix1_lim.h" 3 4
+#define _BITS_POSIX1_LIM_H 1
+
+# 1 "/usr/include/bits/wordsize.h" 1 3 4
+
+
+
+#define __WORDSIZE 64
+
+
+
+
+
+
+
+#define __WORDSIZE_TIME64_COMPAT32 1
+
+#define __SYSCALL_WORDSIZE 64
+# 28 "/usr/include/bits/posix1_lim.h" 2 3 4
+
+
+
+
+#define _POSIX_AIO_LISTIO_MAX 2
+
+
+#define _POSIX_AIO_MAX 1
+
+
+#define _POSIX_ARG_MAX 4096
+
+
+
+#define _POSIX_CHILD_MAX 25
+
+
+
+
+
+#define _POSIX_DELAYTIMER_MAX 32
+
+
+
+#define _POSIX_HOST_NAME_MAX 255
+
+
+#define _POSIX_LINK_MAX 8
+
+
+#define _POSIX_LOGIN_NAME_MAX 9
+
+
+#define _POSIX_MAX_CANON 255
+
+
+
+#define _POSIX_MAX_INPUT 255
+
+
+#define _POSIX_MQ_OPEN_MAX 8
+
+
+#define _POSIX_MQ_PRIO_MAX 32
+
+
+#define _POSIX_NAME_MAX 14
+
+
+
+#define _POSIX_NGROUPS_MAX 8
+
+
+
+
+
+
+#define _POSIX_OPEN_MAX 20
+
+
+
+
+
+
+
+#define _POSIX_FD_SETSIZE _POSIX_OPEN_MAX
+
+
+
+#define _POSIX_PATH_MAX 256
+
+
+#define _POSIX_PIPE_BUF 512
+
+
+
+#define _POSIX_RE_DUP_MAX 255
+
+
+#define _POSIX_RTSIG_MAX 8
+
+
+#define _POSIX_SEM_NSEMS_MAX 256
+
+
+#define _POSIX_SEM_VALUE_MAX 32767
+
+
+#define _POSIX_SIGQUEUE_MAX 32
+
+
+#define _POSIX_SSIZE_MAX 32767
+
+
+#define _POSIX_STREAM_MAX 8
+
+
+#define _POSIX_SYMLINK_MAX 255
+
+
+
+#define _POSIX_SYMLOOP_MAX 8
+
+
+#define _POSIX_TIMER_MAX 32
+
+
+#define _POSIX_TTY_NAME_MAX 9
+
+
+
+#define _POSIX_TZNAME_MAX 6
+
+
+
+
+
+
+#define _POSIX_QLIMIT 1
+
+
+
+#define _POSIX_HIWAT _POSIX_PIPE_BUF
+
+
+#define _POSIX_UIO_MAXIOV 16
+
+
+
+#define _POSIX_CLOCKRES_MIN 20000000
+
+
+
+# 1 "/usr/include/bits/local_lim.h" 1 3 4
+# 25 "/usr/include/bits/local_lim.h" 3 4
+#define __undef_NR_OPEN 
+
+
+#define __undef_LINK_MAX 
+
+
+#define __undef_OPEN_MAX 
+
+
+#define __undef_ARG_MAX 
+
+
+
+# 1 "/usr/include/linux/limits.h" 1 3 4
+
+
+#define _LINUX_LIMITS_H 
+
+#define NR_OPEN 1024
+
+#define NGROUPS_MAX 65536
+#define ARG_MAX 131072
+#define LINK_MAX 127
+#define MAX_CANON 255
+#define MAX_INPUT 255
+#define NAME_MAX 255
+#define PATH_MAX 4096
+#define PIPE_BUF 4096
+#define XATTR_NAME_MAX 255
+#define XATTR_SIZE_MAX 65536
+#define XATTR_LIST_MAX 65536
+
+#define RTSIG_MAX 32
+# 39 "/usr/include/bits/local_lim.h" 2 3 4
+
+
+
+#undef NR_OPEN
+#undef __undef_NR_OPEN
+
+
+
+#undef LINK_MAX
+#undef __undef_LINK_MAX
+
+
+
+#undef OPEN_MAX
+#undef __undef_OPEN_MAX
+
+
+
+#undef ARG_MAX
+#undef __undef_ARG_MAX
+
+
+
+#define _POSIX_THREAD_KEYS_MAX 128
+
+#define PTHREAD_KEYS_MAX 1024
+
+
+#define _POSIX_THREAD_DESTRUCTOR_ITERATIONS 4
+
+#define PTHREAD_DESTRUCTOR_ITERATIONS _POSIX_THREAD_DESTRUCTOR_ITERATIONS
+
+
+#define _POSIX_THREAD_THREADS_MAX 64
+
+#undef PTHREAD_THREADS_MAX
+
+
+
+#define AIO_PRIO_DELTA_MAX 20
+
+
+#define PTHREAD_STACK_MIN 16384
+
+
+#define DELAYTIMER_MAX 2147483647
+
+
+#define TTY_NAME_MAX 32
+
+
+#define LOGIN_NAME_MAX 256
+
+
+#define HOST_NAME_MAX 64
+
+
+#define MQ_PRIO_MAX 32768
+
+
+#define SEM_VALUE_MAX (2147483647)
+# 162 "/usr/include/bits/posix1_lim.h" 2 3 4
+
+
+
+
+
+
+
+#define SSIZE_MAX LONG_MAX
+# 184 "/usr/include/limits.h" 2 3 4
+
+
+
+# 1 "/usr/include/bits/posix2_lim.h" 1 3 4
+# 23 "/usr/include/bits/posix2_lim.h" 3 4
+#define _BITS_POSIX2_LIM_H 1
+
+
+
+#define _POSIX2_BC_BASE_MAX 99
+
+
+#define _POSIX2_BC_DIM_MAX 2048
+
+
+#define _POSIX2_BC_SCALE_MAX 99
+
+
+#define _POSIX2_BC_STRING_MAX 1000
+
+
+
+#define _POSIX2_COLL_WEIGHTS_MAX 2
+
+
+
+#define _POSIX2_EXPR_NEST_MAX 32
+
+
+#define _POSIX2_LINE_MAX 2048
+
+
+
+#define _POSIX2_RE_DUP_MAX 255
+
+
+
+#define _POSIX2_CHARCLASS_NAME_MAX 14
+
+
+
+
+
+
+
+#define BC_BASE_MAX _POSIX2_BC_BASE_MAX
+
+
+#define BC_DIM_MAX _POSIX2_BC_DIM_MAX
+
+
+#define BC_SCALE_MAX _POSIX2_BC_SCALE_MAX
+
+
+#define BC_STRING_MAX _POSIX2_BC_STRING_MAX
+
+
+#define COLL_WEIGHTS_MAX 255
+
+
+#define EXPR_NEST_MAX _POSIX2_EXPR_NEST_MAX
+
+
+#define LINE_MAX _POSIX2_LINE_MAX
+
+
+#define CHARCLASS_NAME_MAX 2048
+
+
+
+#define RE_DUP_MAX (0x7fff)
+# 188 "/usr/include/limits.h" 2 3 4
+
+
+
+# 1 "/usr/include/bits/xopen_lim.h" 1 3 4
+# 30 "/usr/include/bits/xopen_lim.h" 3 4
+#define _XOPEN_LIM_H 1
+# 62 "/usr/include/bits/xopen_lim.h" 3 4
+#define _XOPEN_IOV_MAX _POSIX_UIO_MAXIOV
+
+# 1 "/usr/include/bits/uio_lim.h" 1 3 4
+# 20 "/usr/include/bits/uio_lim.h" 3 4
+#define _BITS_UIO_LIM_H 1
+# 30 "/usr/include/bits/uio_lim.h" 3 4
+#define __IOV_MAX 1024
+# 65 "/usr/include/bits/xopen_lim.h" 2 3 4
+
+#define IOV_MAX __IOV_MAX
+
+
+
+
+
+
+#define NL_ARGMAX _POSIX_ARG_MAX
+
+
+#define NL_LANGMAX _POSIX2_LINE_MAX
+
+
+#define NL_MSGMAX INT_MAX
+
+
+
+
+#define NL_NMAX INT_MAX
+
+
+
+#define NL_SETMAX INT_MAX
+
+
+#define NL_TEXTMAX INT_MAX
+
+
+#define NZERO 20
+# 114 "/usr/include/bits/xopen_lim.h" 3 4
+#define WORD_BIT 32
+# 137 "/usr/include/bits/xopen_lim.h" 3 4
+#define LONG_BIT 64
+# 192 "/usr/include/limits.h" 2 3 4
+# 196 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include-fixed/limits.h" 2 3 4
+# 8 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include-fixed/syslimits.h" 2 3 4
+#undef _GCC_NEXT_LIMITS_H
+# 35 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include-fixed/limits.h" 2 3 4
+# 60 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include-fixed/limits.h" 3 4
+#define _LIMITS_H___ 
+
+
+#undef CHAR_BIT
+#define CHAR_BIT __CHAR_BIT__
+
+
+
+
+
+
+
+#undef SCHAR_MIN
+#define SCHAR_MIN (-SCHAR_MAX - 1)
+#undef SCHAR_MAX
+#define SCHAR_MAX __SCHAR_MAX__
+
+
+#undef UCHAR_MAX
+
+
+
+#define UCHAR_MAX (SCHAR_MAX * 2 + 1)
+# 96 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include-fixed/limits.h" 3 4
+#undef CHAR_MIN
+#define CHAR_MIN SCHAR_MIN
+#undef CHAR_MAX
+#define CHAR_MAX SCHAR_MAX
+
+
+
+#undef SHRT_MIN
+#define SHRT_MIN (-SHRT_MAX - 1)
+#undef SHRT_MAX
+#define SHRT_MAX __SHRT_MAX__
+
+
+#undef USHRT_MAX
+
+
+
+#define USHRT_MAX (SHRT_MAX * 2 + 1)
+
+
+
+#undef INT_MIN
+#define INT_MIN (-INT_MAX - 1)
+#undef INT_MAX
+#define INT_MAX __INT_MAX__
+
+
+#undef UINT_MAX
+#define UINT_MAX (INT_MAX * 2U + 1U)
+
+
+
+#undef LONG_MIN
+#define LONG_MIN (-LONG_MAX - 1L)
+#undef LONG_MAX
+#define LONG_MAX __LONG_MAX__
+
+
+#undef ULONG_MAX
+#define ULONG_MAX (LONG_MAX * 2UL + 1UL)
+# 151 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include-fixed/limits.h" 3 4
+#undef LONG_LONG_MIN
+#define LONG_LONG_MIN (-LONG_LONG_MAX - 1LL)
+#undef LONG_LONG_MAX
+#define LONG_LONG_MAX __LONG_LONG_MAX__
+
+
+#undef ULONG_LONG_MAX
+#define ULONG_LONG_MAX (LONG_LONG_MAX * 2ULL + 1ULL)
+# 43 "/usr/include/c++/10.2.0/climits" 2 3
+
+
+#define _GLIBCXX_CLIMITS 1
+# 13 "/usr/include/boost/integer_fwd.hpp" 2 3 4
+
+
+
+# 1 "/usr/include/boost/limits.hpp" 1 3 4
+# 12 "/usr/include/boost/limits.hpp" 3 4
+#define BOOST_LIMITS 
+# 17 "/usr/include/boost/integer_fwd.hpp" 2 3 4
+# 1 "/usr/include/boost/cstdint.hpp" 1 3 4
+# 24 "/usr/include/boost/cstdint.hpp" 3 4
+#define BOOST_CSTDINT_HPP 
+# 46 "/usr/include/boost/cstdint.hpp" 3 4
+       
+# 47 "/usr/include/boost/cstdint.hpp" 3
+# 114 "/usr/include/boost/cstdint.hpp" 3
+namespace boost
+{
+
+  using ::int8_t;
+  using ::int_least8_t;
+  using ::int_fast8_t;
+  using ::uint8_t;
+  using ::uint_least8_t;
+  using ::uint_fast8_t;
+
+  using ::int16_t;
+  using ::int_least16_t;
+  using ::int_fast16_t;
+  using ::uint16_t;
+  using ::uint_least16_t;
+  using ::uint_fast16_t;
+
+  using ::int32_t;
+  using ::int_least32_t;
+  using ::int_fast32_t;
+  using ::uint32_t;
+  using ::uint_least32_t;
+  using ::uint_fast32_t;
+
+
+
+  using ::int64_t;
+  using ::int_least64_t;
+  using ::int_fast64_t;
+  using ::uint64_t;
+  using ::uint_least64_t;
+  using ::uint_fast64_t;
+
+
+
+  using ::intmax_t;
+  using ::uintmax_t;
+
+}
+# 387 "/usr/include/boost/cstdint.hpp" 3
+namespace boost {
+    using ::intptr_t;
+    using ::uintptr_t;
+}
+#define BOOST_HAS_INTPTR_T 
+# 18 "/usr/include/boost/integer_fwd.hpp" 2 3 4
+
+
+namespace boost
+{
+
+
+
+
+
+
+
+     typedef boost::uintmax_t static_min_max_unsigned_type;
+     typedef boost::intmax_t static_min_max_signed_type;
+     typedef boost::uintmax_t static_log2_argument_type;
+     typedef int static_log2_result_type;
+# 42 "/usr/include/boost/integer_fwd.hpp" 3 4
+template < class T >
+    class integer_traits;
+
+template < >
+    class integer_traits< bool >;
+
+template < >
+    class integer_traits< char >;
+
+template < >
+    class integer_traits< signed char >;
+
+template < >
+    class integer_traits< unsigned char >;
+
+
+template < >
+    class integer_traits< wchar_t >;
+
+
+template < >
+    class integer_traits< short >;
+
+template < >
+    class integer_traits< unsigned short >;
+
+template < >
+    class integer_traits< int >;
+
+template < >
+    class integer_traits< unsigned int >;
+
+template < >
+    class integer_traits< long >;
+
+template < >
+    class integer_traits< unsigned long >;
+
+
+template < >
+class integer_traits< ::boost::long_long_type>;
+
+template < >
+class integer_traits< ::boost::ulong_long_type >;
+# 97 "/usr/include/boost/integer_fwd.hpp" 3 4
+template < typename LeastInt >
+    struct int_fast_t;
+
+template< int Bits >
+    struct int_t;
+
+template< int Bits >
+    struct uint_t;
+
+
+    template< boost::long_long_type MaxValue >
+
+
+
+    struct int_max_value_t;
+
+
+  template< boost::long_long_type MinValue >
+
+
+
+    struct int_min_value_t;
+
+
+  template< boost::ulong_long_type MaxValue >
+
+
+
+    struct uint_value_t;
+
+
+
+
+template < std::size_t Bit >
+    struct high_bit_mask_t;
+
+template < std::size_t Bits >
+    struct low_bits_mask_t;
+
+template < >
+    struct low_bits_mask_t< ::std::numeric_limits<unsigned char>::digits >;
+
+
+
+template <static_log2_argument_type Value >
+    struct static_log2;
+
+template <> struct static_log2<0u>;
+
+
+
+
+template <static_min_max_signed_type Value1, static_min_max_signed_type Value2>
+    struct static_signed_min;
+
+template <static_min_max_signed_type Value1, static_min_max_signed_type Value2>
+    struct static_signed_max;
+
+template <static_min_max_unsigned_type Value1, static_min_max_unsigned_type Value2>
+    struct static_unsigned_min;
+
+template <static_min_max_unsigned_type Value1, static_min_max_unsigned_type Value2>
+    struct static_unsigned_max;
+
+
+namespace integer
+{
+
+
+
+
+
+     typedef boost::uintmax_t static_gcd_type;
+
+
+template < static_gcd_type Value1, static_gcd_type Value2 >
+    struct static_gcd;
+template < static_gcd_type Value1, static_gcd_type Value2 >
+    struct static_lcm;
+
+
+
+
+template < typename IntegerType >
+    class gcd_evaluator;
+template < typename IntegerType >
+    class lcm_evaluator;
+
+}
+
+}
+# 19 "/usr/include/boost/integer.hpp" 2 3 4
+
+# 1 "/usr/include/boost/integer_traits.hpp" 1 3 4
+# 17 "/usr/include/boost/integer_traits.hpp" 3 4
+#define BOOST_INTEGER_TRAITS_HPP 
+
+
+
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include-fixed/limits.h" 1 3 4
+# 24 "/usr/include/boost/integer_traits.hpp" 2 3 4
+# 39 "/usr/include/boost/integer_traits.hpp" 3 4
+       
+# 40 "/usr/include/boost/integer_traits.hpp" 3
+
+
+namespace boost {
+template<class T>
+class integer_traits : public std::numeric_limits<T>
+{
+public:
+  static const bool is_integral = false;
+};
+
+namespace detail {
+template<class T, T min_val, T max_val>
+class integer_traits_base
+{
+public:
+  static const bool is_integral = true;
+  static const T const_min = min_val;
+  static const T const_max = max_val;
+};
+
+
+
+template<class T, T min_val, T max_val>
+const bool integer_traits_base<T, min_val, max_val>::is_integral;
+
+template<class T, T min_val, T max_val>
+const T integer_traits_base<T, min_val, max_val>::const_min;
+
+template<class T, T min_val, T max_val>
+const T integer_traits_base<T, min_val, max_val>::const_max;
+
+
+}
+
+template<>
+class integer_traits<bool>
+  : public std::numeric_limits<bool>,
+    public detail::integer_traits_base<bool, false, true>
+{ };
+
+template<>
+class integer_traits<char>
+  : public std::numeric_limits<char>,
+    public detail::integer_traits_base<char, (-0x7f - 1), 0x7f>
+{ };
+
+template<>
+class integer_traits<signed char>
+  : public std::numeric_limits<signed char>,
+    public detail::integer_traits_base<signed char, (-0x7f - 1), 0x7f>
+{ };
+
+template<>
+class integer_traits<unsigned char>
+  : public std::numeric_limits<unsigned char>,
+    public detail::integer_traits_base<unsigned char, 0, (0x7f * 2 + 1)>
+{ };
+
+
+template<>
+class integer_traits<wchar_t>
+  : public std::numeric_limits<wchar_t>,
+
+
+
+    public detail::integer_traits_base<wchar_t, (-0x7fffffff - 1), 0x7fffffff>
+# 125 "/usr/include/boost/integer_traits.hpp" 3
+{ };
+
+
+template<>
+class integer_traits<short>
+  : public std::numeric_limits<short>,
+    public detail::integer_traits_base<short, (-0x7fff - 1), 0x7fff>
+{ };
+
+template<>
+class integer_traits<unsigned short>
+  : public std::numeric_limits<unsigned short>,
+    public detail::integer_traits_base<unsigned short, 0, (0x7fff * 2 + 1)>
+{ };
+
+template<>
+class integer_traits<int>
+  : public std::numeric_limits<int>,
+    public detail::integer_traits_base<int, (-0x7fffffff - 1), 0x7fffffff>
+{ };
+
+template<>
+class integer_traits<unsigned int>
+  : public std::numeric_limits<unsigned int>,
+    public detail::integer_traits_base<unsigned int, 0, (0x7fffffff * 2U + 1U)>
+{ };
+
+template<>
+class integer_traits<long>
+  : public std::numeric_limits<long>,
+    public detail::integer_traits_base<long, (-0x7fffffffffffffffL - 1L), 0x7fffffffffffffffL>
+{ };
+
+template<>
+class integer_traits<unsigned long>
+  : public std::numeric_limits<unsigned long>,
+    public detail::integer_traits_base<unsigned long, 0, (0x7fffffffffffffffL * 2UL + 1UL)>
+{ };
+
+
+
+
+template<>
+class integer_traits< ::boost::long_long_type>
+  : public std::numeric_limits< ::boost::long_long_type>,
+    public detail::integer_traits_base< ::boost::long_long_type, (-0x7fffffffffffffffLL -1), 0x7fffffffffffffffLL>
+{ };
+
+template<>
+class integer_traits< ::boost::ulong_long_type>
+  : public std::numeric_limits< ::boost::ulong_long_type>,
+    public detail::integer_traits_base< ::boost::ulong_long_type, 0, (0x7fffffffffffffffLL * 2ULL + 1)>
+{ };
+# 251 "/usr/include/boost/integer_traits.hpp" 3
+}
+# 21 "/usr/include/boost/integer.hpp" 2 3 4
+
+# 1 "/usr/include/boost/cstdint.hpp" 1 3 4
+# 23 "/usr/include/boost/integer.hpp" 2 3 4
+# 1 "/usr/include/boost/static_assert.hpp" 1 3 4
+# 15 "/usr/include/boost/static_assert.hpp" 3 4
+#define BOOST_STATIC_ASSERT_HPP 
+# 31 "/usr/include/boost/static_assert.hpp" 3 4
+#define BOOST_STATIC_ASSERT_MSG(...) static_assert(__VA_ARGS__)
+# 56 "/usr/include/boost/static_assert.hpp" 3 4
+#define BOOST_STATIC_ASSERT_BOOL_CAST(...) ((__VA_ARGS__) != 0)
+# 70 "/usr/include/boost/static_assert.hpp" 3 4
+#define BOOST_STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
+# 24 "/usr/include/boost/integer.hpp" 2 3 4
+# 34 "/usr/include/boost/integer.hpp" 3 4
+       
+# 35 "/usr/include/boost/integer.hpp" 3
+
+
+namespace boost
+{
+
+
+
+
+
+  template< typename LeastInt >
+  struct int_fast_t
+  {
+     typedef LeastInt fast;
+     typedef fast type;
+  };
+
+  namespace detail{
+
+
+  template< int Category > struct int_least_helper {};
+  template< int Category > struct uint_least_helper {};
+
+
+
+
+
+  template<> struct int_least_helper<1> { typedef boost::long_long_type least; };
+
+
+
+  template<> struct int_least_helper<2> { typedef long least; };
+  template<> struct int_least_helper<3> { typedef int least; };
+  template<> struct int_least_helper<4> { typedef short least; };
+  template<> struct int_least_helper<5> { typedef signed char least; };
+
+  template<> struct uint_least_helper<1> { typedef boost::ulong_long_type least; };
+
+
+
+  template<> struct uint_least_helper<2> { typedef unsigned long least; };
+  template<> struct uint_least_helper<3> { typedef unsigned int least; };
+  template<> struct uint_least_helper<4> { typedef unsigned short least; };
+  template<> struct uint_least_helper<5> { typedef unsigned char least; };
+
+  template <int Bits>
+  struct exact_signed_base_helper{};
+  template <int Bits>
+  struct exact_unsigned_base_helper{};
+
+  template <> struct exact_signed_base_helper<sizeof(signed char)* 8> { typedef signed char exact; };
+  template <> struct exact_unsigned_base_helper<sizeof(unsigned char)* 8> { typedef unsigned char exact; };
+
+  template <> struct exact_signed_base_helper<sizeof(short)* 8> { typedef short exact; };
+  template <> struct exact_unsigned_base_helper<sizeof(unsigned short)* 8> { typedef unsigned short exact; };
+
+
+  template <> struct exact_signed_base_helper<sizeof(int)* 8> { typedef int exact; };
+  template <> struct exact_unsigned_base_helper<sizeof(unsigned int)* 8> { typedef unsigned int exact; };
+
+
+
+  template <> struct exact_signed_base_helper<sizeof(long)* 8> { typedef long exact; };
+  template <> struct exact_unsigned_base_helper<sizeof(unsigned long)* 8> { typedef unsigned long exact; };
+# 109 "/usr/include/boost/integer.hpp" 3
+  }
+
+
+
+
+  template< int Bits >
+  struct int_t : public boost::detail::exact_signed_base_helper<Bits>
+  {
+      static_assert(Bits <= (int)(sizeof(boost::intmax_t) * 8), "No suitable signed integer type with the requested number of bits is available.")
+                                                                                           ;
+      typedef typename boost::detail::int_least_helper
+        <
+
+          (Bits <= (int)(sizeof(boost::long_long_type) * 8)) +
+
+
+
+          (Bits-1 <= ::std::numeric_limits<long>::digits) +
+          (Bits-1 <= ::std::numeric_limits<int>::digits) +
+          (Bits-1 <= ::std::numeric_limits<short>::digits) +
+          (Bits-1 <= ::std::numeric_limits<signed char>::digits)
+        >::least least;
+      typedef typename int_fast_t<least>::type fast;
+  };
+
+
+  template< int Bits >
+  struct uint_t : public boost::detail::exact_unsigned_base_helper<Bits>
+  {
+     static_assert(Bits <= (int)(sizeof(boost::uintmax_t) * 8), "No suitable unsigned integer type with the requested number of bits is available.")
+                                                                                             ;
+# 150 "/usr/include/boost/integer.hpp" 3
+      typedef typename boost::detail::uint_least_helper
+        <
+
+          (Bits <= (int)(sizeof(boost::long_long_type) * 8)) +
+
+
+
+          (Bits <= ::std::numeric_limits<unsigned long>::digits) +
+          (Bits <= ::std::numeric_limits<unsigned int>::digits) +
+          (Bits <= ::std::numeric_limits<unsigned short>::digits) +
+          (Bits <= ::std::numeric_limits<unsigned char>::digits)
+        >::least least;
+
+      typedef typename int_fast_t<least>::type fast;
+
+  };
+
+
+
+
+
+  template< boost::long_long_type MaxValue >
+
+
+
+  struct int_max_value_t
+  {
+      typedef typename boost::detail::int_least_helper
+        <
+
+          (MaxValue <= ::boost::integer_traits<boost::long_long_type>::const_max) +
+
+
+
+          (MaxValue <= ::boost::integer_traits<long>::const_max) +
+          (MaxValue <= ::boost::integer_traits<int>::const_max) +
+          (MaxValue <= ::boost::integer_traits<short>::const_max) +
+          (MaxValue <= ::boost::integer_traits<signed char>::const_max)
+        >::least least;
+      typedef typename int_fast_t<least>::type fast;
+  };
+
+
+  template< boost::long_long_type MinValue >
+
+
+
+  struct int_min_value_t
+  {
+      typedef typename boost::detail::int_least_helper
+        <
+
+          (MinValue >= ::boost::integer_traits<boost::long_long_type>::const_min) +
+
+
+
+          (MinValue >= ::boost::integer_traits<long>::const_min) +
+          (MinValue >= ::boost::integer_traits<int>::const_min) +
+          (MinValue >= ::boost::integer_traits<short>::const_min) +
+          (MinValue >= ::boost::integer_traits<signed char>::const_min)
+        >::least least;
+      typedef typename int_fast_t<least>::type fast;
+  };
+
+
+
+  template< boost::ulong_long_type MaxValue >
+
+
+
+  struct uint_value_t
+  {
+# 243 "/usr/include/boost/integer.hpp" 3
+      typedef typename boost::detail::uint_least_helper
+        <
+
+          (MaxValue <= ::boost::integer_traits<boost::ulong_long_type>::const_max) +
+
+
+
+          (MaxValue <= ::boost::integer_traits<unsigned long>::const_max) +
+          (MaxValue <= ::boost::integer_traits<unsigned int>::const_max) +
+          (MaxValue <= ::boost::integer_traits<unsigned short>::const_max) +
+          (MaxValue <= ::boost::integer_traits<unsigned char>::const_max)
+        >::least least;
+
+      typedef typename int_fast_t<least>::type fast;
+  };
+
+
+}
+# 21 "/usr/include/boost/function/function_base.hpp" 2 3 4
+# 1 "/usr/include/boost/type_index.hpp" 1 3 4
+# 9 "/usr/include/boost/type_index.hpp" 3 4
+#define BOOST_TYPE_INDEX_HPP 
+# 20 "/usr/include/boost/type_index.hpp" 3 4
+        
+# 29 "/usr/include/boost/type_index.hpp" 3 4
+# 1 "/usr/include/boost/type_index/stl_type_index.hpp" 1 3 4
+# 10 "/usr/include/boost/type_index/stl_type_index.hpp" 3 4
+#define BOOST_TYPE_INDEX_STL_TYPE_INDEX_HPP 
+# 22 "/usr/include/boost/type_index/stl_type_index.hpp" 3 4
+# 1 "/usr/include/boost/type_index/type_index_facade.hpp" 1 3 4
+# 10 "/usr/include/boost/type_index/type_index_facade.hpp" 3 4
+#define BOOST_TYPE_INDEX_TYPE_INDEX_FACADE_HPP 
+
+
+# 1 "/usr/include/boost/container_hash/hash_fwd.hpp" 1 3 4
+# 11 "/usr/include/boost/container_hash/hash_fwd.hpp" 3 4
+#define BOOST_FUNCTIONAL_HASH_FWD_HPP 
+
+
+
+
+
+       
+
+
+
+namespace boost
+{
+    template <class T> struct hash;
+
+    template <class T> void hash_combine(std::size_t& seed, T const& v);
+
+    template <class It> std::size_t hash_range(It, It);
+    template <class It> void hash_range(std::size_t&, It, It);
+
+
+
+
+
+}
+# 14 "/usr/include/boost/type_index/type_index_facade.hpp" 2 3 4
+
+# 1 "/usr/include/c++/10.2.0/cstring" 1 3 4
+# 39 "/usr/include/c++/10.2.0/cstring" 3 4
+       
+# 40 "/usr/include/c++/10.2.0/cstring" 3
+
+
+# 1 "/usr/include/string.h" 1 3 4
+# 23 "/usr/include/string.h" 3 4
+#define _STRING_H 1
+
+#define __GLIBC_INTERNAL_STARTING_HEADER_IMPLEMENTATION 
+# 1 "/usr/include/bits/libc-header-start.h" 1 3 4
+# 31 "/usr/include/bits/libc-header-start.h" 3 4
+#undef __GLIBC_INTERNAL_STARTING_HEADER_IMPLEMENTATION
+
+
+
+
+
+#undef __GLIBC_USE_LIB_EXT2
+
+
+#define __GLIBC_USE_LIB_EXT2 1
+# 49 "/usr/include/bits/libc-header-start.h" 3 4
+#undef __GLIBC_USE_IEC_60559_BFP_EXT
+
+#define __GLIBC_USE_IEC_60559_BFP_EXT 1
+
+
+
+#undef __GLIBC_USE_IEC_60559_BFP_EXT_C2X
+
+#define __GLIBC_USE_IEC_60559_BFP_EXT_C2X 1
+# 66 "/usr/include/bits/libc-header-start.h" 3 4
+#undef __GLIBC_USE_IEC_60559_FUNCS_EXT
+
+#define __GLIBC_USE_IEC_60559_FUNCS_EXT 1
+
+
+
+#undef __GLIBC_USE_IEC_60559_FUNCS_EXT_C2X
+
+#define __GLIBC_USE_IEC_60559_FUNCS_EXT_C2X 1
+
+
+
+
+
+
+#undef __GLIBC_USE_IEC_60559_TYPES_EXT
+
+#define __GLIBC_USE_IEC_60559_TYPES_EXT 1
+# 27 "/usr/include/string.h" 2 3 4
+
+extern "C" {
+
+
+#define __need_size_t 
+#define __need_NULL 
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 1 3 4
+# 155 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef __need_ptrdiff_t
+# 231 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef __need_size_t
+# 340 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef __need_wchar_t
+# 390 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef NULL
+
+#define NULL __null
+# 401 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef __need_NULL
+
+
+
+
+#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
+# 34 "/usr/include/string.h" 2 3 4
+
+
+
+
+#define __CORRECT_ISO_CPP_STRING_H_PROTO 
+
+
+
+
+extern void *memcpy (void *__restrict __dest, const void *__restrict __src,
+       size_t __n) throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern void *memmove (void *__dest, const void *__src, size_t __n)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+
+extern void *memccpy (void *__restrict __dest, const void *__restrict __src,
+        int __c, size_t __n)
+    throw () __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__access__ (__write_only__, 1, 4)));
+
+
+
+
+extern void *memset (void *__s, int __c, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int memcmp (const void *__s1, const void *__s2, size_t __n)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+extern "C++"
+{
+extern void *memchr (void *__s, int __c, size_t __n)
+      throw () __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+extern const void *memchr (const void *__s, int __c, size_t __n)
+      throw () __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+# 89 "/usr/include/string.h" 3 4
+}
+# 99 "/usr/include/string.h" 3 4
+extern "C++" void *rawmemchr (void *__s, int __c)
+     throw () __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+extern "C++" const void *rawmemchr (const void *__s, int __c)
+     throw () __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+
+extern "C++" void *memrchr (void *__s, int __c, size_t __n)
+      throw () __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)))
+      __attribute__ ((__access__ (__read_only__, 1, 3)));
+extern "C++" const void *memrchr (const void *__s, int __c, size_t __n)
+      throw () __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)))
+      __attribute__ ((__access__ (__read_only__, 1, 3)));
+# 125 "/usr/include/string.h" 3 4
+extern char *strcpy (char *__restrict __dest, const char *__restrict __src)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+extern char *strncpy (char *__restrict __dest,
+        const char *__restrict __src, size_t __n)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern char *strcat (char *__restrict __dest, const char *__restrict __src)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+extern char *strncat (char *__restrict __dest, const char *__restrict __src,
+        size_t __n) throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int strcmp (const char *__s1, const char *__s2)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+
+extern int strncmp (const char *__s1, const char *__s2, size_t __n)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int strcoll (const char *__s1, const char *__s2)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+
+extern size_t strxfrm (char *__restrict __dest,
+         const char *__restrict __src, size_t __n)
+    throw () __attribute__ ((__nonnull__ (2))) __attribute__ ((__access__ (__write_only__, 1, 3)));
+
+
+
+
+
+
+extern int strcoll_l (const char *__s1, const char *__s2, locale_t __l)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));
+
+
+extern size_t strxfrm_l (char *__dest, const char *__src, size_t __n,
+    locale_t __l) throw () __attribute__ ((__nonnull__ (2, 4)))
+     __attribute__ ((__access__ (__write_only__, 1, 3)));
+
+
+
+
+
+extern char *strdup (const char *__s)
+     throw () __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+extern char *strndup (const char *__string, size_t __n)
+     throw () __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));
+
+
+
+
+#define strdupa(s) (__extension__ ({ const char *__old = (s); size_t __len = strlen (__old) + 1; char *__new = (char *) __builtin_alloca (__len); (char *) memcpy (__new, __old, __len); }))
+# 195 "/usr/include/string.h" 3 4
+#define strndupa(s,n) (__extension__ ({ const char *__old = (s); size_t __len = strnlen (__old, (n)); char *__new = (char *) __builtin_alloca (__len + 1); __new[__len] = '\0'; (char *) memcpy (__new, __old, __len); }))
+# 208 "/usr/include/string.h" 3 4
+extern "C++"
+{
+extern char *strchr (char *__s, int __c)
+     throw () __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+extern const char *strchr (const char *__s, int __c)
+     throw () __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+# 228 "/usr/include/string.h" 3 4
+}
+
+
+
+
+
+
+extern "C++"
+{
+extern char *strrchr (char *__s, int __c)
+     throw () __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+extern const char *strrchr (const char *__s, int __c)
+     throw () __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+# 255 "/usr/include/string.h" 3 4
+}
+# 265 "/usr/include/string.h" 3 4
+extern "C++" char *strchrnul (char *__s, int __c)
+     throw () __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+extern "C++" const char *strchrnul (const char *__s, int __c)
+     throw () __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+# 277 "/usr/include/string.h" 3 4
+extern size_t strcspn (const char *__s, const char *__reject)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern size_t strspn (const char *__s, const char *__accept)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern "C++"
+{
+extern char *strpbrk (char *__s, const char *__accept)
+     throw () __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+extern const char *strpbrk (const char *__s, const char *__accept)
+     throw () __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+# 305 "/usr/include/string.h" 3 4
+}
+
+
+
+
+
+
+extern "C++"
+{
+extern char *strstr (char *__haystack, const char *__needle)
+     throw () __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+extern const char *strstr (const char *__haystack, const char *__needle)
+     throw () __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+# 332 "/usr/include/string.h" 3 4
+}
+
+
+
+
+
+
+
+extern char *strtok (char *__restrict __s, const char *__restrict __delim)
+     throw () __attribute__ ((__nonnull__ (2)));
+
+
+
+extern char *__strtok_r (char *__restrict __s,
+    const char *__restrict __delim,
+    char **__restrict __save_ptr)
+     throw () __attribute__ ((__nonnull__ (2, 3)));
+
+extern char *strtok_r (char *__restrict __s, const char *__restrict __delim,
+         char **__restrict __save_ptr)
+     throw () __attribute__ ((__nonnull__ (2, 3)));
+
+
+
+
+
+extern "C++" char *strcasestr (char *__haystack, const char *__needle)
+     throw () __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+extern "C++" const char *strcasestr (const char *__haystack,
+         const char *__needle)
+     throw () __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+# 373 "/usr/include/string.h" 3 4
+extern void *memmem (const void *__haystack, size_t __haystacklen,
+       const void *__needle, size_t __needlelen)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 3)))
+    __attribute__ ((__access__ (__read_only__, 1, 2)))
+    __attribute__ ((__access__ (__read_only__, 3, 4)));
+
+
+
+extern void *__mempcpy (void *__restrict __dest,
+   const void *__restrict __src, size_t __n)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern void *mempcpy (void *__restrict __dest,
+        const void *__restrict __src, size_t __n)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+extern size_t strlen (const char *__s)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+
+
+
+
+extern size_t strnlen (const char *__string, size_t __maxlen)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+
+
+
+
+extern char *strerror (int __errnum) throw ();
+# 428 "/usr/include/string.h" 3 4
+extern char *strerror_r (int __errnum, char *__buf, size_t __buflen)
+     throw () __attribute__ ((__nonnull__ (2))) __attribute__ ((__access__ (__write_only__, 2, 3)));
+
+
+
+
+extern const char *strerrordesc_np (int __err) throw ();
+
+extern const char *strerrorname_np (int __err) throw ();
+
+
+
+
+
+extern char *strerror_l (int __errnum, locale_t __l) throw ();
+
+
+
+# 1 "/usr/include/strings.h" 1 3 4
+# 19 "/usr/include/strings.h" 3 4
+#define _STRINGS_H 1
+
+
+#define __need_size_t 
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 1 3 4
+# 155 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef __need_ptrdiff_t
+# 231 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef __need_size_t
+# 340 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef __need_wchar_t
+# 390 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef NULL
+
+#define NULL __null
+# 401 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef __need_NULL
+
+
+
+
+#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
+# 24 "/usr/include/strings.h" 2 3 4
+
+
+
+#define __CORRECT_ISO_CPP_STRINGS_H_PROTO 
+
+
+extern "C" {
+
+
+
+extern int bcmp (const void *__s1, const void *__s2, size_t __n)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern void bcopy (const void *__src, void *__dest, size_t __n)
+  throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern void bzero (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern "C++"
+{
+extern char *index (char *__s, int __c)
+     throw () __asm ("index") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+extern const char *index (const char *__s, int __c)
+     throw () __asm ("index") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+# 66 "/usr/include/strings.h" 3 4
+}
+
+
+
+
+
+
+
+extern "C++"
+{
+extern char *rindex (char *__s, int __c)
+     throw () __asm ("rindex") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+extern const char *rindex (const char *__s, int __c)
+     throw () __asm ("rindex") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+# 94 "/usr/include/strings.h" 3 4
+}
+# 104 "/usr/include/strings.h" 3 4
+extern int ffs (int __i) throw () __attribute__ ((__const__));
+
+
+
+
+
+extern int ffsl (long int __l) throw () __attribute__ ((__const__));
+__extension__ extern int ffsll (long long int __ll)
+     throw () __attribute__ ((__const__));
+
+
+
+extern int strcasecmp (const char *__s1, const char *__s2)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int strncasecmp (const char *__s1, const char *__s2, size_t __n)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+
+
+extern int strcasecmp_l (const char *__s1, const char *__s2, locale_t __loc)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));
+
+
+
+extern int strncasecmp_l (const char *__s1, const char *__s2,
+     size_t __n, locale_t __loc)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 4)));
+
+
+}
+# 447 "/usr/include/string.h" 2 3 4
+
+
+
+extern void explicit_bzero (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)))
+    __attribute__ ((__access__ (__write_only__, 1, 2)));
+
+
+
+extern char *strsep (char **__restrict __stringp,
+       const char *__restrict __delim)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+extern char *strsignal (int __sig) throw ();
+
+
+
+extern const char *sigabbrev_np (int __sig) throw ();
+
+
+extern const char *sigdescr_np (int __sig) throw ();
+
+
+
+extern char *__stpcpy (char *__restrict __dest, const char *__restrict __src)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern char *stpcpy (char *__restrict __dest, const char *__restrict __src)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+extern char *__stpncpy (char *__restrict __dest,
+   const char *__restrict __src, size_t __n)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern char *stpncpy (char *__restrict __dest,
+        const char *__restrict __src, size_t __n)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+extern int strverscmp (const char *__s1, const char *__s2)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern char *strfry (char *__string) throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern void *memfrob (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)))
+    __attribute__ ((__access__ (__write_only__, 1, 2)));
+
+
+
+
+
+
+
+extern "C++" char *basename (char *__filename)
+     throw () __asm ("basename") __attribute__ ((__nonnull__ (1)));
+extern "C++" const char *basename (const char *__filename)
+     throw () __asm ("basename") __attribute__ ((__nonnull__ (1)));
+# 523 "/usr/include/string.h" 3 4
+}
+# 43 "/usr/include/c++/10.2.0/cstring" 2 3
+
+
+#define _GLIBCXX_CSTRING 1
+
+
+#undef memchr
+#undef memcmp
+#undef memcpy
+#undef memmove
+#undef memset
+#undef strcat
+#undef strchr
+#undef strcmp
+#undef strcoll
+#undef strcpy
+#undef strcspn
+#undef strerror
+#undef strlen
+#undef strncat
+#undef strncmp
+#undef strncpy
+#undef strpbrk
+#undef strrchr
+#undef strspn
+#undef strstr
+#undef strtok
+#undef strxfrm
+
+extern "C++"
+{
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  using ::memchr;
+  using ::memcmp;
+  using ::memcpy;
+  using ::memmove;
+  using ::memset;
+  using ::strcat;
+  using ::strcmp;
+  using ::strcoll;
+  using ::strcpy;
+  using ::strcspn;
+  using ::strerror;
+  using ::strlen;
+  using ::strncat;
+  using ::strncmp;
+  using ::strncpy;
+  using ::strspn;
+  using ::strtok;
+  using ::strxfrm;
+  using ::strchr;
+  using ::strpbrk;
+  using ::strrchr;
+  using ::strstr;
+# 122 "/usr/include/c++/10.2.0/cstring" 3
+
+}
+}
+# 16 "/usr/include/boost/type_index/type_index_facade.hpp" 2 3 4
+# 26 "/usr/include/boost/type_index/type_index_facade.hpp" 3 4
+        
+
+
+namespace boost { namespace typeindex {
+# 61 "/usr/include/boost/type_index/type_index_facade.hpp" 3 4
+template <class Derived, class TypeInfo>
+class type_index_facade {
+private:
+
+    constexpr const Derived & derived() const noexcept {
+      return *static_cast<Derived const*>(this);
+    }
+
+public:
+    typedef TypeInfo type_info_t;
+
+
+
+    inline const char* name() const noexcept {
+        return derived().raw_name();
+    }
+
+
+
+    inline std::string pretty_name() const {
+        return derived().name();
+    }
+
+
+
+    inline bool equal(const Derived& rhs) const noexcept {
+        const char* const left = derived().raw_name();
+        const char* const right = rhs.raw_name();
+        return left == right || !std::strcmp(left, right);
+    }
+
+
+
+    inline bool before(const Derived& rhs) const noexcept {
+        const char* const left = derived().raw_name();
+        const char* const right = rhs.raw_name();
+        return left != right && std::strcmp(left, right) < 0;
+    }
+
+
+
+
+
+    inline std::size_t hash_code() const noexcept {
+        const char* const name_raw = derived().raw_name();
+        return boost::hash_range(name_raw, name_raw + std::strlen(name_raw));
+    }
+# 150 "/usr/include/boost/type_index/type_index_facade.hpp" 3 4
+};
+
+
+template <class Derived, class TypeInfo>
+constexpr inline bool operator == (const type_index_facade<Derived, TypeInfo>& lhs, const type_index_facade<Derived, TypeInfo>& rhs) noexcept {
+    return static_cast<Derived const&>(lhs).equal(static_cast<Derived const&>(rhs));
+}
+
+template <class Derived, class TypeInfo>
+constexpr inline bool operator < (const type_index_facade<Derived, TypeInfo>& lhs, const type_index_facade<Derived, TypeInfo>& rhs) noexcept {
+    return static_cast<Derived const&>(lhs).before(static_cast<Derived const&>(rhs));
+}
+
+
+
+template <class Derived, class TypeInfo>
+constexpr inline bool operator > (const type_index_facade<Derived, TypeInfo>& lhs, const type_index_facade<Derived, TypeInfo>& rhs) noexcept {
+    return rhs < lhs;
+}
+
+template <class Derived, class TypeInfo>
+constexpr inline bool operator <= (const type_index_facade<Derived, TypeInfo>& lhs, const type_index_facade<Derived, TypeInfo>& rhs) noexcept {
+    return !(lhs > rhs);
+}
+
+template <class Derived, class TypeInfo>
+constexpr inline bool operator >= (const type_index_facade<Derived, TypeInfo>& lhs, const type_index_facade<Derived, TypeInfo>& rhs) noexcept {
+    return !(lhs < rhs);
+}
+
+template <class Derived, class TypeInfo>
+constexpr inline bool operator != (const type_index_facade<Derived, TypeInfo>& lhs, const type_index_facade<Derived, TypeInfo>& rhs) noexcept {
+    return !(lhs == rhs);
+}
+
+
+template <class Derived, class TypeInfo>
+inline bool operator == (const TypeInfo& lhs, const type_index_facade<Derived, TypeInfo>& rhs) noexcept {
+    return Derived(lhs) == rhs;
+}
+
+template <class Derived, class TypeInfo>
+inline bool operator < (const TypeInfo& lhs, const type_index_facade<Derived, TypeInfo>& rhs) noexcept {
+    return Derived(lhs) < rhs;
+}
+
+template <class Derived, class TypeInfo>
+inline bool operator > (const TypeInfo& lhs, const type_index_facade<Derived, TypeInfo>& rhs) noexcept {
+    return rhs < Derived(lhs);
+}
+
+template <class Derived, class TypeInfo>
+inline bool operator <= (const TypeInfo& lhs, const type_index_facade<Derived, TypeInfo>& rhs) noexcept {
+    return !(Derived(lhs) > rhs);
+}
+
+template <class Derived, class TypeInfo>
+inline bool operator >= (const TypeInfo& lhs, const type_index_facade<Derived, TypeInfo>& rhs) noexcept {
+    return !(Derived(lhs) < rhs);
+}
+
+template <class Derived, class TypeInfo>
+inline bool operator != (const TypeInfo& lhs, const type_index_facade<Derived, TypeInfo>& rhs) noexcept {
+    return !(Derived(lhs) == rhs);
+}
+
+
+template <class Derived, class TypeInfo>
+inline bool operator == (const type_index_facade<Derived, TypeInfo>& lhs, const TypeInfo& rhs) noexcept {
+    return lhs == Derived(rhs);
+}
+
+template <class Derived, class TypeInfo>
+inline bool operator < (const type_index_facade<Derived, TypeInfo>& lhs, const TypeInfo& rhs) noexcept {
+    return lhs < Derived(rhs);
+}
+
+template <class Derived, class TypeInfo>
+inline bool operator > (const type_index_facade<Derived, TypeInfo>& lhs, const TypeInfo& rhs) noexcept {
+    return Derived(rhs) < lhs;
+}
+
+template <class Derived, class TypeInfo>
+inline bool operator <= (const type_index_facade<Derived, TypeInfo>& lhs, const TypeInfo& rhs) noexcept {
+    return !(lhs > Derived(rhs));
+}
+
+template <class Derived, class TypeInfo>
+inline bool operator >= (const type_index_facade<Derived, TypeInfo>& lhs, const TypeInfo& rhs) noexcept {
+    return !(lhs < Derived(rhs));
+}
+
+template <class Derived, class TypeInfo>
+inline bool operator != (const type_index_facade<Derived, TypeInfo>& lhs, const TypeInfo& rhs) noexcept {
+    return !(lhs == Derived(rhs));
+}
+# 276 "/usr/include/boost/type_index/type_index_facade.hpp" 3 4
+template <class CharT, class TriatT, class Derived, class TypeInfo>
+inline std::basic_ostream<CharT, TriatT>& operator<<(
+    std::basic_ostream<CharT, TriatT>& ostr,
+    const type_index_facade<Derived, TypeInfo>& ind)
+{
+    ostr << static_cast<Derived const&>(ind).pretty_name();
+    return ostr;
+}
+
+
+
+
+
+template <class Derived, class TypeInfo>
+inline std::size_t hash_value(const type_index_facade<Derived, TypeInfo>& lhs) noexcept {
+    return static_cast<Derived const&>(lhs).hash_code();
+}
+
+}}
+# 23 "/usr/include/boost/type_index/stl_type_index.hpp" 2 3 4
+
+
+
+
+
+
+
+# 1 "/usr/include/c++/10.2.0/cstring" 1 3 4
+# 39 "/usr/include/c++/10.2.0/cstring" 3 4
+       
+# 40 "/usr/include/c++/10.2.0/cstring" 3
+# 31 "/usr/include/boost/type_index/stl_type_index.hpp" 2 3 4
+
+
+
+# 1 "/usr/include/boost/core/demangle.hpp" 1 3 4
+
+#define BOOST_CORE_DEMANGLE_HPP_INCLUDED 
+# 17 "/usr/include/boost/core/demangle.hpp" 3 4
+        
+
+
+
+
+
+
+
+#define BOOST_CORE_HAS_CXXABI_H 
+
+
+
+
+
+
+# 1 "/usr/include/c++/10.2.0/cxxabi.h" 1 3 4
+# 42 "/usr/include/c++/10.2.0/cxxabi.h" 3 4
+#define _CXXABI_H 1
+
+       
+# 45 "/usr/include/c++/10.2.0/cxxabi.h" 3
+
+#pragma GCC visibility push(default)
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 1 3 4
+# 49 "/usr/include/c++/10.2.0/cxxabi.h" 2 3
+
+# 1 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/cxxabi_tweaks.h" 1 3
+# 31 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/cxxabi_tweaks.h" 3
+#define _CXXABI_TWEAKS_H 1
+
+
+namespace __cxxabiv1
+{
+  extern "C"
+  {
+
+
+
+#define _GLIBCXX_GUARD_TEST(x) (*(char *) (x) != 0)
+#define _GLIBCXX_GUARD_SET(x) *(char *) (x) = 1
+#define _GLIBCXX_GUARD_BIT __guard_test_bit (0, 1)
+#define _GLIBCXX_GUARD_PENDING_BIT __guard_test_bit (1, 1)
+#define _GLIBCXX_GUARD_WAITING_BIT __guard_test_bit (2, 1)
+  __extension__ typedef int __guard __attribute__((mode (__DI__)));
+
+
+  typedef void __cxa_vec_ctor_return_type;
+#define _GLIBCXX_CXA_VEC_CTOR_RETURN(x) return
+
+  typedef void __cxa_cdtor_return_type;
+
+
+  }
+}
+# 51 "/usr/include/c++/10.2.0/cxxabi.h" 2 3
+
+
+
+
+namespace __cxxabiv1
+{
+  extern "C"
+  {
+
+
+  typedef __cxa_cdtor_return_type (*__cxa_cdtor_type)(void *);
+
+
+  void*
+  __cxa_vec_new(size_t __element_count, size_t __element_size,
+  size_t __padding_size, __cxa_cdtor_type __constructor,
+  __cxa_cdtor_type __destructor);
+
+  void*
+  __cxa_vec_new2(size_t __element_count, size_t __element_size,
+   size_t __padding_size, __cxa_cdtor_type __constructor,
+   __cxa_cdtor_type __destructor, void *(*__alloc) (size_t),
+   void (*__dealloc) (void*));
+
+  void*
+  __cxa_vec_new3(size_t __element_count, size_t __element_size,
+   size_t __padding_size, __cxa_cdtor_type __constructor,
+   __cxa_cdtor_type __destructor, void *(*__alloc) (size_t),
+   void (*__dealloc) (void*, size_t));
+
+
+  __cxa_vec_ctor_return_type
+  __cxa_vec_ctor(void* __array_address, size_t __element_count,
+   size_t __element_size, __cxa_cdtor_type __constructor,
+   __cxa_cdtor_type __destructor);
+
+  __cxa_vec_ctor_return_type
+  __cxa_vec_cctor(void* __dest_array, void* __src_array,
+    size_t __element_count, size_t __element_size,
+    __cxa_cdtor_return_type (*__constructor) (void*, void*),
+    __cxa_cdtor_type __destructor);
+
+
+  void
+  __cxa_vec_dtor(void* __array_address, size_t __element_count,
+   size_t __element_size, __cxa_cdtor_type __destructor);
+
+  void
+  __cxa_vec_cleanup(void* __array_address, size_t __element_count, size_t __s,
+      __cxa_cdtor_type __destructor) noexcept;
+
+
+  void
+  __cxa_vec_delete(void* __array_address, size_t __element_size,
+     size_t __padding_size, __cxa_cdtor_type __destructor);
+
+  void
+  __cxa_vec_delete2(void* __array_address, size_t __element_size,
+      size_t __padding_size, __cxa_cdtor_type __destructor,
+      void (*__dealloc) (void*));
+
+  void
+  __cxa_vec_delete3(void* __array_address, size_t __element_size,
+      size_t __padding_size, __cxa_cdtor_type __destructor,
+      void (*__dealloc) (void*, size_t));
+
+  int
+  __cxa_guard_acquire(__guard*);
+
+  void
+  __cxa_guard_release(__guard*) noexcept;
+
+  void
+  __cxa_guard_abort(__guard*) noexcept;
+
+
+  int
+  __cxa_atexit(void (*)(void*), void*, void*) noexcept;
+
+  int
+  __cxa_finalize(void*);
+
+
+  int
+  __cxa_thread_atexit(void (*)(void*), void*, void *) noexcept;
+
+
+  void
+  __cxa_pure_virtual(void) __attribute__ ((__noreturn__));
+
+  void
+  __cxa_deleted_virtual(void) __attribute__ ((__noreturn__));
+
+
+  void
+  __cxa_bad_cast() __attribute__((__noreturn__));
+
+  void
+  __cxa_bad_typeid() __attribute__((__noreturn__));
+
+  void
+  __cxa_throw_bad_array_new_length() __attribute__((__noreturn__));
+# 195 "/usr/include/c++/10.2.0/cxxabi.h" 3
+  char*
+  __cxa_demangle(const char* __mangled_name, char* __output_buffer,
+   size_t* __length, int* __status);
+
+
+  }
+}
+
+
+
+
+
+
+namespace __cxxabiv1
+{
+
+  class __fundamental_type_info : public std::type_info
+  {
+  public:
+    explicit
+    __fundamental_type_info(const char* __n) : std::type_info(__n) { }
+
+    virtual
+    ~__fundamental_type_info();
+  };
+
+
+  class __array_type_info : public std::type_info
+  {
+  public:
+    explicit
+    __array_type_info(const char* __n) : std::type_info(__n) { }
+
+    virtual
+    ~__array_type_info();
+  };
+
+
+  class __function_type_info : public std::type_info
+  {
+  public:
+    explicit
+    __function_type_info(const char* __n) : std::type_info(__n) { }
+
+    virtual
+    ~__function_type_info();
+
+  protected:
+
+    virtual bool
+    __is_function_p() const;
+  };
+
+
+  class __enum_type_info : public std::type_info
+  {
+  public:
+    explicit
+    __enum_type_info(const char* __n) : std::type_info(__n) { }
+
+    virtual
+    ~__enum_type_info();
+  };
+
+
+  class __pbase_type_info : public std::type_info
+  {
+  public:
+    unsigned int __flags;
+    const std::type_info* __pointee;
+
+    explicit
+    __pbase_type_info(const char* __n, int __quals,
+        const std::type_info* __type)
+    : std::type_info(__n), __flags(__quals), __pointee(__type)
+    { }
+
+    virtual
+    ~__pbase_type_info();
+
+
+    enum __masks
+      {
+ __const_mask = 0x1,
+ __volatile_mask = 0x2,
+ __restrict_mask = 0x4,
+ __incomplete_mask = 0x8,
+ __incomplete_class_mask = 0x10,
+ __transaction_safe_mask = 0x20,
+ __noexcept_mask = 0x40
+      };
+
+  protected:
+    __pbase_type_info(const __pbase_type_info&);
+
+    __pbase_type_info&
+    operator=(const __pbase_type_info&);
+
+
+    virtual bool
+    __do_catch(const std::type_info* __thr_type, void** __thr_obj,
+        unsigned int __outer) const;
+
+    inline virtual bool
+    __pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj,
+      unsigned __outer) const;
+  };
+
+  inline bool __pbase_type_info::
+  __pointer_catch (const __pbase_type_info *thrown_type,
+     void **thr_obj,
+     unsigned outer) const
+  {
+    return __pointee->__do_catch (thrown_type->__pointee, thr_obj, outer + 2);
+  }
+
+
+  class __pointer_type_info : public __pbase_type_info
+  {
+  public:
+    explicit
+    __pointer_type_info(const char* __n, int __quals,
+   const std::type_info* __type)
+    : __pbase_type_info (__n, __quals, __type) { }
+
+
+    virtual
+    ~__pointer_type_info();
+
+  protected:
+
+    virtual bool
+    __is_pointer_p() const;
+
+    virtual bool
+    __pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj,
+      unsigned __outer) const;
+  };
+
+  class __class_type_info;
+
+
+  class __pointer_to_member_type_info : public __pbase_type_info
+  {
+  public:
+    __class_type_info* __context;
+
+    explicit
+    __pointer_to_member_type_info(const char* __n, int __quals,
+      const std::type_info* __type,
+      __class_type_info* __klass)
+    : __pbase_type_info(__n, __quals, __type), __context(__klass) { }
+
+    virtual
+    ~__pointer_to_member_type_info();
+
+  protected:
+    __pointer_to_member_type_info(const __pointer_to_member_type_info&);
+
+    __pointer_to_member_type_info&
+    operator=(const __pointer_to_member_type_info&);
+
+
+    virtual bool
+    __pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj,
+      unsigned __outer) const;
+  };
+
+
+  class __base_class_type_info
+  {
+  public:
+    const __class_type_info* __base_type;
+
+
+
+    long __offset_flags;
+
+
+    enum __offset_flags_masks
+      {
+ __virtual_mask = 0x1,
+ __public_mask = 0x2,
+ __hwm_bit = 2,
+ __offset_shift = 8
+      };
+
+
+    bool
+    __is_virtual_p() const
+    { return __offset_flags & __virtual_mask; }
+
+    bool
+    __is_public_p() const
+    { return __offset_flags & __public_mask; }
+
+    ptrdiff_t
+    __offset() const
+    {
+
+
+
+      return static_cast<ptrdiff_t>(__offset_flags) >> __offset_shift;
+    }
+  };
+
+
+  class __class_type_info : public std::type_info
+  {
+  public:
+    explicit
+    __class_type_info (const char *__n) : type_info(__n) { }
+
+    virtual
+    ~__class_type_info ();
+
+
+
+
+
+
+    enum __sub_kind
+      {
+
+ __unknown = 0,
+
+
+
+ __not_contained,
+
+
+ __contained_ambig,
+
+
+ __contained_virtual_mask = __base_class_type_info::__virtual_mask,
+
+
+ __contained_public_mask = __base_class_type_info::__public_mask,
+
+
+ __contained_mask = 1 << __base_class_type_info::__hwm_bit,
+
+ __contained_private = __contained_mask,
+ __contained_public = __contained_mask | __contained_public_mask
+      };
+
+    struct __upcast_result;
+    struct __dyncast_result;
+
+  protected:
+
+    virtual bool
+    __do_upcast(const __class_type_info* __dst_type, void**__obj_ptr) const;
+
+    virtual bool
+    __do_catch(const type_info* __thr_type, void** __thr_obj,
+        unsigned __outer) const;
+
+  public:
+
+
+    virtual bool
+    __do_upcast(const __class_type_info* __dst, const void* __obj,
+  __upcast_result& __restrict __result) const;
+
+
+
+
+
+
+
+    inline __sub_kind
+    __find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
+        const __class_type_info* __src_type,
+        const void* __src_ptr) const;
+# 478 "/usr/include/c++/10.2.0/cxxabi.h" 3
+    virtual bool
+    __do_dyncast(ptrdiff_t __src2dst, __sub_kind __access_path,
+   const __class_type_info* __dst_type, const void* __obj_ptr,
+   const __class_type_info* __src_type, const void* __src_ptr,
+   __dyncast_result& __result) const;
+
+
+
+
+
+    virtual __sub_kind
+    __do_find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
+    const __class_type_info* __src_type,
+    const void* __src_ptr) const;
+  };
+
+
+  class __si_class_type_info : public __class_type_info
+  {
+  public:
+    const __class_type_info* __base_type;
+
+    explicit
+    __si_class_type_info(const char *__n, const __class_type_info *__base)
+    : __class_type_info(__n), __base_type(__base) { }
+
+    virtual
+    ~__si_class_type_info();
+
+  protected:
+    __si_class_type_info(const __si_class_type_info&);
+
+    __si_class_type_info&
+    operator=(const __si_class_type_info&);
+
+
+    virtual bool
+    __do_dyncast(ptrdiff_t __src2dst, __sub_kind __access_path,
+   const __class_type_info* __dst_type, const void* __obj_ptr,
+   const __class_type_info* __src_type, const void* __src_ptr,
+   __dyncast_result& __result) const;
+
+    virtual __sub_kind
+    __do_find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
+    const __class_type_info* __src_type,
+    const void* __sub_ptr) const;
+
+    virtual bool
+    __do_upcast(const __class_type_info*__dst, const void*__obj,
+  __upcast_result& __restrict __result) const;
+  };
+
+
+  class __vmi_class_type_info : public __class_type_info
+  {
+  public:
+    unsigned int __flags;
+    unsigned int __base_count;
+
+
+
+
+    __base_class_type_info __base_info[1];
+
+    explicit
+    __vmi_class_type_info(const char* __n, int ___flags)
+    : __class_type_info(__n), __flags(___flags), __base_count(0) { }
+
+    virtual
+    ~__vmi_class_type_info();
+
+
+    enum __flags_masks
+      {
+ __non_diamond_repeat_mask = 0x1,
+ __diamond_shaped_mask = 0x2,
+ __flags_unknown_mask = 0x10
+      };
+
+  protected:
+
+    virtual bool
+    __do_dyncast(ptrdiff_t __src2dst, __sub_kind __access_path,
+   const __class_type_info* __dst_type, const void* __obj_ptr,
+   const __class_type_info* __src_type, const void* __src_ptr,
+   __dyncast_result& __result) const;
+
+    virtual __sub_kind
+    __do_find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
+    const __class_type_info* __src_type,
+    const void* __src_ptr) const;
+
+    virtual bool
+    __do_upcast(const __class_type_info* __dst, const void* __obj,
+  __upcast_result& __restrict __result) const;
+  };
+
+
+  struct __cxa_exception;
+  struct __cxa_refcounted_exception;
+  struct __cxa_dependent_exception;
+  struct __cxa_eh_globals;
+
+  extern "C"
+  {
+# 591 "/usr/include/c++/10.2.0/cxxabi.h" 3
+  void*
+  __dynamic_cast(const void* __src_ptr,
+   const __class_type_info* __src_type,
+   const __class_type_info* __dst_type,
+   ptrdiff_t __src2dst);
+# 604 "/usr/include/c++/10.2.0/cxxabi.h" 3
+  __cxa_eh_globals*
+  __cxa_get_globals() noexcept __attribute__ ((__const__));
+
+  __cxa_eh_globals*
+  __cxa_get_globals_fast() noexcept __attribute__ ((__const__));
+
+
+  void
+  __cxa_free_exception(void*) noexcept;
+
+
+  void
+  __cxa_throw(void*, std::type_info*, void ( *) (void *))
+  __attribute__((__noreturn__));
+
+
+  void*
+  __cxa_get_exception_ptr(void*) noexcept __attribute__ ((__pure__));
+
+  void*
+  __cxa_begin_catch(void*) noexcept;
+
+  void
+  __cxa_end_catch();
+
+  void
+  __cxa_rethrow() __attribute__((__noreturn__));
+
+
+
+  std::type_info*
+  __cxa_current_exception_type() noexcept __attribute__ ((__pure__));
+
+
+
+
+  __cxa_dependent_exception*
+  __cxa_allocate_dependent_exception() noexcept;
+
+
+  void
+  __cxa_free_dependent_exception(__cxa_dependent_exception*) noexcept;
+
+  }
+
+
+
+  class __foreign_exception
+  {
+    virtual ~__foreign_exception() throw();
+    virtual void __pure_dummy() = 0;
+  };
+
+}
+# 679 "/usr/include/c++/10.2.0/cxxabi.h" 3
+namespace abi = __cxxabiv1;
+
+namespace __gnu_cxx
+{
+# 696 "/usr/include/c++/10.2.0/cxxabi.h" 3
+  class recursive_init_error: public std::exception
+  {
+  public:
+    recursive_init_error() noexcept;
+    virtual ~recursive_init_error() noexcept;
+  };
+}
+
+
+#pragma GCC visibility pop
+# 33 "/usr/include/boost/core/demangle.hpp" 2 3 4
+
+
+
+
+
+
+# 1 "/usr/include/c++/10.2.0/cstdlib" 1 3 4
+# 39 "/usr/include/c++/10.2.0/cstdlib" 3 4
+       
+# 40 "/usr/include/c++/10.2.0/cstdlib" 3
+# 40 "/usr/include/boost/core/demangle.hpp" 2 3 4
+
+
+
+
+namespace boost
+{
+
+namespace core
+{
+
+inline char const * demangle_alloc( char const * name ) noexcept;
+inline void demangle_free( char const * name ) noexcept;
+
+class scoped_demangled_name
+{
+private:
+    char const * m_p;
+
+public:
+    explicit scoped_demangled_name( char const * name ) noexcept :
+        m_p( demangle_alloc( name ) )
+    {
+    }
+
+    ~scoped_demangled_name() noexcept
+    {
+        demangle_free( m_p );
+    }
+
+    char const * get() const noexcept
+    {
+        return m_p;
+    }
+
+    scoped_demangled_name( scoped_demangled_name const& ) = delete;
+    scoped_demangled_name& operator= ( scoped_demangled_name const& ) = delete;
+};
+
+
+
+
+inline char const * demangle_alloc( char const * name ) noexcept
+{
+    int status = 0;
+    std::size_t size = 0;
+    return abi::__cxa_demangle( name, __null, &size, &status );
+}
+
+inline void demangle_free( char const * name ) noexcept
+{
+    std::free( const_cast< char* >( name ) );
+}
+
+inline std::string demangle( char const * name )
+{
+    scoped_demangled_name demangled_name( name );
+    char const * p = demangled_name.get();
+    if( !p )
+        p = name;
+    return p;
+}
+# 120 "/usr/include/boost/core/demangle.hpp" 3 4
+}
+
+}
+
+#undef BOOST_CORE_HAS_CXXABI_H
+# 35 "/usr/include/boost/type_index/stl_type_index.hpp" 2 3 4
+# 1 "/usr/include/boost/type_traits/conditional.hpp" 1 3 4
+# 10 "/usr/include/boost/type_traits/conditional.hpp" 3 4
+#define BOOST_TT_CONDITIONAL_HPP_INCLUDED 
+
+
+
+namespace boost {
+
+template <bool b, class T, class U> struct conditional { typedef T type; };
+template <class T, class U> struct conditional<false, T, U> { typedef U type; };
+
+
+
+   template <bool b, class T, class U> using conditional_t = typename conditional<b, T, U>::type;
+
+
+
+}
+# 36 "/usr/include/boost/type_index/stl_type_index.hpp" 2 3 4
+# 1 "/usr/include/boost/type_traits/is_const.hpp" 1 3 4
+# 22 "/usr/include/boost/type_traits/is_const.hpp" 3 4
+#define BOOST_TT_IS_CONST_HPP_INCLUDED 
+
+
+
+
+namespace boost {
+# 36 "/usr/include/boost/type_traits/is_const.hpp" 3 4
+   template <class T>
+   struct is_const : public false_type {};
+   template <class T> struct is_const<T const> : public true_type{};
+   template <class T, std::size_t N> struct is_const<T const[N]> : public true_type{};
+   template <class T> struct is_const<T const[]> : public true_type{};
+
+
+
+}
+# 37 "/usr/include/boost/type_index/stl_type_index.hpp" 2 3 4
+# 1 "/usr/include/boost/type_traits/is_reference.hpp" 1 3 4
+# 13 "/usr/include/boost/type_traits/is_reference.hpp" 3 4
+#define BOOST_TT_IS_REFERENCE_HPP_INCLUDED 
+
+# 1 "/usr/include/boost/type_traits/is_lvalue_reference.hpp" 1 3 4
+# 22 "/usr/include/boost/type_traits/is_lvalue_reference.hpp" 3 4
+#define BOOST_TT_IS_LVALUE_REFERENCE_HPP_INCLUDED 
+
+
+
+namespace boost {
+
+
+
+
+
+   template <class T> struct is_lvalue_reference : public false_type{};
+   template <class T> struct is_lvalue_reference<T&> : public true_type{};
+# 47 "/usr/include/boost/type_traits/is_lvalue_reference.hpp" 3 4
+}
+# 16 "/usr/include/boost/type_traits/is_reference.hpp" 2 3 4
+# 1 "/usr/include/boost/type_traits/is_rvalue_reference.hpp" 1 3 4
+# 10 "/usr/include/boost/type_traits/is_rvalue_reference.hpp" 3 4
+#define BOOST_TT_IS_RVALUE_REFERENCE_HPP_INCLUDED 
+
+
+
+
+namespace boost {
+
+template <class T> struct is_rvalue_reference : public false_type {};
+
+template <class T> struct is_rvalue_reference<T&&> : public true_type {};
+
+
+}
+# 17 "/usr/include/boost/type_traits/is_reference.hpp" 2 3 4
+
+namespace boost {
+
+template <class T> struct is_reference
+   : public
+   integral_constant<
+      bool,
+      ::boost::is_lvalue_reference<T>::value || ::boost::is_rvalue_reference<T>::value>
+{};
+
+}
+# 38 "/usr/include/boost/type_index/stl_type_index.hpp" 2 3 4
+# 1 "/usr/include/boost/type_traits/is_volatile.hpp" 1 3 4
+# 22 "/usr/include/boost/type_traits/is_volatile.hpp" 3 4
+#define BOOST_TT_IS_VOLATILE_HPP_INCLUDED 
+
+
+
+
+namespace boost {
+# 36 "/usr/include/boost/type_traits/is_volatile.hpp" 3 4
+   template <class T>
+   struct is_volatile : public false_type {};
+   template <class T> struct is_volatile<T volatile> : public true_type{};
+   template <class T, std::size_t N> struct is_volatile<T volatile[N]> : public true_type{};
+   template <class T> struct is_volatile<T volatile[]> : public true_type{};
+
+
+
+}
+# 39 "/usr/include/boost/type_index/stl_type_index.hpp" 2 3 4
+
+
+
+
+
+
+#define BOOST_TYPE_INDEX_STD_TYPE_INDEX_HAS_HASH_CODE 
+# 58 "/usr/include/boost/type_index/stl_type_index.hpp" 3 4
+        
+
+
+namespace boost { namespace typeindex {
+
+
+
+
+
+
+class stl_type_index
+    : public type_index_facade<
+        stl_type_index,
+
+
+
+            std::type_info
+
+    >
+{
+public:
+
+
+
+    typedef std::type_info type_info_t;
+
+
+private:
+    const type_info_t* data_;
+
+public:
+    inline stl_type_index() noexcept
+        : data_(&typeid(void))
+    {}
+
+    inline stl_type_index(const type_info_t& data) noexcept
+        : data_(&data)
+    {}
+
+    inline const type_info_t& type_info() const noexcept;
+
+    inline const char* raw_name() const noexcept;
+    inline const char* name() const noexcept;
+    inline std::string pretty_name() const;
+
+    inline std::size_t hash_code() const noexcept;
+    inline bool equal(const stl_type_index& rhs) const noexcept;
+    inline bool before(const stl_type_index& rhs) const noexcept;
+
+    template <class T>
+    inline static stl_type_index type_id() noexcept;
+
+    template <class T>
+    inline static stl_type_index type_id_with_cvr() noexcept;
+
+    template <class T>
+    inline static stl_type_index type_id_runtime(const T& value) noexcept;
+};
+
+inline const stl_type_index::type_info_t& stl_type_index::type_info() const noexcept {
+    return *data_;
+}
+
+
+inline const char* stl_type_index::raw_name() const noexcept {
+
+
+
+    return data_->name();
+
+}
+
+inline const char* stl_type_index::name() const noexcept {
+    return data_->name();
+}
+
+inline std::string stl_type_index::pretty_name() const {
+    static const char cvr_saver_name[] = "boost::typeindex::detail::cvr_saver<";
+    static constexpr std::string::size_type cvr_saver_name_len = sizeof(cvr_saver_name) - 1;
+
+
+
+    const boost::core::scoped_demangled_name demangled_name(data_->name());
+
+    const char* begin = demangled_name.get();
+    if (!begin) {
+        boost::throw_exception(std::runtime_error("Type name demangling failed"));
+    }
+
+    const std::string::size_type len = std::strlen(begin);
+    const char* end = begin + len;
+
+    if (len > cvr_saver_name_len) {
+        const char* b = std::strstr(begin, cvr_saver_name);
+        if (b) {
+            b += cvr_saver_name_len;
+
+
+            while (*b == ' ') {
+                ++ b;
+            }
+
+
+            const char* e = end - 1;
+            while (e > b && *e != '>') {
+                -- e;
+            }
+
+
+            while (e > b && *(e - 1) == ' ') {
+                -- e;
+            }
+
+            if (b < e) {
+
+                begin = b;
+                end = e;
+            }
+        }
+    }
+
+    return std::string(begin, end);
+}
+
+
+inline std::size_t stl_type_index::hash_code() const noexcept {
+
+    return data_->hash_code();
+
+
+
+}
+# 206 "/usr/include/boost/type_index/stl_type_index.hpp" 3 4
+inline bool stl_type_index::equal(const stl_type_index& rhs) const noexcept {
+
+
+
+    return !!(*data_ == *rhs.data_);
+
+}
+
+inline bool stl_type_index::before(const stl_type_index& rhs) const noexcept {
+
+
+
+    return !!data_->before(*rhs.data_);
+
+}
+
+#undef BOOST_TYPE_INDEX_CLASSINFO_COMPARE_BY_NAMES
+
+
+template <class T>
+inline stl_type_index stl_type_index::type_id() noexcept {
+    typedef typename boost::remove_reference<T>::type no_ref_t;
+    typedef typename boost::remove_cv<no_ref_t>::type no_cvr_prefinal_t;
+# 243 "/usr/include/boost/type_index/stl_type_index.hpp" 3 4
+        typedef no_cvr_prefinal_t no_cvr_t;
+
+
+    return typeid(no_cvr_t);
+}
+
+namespace detail {
+    template <class T> class cvr_saver{};
+}
+
+template <class T>
+inline stl_type_index stl_type_index::type_id_with_cvr() noexcept {
+    typedef typename boost::conditional<
+        boost::is_reference<T>::value || boost::is_const<T>::value || boost::is_volatile<T>::value,
+        detail::cvr_saver<T>,
+        T
+    >::type type;
+
+    return typeid(type);
+}
+
+
+template <class T>
+inline stl_type_index stl_type_index::type_id_runtime(const T& value) noexcept {
+
+
+
+    return typeid(value);
+
+}
+
+}}
+
+#undef BOOST_TYPE_INDEX_STD_TYPE_INDEX_HAS_HASH_CODE
+# 30 "/usr/include/boost/type_index.hpp" 2 3 4
+# 49 "/usr/include/boost/type_index.hpp" 3 4
+#define BOOST_TYPE_INDEX_REGISTER_CLASS 
+
+
+namespace boost { namespace typeindex {
+# 132 "/usr/include/boost/type_index.hpp" 3 4
+    typedef boost::typeindex::stl_type_index type_index;
+# 144 "/usr/include/boost/type_index.hpp" 3 4
+typedef type_index::type_info_t type_info;
+# 210 "/usr/include/boost/type_index.hpp" 3 4
+template <class T>
+inline type_index type_id() noexcept {
+    return type_index::type_id<T>();
+}
+# 230 "/usr/include/boost/type_index.hpp" 3 4
+template <class T>
+inline type_index type_id_with_cvr() noexcept {
+    return type_index::type_id_with_cvr<T>();
+}
+# 255 "/usr/include/boost/type_index.hpp" 3 4
+template <class T>
+inline type_index type_id_runtime(const T& runtime_val) noexcept {
+    return type_index::type_id_runtime(runtime_val);
+}
+
+}}
+# 22 "/usr/include/boost/function/function_base.hpp" 2 3 4
+# 1 "/usr/include/boost/type_traits/has_trivial_copy.hpp" 1 3 4
+# 10 "/usr/include/boost/type_traits/has_trivial_copy.hpp" 3 4
+#define BOOST_TT_HAS_TRIVIAL_COPY_HPP_INCLUDED 
+
+
+
+# 1 "/usr/include/boost/type_traits/is_pod.hpp" 1 3 4
+# 10 "/usr/include/boost/type_traits/is_pod.hpp" 3 4
+#define BOOST_TT_IS_POD_HPP_INCLUDED 
+
+
+
+# 1 "/usr/include/boost/type_traits/is_void.hpp" 1 3 4
+# 10 "/usr/include/boost/type_traits/is_void.hpp" 3 4
+#define BOOST_TT_IS_VOID_HPP_INCLUDED 
+
+
+
+namespace boost {
+
+template <class T>
+struct is_void : public false_type {};
+
+template<> struct is_void<void> : public true_type {};
+template<> struct is_void<const void> : public true_type{};
+template<> struct is_void<const volatile void> : public true_type{};
+template<> struct is_void<volatile void> : public true_type{};
+
+}
+# 15 "/usr/include/boost/type_traits/is_pod.hpp" 2 3 4
+# 1 "/usr/include/boost/type_traits/is_scalar.hpp" 1 3 4
+# 10 "/usr/include/boost/type_traits/is_scalar.hpp" 3 4
+#define BOOST_TT_IS_SCALAR_HPP_INCLUDED 
+
+
+
+
+# 1 "/usr/include/boost/type_traits/is_member_pointer.hpp" 1 3 4
+# 22 "/usr/include/boost/type_traits/is_member_pointer.hpp" 3 4
+#define BOOST_TT_IS_MEMBER_POINTER_HPP_INCLUDED 
+
+
+# 1 "/usr/include/boost/type_traits/is_member_function_pointer.hpp" 1 3 4
+# 12 "/usr/include/boost/type_traits/is_member_function_pointer.hpp" 3 4
+#define BOOST_TT_IS_MEMBER_FUNCTION_POINTER_HPP_INCLUDED 
+
+
+
+
+
+# 1 "/usr/include/boost/type_traits/detail/is_member_function_pointer_cxx_11.hpp" 1 3 4
+# 12 "/usr/include/boost/type_traits/detail/is_member_function_pointer_cxx_11.hpp" 3 4
+#define BOOST_TT_IS_MEMBER_FUNCTION_POINTER_CXX_11_HPP_INCLUDED 
+
+
+
+namespace boost {
+
+
+
+
+#define BOOST_TT_DEF_CALL 
+
+
+
+   template <class T>
+   struct is_member_function_pointer : public false_type {};
+   template <class T>
+   struct is_member_function_pointer<T const> : public is_member_function_pointer<T> {};
+   template <class T>
+   struct is_member_function_pointer<T volatile> : public is_member_function_pointer<T> {};
+   template <class T>
+   struct is_member_function_pointer<T const volatile> : public is_member_function_pointer<T> {};
+
+
+
+
+
+
+
+#define BOOST_TT_NOEXCEPT_PARAM , bool NE
+#define BOOST_TT_NOEXCEPT_DECL noexcept(NE)
+
+
+
+
+
+   template <class Ret, class C, class...Args , bool NE>
+   struct is_member_function_pointer<Ret ( C::*)(Args...)noexcept(NE)> : public true_type {};
+   template <class Ret, class C, class ...Args , bool NE>
+   struct is_member_function_pointer<Ret (C::*)(Args..., ...)noexcept(NE)> : public true_type {};
+
+   template <class Ret, class C, class...Args , bool NE>
+   struct is_member_function_pointer<Ret ( C::*)(Args...)const noexcept(NE)> : public true_type {};
+   template <class Ret, class C, class ...Args , bool NE>
+   struct is_member_function_pointer<Ret(C::*)(Args..., ...)const noexcept(NE)> : public true_type {};
+
+   template <class Ret, class C, class...Args , bool NE>
+   struct is_member_function_pointer<Ret ( C::*)(Args...)volatile noexcept(NE)> : public true_type {};
+   template <class Ret, class C, class ...Args , bool NE>
+   struct is_member_function_pointer<Ret(C::*)(Args..., ...)volatile noexcept(NE)> : public true_type {};
+
+   template <class Ret, class C, class...Args , bool NE>
+   struct is_member_function_pointer<Ret ( C::*)(Args...)const volatile noexcept(NE)> : public true_type {};
+   template <class Ret, class C, class ...Args , bool NE>
+   struct is_member_function_pointer<Ret(C::*)(Args..., ...)const volatile noexcept(NE)> : public true_type {};
+
+
+
+   template <class Ret, class C, class...Args , bool NE>
+   struct is_member_function_pointer<Ret ( C::*)(Args...)& noexcept(NE)> : public true_type {};
+   template <class Ret, class C, class ...Args , bool NE>
+   struct is_member_function_pointer<Ret(C::*)(Args..., ...)& noexcept(NE)> : public true_type {};
+
+   template <class Ret, class C, class...Args , bool NE>
+   struct is_member_function_pointer<Ret ( C::*)(Args...)const & noexcept(NE)> : public true_type {};
+   template <class Ret, class C, class ...Args , bool NE>
+   struct is_member_function_pointer<Ret(C::*)(Args..., ...)const & noexcept(NE)> : public true_type {};
+
+   template <class Ret, class C, class...Args , bool NE>
+   struct is_member_function_pointer<Ret ( C::*)(Args...)volatile & noexcept(NE)> : public true_type {};
+   template <class Ret, class C, class ...Args , bool NE>
+   struct is_member_function_pointer<Ret(C::*)(Args..., ...)volatile & noexcept(NE)> : public true_type {};
+
+   template <class Ret, class C, class...Args , bool NE>
+   struct is_member_function_pointer<Ret ( C::*)(Args...)const volatile & noexcept(NE)> : public true_type {};
+   template <class Ret, class C, class ...Args , bool NE>
+   struct is_member_function_pointer<Ret(C::*)(Args..., ...)const volatile & noexcept(NE)> : public true_type {};
+
+
+
+   template <class Ret, class C, class...Args , bool NE>
+   struct is_member_function_pointer<Ret ( C::*)(Args...) && noexcept(NE)> : public true_type {};
+   template <class Ret, class C, class ...Args , bool NE>
+   struct is_member_function_pointer<Ret(C::*)(Args..., ...) && noexcept(NE)> : public true_type {};
+
+   template <class Ret, class C, class...Args , bool NE>
+   struct is_member_function_pointer<Ret ( C::*)(Args...)const && noexcept(NE)> : public true_type {};
+   template <class Ret, class C, class ...Args , bool NE>
+   struct is_member_function_pointer<Ret(C::*)(Args..., ...)const && noexcept(NE)> : public true_type {};
+
+   template <class Ret, class C, class...Args , bool NE>
+   struct is_member_function_pointer<Ret ( C::*)(Args...)volatile && noexcept(NE)> : public true_type {};
+   template <class Ret, class C, class ...Args , bool NE>
+   struct is_member_function_pointer<Ret(C::*)(Args..., ...)volatile && noexcept(NE)> : public true_type {};
+
+   template <class Ret, class C, class...Args , bool NE>
+   struct is_member_function_pointer<Ret ( C::*)(Args...)const volatile && noexcept(NE)> : public true_type {};
+   template <class Ret, class C, class ...Args , bool NE>
+   struct is_member_function_pointer<Ret(C::*)(Args..., ...)const volatile && noexcept(NE)> : public true_type {};
+# 667 "/usr/include/boost/type_traits/detail/is_member_function_pointer_cxx_11.hpp" 3 4
+#undef BOOST_TT_NOEXCEPT_DECL
+#undef BOOST_TT_NOEXCEPT_PARAM
+#undef BOOST_TT_DEF_CALL
+}
+# 19 "/usr/include/boost/type_traits/is_member_function_pointer.hpp" 2 3 4
+# 26 "/usr/include/boost/type_traits/is_member_pointer.hpp" 2 3 4
+
+namespace boost {
+
+
+
+
+template <class T> struct is_member_pointer : public integral_constant<bool, ::boost::is_member_function_pointer<T>::value>{};
+template <class T, class U> struct is_member_pointer<U T::* > : public true_type{};
+
+
+template <class T, class U> struct is_member_pointer<U T::*const> : public true_type{};
+template <class T, class U> struct is_member_pointer<U T::*const volatile> : public true_type{};
+template <class T, class U> struct is_member_pointer<U T::*volatile> : public true_type{};
+
+
+
+
+}
+# 16 "/usr/include/boost/type_traits/is_scalar.hpp" 2 3 4
+
+
+namespace boost {
+
+template <typename T>
+struct is_scalar
+   : public integral_constant<bool, ::boost::is_arithmetic<T>::value || ::boost::is_enum<T>::value || ::boost::is_pointer<T>::value || ::boost::is_member_pointer<T>::value>
+{};
+
+}
+# 16 "/usr/include/boost/type_traits/is_pod.hpp" 2 3 4
+# 27 "/usr/include/boost/type_traits/is_pod.hpp" 3 4
+#define BOOST_INTERNAL_IS_POD(T) BOOST_IS_POD(T)
+
+
+namespace boost {
+
+
+template< typename T > struct is_POD;
+
+template <typename T> struct is_pod
+: public integral_constant<bool, ::boost::is_scalar<T>::value || ::boost::is_void<T>::value || __is_pod(T)>
+{};
+
+
+template <typename T, std::size_t sz> struct is_pod<T[sz]> : public is_pod<T>{};
+
+
+
+
+template<> struct is_pod<void> : public true_type{};
+
+
+template<> struct is_pod<void const> : public true_type{};
+template<> struct is_pod<void const volatile> : public true_type{};
+template<> struct is_pod<void volatile> : public true_type{};
+
+
+template<class T> struct is_POD : public is_pod<T>{};
+
+}
+
+#undef BOOST_INTERNAL_IS_POD
+# 15 "/usr/include/boost/type_traits/has_trivial_copy.hpp" 2 3 4
+
+
+
+# 1 "/usr/include/boost/type_traits/is_copy_constructible.hpp" 1 3 4
+# 10 "/usr/include/boost/type_traits/is_copy_constructible.hpp" 3 4
+#define BOOST_TT_IS_COPY_CONSTRUCTIBLE_HPP_INCLUDED 
+
+
+
+
+
+
+# 1 "/usr/include/boost/type_traits/is_constructible.hpp" 1 3 4
+# 10 "/usr/include/boost/type_traits/is_constructible.hpp" 3 4
+#define BOOST_TT_IS_CONSTRUCTIBLE_HPP_INCLUDED 
+
+
+
+
+
+
+# 1 "/usr/include/boost/type_traits/is_destructible.hpp" 1 3 4
+# 10 "/usr/include/boost/type_traits/is_destructible.hpp" 3 4
+#define BOOST_TT_IS_DESTRUCTIBLE_HPP_INCLUDED 
+
+
+
+
+# 1 "/usr/include/boost/type_traits/is_complete.hpp" 1 3 4
+# 10 "/usr/include/boost/type_traits/is_complete.hpp" 3 4
+#define BOOST_TT_IS_COMPLETE_HPP_INCLUDED 
+
+# 1 "/usr/include/boost/type_traits/declval.hpp" 1 3 4
+# 9 "/usr/include/boost/type_traits/declval.hpp" 3 4
+#define BOOST_TYPE_TRAITS_DECLVAL_HPP_INCLUDED 
+
+
+
+
+
+# 1 "/usr/include/boost/type_traits/add_rvalue_reference.hpp" 1 3 4
+# 9 "/usr/include/boost/type_traits/add_rvalue_reference.hpp" 3 4
+#define BOOST_TYPE_TRAITS_EXT_ADD_RVALUE_REFERENCE__HPP 
+# 31 "/usr/include/boost/type_traits/add_rvalue_reference.hpp" 3 4
+namespace boost {
+
+namespace type_traits_detail {
+
+    template <typename T, bool b>
+    struct add_rvalue_reference_helper
+    { typedef T type; };
+
+
+    template <typename T>
+    struct add_rvalue_reference_helper<T, true>
+    {
+        typedef T&& type;
+    };
+
+
+    template <typename T>
+    struct add_rvalue_reference_imp
+    {
+       typedef typename boost::type_traits_detail::add_rvalue_reference_helper
+                  <T, (is_void<T>::value == false && is_reference<T>::value == false) >::type type;
+    };
+
+}
+
+template <class T> struct add_rvalue_reference
+{
+   typedef typename boost::type_traits_detail::add_rvalue_reference_imp<T>::type type;
+};
+
+
+
+   template <class T> using add_rvalue_reference_t = typename add_rvalue_reference<T>::type;
+
+
+
+}
+# 16 "/usr/include/boost/type_traits/declval.hpp" 2 3 4
+# 37 "/usr/include/boost/type_traits/declval.hpp" 3 4
+namespace boost {
+
+    template <typename T>
+    typename add_rvalue_reference<T>::type declval() noexcept;
+
+}
+# 13 "/usr/include/boost/type_traits/is_complete.hpp" 2 3 4
+
+
+# 1 "/usr/include/boost/type_traits/is_function.hpp" 1 3 4
+# 12 "/usr/include/boost/type_traits/is_function.hpp" 3 4
+#define BOOST_TT_IS_FUNCTION_HPP_INCLUDED 
+
+
+
+
+
+
+# 1 "/usr/include/boost/type_traits/detail/is_function_cxx_11.hpp" 1 3 4
+# 12 "/usr/include/boost/type_traits/detail/is_function_cxx_11.hpp" 3 4
+#define BOOST_TT_IS_FUNCTION_CXX_11_HPP_INCLUDED 
+
+
+
+namespace boost {
+
+   template <class T>
+   struct is_function : public false_type {};
+
+
+#define BOOST_TT_NOEXCEPT_PARAM , bool NE
+#define BOOST_TT_NOEXCEPT_DECL noexcept(NE)
+# 32 "/usr/include/boost/type_traits/detail/is_function_cxx_11.hpp" 3 4
+#define BOOST_TT_DEF_CALL 
+
+
+   template <class Ret, class...Args , bool NE>
+   struct is_function<Ret (Args...)noexcept(NE)> : public true_type {};
+   template <class Ret, class ...Args , bool NE>
+   struct is_function<Ret(Args..., ...)noexcept(NE)> : public true_type {};
+
+   template <class Ret, class...Args , bool NE>
+   struct is_function<Ret (Args...)const noexcept(NE)> : public true_type {};
+   template <class Ret, class ...Args , bool NE>
+   struct is_function<Ret(Args..., ...)const noexcept(NE)> : public true_type {};
+
+   template <class Ret, class...Args , bool NE>
+   struct is_function<Ret (Args...)volatile noexcept(NE)> : public true_type {};
+   template <class Ret, class ...Args , bool NE>
+   struct is_function<Ret(Args..., ...)volatile noexcept(NE)> : public true_type {};
+
+   template <class Ret, class...Args , bool NE>
+   struct is_function<Ret (Args...)const volatile noexcept(NE)> : public true_type {};
+   template <class Ret, class ...Args , bool NE>
+   struct is_function<Ret(Args..., ...)const volatile noexcept(NE)> : public true_type {};
+
+
+
+   template <class Ret, class...Args , bool NE>
+   struct is_function<Ret (Args...)& noexcept(NE)> : public true_type {};
+   template <class Ret, class ...Args , bool NE>
+   struct is_function<Ret(Args..., ...)& noexcept(NE)> : public true_type {};
+
+   template <class Ret, class...Args , bool NE>
+   struct is_function<Ret (Args...)const & noexcept(NE)> : public true_type {};
+   template <class Ret, class ...Args , bool NE>
+   struct is_function<Ret(Args..., ...)const & noexcept(NE)> : public true_type {};
+
+   template <class Ret, class...Args , bool NE>
+   struct is_function<Ret (Args...)volatile & noexcept(NE)> : public true_type {};
+   template <class Ret, class ...Args , bool NE>
+   struct is_function<Ret(Args..., ...)volatile & noexcept(NE)> : public true_type {};
+
+   template <class Ret, class...Args , bool NE>
+   struct is_function<Ret (Args...)const volatile & noexcept(NE)> : public true_type {};
+   template <class Ret, class ...Args , bool NE>
+   struct is_function<Ret(Args..., ...)const volatile & noexcept(NE)> : public true_type {};
+
+
+
+   template <class Ret, class...Args , bool NE>
+   struct is_function<Ret (Args...)&& noexcept(NE)> : public true_type {};
+   template <class Ret, class ...Args , bool NE>
+   struct is_function<Ret(Args..., ...)&& noexcept(NE)> : public true_type {};
+
+   template <class Ret, class...Args , bool NE>
+   struct is_function<Ret (Args...)const && noexcept(NE)> : public true_type {};
+   template <class Ret, class ...Args , bool NE>
+   struct is_function<Ret(Args..., ...)const && noexcept(NE)> : public true_type {};
+
+   template <class Ret, class...Args , bool NE>
+   struct is_function<Ret (Args...)volatile && noexcept(NE)> : public true_type {};
+   template <class Ret, class ...Args , bool NE>
+   struct is_function<Ret(Args..., ...)volatile && noexcept(NE)> : public true_type {};
+
+   template <class Ret, class...Args , bool NE>
+   struct is_function<Ret (Args...)const volatile && noexcept(NE)> : public true_type {};
+   template <class Ret, class ...Args , bool NE>
+   struct is_function<Ret(Args..., ...)const volatile && noexcept(NE)> : public true_type {};
+# 590 "/usr/include/boost/type_traits/detail/is_function_cxx_11.hpp" 3 4
+}
+
+#undef BOOST_TT_NOEXCEPT_DECL
+#undef BOOST_TT_NOEXCEPT_PARAM
+#undef BOOST_TT_DEF_CALL
+# 20 "/usr/include/boost/type_traits/is_function.hpp" 2 3 4
+# 16 "/usr/include/boost/type_traits/is_complete.hpp" 2 3 4
+# 1 "/usr/include/boost/type_traits/detail/yes_no_type.hpp" 1 3 4
+# 12 "/usr/include/boost/type_traits/detail/yes_no_type.hpp" 3 4
+#define BOOST_TT_DETAIL_YES_NO_TYPE_HPP_INCLUDED 
+
+namespace boost {
+namespace type_traits {
+
+typedef char yes_type;
+struct no_type
+{
+   char padding[8];
+};
+
+}
+}
+# 17 "/usr/include/boost/type_traits/is_complete.hpp" 2 3 4
+# 31 "/usr/include/boost/type_traits/is_complete.hpp" 3 4
+namespace boost {
+
+
+
+
+
+#define BOOST_TT_HAS_WORKING_IS_COMPLETE 
+
+
+
+   namespace detail{
+
+      template <unsigned N>
+      struct ok_tag { double d; char c[N]; };
+
+      template <class T>
+      ok_tag<sizeof(T)> check_is_complete(int);
+      template <class T>
+      char check_is_complete(...);
+   }
+
+   template <class T> struct is_complete
+      : public integral_constant<bool, ::boost::is_function<typename boost::remove_reference<T>::type>::value || (sizeof(boost::detail::check_is_complete<T>(0)) != sizeof(char))> {};
+# 90 "/usr/include/boost/type_traits/is_complete.hpp" 3 4
+}
+# 16 "/usr/include/boost/type_traits/is_destructible.hpp" 2 3 4
+
+
+
+
+
+
+
+namespace boost{
+
+   namespace detail{
+
+      struct is_destructible_imp
+      {
+         template<typename T, typename = decltype(boost::declval<T&>().~T())>
+         static boost::type_traits::yes_type test(int);
+         template<typename>
+         static boost::type_traits::no_type test(...);
+      };
+
+   }
+
+   template <class T> struct is_destructible : public integral_constant<bool, sizeof(boost::detail::is_destructible_imp::test<T>(0)) == sizeof(boost::type_traits::yes_type)>
+   {
+      static_assert(boost::is_complete<T>::value, "Arguments to is_destructible must be complete types");
+   };
+# 56 "/usr/include/boost/type_traits/is_destructible.hpp" 3 4
+   template <> struct is_destructible<void> : public false_type{};
+   template <> struct is_destructible<void const> : public false_type{};
+   template <> struct is_destructible<void volatile> : public false_type{};
+   template <> struct is_destructible<void const volatile> : public false_type{};
+   template <class T> struct is_destructible<T&> : public is_destructible<T>{};
+
+   template <class T> struct is_destructible<T&&> : public is_destructible<T>{};
+
+   template <class T, std::size_t N> struct is_destructible<T[N]> : public is_destructible<T>{};
+   template <class T> struct is_destructible<T[]> : public is_destructible<T>{};
+
+}
+# 18 "/usr/include/boost/type_traits/is_constructible.hpp" 2 3 4
+# 1 "/usr/include/boost/type_traits/is_default_constructible.hpp" 1 3 4
+# 10 "/usr/include/boost/type_traits/is_default_constructible.hpp" 3 4
+#define BOOST_TT_IS_DEFAULT_CONSTRUCTIBLE_HPP_INCLUDED 
+# 29 "/usr/include/boost/type_traits/is_default_constructible.hpp" 3 4
+namespace boost{
+
+   namespace detail{
+
+      struct is_default_constructible_imp
+      {
+         template<typename _Tp, typename = decltype(_Tp())>
+         static boost::type_traits::yes_type test(int);
+
+         template<typename>
+         static boost::type_traits::no_type test(...);
+      };
+# 53 "/usr/include/boost/type_traits/is_default_constructible.hpp" 3 4
+   }
+
+
+
+
+
+
+
+   template <class T> struct is_default_constructible : public integral_constant<bool, sizeof(boost::detail::is_default_constructible_imp::test<T>(0)) == sizeof(boost::type_traits::yes_type)>
+   {
+      static_assert(boost::is_complete<T>::value, "Arguments to is_default_constructible must be complete types");
+   };
+
+   template <class T, std::size_t N> struct is_default_constructible<T[N]> : public is_default_constructible<T>{};
+   template <class T> struct is_default_constructible<T[]> : public is_default_constructible<T>{};
+   template <class T> struct is_default_constructible<T&> : public integral_constant<bool, false>{};
+
+
+
+
+   template <class T> struct is_default_constructible<T&&> : public integral_constant<bool, false>{};
+
+   template <> struct is_default_constructible<void> : public integral_constant<bool, false>{};
+   template <> struct is_default_constructible<void const> : public integral_constant<bool, false>{};
+   template <> struct is_default_constructible<void volatile> : public integral_constant<bool, false>{};
+   template <> struct is_default_constructible<void const volatile> : public integral_constant<bool, false>{};
+# 96 "/usr/include/boost/type_traits/is_default_constructible.hpp" 3 4
+}
+# 19 "/usr/include/boost/type_traits/is_constructible.hpp" 2 3 4
+
+
+
+
+
+#define BOOST_TT_IS_CONSTRUCTIBLE_CONFORMING 1
+
+namespace boost{
+
+   namespace detail{
+
+      struct is_constructible_imp
+      {
+         template<typename T, typename ...TheArgs, typename = decltype(T(boost::declval<TheArgs>()...))>
+         static boost::type_traits::yes_type test(int);
+         template<typename, typename...>
+         static boost::type_traits::no_type test(...);
+
+         template<typename T, typename Arg, typename = decltype(::new T(boost::declval<Arg>()))>
+         static boost::type_traits::yes_type test1(int);
+         template<typename, typename>
+         static boost::type_traits::no_type test1(...);
+
+         template <typename T>
+         static boost::type_traits::yes_type ref_test(T);
+         template <typename T>
+         static boost::type_traits::no_type ref_test(...);
+      };
+
+   }
+
+   template <class T, class ...Args> struct is_constructible : public integral_constant<bool, sizeof(detail::is_constructible_imp::test<T, Args...>(0)) == sizeof(boost::type_traits::yes_type)>
+   {
+      static_assert(::boost::is_complete<T>::value, "The target type must be complete in order to test for constructibility");
+   };
+   template <class T, class Arg> struct is_constructible<T, Arg> : public integral_constant<bool, is_destructible<T>::value && sizeof(boost::detail::is_constructible_imp::test1<T, Arg>(0)) == sizeof(boost::type_traits::yes_type)>
+   {
+      static_assert(::boost::is_complete<T>::value, "The target type must be complete in order to test for constructibility");
+   };
+   template <class Ref, class Arg> struct is_constructible<Ref&, Arg> : public integral_constant<bool, sizeof(detail::is_constructible_imp::ref_test<Ref&>(boost::declval<Arg>())) == sizeof(boost::type_traits::yes_type)>{};
+   template <class Ref, class Arg> struct is_constructible<Ref&&, Arg> : public integral_constant<bool, sizeof(detail::is_constructible_imp::ref_test<Ref&&>(boost::declval<Arg>())) == sizeof(boost::type_traits::yes_type)>{};
+
+   template <> struct is_constructible<void> : public false_type{};
+   template <> struct is_constructible<void const> : public false_type{};
+   template <> struct is_constructible<void const volatile> : public false_type{};
+   template <> struct is_constructible<void volatile> : public false_type{};
+
+   template <class T> struct is_constructible<T> : public is_default_constructible<T>{};
+# 88 "/usr/include/boost/type_traits/is_constructible.hpp" 3 4
+}
+# 18 "/usr/include/boost/type_traits/is_copy_constructible.hpp" 2 3 4
+
+
+
+namespace boost {
+
+template <class T> struct is_copy_constructible : public boost::is_constructible<T, const T&>{};
+
+template <> struct is_copy_constructible<void> : public false_type{};
+template <> struct is_copy_constructible<void const> : public false_type{};
+template <> struct is_copy_constructible<void const volatile> : public false_type{};
+template <> struct is_copy_constructible<void volatile> : public false_type{};
+
+}
+# 19 "/usr/include/boost/type_traits/has_trivial_copy.hpp" 2 3 4
+#define BOOST_TT_TRIVIAL_CONSTRUCT_FIX && is_copy_constructible<T>::value
+# 29 "/usr/include/boost/type_traits/has_trivial_copy.hpp" 3 4
+namespace boost {
+
+template <typename T> struct has_trivial_copy
+: public integral_constant<bool,
+
+   ((__has_trivial_copy(T) ) && !is_reference<T>::value) && is_copy_constructible<T>::value
+
+
+
+>{};
+
+template <typename T, std::size_t N> struct has_trivial_copy<T[N]> : public false_type{};
+template <typename T> struct has_trivial_copy<T[]> : public false_type{};
+
+template <typename T> struct has_trivial_copy<T volatile> : public false_type{};
+
+template <> struct has_trivial_copy<void> : public false_type{};
+
+template <> struct has_trivial_copy<void const> : public false_type{};
+template <> struct has_trivial_copy<void volatile> : public false_type{};
+template <> struct has_trivial_copy<void const volatile> : public false_type{};
+
+
+template <class T> struct has_trivial_copy<T&> : public false_type{};
+
+template <class T> struct has_trivial_copy<T&&> : public false_type{};
+
+
+template <class T> struct has_trivial_copy_constructor : public has_trivial_copy<T>{};
+
+#undef BOOST_TT_TRIVIAL_CONSTRUCT_FIX
+
+}
+# 23 "/usr/include/boost/function/function_base.hpp" 2 3 4
+# 1 "/usr/include/boost/type_traits/has_trivial_destructor.hpp" 1 3 4
+# 10 "/usr/include/boost/type_traits/has_trivial_destructor.hpp" 3 4
+#define BOOST_TT_HAS_TRIVIAL_DESTRUCTOR_HPP_INCLUDED 
+# 28 "/usr/include/boost/type_traits/has_trivial_destructor.hpp" 3 4
+namespace boost {
+
+template <typename T> struct has_trivial_destructor : public integral_constant<bool, (__has_trivial_destructor(T) && is_destructible<T>::value)>{};
+# 39 "/usr/include/boost/type_traits/has_trivial_destructor.hpp" 3 4
+template <> struct has_trivial_destructor<void> : public false_type{};
+
+template <> struct has_trivial_destructor<void const> : public false_type{};
+template <> struct has_trivial_destructor<void const volatile> : public false_type{};
+template <> struct has_trivial_destructor<void volatile> : public false_type{};
+
+
+}
+# 24 "/usr/include/boost/function/function_base.hpp" 2 3 4
+
+
+
+# 1 "/usr/include/boost/type_traits/composite_traits.hpp" 1 3 4
+# 14 "/usr/include/boost/type_traits/composite_traits.hpp" 3 4
+#define BOOST_TT_COMPOSITE_TRAITS_HPP_INCLUDED 
+
+# 1 "/usr/include/boost/type_traits/is_array.hpp" 1 3 4
+# 15 "/usr/include/boost/type_traits/is_array.hpp" 3 4
+#define BOOST_TT_IS_ARRAY_HPP_INCLUDED 
+
+
+
+
+namespace boost {
+
+
+
+
+   template <class T> struct is_array : public false_type {};
+
+   template <class T, std::size_t N> struct is_array<T[N]> : public true_type {};
+   template <class T, std::size_t N> struct is_array<T const[N]> : public true_type{};
+   template <class T, std::size_t N> struct is_array<T volatile[N]> : public true_type{};
+   template <class T, std::size_t N> struct is_array<T const volatile[N]> : public true_type{};
+
+   template <class T> struct is_array<T[]> : public true_type{};
+   template <class T> struct is_array<T const[]> : public true_type{};
+   template <class T> struct is_array<T const volatile[]> : public true_type{};
+   template <class T> struct is_array<T volatile[]> : public true_type{};
+
+
+
+
+
+}
+# 17 "/usr/include/boost/type_traits/composite_traits.hpp" 2 3 4
+
+
+
+
+
+# 1 "/usr/include/boost/type_traits/is_union.hpp" 1 3 4
+# 12 "/usr/include/boost/type_traits/is_union.hpp" 3 4
+#define BOOST_TT_IS_UNION_HPP_INCLUDED 
+
+
+
+
+namespace boost {
+
+
+template <class T> struct is_union : public integral_constant<bool, __is_union(T)> {};
+
+
+
+
+template <class T> struct is_union<T const> : public is_union<T>{};
+template <class T> struct is_union<T volatile const> : public is_union<T>{};
+template <class T> struct is_union<T volatile> : public is_union<T>{};
+
+}
+# 23 "/usr/include/boost/type_traits/composite_traits.hpp" 2 3 4
+# 28 "/usr/include/boost/function/function_base.hpp" 2 3 4
+# 1 "/usr/include/boost/ref.hpp" 1 3 4
+# 10 "/usr/include/boost/ref.hpp" 3 4
+#define BOOST_REF_HPP 
+
+
+
+
+# 1 "/usr/include/boost/core/ref.hpp" 1 3 4
+
+#define BOOST_CORE_REF_HPP 
+# 40 "/usr/include/boost/core/ref.hpp" 3 4
+namespace boost
+{
+# 60 "/usr/include/boost/core/ref.hpp" 3 4
+template<class T> class reference_wrapper
+{
+public:
+
+
+
+    typedef T type;
+
+
+
+
+
+
+
+    inline __attribute__ ((__always_inline__)) explicit reference_wrapper(T& t): t_(boost::addressof(t)) {}
+# 86 "/usr/include/boost/core/ref.hpp" 3 4
+    reference_wrapper(T&& t) = delete;
+public:
+
+
+
+
+
+
+    inline __attribute__ ((__always_inline__)) operator T& () const { return *t_; }
+
+
+
+
+
+    inline __attribute__ ((__always_inline__)) T& get() const { return *t_; }
+
+
+
+
+
+
+    inline __attribute__ ((__always_inline__)) T* get_pointer() const { return t_; }
+
+private:
+
+    T* t_;
+};
+# 122 "/usr/include/boost/core/ref.hpp" 3 4
+#define BOOST_REF_CONST const
+# 132 "/usr/include/boost/core/ref.hpp" 3 4
+template<class T> inline __attribute__ ((__always_inline__)) reference_wrapper<T> const ref( T & t )
+{
+
+
+
+
+
+
+    return reference_wrapper<T>( t );
+
+
+}
+
+
+
+
+
+
+
+template<class T> inline __attribute__ ((__always_inline__)) reference_wrapper<T const> const cref( T const & t )
+{
+    return reference_wrapper<T const>(t);
+}
+
+#undef BOOST_REF_CONST
+# 166 "/usr/include/boost/core/ref.hpp" 3 4
+#define BOOST_REF_DELETE = delete
+# 175 "/usr/include/boost/core/ref.hpp" 3 4
+template<class T> void ref(T const&&) = delete;
+
+
+
+
+template<class T> void cref(T const&&) = delete;
+
+#undef BOOST_REF_DELETE
+# 195 "/usr/include/boost/core/ref.hpp" 3 4
+template<typename T> struct is_reference_wrapper
+{
+    static const bool value = false;
+};
+
+
+
+
+template<typename T> struct is_reference_wrapper< reference_wrapper<T> >
+{
+    static const bool value = true;
+};
+
+
+
+template<typename T> struct is_reference_wrapper< reference_wrapper<T> const >
+{
+    static const bool value = true;
+};
+
+template<typename T> struct is_reference_wrapper< reference_wrapper<T> volatile >
+{
+    static const bool value = true;
+};
+
+template<typename T> struct is_reference_wrapper< reference_wrapper<T> const volatile >
+{
+    static const bool value = true;
+};
+# 240 "/usr/include/boost/core/ref.hpp" 3 4
+template<typename T> struct unwrap_reference
+{
+    typedef T type;
+};
+
+
+
+
+template<typename T> struct unwrap_reference< reference_wrapper<T> >
+{
+    typedef T type;
+};
+
+
+
+template<typename T> struct unwrap_reference< reference_wrapper<T> const >
+{
+    typedef T type;
+};
+
+template<typename T> struct unwrap_reference< reference_wrapper<T> volatile >
+{
+    typedef T type;
+};
+
+template<typename T> struct unwrap_reference< reference_wrapper<T> const volatile >
+{
+    typedef T type;
+};
+# 282 "/usr/include/boost/core/ref.hpp" 3 4
+template<class T> inline __attribute__ ((__always_inline__)) typename unwrap_reference<T>::type& unwrap_ref( T & t )
+{
+    return t;
+}
+
+
+
+
+
+
+template<class T> inline __attribute__ ((__always_inline__)) T* get_pointer( reference_wrapper<T> const & r )
+{
+    return r.get_pointer();
+}
+
+
+
+
+}
+# 16 "/usr/include/boost/ref.hpp" 2 3 4
+# 29 "/usr/include/boost/function/function_base.hpp" 2 3 4
+
+
+# 1 "/usr/include/boost/type_traits/alignment_of.hpp" 1 3 4
+# 10 "/usr/include/boost/type_traits/alignment_of.hpp" 3 4
+#define BOOST_TT_ALIGNMENT_OF_HPP_INCLUDED 
+# 26 "/usr/include/boost/type_traits/alignment_of.hpp" 3 4
+namespace boost {
+
+template <typename T> struct alignment_of;
+
+
+namespace detail {
+
+
+
+
+
+template <typename T>
+struct alignment_of_hack
+{
+    char c;
+    T t;
+    alignment_of_hack();
+};
+
+
+
+
+template <unsigned A, unsigned S>
+struct alignment_logic
+{
+    static const std::size_t value = A < S ? A : S;
+};
+
+
+template< typename T >
+struct alignment_of_impl
+{
+# 82 "/usr/include/boost/type_traits/alignment_of.hpp" 3 4
+   static const std::size_t value = __alignof__(T);
+
+};
+
+}
+
+template <class T> struct alignment_of : public integral_constant<std::size_t, ::boost::detail::alignment_of_impl<T>::value>{};
+
+
+
+template <typename T> struct alignment_of<T&> : public alignment_of<T*>{};
+# 102 "/usr/include/boost/type_traits/alignment_of.hpp" 3 4
+template<> struct alignment_of<void> : integral_constant<std::size_t, 0>{};
+
+template<> struct alignment_of<void const> : integral_constant<std::size_t, 0>{};
+template<> struct alignment_of<void const volatile> : integral_constant<std::size_t, 0>{};
+template<> struct alignment_of<void volatile> : integral_constant<std::size_t, 0>{};
+
+
+}
+# 32 "/usr/include/boost/function/function_base.hpp" 2 3 4
+
+# 1 "/usr/include/boost/type_traits/enable_if.hpp" 1 3 4
+# 16 "/usr/include/boost/type_traits/enable_if.hpp" 3 4
+#define BOOST_TT_ENABLE_IF_HPP_INCLUDED 
+
+
+
+namespace boost {
+
+template<bool B, class T = void>
+struct enable_if_ {
+    typedef T type;
+};
+
+template<class T>
+struct enable_if_<false, T> { };
+
+
+template<bool B, class T = void>
+using enable_if_t = typename enable_if_<B, T>::type;
+
+
+}
+# 34 "/usr/include/boost/function/function_base.hpp" 2 3 4
+
+
+
+# 1 "/usr/include/boost/function_equal.hpp" 1 3 4
+# 11 "/usr/include/boost/function_equal.hpp" 3 4
+#define BOOST_FUNCTION_EQUAL_HPP 
+
+namespace boost {
+
+template<typename F, typename G>
+  bool function_equal_impl(const F& f, const G& g, long)
+  { return f == g; }
+
+
+
+
+template<typename F, typename G>
+  bool function_equal(const F& f, const G& g)
+  { return function_equal_impl(f, g, 0); }
+
+}
+# 38 "/usr/include/boost/function/function_base.hpp" 2 3 4
+# 1 "/usr/include/boost/function/function_fwd.hpp" 1 3 4
+# 10 "/usr/include/boost/function/function_fwd.hpp" 3 4
+#define BOOST_FUNCTION_FWD_HPP 
+# 27 "/usr/include/boost/function/function_fwd.hpp" 3 4
+namespace boost {
+  class bad_function_call;
+
+
+
+  template<typename Signature> class function;
+
+  template<typename Signature>
+  inline void swap(function<Signature>& f1, function<Signature>& f2)
+  {
+    f1.swap(f2);
+  }
+
+
+
+  template<typename R> class function0;
+  template<typename R, typename T1> class function1;
+  template<typename R, typename T1, typename T2> class function2;
+  template<typename R, typename T1, typename T2, typename T3> class function3;
+  template<typename R, typename T1, typename T2, typename T3, typename T4>
+    class function4;
+  template<typename R, typename T1, typename T2, typename T3, typename T4,
+           typename T5>
+    class function5;
+  template<typename R, typename T1, typename T2, typename T3, typename T4,
+           typename T5, typename T6>
+    class function6;
+  template<typename R, typename T1, typename T2, typename T3, typename T4,
+           typename T5, typename T6, typename T7>
+    class function7;
+  template<typename R, typename T1, typename T2, typename T3, typename T4,
+           typename T5, typename T6, typename T7, typename T8>
+    class function8;
+  template<typename R, typename T1, typename T2, typename T3, typename T4,
+           typename T5, typename T6, typename T7, typename T8, typename T9>
+    class function9;
+  template<typename R, typename T1, typename T2, typename T3, typename T4,
+           typename T5, typename T6, typename T7, typename T8, typename T9,
+           typename T10>
+    class function10;
+}
+# 39 "/usr/include/boost/function/function_base.hpp" 2 3 4
+# 49 "/usr/include/boost/function/function_base.hpp" 3 4
+#define BOOST_FUNCTION_TARGET_FIX(x) 
+
+
+#define BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor,Type) typename ::boost::enable_if_< !(::boost::is_integral<Functor>::value), Type>::type
+
+
+
+
+namespace boost {
+  namespace detail {
+    namespace function {
+      class X;
+
+
+
+
+
+
+
+      union function_buffer_members
+      {
+
+        typedef void* obj_ptr_t;
+        mutable obj_ptr_t obj_ptr;
+
+
+        struct type_t {
+
+          const boost::typeindex::type_info* type;
+
+
+          bool const_qualified;
+
+          bool volatile_qualified;
+        } type;
+
+
+        typedef void (*func_ptr_t)();
+        mutable func_ptr_t func_ptr;
+
+
+        struct bound_memfunc_ptr_t {
+          void (X::*memfunc_ptr)(int);
+          void* obj_ptr;
+        } bound_memfunc_ptr;
+
+
+
+        struct obj_ref_t {
+          mutable void* obj_ptr;
+          bool is_const_qualified;
+          bool is_volatile_qualified;
+        } obj_ref;
+      };
+
+      union __attribute__((__visibility__("default"))) function_buffer
+      {
+
+        mutable function_buffer_members members;
+
+
+        mutable char data[sizeof(function_buffer_members)];
+      };
+
+
+
+
+
+
+
+      struct unusable
+      {
+        unusable() {}
+        template<typename T> unusable(const T&) {}
+      };
+
+
+
+
+
+      template<typename T> struct function_return_type { typedef T type; };
+
+      template<>
+      struct function_return_type<void>
+      {
+        typedef unusable type;
+      };
+
+
+      enum functor_manager_operation_type {
+        clone_functor_tag,
+        move_functor_tag,
+        destroy_functor_tag,
+        check_functor_type_tag,
+        get_functor_type_tag
+      };
+
+
+      struct function_ptr_tag {};
+      struct function_obj_tag {};
+      struct member_ptr_tag {};
+      struct function_obj_ref_tag {};
+
+      template<typename F>
+      class get_function_tag
+      {
+        typedef typename conditional<(is_pointer<F>::value),
+                                   function_ptr_tag,
+                                   function_obj_tag>::type ptr_or_obj_tag;
+
+        typedef typename conditional<(is_member_pointer<F>::value),
+                                   member_ptr_tag,
+                                   ptr_or_obj_tag>::type ptr_or_obj_or_mem_tag;
+
+        typedef typename conditional<(is_reference_wrapper<F>::value),
+                                   function_obj_ref_tag,
+                                   ptr_or_obj_or_mem_tag>::type or_ref_tag;
+
+      public:
+        typedef or_ref_tag type;
+      };
+
+
+
+      template<typename F>
+      struct reference_manager
+      {
+        static inline void
+        manage(const function_buffer& in_buffer, function_buffer& out_buffer,
+               functor_manager_operation_type op)
+        {
+          switch (op) {
+          case clone_functor_tag:
+            out_buffer.members.obj_ref = in_buffer.members.obj_ref;
+            return;
+
+          case move_functor_tag:
+            out_buffer.members.obj_ref = in_buffer.members.obj_ref;
+            in_buffer.members.obj_ref.obj_ptr = 0;
+            return;
+
+          case destroy_functor_tag:
+            out_buffer.members.obj_ref.obj_ptr = 0;
+            return;
+
+          case check_functor_type_tag:
+            {
+
+
+              if (*out_buffer.members.type.type == boost::typeindex::type_id<F>()
+                  && (!in_buffer.members.obj_ref.is_const_qualified
+                      || out_buffer.members.type.const_qualified)
+                  && (!in_buffer.members.obj_ref.is_volatile_qualified
+                      || out_buffer.members.type.volatile_qualified))
+                out_buffer.members.obj_ptr = in_buffer.members.obj_ref.obj_ptr;
+              else
+                out_buffer.members.obj_ptr = 0;
+            }
+            return;
+
+          case get_functor_type_tag:
+            out_buffer.members.type.type = &boost::typeindex::type_id<F>().type_info();
+            out_buffer.members.type.const_qualified = in_buffer.members.obj_ref.is_const_qualified;
+            out_buffer.members.type.volatile_qualified = in_buffer.members.obj_ref.is_volatile_qualified;
+            return;
+          }
+        }
+      };
+
+
+
+
+
+      template<typename F>
+      struct function_allows_small_object_optimization
+      {
+        static const bool value = ((sizeof(F) <= sizeof(function_buffer) && (alignment_of<function_buffer>::value % alignment_of<F>::value == 0)))
+
+
+
+                                                       ;
+      };
+
+      template <typename F,typename A>
+      struct functor_wrapper: public F, public A
+      {
+        functor_wrapper( F f, A a ):
+          F(f),
+          A(a)
+        {
+        }
+
+        functor_wrapper(const functor_wrapper& f) :
+          F(static_cast<const F&>(f)),
+          A(static_cast<const A&>(f))
+        {
+        }
+      };
+
+
+
+
+
+      template<typename Functor>
+      struct functor_manager_common
+      {
+        typedef Functor functor_type;
+
+
+        static inline void
+        manage_ptr(const function_buffer& in_buffer, function_buffer& out_buffer,
+                functor_manager_operation_type op)
+        {
+          if (op == clone_functor_tag)
+            out_buffer.members.func_ptr = in_buffer.members.func_ptr;
+          else if (op == move_functor_tag) {
+            out_buffer.members.func_ptr = in_buffer.members.func_ptr;
+            in_buffer.members.func_ptr = 0;
+          } else if (op == destroy_functor_tag)
+            out_buffer.members.func_ptr = 0;
+          else if (op == check_functor_type_tag) {
+            if (*out_buffer.members.type.type == boost::typeindex::type_id<Functor>())
+              out_buffer.members.obj_ptr = &in_buffer.members.func_ptr;
+            else
+              out_buffer.members.obj_ptr = 0;
+          } else {
+            out_buffer.members.type.type = &boost::typeindex::type_id<Functor>().type_info();
+            out_buffer.members.type.const_qualified = false;
+            out_buffer.members.type.volatile_qualified = false;
+          }
+        }
+
+
+        static inline void
+        manage_small(const function_buffer& in_buffer, function_buffer& out_buffer,
+                functor_manager_operation_type op)
+        {
+          if (op == clone_functor_tag || op == move_functor_tag) {
+            const functor_type* in_functor =
+              reinterpret_cast<const functor_type*>(in_buffer.data);
+            new (reinterpret_cast<void*>(out_buffer.data)) functor_type(*in_functor);
+
+            if (op == move_functor_tag) {
+              functor_type* f = reinterpret_cast<functor_type*>(in_buffer.data);
+              (void)f;
+              f->~Functor();
+            }
+          } else if (op == destroy_functor_tag) {
+
+             functor_type* f = reinterpret_cast<functor_type*>(out_buffer.data);
+             (void)f;
+             f->~Functor();
+          } else if (op == check_functor_type_tag) {
+             if (*out_buffer.members.type.type == boost::typeindex::type_id<Functor>())
+              out_buffer.members.obj_ptr = in_buffer.data;
+            else
+              out_buffer.members.obj_ptr = 0;
+          } else {
+            out_buffer.members.type.type = &boost::typeindex::type_id<Functor>().type_info();
+            out_buffer.members.type.const_qualified = false;
+            out_buffer.members.type.volatile_qualified = false;
+          }
+        }
+      };
+
+      template<typename Functor>
+      struct functor_manager
+      {
+      private:
+        typedef Functor functor_type;
+
+
+        static inline void
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+                functor_manager_operation_type op, function_ptr_tag)
+        {
+          functor_manager_common<Functor>::manage_ptr(in_buffer,out_buffer,op);
+        }
+
+
+        static inline void
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+                functor_manager_operation_type op, true_type)
+        {
+          functor_manager_common<Functor>::manage_small(in_buffer,out_buffer,op);
+        }
+
+
+        static inline void
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+                functor_manager_operation_type op, false_type)
+        {
+          if (op == clone_functor_tag) {
+
+
+
+
+
+            const functor_type* f =
+              static_cast<const functor_type*>(in_buffer.members.obj_ptr);
+            functor_type* new_f = new functor_type(*f);
+            out_buffer.members.obj_ptr = new_f;
+          } else if (op == move_functor_tag) {
+            out_buffer.members.obj_ptr = in_buffer.members.obj_ptr;
+            in_buffer.members.obj_ptr = 0;
+          } else if (op == destroy_functor_tag) {
+
+            functor_type* f =
+              static_cast<functor_type*>(out_buffer.members.obj_ptr);
+            delete f;
+            out_buffer.members.obj_ptr = 0;
+          } else if (op == check_functor_type_tag) {
+            if (*out_buffer.members.type.type == boost::typeindex::type_id<Functor>())
+              out_buffer.members.obj_ptr = in_buffer.members.obj_ptr;
+            else
+              out_buffer.members.obj_ptr = 0;
+          } else {
+            out_buffer.members.type.type = &boost::typeindex::type_id<Functor>().type_info();
+            out_buffer.members.type.const_qualified = false;
+            out_buffer.members.type.volatile_qualified = false;
+          }
+        }
+
+
+
+
+        static inline void
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+                functor_manager_operation_type op, function_obj_tag)
+        {
+          manager(in_buffer, out_buffer, op,
+                  integral_constant<bool, (function_allows_small_object_optimization<functor_type>::value)>());
+        }
+
+
+        static inline void
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+                functor_manager_operation_type op, member_ptr_tag)
+        {
+          manager(in_buffer, out_buffer, op, true_type());
+        }
+
+      public:
+
+
+        static inline void
+        manage(const function_buffer& in_buffer, function_buffer& out_buffer,
+               functor_manager_operation_type op)
+        {
+          typedef typename get_function_tag<functor_type>::type tag_type;
+          if (op == get_functor_type_tag) {
+            out_buffer.members.type.type = &boost::typeindex::type_id<functor_type>().type_info();
+            out_buffer.members.type.const_qualified = false;
+            out_buffer.members.type.volatile_qualified = false;
+          } else {
+            manager(in_buffer, out_buffer, op, tag_type());
+          }
+        }
+      };
+
+      template<typename Functor, typename Allocator>
+      struct functor_manager_a
+      {
+      private:
+        typedef Functor functor_type;
+
+
+        static inline void
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+                functor_manager_operation_type op, function_ptr_tag)
+        {
+          functor_manager_common<Functor>::manage_ptr(in_buffer,out_buffer,op);
+        }
+
+
+        static inline void
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+                functor_manager_operation_type op, true_type)
+        {
+          functor_manager_common<Functor>::manage_small(in_buffer,out_buffer,op);
+        }
+
+
+        static inline void
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+                functor_manager_operation_type op, false_type)
+        {
+          typedef functor_wrapper<Functor,Allocator> functor_wrapper_type;
+
+
+
+
+
+          using wrapper_allocator_type = typename std::allocator_traits<Allocator>::template rebind_alloc<functor_wrapper_type>;
+          using wrapper_allocator_pointer_type = typename std::allocator_traits<wrapper_allocator_type>::pointer;
+
+
+          if (op == clone_functor_tag) {
+
+
+
+            const functor_wrapper_type* f =
+              static_cast<const functor_wrapper_type*>(in_buffer.members.obj_ptr);
+            wrapper_allocator_type wrapper_allocator(static_cast<Allocator const &>(*f));
+            wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
+
+
+
+            std::allocator_traits<wrapper_allocator_type>::construct(wrapper_allocator, copy, *f);
+
+
+
+            functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
+            out_buffer.members.obj_ptr = new_f;
+          } else if (op == move_functor_tag) {
+            out_buffer.members.obj_ptr = in_buffer.members.obj_ptr;
+            in_buffer.members.obj_ptr = 0;
+          } else if (op == destroy_functor_tag) {
+
+            functor_wrapper_type* victim =
+              static_cast<functor_wrapper_type*>(in_buffer.members.obj_ptr);
+            wrapper_allocator_type wrapper_allocator(static_cast<Allocator const &>(*victim));
+
+
+
+            std::allocator_traits<wrapper_allocator_type>::destroy(wrapper_allocator, victim);
+
+            wrapper_allocator.deallocate(victim,1);
+            out_buffer.members.obj_ptr = 0;
+          } else if (op == check_functor_type_tag) {
+            if (*out_buffer.members.type.type == boost::typeindex::type_id<Functor>())
+              out_buffer.members.obj_ptr = in_buffer.members.obj_ptr;
+            else
+              out_buffer.members.obj_ptr = 0;
+          } else {
+            out_buffer.members.type.type = &boost::typeindex::type_id<Functor>().type_info();
+            out_buffer.members.type.const_qualified = false;
+            out_buffer.members.type.volatile_qualified = false;
+          }
+        }
+
+
+
+
+        static inline void
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+                functor_manager_operation_type op, function_obj_tag)
+        {
+          manager(in_buffer, out_buffer, op,
+                  integral_constant<bool, (function_allows_small_object_optimization<functor_type>::value)>());
+        }
+
+      public:
+
+
+        static inline void
+        manage(const function_buffer& in_buffer, function_buffer& out_buffer,
+               functor_manager_operation_type op)
+        {
+          typedef typename get_function_tag<functor_type>::type tag_type;
+          if (op == get_functor_type_tag) {
+            out_buffer.members.type.type = &boost::typeindex::type_id<functor_type>().type_info();
+            out_buffer.members.type.const_qualified = false;
+            out_buffer.members.type.volatile_qualified = false;
+          } else {
+            manager(in_buffer, out_buffer, op, tag_type());
+          }
+        }
+      };
+
+
+      struct useless_clear_type {};
+# 585 "/usr/include/boost/function/function_base.hpp" 3 4
+      struct vtable_base
+      {
+        void (*manager)(const function_buffer& in_buffer,
+                        function_buffer& out_buffer,
+                        functor_manager_operation_type op);
+      };
+    }
+  }
+
+
+
+
+
+
+
+class function_base
+{
+public:
+  function_base() : vtable(0) { }
+
+
+  bool empty() const { return !vtable; }
+
+
+
+  const boost::typeindex::type_info& target_type() const
+  {
+    if (!vtable) return boost::typeindex::type_id<void>().type_info();
+
+    detail::function::function_buffer type;
+    get_vtable()->manager(functor, type, detail::function::get_functor_type_tag);
+    return *type.members.type.type;
+  }
+
+  template<typename Functor>
+    Functor* target()
+    {
+      if (!vtable) return 0;
+
+      detail::function::function_buffer type_result;
+      type_result.members.type.type = &boost::typeindex::type_id<Functor>().type_info();
+      type_result.members.type.const_qualified = is_const<Functor>::value;
+      type_result.members.type.volatile_qualified = is_volatile<Functor>::value;
+      get_vtable()->manager(functor, type_result,
+                      detail::function::check_functor_type_tag);
+      return static_cast<Functor*>(type_result.members.obj_ptr);
+    }
+
+  template<typename Functor>
+    const Functor* target() const
+    {
+      if (!vtable) return 0;
+
+      detail::function::function_buffer type_result;
+      type_result.members.type.type = &boost::typeindex::type_id<Functor>().type_info();
+      type_result.members.type.const_qualified = true;
+      type_result.members.type.volatile_qualified = is_volatile<Functor>::value;
+      get_vtable()->manager(functor, type_result,
+                      detail::function::check_functor_type_tag);
+
+
+      return static_cast<const Functor*>(type_result.members.obj_ptr);
+    }
+
+  template<typename F>
+    bool contains(const F& f) const
+    {
+      if (const F* fp = this->template target<F>())
+      {
+        return function_equal(*fp, f);
+      } else {
+        return false;
+      }
+    }
+# 683 "/usr/include/boost/function/function_base.hpp" 3 4
+public:
+  detail::function::vtable_base* get_vtable() const {
+    return reinterpret_cast<detail::function::vtable_base*>(
+             reinterpret_cast<std::size_t>(vtable) & ~static_cast<std::size_t>(0x01));
+  }
+
+  bool has_trivial_copy_and_destroy() const {
+    return reinterpret_cast<std::size_t>(vtable) & 0x01;
+  }
+
+  detail::function::vtable_base* vtable;
+  mutable detail::function::function_buffer functor;
+};
+# 705 "/usr/include/boost/function/function_base.hpp" 3 4
+class __attribute__((__visibility__("default"))) bad_function_call : public std::runtime_error
+{
+public:
+  bad_function_call() : std::runtime_error("call to empty boost::function") {}
+};
+
+
+
+
+
+inline bool operator==(const function_base& f,
+                       detail::function::useless_clear_type*)
+{
+  return f.empty();
+}
+
+inline bool operator!=(const function_base& f,
+                       detail::function::useless_clear_type*)
+{
+  return !f.empty();
+}
+
+inline bool operator==(detail::function::useless_clear_type*,
+                       const function_base& f)
+{
+  return f.empty();
+}
+
+inline bool operator!=(detail::function::useless_clear_type*,
+                       const function_base& f)
+{
+  return !f.empty();
+}
+# 775 "/usr/include/boost/function/function_base.hpp" 3 4
+template<typename Functor>
+  typename ::boost::enable_if_< !(::boost::is_integral<Functor>::value), bool>::type
+  operator==(const function_base& f, Functor g)
+  {
+    if (const Functor* fp = f.template target<Functor>())
+      return function_equal(*fp, g);
+    else return false;
+  }
+
+template<typename Functor>
+  typename ::boost::enable_if_< !(::boost::is_integral<Functor>::value), bool>::type
+  operator==(Functor g, const function_base& f)
+  {
+    if (const Functor* fp = f.template target<Functor>())
+      return function_equal(g, *fp);
+    else return false;
+  }
+
+template<typename Functor>
+  typename ::boost::enable_if_< !(::boost::is_integral<Functor>::value), bool>::type
+  operator!=(const function_base& f, Functor g)
+  {
+    if (const Functor* fp = f.template target<Functor>())
+      return !function_equal(*fp, g);
+    else return true;
+  }
+
+template<typename Functor>
+  typename ::boost::enable_if_< !(::boost::is_integral<Functor>::value), bool>::type
+  operator!=(Functor g, const function_base& f)
+  {
+    if (const Functor* fp = f.template target<Functor>())
+      return !function_equal(g, *fp);
+    else return true;
+  }
+
+
+template<typename Functor>
+  typename ::boost::enable_if_< !(::boost::is_integral<Functor>::value), bool>::type
+  operator==(const function_base& f, reference_wrapper<Functor> g)
+  {
+    if (const Functor* fp = f.template target<Functor>())
+      return fp == g.get_pointer();
+    else return false;
+  }
+
+template<typename Functor>
+  typename ::boost::enable_if_< !(::boost::is_integral<Functor>::value), bool>::type
+  operator==(reference_wrapper<Functor> g, const function_base& f)
+  {
+    if (const Functor* fp = f.template target<Functor>())
+      return g.get_pointer() == fp;
+    else return false;
+  }
+
+template<typename Functor>
+  typename ::boost::enable_if_< !(::boost::is_integral<Functor>::value), bool>::type
+  operator!=(const function_base& f, reference_wrapper<Functor> g)
+  {
+    if (const Functor* fp = f.template target<Functor>())
+      return fp != g.get_pointer();
+    else return true;
+  }
+
+template<typename Functor>
+  typename ::boost::enable_if_< !(::boost::is_integral<Functor>::value), bool>::type
+  operator!=(reference_wrapper<Functor> g, const function_base& f)
+  {
+    if (const Functor* fp = f.template target<Functor>())
+      return g.get_pointer() != fp;
+    else return true;
+  }
+
+
+
+namespace detail {
+  namespace function {
+    inline bool has_empty_target(const function_base* f)
+    {
+      return f->empty();
+    }
+
+
+
+
+
+
+
+    inline bool has_empty_target(...)
+    {
+      return false;
+    }
+
+  }
+}
+}
+
+#undef BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL
+# 18 "/usr/include/boost/function/detail/prologue.hpp" 2 3 4
+# 1 "/usr/include/boost/mem_fn.hpp" 1 3 4
+
+#define BOOST_MEM_FN_HPP_INCLUDED 
+# 22 "/usr/include/boost/mem_fn.hpp" 3 4
+# 1 "/usr/include/boost/bind/mem_fn.hpp" 1 3 4
+
+#define BOOST_BIND_MEM_FN_HPP_INCLUDED 
+# 25 "/usr/include/boost/bind/mem_fn.hpp" 3 4
+# 1 "/usr/include/boost/get_pointer.hpp" 1 3 4
+
+
+
+
+
+#define GET_POINTER_DWA20021219_HPP 
+# 16 "/usr/include/boost/get_pointer.hpp" 3 4
+namespace boost {
+
+
+
+template<class T> T * get_pointer(T * p)
+{
+    return p;
+}
+# 32 "/usr/include/boost/get_pointer.hpp" 3 4
+#define BOOST_CORE_DETAIL_DISABLE_LIBSTDCXX_DEPRECATED_WARNINGS 
+# 43 "/usr/include/boost/get_pointer.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#define BOOST_CORE_DETAIL_DISABLED_DEPRECATED_WARNINGS 
+
+
+template<class T> T * get_pointer(std::auto_ptr<T> const& p)
+{
+    return p.get();
+}
+
+
+#pragma GCC diagnostic pop
+#undef BOOST_CORE_DETAIL_DISABLE_LIBSTDCXX_DEPRECATED_WARNINGS
+
+
+
+
+
+
+template<class T> T * get_pointer( std::unique_ptr<T> const& p )
+{
+    return p.get();
+}
+
+template<class T> T * get_pointer( std::shared_ptr<T> const& p )
+{
+    return p.get();
+}
+
+
+
+}
+# 26 "/usr/include/boost/bind/mem_fn.hpp" 2 3 4
+
+
+namespace boost
+{
+# 204 "/usr/include/boost/bind/mem_fn.hpp" 3 4
+#define BOOST_MEM_FN_CLASS_F 
+#define BOOST_MEM_FN_TYPEDEF(X) typedef X;
+
+namespace _mfi
+{
+
+#define BOOST_MEM_FN_RETURN return
+
+#define BOOST_MEM_FN_NAME(X) X
+#define BOOST_MEM_FN_CC 
+
+# 1 "/usr/include/boost/bind/mem_fn_template.hpp" 1 3 4
+# 16 "/usr/include/boost/bind/mem_fn_template.hpp" 3 4
+#define BOOST_MEM_FN_ENABLE_CONST_OVERLOADS 
+
+
+
+
+template<class R, class T > class mf0
+{
+public:
+
+    typedef R result_type;
+    typedef T * argument_type;
+
+private:
+
+    typedef R ( T::*F) ();
+    F f_;
+
+    template<class U> R call(U & u, T const *) const
+    {
+        return (u.*f_)();
+    }
+
+    template<class U> R call(U & u, void const *) const
+    {
+        return (get_pointer(u)->*f_)();
+    }
+
+public:
+
+    explicit mf0(F f): f_(f) {}
+
+    R operator()(T * p) const
+    {
+        return (p->*f_)();
+    }
+
+    template<class U> R operator()(U & u) const
+    {
+        U const * p = 0;
+        return call(u, p);
+    }
+
+
+
+    template<class U> R operator()(U const & u) const
+    {
+        U const * p = 0;
+        return call(u, p);
+    }
+
+
+
+    R operator()(T & t) const
+    {
+        return (t.*f_)();
+    }
+
+    bool operator==(mf0 const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+
+    bool operator!=(mf0 const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
+};
+
+
+
+template<class R, class T > class cmf0
+{
+public:
+
+    typedef R result_type;
+    typedef T const * argument_type;
+
+private:
+
+    typedef R ( T::*F) () const;
+    F f_;
+
+    template<class U> R call(U & u, T const *) const
+    {
+        return (u.*f_)();
+    }
+
+    template<class U> R call(U & u, void const *) const
+    {
+        return (get_pointer(u)->*f_)();
+    }
+
+public:
+
+    explicit cmf0(F f): f_(f) {}
+
+    template<class U> R operator()(U const & u) const
+    {
+        U const * p = 0;
+        return call(u, p);
+    }
+
+    R operator()(T const & t) const
+    {
+        return (t.*f_)();
+    }
+
+    bool operator==(cmf0 const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+
+    bool operator!=(cmf0 const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
+};
+
+
+
+template<class R, class T, class A1 > class mf1
+{
+public:
+
+    typedef R result_type;
+    typedef T * first_argument_type;
+    typedef A1 second_argument_type;
+
+private:
+
+    typedef R ( T::*F) (A1);
+    F f_;
+
+    template<class U, class B1> R call(U & u, T const *, B1 & b1) const
+    {
+        return (u.*f_)(b1);
+    }
+
+    template<class U, class B1> R call(U & u, void const *, B1 & b1) const
+    {
+        return (get_pointer(u)->*f_)(b1);
+    }
+
+public:
+
+    explicit mf1(F f): f_(f) {}
+
+    R operator()(T * p, A1 a1) const
+    {
+        return (p->*f_)(a1);
+    }
+
+    template<class U> R operator()(U & u, A1 a1) const
+    {
+        U const * p = 0;
+        return call(u, p, a1);
+    }
+
+
+
+    template<class U> R operator()(U const & u, A1 a1) const
+    {
+        U const * p = 0;
+        return call(u, p, a1);
+    }
+
+
+
+    R operator()(T & t, A1 a1) const
+    {
+        return (t.*f_)(a1);
+    }
+
+    bool operator==(mf1 const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+
+    bool operator!=(mf1 const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
+};
+
+
+
+template<class R, class T, class A1 > class cmf1
+{
+public:
+
+    typedef R result_type;
+    typedef T const * first_argument_type;
+    typedef A1 second_argument_type;
+
+private:
+
+    typedef R ( T::*F) (A1) const;
+    F f_;
+
+    template<class U, class B1> R call(U & u, T const *, B1 & b1) const
+    {
+        return (u.*f_)(b1);
+    }
+
+    template<class U, class B1> R call(U & u, void const *, B1 & b1) const
+    {
+        return (get_pointer(u)->*f_)(b1);
+    }
+
+public:
+
+    explicit cmf1(F f): f_(f) {}
+
+    template<class U> R operator()(U const & u, A1 a1) const
+    {
+        U const * p = 0;
+        return call(u, p, a1);
+    }
+
+    R operator()(T const & t, A1 a1) const
+    {
+        return (t.*f_)(a1);
+    }
+
+    bool operator==(cmf1 const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+
+    bool operator!=(cmf1 const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
+};
+
+
+
+template<class R, class T, class A1, class A2 > class mf2
+{
+public:
+
+    typedef R result_type;
+
+private:
+
+    typedef R ( T::*F) (A1, A2);
+    F f_;
+
+    template<class U, class B1, class B2> R call(U & u, T const *, B1 & b1, B2 & b2) const
+    {
+        return (u.*f_)(b1, b2);
+    }
+
+    template<class U, class B1, class B2> R call(U & u, void const *, B1 & b1, B2 & b2) const
+    {
+        return (get_pointer(u)->*f_)(b1, b2);
+    }
+
+public:
+
+    explicit mf2(F f): f_(f) {}
+
+    R operator()(T * p, A1 a1, A2 a2) const
+    {
+        return (p->*f_)(a1, a2);
+    }
+
+    template<class U> R operator()(U & u, A1 a1, A2 a2) const
+    {
+        U const * p = 0;
+        return call(u, p, a1, a2);
+    }
+
+
+
+    template<class U> R operator()(U const & u, A1 a1, A2 a2) const
+    {
+        U const * p = 0;
+        return call(u, p, a1, a2);
+    }
+
+
+
+    R operator()(T & t, A1 a1, A2 a2) const
+    {
+        return (t.*f_)(a1, a2);
+    }
+
+    bool operator==(mf2 const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+
+    bool operator!=(mf2 const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
+};
+
+
+
+template<class R, class T, class A1, class A2 > class cmf2
+{
+public:
+
+    typedef R result_type;
+
+private:
+
+    typedef R ( T::*F) (A1, A2) const;
+    F f_;
+
+    template<class U, class B1, class B2> R call(U & u, T const *, B1 & b1, B2 & b2) const
+    {
+        return (u.*f_)(b1, b2);
+    }
+
+    template<class U, class B1, class B2> R call(U & u, void const *, B1 & b1, B2 & b2) const
+    {
+        return (get_pointer(u)->*f_)(b1, b2);
+    }
+
+public:
+
+    explicit cmf2(F f): f_(f) {}
+
+    template<class U> R operator()(U const & u, A1 a1, A2 a2) const
+    {
+        U const * p = 0;
+        return call(u, p, a1, a2);
+    }
+
+    R operator()(T const & t, A1 a1, A2 a2) const
+    {
+        return (t.*f_)(a1, a2);
+    }
+
+    bool operator==(cmf2 const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+
+    bool operator!=(cmf2 const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
+};
+
+
+
+template<class R, class T, class A1, class A2, class A3 > class mf3
+{
+public:
+
+    typedef R result_type;
+
+private:
+
+    typedef R ( T::*F) (A1, A2, A3);
+    F f_;
+
+    template<class U, class B1, class B2, class B3> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3) const
+    {
+        return (u.*f_)(b1, b2, b3);
+    }
+
+    template<class U, class B1, class B2, class B3> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3) const
+    {
+        return (get_pointer(u)->*f_)(b1, b2, b3);
+    }
+
+public:
+
+    explicit mf3(F f): f_(f) {}
+
+    R operator()(T * p, A1 a1, A2 a2, A3 a3) const
+    {
+        return (p->*f_)(a1, a2, a3);
+    }
+
+    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3) const
+    {
+        U const * p = 0;
+        return call(u, p, a1, a2, a3);
+    }
+
+
+
+    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3) const
+    {
+        U const * p = 0;
+        return call(u, p, a1, a2, a3);
+    }
+
+
+
+    R operator()(T & t, A1 a1, A2 a2, A3 a3) const
+    {
+        return (t.*f_)(a1, a2, a3);
+    }
+
+    bool operator==(mf3 const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+
+    bool operator!=(mf3 const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
+};
+
+
+
+template<class R, class T, class A1, class A2, class A3 > class cmf3
+{
+public:
+
+    typedef R result_type;
+
+private:
+
+    typedef R ( T::*F) (A1, A2, A3) const;
+    F f_;
+
+    template<class U, class B1, class B2, class B3> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3) const
+    {
+        return (u.*f_)(b1, b2, b3);
+    }
+
+    template<class U, class B1, class B2, class B3> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3) const
+    {
+        return (get_pointer(u)->*f_)(b1, b2, b3);
+    }
+
+public:
+
+    explicit cmf3(F f): f_(f) {}
+
+    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3) const
+    {
+        U const * p = 0;
+        return call(u, p, a1, a2, a3);
+    }
+
+    R operator()(T const & t, A1 a1, A2 a2, A3 a3) const
+    {
+        return (t.*f_)(a1, a2, a3);
+    }
+
+    bool operator==(cmf3 const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+
+    bool operator!=(cmf3 const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
+};
+
+
+
+template<class R, class T, class A1, class A2, class A3, class A4 > class mf4
+{
+public:
+
+    typedef R result_type;
+
+private:
+
+    typedef R ( T::*F) (A1, A2, A3, A4);
+    F f_;
+
+    template<class U, class B1, class B2, class B3, class B4> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const
+    {
+        return (u.*f_)(b1, b2, b3, b4);
+    }
+
+    template<class U, class B1, class B2, class B3, class B4> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const
+    {
+        return (get_pointer(u)->*f_)(b1, b2, b3, b4);
+    }
+
+public:
+
+    explicit mf4(F f): f_(f) {}
+
+    R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4) const
+    {
+        return (p->*f_)(a1, a2, a3, a4);
+    }
+
+    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4) const
+    {
+        U const * p = 0;
+        return call(u, p, a1, a2, a3, a4);
+    }
+
+
+
+    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4) const
+    {
+        U const * p = 0;
+        return call(u, p, a1, a2, a3, a4);
+    }
+
+
+
+    R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4) const
+    {
+        return (t.*f_)(a1, a2, a3, a4);
+    }
+
+    bool operator==(mf4 const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+
+    bool operator!=(mf4 const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
+};
+
+
+
+template<class R, class T, class A1, class A2, class A3, class A4 > class cmf4
+{
+public:
+
+    typedef R result_type;
+
+private:
+
+    typedef R ( T::*F) (A1, A2, A3, A4) const;
+    F f_;
+
+    template<class U, class B1, class B2, class B3, class B4> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const
+    {
+        return (u.*f_)(b1, b2, b3, b4);
+    }
+
+    template<class U, class B1, class B2, class B3, class B4> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const
+    {
+        return (get_pointer(u)->*f_)(b1, b2, b3, b4);
+    }
+
+public:
+
+    explicit cmf4(F f): f_(f) {}
+
+    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4) const
+    {
+        U const * p = 0;
+        return call(u, p, a1, a2, a3, a4);
+    }
+
+    R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4) const
+    {
+        return (t.*f_)(a1, a2, a3, a4);
+    }
+
+    bool operator==(cmf4 const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+
+    bool operator!=(cmf4 const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
+};
+
+
+
+template<class R, class T, class A1, class A2, class A3, class A4, class A5 > class mf5
+{
+public:
+
+    typedef R result_type;
+
+private:
+
+    typedef R ( T::*F) (A1, A2, A3, A4, A5);
+    F f_;
+
+    template<class U, class B1, class B2, class B3, class B4, class B5> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5) const
+    {
+        return (u.*f_)(b1, b2, b3, b4, b5);
+    }
+
+    template<class U, class B1, class B2, class B3, class B4, class B5> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5) const
+    {
+        return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5);
+    }
+
+public:
+
+    explicit mf5(F f): f_(f) {}
+
+    R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
+    {
+        return (p->*f_)(a1, a2, a3, a4, a5);
+    }
+
+    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
+    {
+        U const * p = 0;
+        return call(u, p, a1, a2, a3, a4, a5);
+    }
+
+
+
+    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
+    {
+        U const * p = 0;
+        return call(u, p, a1, a2, a3, a4, a5);
+    }
+
+
+
+    R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
+    {
+        return (t.*f_)(a1, a2, a3, a4, a5);
+    }
+
+    bool operator==(mf5 const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+
+    bool operator!=(mf5 const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
+};
+
+
+
+template<class R, class T, class A1, class A2, class A3, class A4, class A5 > class cmf5
+{
+public:
+
+    typedef R result_type;
+
+private:
+
+    typedef R ( T::*F) (A1, A2, A3, A4, A5) const;
+    F f_;
+
+    template<class U, class B1, class B2, class B3, class B4, class B5> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5) const
+    {
+        return (u.*f_)(b1, b2, b3, b4, b5);
+    }
+
+    template<class U, class B1, class B2, class B3, class B4, class B5> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5) const
+    {
+        return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5);
+    }
+
+public:
+
+    explicit cmf5(F f): f_(f) {}
+
+    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
+    {
+        U const * p = 0;
+        return call(u, p, a1, a2, a3, a4, a5);
+    }
+
+    R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
+    {
+        return (t.*f_)(a1, a2, a3, a4, a5);
+    }
+
+    bool operator==(cmf5 const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+
+    bool operator!=(cmf5 const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
+};
+
+
+
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6 > class mf6
+{
+public:
+
+    typedef R result_type;
+
+private:
+
+    typedef R ( T::*F) (A1, A2, A3, A4, A5, A6);
+    F f_;
+
+    template<class U, class B1, class B2, class B3, class B4, class B5, class B6> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6) const
+    {
+        return (u.*f_)(b1, b2, b3, b4, b5, b6);
+    }
+
+    template<class U, class B1, class B2, class B3, class B4, class B5, class B6> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6) const
+    {
+        return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6);
+    }
+
+public:
+
+    explicit mf6(F f): f_(f) {}
+
+    R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
+    {
+        return (p->*f_)(a1, a2, a3, a4, a5, a6);
+    }
+
+    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
+    {
+        U const * p = 0;
+        return call(u, p, a1, a2, a3, a4, a5, a6);
+    }
+
+
+
+    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
+    {
+        U const * p = 0;
+        return call(u, p, a1, a2, a3, a4, a5, a6);
+    }
+
+
+
+    R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
+    {
+        return (t.*f_)(a1, a2, a3, a4, a5, a6);
+    }
+
+    bool operator==(mf6 const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+
+    bool operator!=(mf6 const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
+};
+
+
+
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6 > class cmf6
+{
+public:
+
+    typedef R result_type;
+
+private:
+
+    typedef R ( T::*F) (A1, A2, A3, A4, A5, A6) const;
+    F f_;
+
+    template<class U, class B1, class B2, class B3, class B4, class B5, class B6> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6) const
+    {
+        return (u.*f_)(b1, b2, b3, b4, b5, b6);
+    }
+
+    template<class U, class B1, class B2, class B3, class B4, class B5, class B6> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6) const
+    {
+        return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6);
+    }
+
+public:
+
+    explicit cmf6(F f): f_(f) {}
+
+    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
+    {
+        U const * p = 0;
+        return call(u, p, a1, a2, a3, a4, a5, a6);
+    }
+
+    R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
+    {
+        return (t.*f_)(a1, a2, a3, a4, a5, a6);
+    }
+
+    bool operator==(cmf6 const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+
+    bool operator!=(cmf6 const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
+};
+
+
+
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7 > class mf7
+{
+public:
+
+    typedef R result_type;
+
+private:
+
+    typedef R ( T::*F) (A1, A2, A3, A4, A5, A6, A7);
+    F f_;
+
+    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7) const
+    {
+        return (u.*f_)(b1, b2, b3, b4, b5, b6, b7);
+    }
+
+    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7) const
+    {
+        return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7);
+    }
+
+public:
+
+    explicit mf7(F f): f_(f) {}
+
+    R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
+    {
+        return (p->*f_)(a1, a2, a3, a4, a5, a6, a7);
+    }
+
+    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
+    {
+        U const * p = 0;
+        return call(u, p, a1, a2, a3, a4, a5, a6, a7);
+    }
+
+
+
+    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
+    {
+        U const * p = 0;
+        return call(u, p, a1, a2, a3, a4, a5, a6, a7);
+    }
+
+
+
+    R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
+    {
+        return (t.*f_)(a1, a2, a3, a4, a5, a6, a7);
+    }
+
+    bool operator==(mf7 const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+
+    bool operator!=(mf7 const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
+};
+
+
+
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7 > class cmf7
+{
+public:
+
+    typedef R result_type;
+
+private:
+
+    typedef R ( T::*F) (A1, A2, A3, A4, A5, A6, A7) const;
+    F f_;
+
+    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7) const
+    {
+        return (u.*f_)(b1, b2, b3, b4, b5, b6, b7);
+    }
+
+    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7) const
+    {
+        return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7);
+    }
+
+public:
+
+    explicit cmf7(F f): f_(f) {}
+
+    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
+    {
+        U const * p = 0;
+        return call(u, p, a1, a2, a3, a4, a5, a6, a7);
+    }
+
+    R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
+    {
+        return (t.*f_)(a1, a2, a3, a4, a5, a6, a7);
+    }
+
+    bool operator==(cmf7 const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+
+    bool operator!=(cmf7 const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
+};
+
+
+
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 > class mf8
+{
+public:
+
+    typedef R result_type;
+
+private:
+
+    typedef R ( T::*F) (A1, A2, A3, A4, A5, A6, A7, A8);
+    F f_;
+
+    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7, B8 & b8) const
+    {
+        return (u.*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
+    }
+
+    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7, B8 & b8) const
+    {
+        return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
+    }
+
+public:
+
+    explicit mf8(F f): f_(f) {}
+
+    R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
+    {
+        return (p->*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
+    }
+
+    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
+    {
+        U const * p = 0;
+        return call(u, p, a1, a2, a3, a4, a5, a6, a7, a8);
+    }
+
+
+
+    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
+    {
+        U const * p = 0;
+        return call(u, p, a1, a2, a3, a4, a5, a6, a7, a8);
+    }
+
+
+
+    R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
+    {
+        return (t.*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
+    }
+
+    bool operator==(mf8 const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+
+    bool operator!=(mf8 const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
+};
+
+
+
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 > class cmf8
+{
+public:
+
+    typedef R result_type;
+
+private:
+
+    typedef R ( T::*F) (A1, A2, A3, A4, A5, A6, A7, A8) const;
+    F f_;
+
+    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7, B8 & b8) const
+    {
+        return (u.*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
+    }
+
+    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7, B8 & b8) const
+    {
+        return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
+    }
+
+public:
+
+    explicit cmf8(F f): f_(f) {}
+
+    R operator()(T const * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
+    {
+        return (p->*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
+    }
+
+    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
+    {
+        U const * p = 0;
+        return call(u, p, a1, a2, a3, a4, a5, a6, a7, a8);
+    }
+
+    R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
+    {
+        return (t.*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
+    }
+
+    bool operator==(cmf8 const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+
+    bool operator!=(cmf8 const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
+};
+
+#undef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
+# 216 "/usr/include/boost/bind/mem_fn.hpp" 2 3 4
+
+#undef BOOST_MEM_FN_CC
+#undef BOOST_MEM_FN_NAME
+# 256 "/usr/include/boost/bind/mem_fn.hpp" 3 4
+#undef BOOST_MEM_FN_RETURN
+
+}
+
+#undef BOOST_MEM_FN_CLASS_F
+#undef BOOST_MEM_FN_TYPEDEF
+
+
+
+#define BOOST_MEM_FN_NAME(X) X
+#define BOOST_MEM_FN_CC 
+
+# 1 "/usr/include/boost/bind/mem_fn_cc.hpp" 1 3 4
+# 15 "/usr/include/boost/bind/mem_fn_cc.hpp" 3 4
+template<class R, class T> _mfi::mf0<R, T> mem_fn(R ( T::*f) ())
+{
+    return _mfi::mf0<R, T>(f);
+}
+
+template<class R, class T> _mfi::cmf0<R, T> mem_fn(R ( T::*f) () const)
+{
+    return _mfi::cmf0<R, T>(f);
+}
+
+template<class R, class T, class A1> _mfi::mf1<R, T, A1> mem_fn(R ( T::*f) (A1))
+{
+    return _mfi::mf1<R, T, A1>(f);
+}
+
+template<class R, class T, class A1> _mfi::cmf1<R, T, A1> mem_fn(R ( T::*f) (A1) const)
+{
+    return _mfi::cmf1<R, T, A1>(f);
+}
+
+template<class R, class T, class A1, class A2> _mfi::mf2<R, T, A1, A2> mem_fn(R ( T::*f) (A1, A2))
+{
+    return _mfi::mf2<R, T, A1, A2>(f);
+}
+
+template<class R, class T, class A1, class A2> _mfi::cmf2<R, T, A1, A2> mem_fn(R ( T::*f) (A1, A2) const)
+{
+    return _mfi::cmf2<R, T, A1, A2>(f);
+}
+
+template<class R, class T, class A1, class A2, class A3> _mfi::mf3<R, T, A1, A2, A3> mem_fn(R ( T::*f) (A1, A2, A3))
+{
+    return _mfi::mf3<R, T, A1, A2, A3>(f);
+}
+
+template<class R, class T, class A1, class A2, class A3> _mfi::cmf3<R, T, A1, A2, A3> mem_fn(R ( T::*f) (A1, A2, A3) const)
+{
+    return _mfi::cmf3<R, T, A1, A2, A3>(f);
+}
+
+template<class R, class T, class A1, class A2, class A3, class A4> _mfi::mf4<R, T, A1, A2, A3, A4> mem_fn(R ( T::*f) (A1, A2, A3, A4))
+{
+    return _mfi::mf4<R, T, A1, A2, A3, A4>(f);
+}
+
+template<class R, class T, class A1, class A2, class A3, class A4> _mfi::cmf4<R, T, A1, A2, A3, A4> mem_fn(R ( T::*f) (A1, A2, A3, A4) const)
+{
+    return _mfi::cmf4<R, T, A1, A2, A3, A4>(f);
+}
+
+template<class R, class T, class A1, class A2, class A3, class A4, class A5> _mfi::mf5<R, T, A1, A2, A3, A4, A5> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5))
+{
+    return _mfi::mf5<R, T, A1, A2, A3, A4, A5>(f);
+}
+
+template<class R, class T, class A1, class A2, class A3, class A4, class A5> _mfi::cmf5<R, T, A1, A2, A3, A4, A5> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5) const)
+{
+    return _mfi::cmf5<R, T, A1, A2, A3, A4, A5>(f);
+}
+
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6> _mfi::mf6<R, T, A1, A2, A3, A4, A5, A6> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5, A6))
+{
+    return _mfi::mf6<R, T, A1, A2, A3, A4, A5, A6>(f);
+}
+
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6> _mfi::cmf6<R, T, A1, A2, A3, A4, A5, A6> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5, A6) const)
+{
+    return _mfi::cmf6<R, T, A1, A2, A3, A4, A5, A6>(f);
+}
+
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7> _mfi::mf7<R, T, A1, A2, A3, A4, A5, A6, A7> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5, A6, A7))
+{
+    return _mfi::mf7<R, T, A1, A2, A3, A4, A5, A6, A7>(f);
+}
+
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7> _mfi::cmf7<R, T, A1, A2, A3, A4, A5, A6, A7> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5, A6, A7) const)
+{
+    return _mfi::cmf7<R, T, A1, A2, A3, A4, A5, A6, A7>(f);
+}
+
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> _mfi::mf8<R, T, A1, A2, A3, A4, A5, A6, A7, A8> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5, A6, A7, A8))
+{
+    return _mfi::mf8<R, T, A1, A2, A3, A4, A5, A6, A7, A8>(f);
+}
+
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> _mfi::cmf8<R, T, A1, A2, A3, A4, A5, A6, A7, A8> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5, A6, A7, A8) const)
+{
+    return _mfi::cmf8<R, T, A1, A2, A3, A4, A5, A6, A7, A8>(f);
+}
+# 269 "/usr/include/boost/bind/mem_fn.hpp" 2 3 4
+
+#undef BOOST_MEM_FN_NAME
+#undef BOOST_MEM_FN_CC
+# 311 "/usr/include/boost/bind/mem_fn.hpp" 3 4
+namespace _mfi
+{
+
+template<class R, class T> class dm
+{
+public:
+
+    typedef R const & result_type;
+    typedef T const * argument_type;
+
+private:
+
+    typedef R (T::*F);
+    F f_;
+
+    template<class U> R const & call(U & u, T const *) const
+    {
+        return (u.*f_);
+    }
+
+    template<class U> R const & call(U & u, void const *) const
+    {
+        return (get_pointer(u)->*f_);
+    }
+
+public:
+
+    explicit dm(F f): f_(f) {}
+
+    R & operator()(T * p) const
+    {
+        return (p->*f_);
+    }
+
+    R const & operator()(T const * p) const
+    {
+        return (p->*f_);
+    }
+
+    template<class U> R const & operator()(U const & u) const
+    {
+        return call(u, &u);
+    }
+
+
+
+    R & operator()(T & t) const
+    {
+        return (t.*f_);
+    }
+
+    R const & operator()(T const & t) const
+    {
+        return (t.*f_);
+    }
+
+
+
+    bool operator==(dm const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+
+    bool operator!=(dm const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
+};
+
+}
+
+template<class R, class T> _mfi::dm<R, T> mem_fn(R T::*f)
+{
+    return _mfi::dm<R, T>(f);
+}
+
+}
+# 23 "/usr/include/boost/mem_fn.hpp" 2 3 4
+# 19 "/usr/include/boost/function/detail/prologue.hpp" 2 3 4
+
+# 1 "/usr/include/boost/preprocessor/enum.hpp" 1 3 4
+# 13 "/usr/include/boost/preprocessor/enum.hpp" 3 4
+#define BOOST_PREPROCESSOR_ENUM_HPP 
+
+# 1 "/usr/include/boost/preprocessor/repetition/enum.hpp" 1 3 4
+# 15 "/usr/include/boost/preprocessor/repetition/enum.hpp" 3 4
+#define BOOST_PREPROCESSOR_REPETITION_ENUM_HPP 
+
+
+
+
+# 1 "/usr/include/boost/preprocessor/detail/auto_rec.hpp" 1 3 4
+# 21 "/usr/include/boost/preprocessor/repetition/enum.hpp" 2 3 4
+# 1 "/usr/include/boost/preprocessor/punctuation/comma_if.hpp" 1 3 4
+# 15 "/usr/include/boost/preprocessor/punctuation/comma_if.hpp" 3 4
+#define BOOST_PREPROCESSOR_PUNCTUATION_COMMA_IF_HPP 
+
+
+
+
+# 1 "/usr/include/boost/preprocessor/punctuation/comma.hpp" 1 3 4
+# 15 "/usr/include/boost/preprocessor/punctuation/comma.hpp" 3 4
+#define BOOST_PREPROCESSOR_PUNCTUATION_COMMA_HPP 
+
+
+
+#define BOOST_PP_COMMA() ,
+# 21 "/usr/include/boost/preprocessor/punctuation/comma_if.hpp" 2 3 4
+
+
+
+
+#define BOOST_PP_COMMA_IF(cond) BOOST_PP_IF(cond, BOOST_PP_COMMA, BOOST_PP_EMPTY)()
+# 22 "/usr/include/boost/preprocessor/repetition/enum.hpp" 2 3 4
+# 1 "/usr/include/boost/preprocessor/repetition/repeat.hpp" 1 3 4
+# 15 "/usr/include/boost/preprocessor/repetition/repeat.hpp" 3 4
+#define BOOST_PREPROCESSOR_REPETITION_REPEAT_HPP 
+
+
+
+
+# 1 "/usr/include/boost/preprocessor/detail/auto_rec.hpp" 1 3 4
+# 21 "/usr/include/boost/preprocessor/repetition/repeat.hpp" 2 3 4
+# 29 "/usr/include/boost/preprocessor/repetition/repeat.hpp" 3 4
+#define BOOST_PP_REPEAT BOOST_PP_CAT(BOOST_PP_REPEAT_, BOOST_PP_AUTO_REC(BOOST_PP_REPEAT_P, 4))
+
+#define BOOST_PP_REPEAT_P(n) BOOST_PP_CAT(BOOST_PP_REPEAT_CHECK_, BOOST_PP_REPEAT_ ## n(1, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3, BOOST_PP_NIL))
+
+#define BOOST_PP_REPEAT_CHECK_BOOST_PP_NIL 1
+#define BOOST_PP_REPEAT_CHECK_BOOST_PP_REPEAT_1(c,m,d) 0
+#define BOOST_PP_REPEAT_CHECK_BOOST_PP_REPEAT_2(c,m,d) 0
+#define BOOST_PP_REPEAT_CHECK_BOOST_PP_REPEAT_3(c,m,d) 0
+
+#define BOOST_PP_REPEAT_1(c,m,d) BOOST_PP_REPEAT_1_I(c, m, d)
+#define BOOST_PP_REPEAT_2(c,m,d) BOOST_PP_REPEAT_2_I(c, m, d)
+#define BOOST_PP_REPEAT_3(c,m,d) BOOST_PP_REPEAT_3_I(c, m, d)
+#define BOOST_PP_REPEAT_4(c,m,d) BOOST_PP_ERROR(0x0003)
+
+#define BOOST_PP_REPEAT_1_I(c,m,d) BOOST_PP_REPEAT_1_ ## c(m, d)
+#define BOOST_PP_REPEAT_2_I(c,m,d) BOOST_PP_REPEAT_2_ ## c(m, d)
+#define BOOST_PP_REPEAT_3_I(c,m,d) BOOST_PP_REPEAT_3_ ## c(m, d)
+
+#define BOOST_PP_REPEAT_1ST BOOST_PP_REPEAT_1
+#define BOOST_PP_REPEAT_2ND BOOST_PP_REPEAT_2
+#define BOOST_PP_REPEAT_3RD BOOST_PP_REPEAT_3
+
+#define BOOST_PP_REPEAT_1_0(m,d) 
+#define BOOST_PP_REPEAT_1_1(m,d) m(2, 0, d)
+#define BOOST_PP_REPEAT_1_2(m,d) BOOST_PP_REPEAT_1_1(m, d) m(2, 1, d)
+#define BOOST_PP_REPEAT_1_3(m,d) BOOST_PP_REPEAT_1_2(m, d) m(2, 2, d)
+#define BOOST_PP_REPEAT_1_4(m,d) BOOST_PP_REPEAT_1_3(m, d) m(2, 3, d)
+#define BOOST_PP_REPEAT_1_5(m,d) BOOST_PP_REPEAT_1_4(m, d) m(2, 4, d)
+#define BOOST_PP_REPEAT_1_6(m,d) BOOST_PP_REPEAT_1_5(m, d) m(2, 5, d)
+#define BOOST_PP_REPEAT_1_7(m,d) BOOST_PP_REPEAT_1_6(m, d) m(2, 6, d)
+#define BOOST_PP_REPEAT_1_8(m,d) BOOST_PP_REPEAT_1_7(m, d) m(2, 7, d)
+#define BOOST_PP_REPEAT_1_9(m,d) BOOST_PP_REPEAT_1_8(m, d) m(2, 8, d)
+#define BOOST_PP_REPEAT_1_10(m,d) BOOST_PP_REPEAT_1_9(m, d) m(2, 9, d)
+#define BOOST_PP_REPEAT_1_11(m,d) BOOST_PP_REPEAT_1_10(m, d) m(2, 10, d)
+#define BOOST_PP_REPEAT_1_12(m,d) BOOST_PP_REPEAT_1_11(m, d) m(2, 11, d)
+#define BOOST_PP_REPEAT_1_13(m,d) BOOST_PP_REPEAT_1_12(m, d) m(2, 12, d)
+#define BOOST_PP_REPEAT_1_14(m,d) BOOST_PP_REPEAT_1_13(m, d) m(2, 13, d)
+#define BOOST_PP_REPEAT_1_15(m,d) BOOST_PP_REPEAT_1_14(m, d) m(2, 14, d)
+#define BOOST_PP_REPEAT_1_16(m,d) BOOST_PP_REPEAT_1_15(m, d) m(2, 15, d)
+#define BOOST_PP_REPEAT_1_17(m,d) BOOST_PP_REPEAT_1_16(m, d) m(2, 16, d)
+#define BOOST_PP_REPEAT_1_18(m,d) BOOST_PP_REPEAT_1_17(m, d) m(2, 17, d)
+#define BOOST_PP_REPEAT_1_19(m,d) BOOST_PP_REPEAT_1_18(m, d) m(2, 18, d)
+#define BOOST_PP_REPEAT_1_20(m,d) BOOST_PP_REPEAT_1_19(m, d) m(2, 19, d)
+#define BOOST_PP_REPEAT_1_21(m,d) BOOST_PP_REPEAT_1_20(m, d) m(2, 20, d)
+#define BOOST_PP_REPEAT_1_22(m,d) BOOST_PP_REPEAT_1_21(m, d) m(2, 21, d)
+#define BOOST_PP_REPEAT_1_23(m,d) BOOST_PP_REPEAT_1_22(m, d) m(2, 22, d)
+#define BOOST_PP_REPEAT_1_24(m,d) BOOST_PP_REPEAT_1_23(m, d) m(2, 23, d)
+#define BOOST_PP_REPEAT_1_25(m,d) BOOST_PP_REPEAT_1_24(m, d) m(2, 24, d)
+#define BOOST_PP_REPEAT_1_26(m,d) BOOST_PP_REPEAT_1_25(m, d) m(2, 25, d)
+#define BOOST_PP_REPEAT_1_27(m,d) BOOST_PP_REPEAT_1_26(m, d) m(2, 26, d)
+#define BOOST_PP_REPEAT_1_28(m,d) BOOST_PP_REPEAT_1_27(m, d) m(2, 27, d)
+#define BOOST_PP_REPEAT_1_29(m,d) BOOST_PP_REPEAT_1_28(m, d) m(2, 28, d)
+#define BOOST_PP_REPEAT_1_30(m,d) BOOST_PP_REPEAT_1_29(m, d) m(2, 29, d)
+#define BOOST_PP_REPEAT_1_31(m,d) BOOST_PP_REPEAT_1_30(m, d) m(2, 30, d)
+#define BOOST_PP_REPEAT_1_32(m,d) BOOST_PP_REPEAT_1_31(m, d) m(2, 31, d)
+#define BOOST_PP_REPEAT_1_33(m,d) BOOST_PP_REPEAT_1_32(m, d) m(2, 32, d)
+#define BOOST_PP_REPEAT_1_34(m,d) BOOST_PP_REPEAT_1_33(m, d) m(2, 33, d)
+#define BOOST_PP_REPEAT_1_35(m,d) BOOST_PP_REPEAT_1_34(m, d) m(2, 34, d)
+#define BOOST_PP_REPEAT_1_36(m,d) BOOST_PP_REPEAT_1_35(m, d) m(2, 35, d)
+#define BOOST_PP_REPEAT_1_37(m,d) BOOST_PP_REPEAT_1_36(m, d) m(2, 36, d)
+#define BOOST_PP_REPEAT_1_38(m,d) BOOST_PP_REPEAT_1_37(m, d) m(2, 37, d)
+#define BOOST_PP_REPEAT_1_39(m,d) BOOST_PP_REPEAT_1_38(m, d) m(2, 38, d)
+#define BOOST_PP_REPEAT_1_40(m,d) BOOST_PP_REPEAT_1_39(m, d) m(2, 39, d)
+#define BOOST_PP_REPEAT_1_41(m,d) BOOST_PP_REPEAT_1_40(m, d) m(2, 40, d)
+#define BOOST_PP_REPEAT_1_42(m,d) BOOST_PP_REPEAT_1_41(m, d) m(2, 41, d)
+#define BOOST_PP_REPEAT_1_43(m,d) BOOST_PP_REPEAT_1_42(m, d) m(2, 42, d)
+#define BOOST_PP_REPEAT_1_44(m,d) BOOST_PP_REPEAT_1_43(m, d) m(2, 43, d)
+#define BOOST_PP_REPEAT_1_45(m,d) BOOST_PP_REPEAT_1_44(m, d) m(2, 44, d)
+#define BOOST_PP_REPEAT_1_46(m,d) BOOST_PP_REPEAT_1_45(m, d) m(2, 45, d)
+#define BOOST_PP_REPEAT_1_47(m,d) BOOST_PP_REPEAT_1_46(m, d) m(2, 46, d)
+#define BOOST_PP_REPEAT_1_48(m,d) BOOST_PP_REPEAT_1_47(m, d) m(2, 47, d)
+#define BOOST_PP_REPEAT_1_49(m,d) BOOST_PP_REPEAT_1_48(m, d) m(2, 48, d)
+#define BOOST_PP_REPEAT_1_50(m,d) BOOST_PP_REPEAT_1_49(m, d) m(2, 49, d)
+#define BOOST_PP_REPEAT_1_51(m,d) BOOST_PP_REPEAT_1_50(m, d) m(2, 50, d)
+#define BOOST_PP_REPEAT_1_52(m,d) BOOST_PP_REPEAT_1_51(m, d) m(2, 51, d)
+#define BOOST_PP_REPEAT_1_53(m,d) BOOST_PP_REPEAT_1_52(m, d) m(2, 52, d)
+#define BOOST_PP_REPEAT_1_54(m,d) BOOST_PP_REPEAT_1_53(m, d) m(2, 53, d)
+#define BOOST_PP_REPEAT_1_55(m,d) BOOST_PP_REPEAT_1_54(m, d) m(2, 54, d)
+#define BOOST_PP_REPEAT_1_56(m,d) BOOST_PP_REPEAT_1_55(m, d) m(2, 55, d)
+#define BOOST_PP_REPEAT_1_57(m,d) BOOST_PP_REPEAT_1_56(m, d) m(2, 56, d)
+#define BOOST_PP_REPEAT_1_58(m,d) BOOST_PP_REPEAT_1_57(m, d) m(2, 57, d)
+#define BOOST_PP_REPEAT_1_59(m,d) BOOST_PP_REPEAT_1_58(m, d) m(2, 58, d)
+#define BOOST_PP_REPEAT_1_60(m,d) BOOST_PP_REPEAT_1_59(m, d) m(2, 59, d)
+#define BOOST_PP_REPEAT_1_61(m,d) BOOST_PP_REPEAT_1_60(m, d) m(2, 60, d)
+#define BOOST_PP_REPEAT_1_62(m,d) BOOST_PP_REPEAT_1_61(m, d) m(2, 61, d)
+#define BOOST_PP_REPEAT_1_63(m,d) BOOST_PP_REPEAT_1_62(m, d) m(2, 62, d)
+#define BOOST_PP_REPEAT_1_64(m,d) BOOST_PP_REPEAT_1_63(m, d) m(2, 63, d)
+#define BOOST_PP_REPEAT_1_65(m,d) BOOST_PP_REPEAT_1_64(m, d) m(2, 64, d)
+#define BOOST_PP_REPEAT_1_66(m,d) BOOST_PP_REPEAT_1_65(m, d) m(2, 65, d)
+#define BOOST_PP_REPEAT_1_67(m,d) BOOST_PP_REPEAT_1_66(m, d) m(2, 66, d)
+#define BOOST_PP_REPEAT_1_68(m,d) BOOST_PP_REPEAT_1_67(m, d) m(2, 67, d)
+#define BOOST_PP_REPEAT_1_69(m,d) BOOST_PP_REPEAT_1_68(m, d) m(2, 68, d)
+#define BOOST_PP_REPEAT_1_70(m,d) BOOST_PP_REPEAT_1_69(m, d) m(2, 69, d)
+#define BOOST_PP_REPEAT_1_71(m,d) BOOST_PP_REPEAT_1_70(m, d) m(2, 70, d)
+#define BOOST_PP_REPEAT_1_72(m,d) BOOST_PP_REPEAT_1_71(m, d) m(2, 71, d)
+#define BOOST_PP_REPEAT_1_73(m,d) BOOST_PP_REPEAT_1_72(m, d) m(2, 72, d)
+#define BOOST_PP_REPEAT_1_74(m,d) BOOST_PP_REPEAT_1_73(m, d) m(2, 73, d)
+#define BOOST_PP_REPEAT_1_75(m,d) BOOST_PP_REPEAT_1_74(m, d) m(2, 74, d)
+#define BOOST_PP_REPEAT_1_76(m,d) BOOST_PP_REPEAT_1_75(m, d) m(2, 75, d)
+#define BOOST_PP_REPEAT_1_77(m,d) BOOST_PP_REPEAT_1_76(m, d) m(2, 76, d)
+#define BOOST_PP_REPEAT_1_78(m,d) BOOST_PP_REPEAT_1_77(m, d) m(2, 77, d)
+#define BOOST_PP_REPEAT_1_79(m,d) BOOST_PP_REPEAT_1_78(m, d) m(2, 78, d)
+#define BOOST_PP_REPEAT_1_80(m,d) BOOST_PP_REPEAT_1_79(m, d) m(2, 79, d)
+#define BOOST_PP_REPEAT_1_81(m,d) BOOST_PP_REPEAT_1_80(m, d) m(2, 80, d)
+#define BOOST_PP_REPEAT_1_82(m,d) BOOST_PP_REPEAT_1_81(m, d) m(2, 81, d)
+#define BOOST_PP_REPEAT_1_83(m,d) BOOST_PP_REPEAT_1_82(m, d) m(2, 82, d)
+#define BOOST_PP_REPEAT_1_84(m,d) BOOST_PP_REPEAT_1_83(m, d) m(2, 83, d)
+#define BOOST_PP_REPEAT_1_85(m,d) BOOST_PP_REPEAT_1_84(m, d) m(2, 84, d)
+#define BOOST_PP_REPEAT_1_86(m,d) BOOST_PP_REPEAT_1_85(m, d) m(2, 85, d)
+#define BOOST_PP_REPEAT_1_87(m,d) BOOST_PP_REPEAT_1_86(m, d) m(2, 86, d)
+#define BOOST_PP_REPEAT_1_88(m,d) BOOST_PP_REPEAT_1_87(m, d) m(2, 87, d)
+#define BOOST_PP_REPEAT_1_89(m,d) BOOST_PP_REPEAT_1_88(m, d) m(2, 88, d)
+#define BOOST_PP_REPEAT_1_90(m,d) BOOST_PP_REPEAT_1_89(m, d) m(2, 89, d)
+#define BOOST_PP_REPEAT_1_91(m,d) BOOST_PP_REPEAT_1_90(m, d) m(2, 90, d)
+#define BOOST_PP_REPEAT_1_92(m,d) BOOST_PP_REPEAT_1_91(m, d) m(2, 91, d)
+#define BOOST_PP_REPEAT_1_93(m,d) BOOST_PP_REPEAT_1_92(m, d) m(2, 92, d)
+#define BOOST_PP_REPEAT_1_94(m,d) BOOST_PP_REPEAT_1_93(m, d) m(2, 93, d)
+#define BOOST_PP_REPEAT_1_95(m,d) BOOST_PP_REPEAT_1_94(m, d) m(2, 94, d)
+#define BOOST_PP_REPEAT_1_96(m,d) BOOST_PP_REPEAT_1_95(m, d) m(2, 95, d)
+#define BOOST_PP_REPEAT_1_97(m,d) BOOST_PP_REPEAT_1_96(m, d) m(2, 96, d)
+#define BOOST_PP_REPEAT_1_98(m,d) BOOST_PP_REPEAT_1_97(m, d) m(2, 97, d)
+#define BOOST_PP_REPEAT_1_99(m,d) BOOST_PP_REPEAT_1_98(m, d) m(2, 98, d)
+#define BOOST_PP_REPEAT_1_100(m,d) BOOST_PP_REPEAT_1_99(m, d) m(2, 99, d)
+#define BOOST_PP_REPEAT_1_101(m,d) BOOST_PP_REPEAT_1_100(m, d) m(2, 100, d)
+#define BOOST_PP_REPEAT_1_102(m,d) BOOST_PP_REPEAT_1_101(m, d) m(2, 101, d)
+#define BOOST_PP_REPEAT_1_103(m,d) BOOST_PP_REPEAT_1_102(m, d) m(2, 102, d)
+#define BOOST_PP_REPEAT_1_104(m,d) BOOST_PP_REPEAT_1_103(m, d) m(2, 103, d)
+#define BOOST_PP_REPEAT_1_105(m,d) BOOST_PP_REPEAT_1_104(m, d) m(2, 104, d)
+#define BOOST_PP_REPEAT_1_106(m,d) BOOST_PP_REPEAT_1_105(m, d) m(2, 105, d)
+#define BOOST_PP_REPEAT_1_107(m,d) BOOST_PP_REPEAT_1_106(m, d) m(2, 106, d)
+#define BOOST_PP_REPEAT_1_108(m,d) BOOST_PP_REPEAT_1_107(m, d) m(2, 107, d)
+#define BOOST_PP_REPEAT_1_109(m,d) BOOST_PP_REPEAT_1_108(m, d) m(2, 108, d)
+#define BOOST_PP_REPEAT_1_110(m,d) BOOST_PP_REPEAT_1_109(m, d) m(2, 109, d)
+#define BOOST_PP_REPEAT_1_111(m,d) BOOST_PP_REPEAT_1_110(m, d) m(2, 110, d)
+#define BOOST_PP_REPEAT_1_112(m,d) BOOST_PP_REPEAT_1_111(m, d) m(2, 111, d)
+#define BOOST_PP_REPEAT_1_113(m,d) BOOST_PP_REPEAT_1_112(m, d) m(2, 112, d)
+#define BOOST_PP_REPEAT_1_114(m,d) BOOST_PP_REPEAT_1_113(m, d) m(2, 113, d)
+#define BOOST_PP_REPEAT_1_115(m,d) BOOST_PP_REPEAT_1_114(m, d) m(2, 114, d)
+#define BOOST_PP_REPEAT_1_116(m,d) BOOST_PP_REPEAT_1_115(m, d) m(2, 115, d)
+#define BOOST_PP_REPEAT_1_117(m,d) BOOST_PP_REPEAT_1_116(m, d) m(2, 116, d)
+#define BOOST_PP_REPEAT_1_118(m,d) BOOST_PP_REPEAT_1_117(m, d) m(2, 117, d)
+#define BOOST_PP_REPEAT_1_119(m,d) BOOST_PP_REPEAT_1_118(m, d) m(2, 118, d)
+#define BOOST_PP_REPEAT_1_120(m,d) BOOST_PP_REPEAT_1_119(m, d) m(2, 119, d)
+#define BOOST_PP_REPEAT_1_121(m,d) BOOST_PP_REPEAT_1_120(m, d) m(2, 120, d)
+#define BOOST_PP_REPEAT_1_122(m,d) BOOST_PP_REPEAT_1_121(m, d) m(2, 121, d)
+#define BOOST_PP_REPEAT_1_123(m,d) BOOST_PP_REPEAT_1_122(m, d) m(2, 122, d)
+#define BOOST_PP_REPEAT_1_124(m,d) BOOST_PP_REPEAT_1_123(m, d) m(2, 123, d)
+#define BOOST_PP_REPEAT_1_125(m,d) BOOST_PP_REPEAT_1_124(m, d) m(2, 124, d)
+#define BOOST_PP_REPEAT_1_126(m,d) BOOST_PP_REPEAT_1_125(m, d) m(2, 125, d)
+#define BOOST_PP_REPEAT_1_127(m,d) BOOST_PP_REPEAT_1_126(m, d) m(2, 126, d)
+#define BOOST_PP_REPEAT_1_128(m,d) BOOST_PP_REPEAT_1_127(m, d) m(2, 127, d)
+#define BOOST_PP_REPEAT_1_129(m,d) BOOST_PP_REPEAT_1_128(m, d) m(2, 128, d)
+#define BOOST_PP_REPEAT_1_130(m,d) BOOST_PP_REPEAT_1_129(m, d) m(2, 129, d)
+#define BOOST_PP_REPEAT_1_131(m,d) BOOST_PP_REPEAT_1_130(m, d) m(2, 130, d)
+#define BOOST_PP_REPEAT_1_132(m,d) BOOST_PP_REPEAT_1_131(m, d) m(2, 131, d)
+#define BOOST_PP_REPEAT_1_133(m,d) BOOST_PP_REPEAT_1_132(m, d) m(2, 132, d)
+#define BOOST_PP_REPEAT_1_134(m,d) BOOST_PP_REPEAT_1_133(m, d) m(2, 133, d)
+#define BOOST_PP_REPEAT_1_135(m,d) BOOST_PP_REPEAT_1_134(m, d) m(2, 134, d)
+#define BOOST_PP_REPEAT_1_136(m,d) BOOST_PP_REPEAT_1_135(m, d) m(2, 135, d)
+#define BOOST_PP_REPEAT_1_137(m,d) BOOST_PP_REPEAT_1_136(m, d) m(2, 136, d)
+#define BOOST_PP_REPEAT_1_138(m,d) BOOST_PP_REPEAT_1_137(m, d) m(2, 137, d)
+#define BOOST_PP_REPEAT_1_139(m,d) BOOST_PP_REPEAT_1_138(m, d) m(2, 138, d)
+#define BOOST_PP_REPEAT_1_140(m,d) BOOST_PP_REPEAT_1_139(m, d) m(2, 139, d)
+#define BOOST_PP_REPEAT_1_141(m,d) BOOST_PP_REPEAT_1_140(m, d) m(2, 140, d)
+#define BOOST_PP_REPEAT_1_142(m,d) BOOST_PP_REPEAT_1_141(m, d) m(2, 141, d)
+#define BOOST_PP_REPEAT_1_143(m,d) BOOST_PP_REPEAT_1_142(m, d) m(2, 142, d)
+#define BOOST_PP_REPEAT_1_144(m,d) BOOST_PP_REPEAT_1_143(m, d) m(2, 143, d)
+#define BOOST_PP_REPEAT_1_145(m,d) BOOST_PP_REPEAT_1_144(m, d) m(2, 144, d)
+#define BOOST_PP_REPEAT_1_146(m,d) BOOST_PP_REPEAT_1_145(m, d) m(2, 145, d)
+#define BOOST_PP_REPEAT_1_147(m,d) BOOST_PP_REPEAT_1_146(m, d) m(2, 146, d)
+#define BOOST_PP_REPEAT_1_148(m,d) BOOST_PP_REPEAT_1_147(m, d) m(2, 147, d)
+#define BOOST_PP_REPEAT_1_149(m,d) BOOST_PP_REPEAT_1_148(m, d) m(2, 148, d)
+#define BOOST_PP_REPEAT_1_150(m,d) BOOST_PP_REPEAT_1_149(m, d) m(2, 149, d)
+#define BOOST_PP_REPEAT_1_151(m,d) BOOST_PP_REPEAT_1_150(m, d) m(2, 150, d)
+#define BOOST_PP_REPEAT_1_152(m,d) BOOST_PP_REPEAT_1_151(m, d) m(2, 151, d)
+#define BOOST_PP_REPEAT_1_153(m,d) BOOST_PP_REPEAT_1_152(m, d) m(2, 152, d)
+#define BOOST_PP_REPEAT_1_154(m,d) BOOST_PP_REPEAT_1_153(m, d) m(2, 153, d)
+#define BOOST_PP_REPEAT_1_155(m,d) BOOST_PP_REPEAT_1_154(m, d) m(2, 154, d)
+#define BOOST_PP_REPEAT_1_156(m,d) BOOST_PP_REPEAT_1_155(m, d) m(2, 155, d)
+#define BOOST_PP_REPEAT_1_157(m,d) BOOST_PP_REPEAT_1_156(m, d) m(2, 156, d)
+#define BOOST_PP_REPEAT_1_158(m,d) BOOST_PP_REPEAT_1_157(m, d) m(2, 157, d)
+#define BOOST_PP_REPEAT_1_159(m,d) BOOST_PP_REPEAT_1_158(m, d) m(2, 158, d)
+#define BOOST_PP_REPEAT_1_160(m,d) BOOST_PP_REPEAT_1_159(m, d) m(2, 159, d)
+#define BOOST_PP_REPEAT_1_161(m,d) BOOST_PP_REPEAT_1_160(m, d) m(2, 160, d)
+#define BOOST_PP_REPEAT_1_162(m,d) BOOST_PP_REPEAT_1_161(m, d) m(2, 161, d)
+#define BOOST_PP_REPEAT_1_163(m,d) BOOST_PP_REPEAT_1_162(m, d) m(2, 162, d)
+#define BOOST_PP_REPEAT_1_164(m,d) BOOST_PP_REPEAT_1_163(m, d) m(2, 163, d)
+#define BOOST_PP_REPEAT_1_165(m,d) BOOST_PP_REPEAT_1_164(m, d) m(2, 164, d)
+#define BOOST_PP_REPEAT_1_166(m,d) BOOST_PP_REPEAT_1_165(m, d) m(2, 165, d)
+#define BOOST_PP_REPEAT_1_167(m,d) BOOST_PP_REPEAT_1_166(m, d) m(2, 166, d)
+#define BOOST_PP_REPEAT_1_168(m,d) BOOST_PP_REPEAT_1_167(m, d) m(2, 167, d)
+#define BOOST_PP_REPEAT_1_169(m,d) BOOST_PP_REPEAT_1_168(m, d) m(2, 168, d)
+#define BOOST_PP_REPEAT_1_170(m,d) BOOST_PP_REPEAT_1_169(m, d) m(2, 169, d)
+#define BOOST_PP_REPEAT_1_171(m,d) BOOST_PP_REPEAT_1_170(m, d) m(2, 170, d)
+#define BOOST_PP_REPEAT_1_172(m,d) BOOST_PP_REPEAT_1_171(m, d) m(2, 171, d)
+#define BOOST_PP_REPEAT_1_173(m,d) BOOST_PP_REPEAT_1_172(m, d) m(2, 172, d)
+#define BOOST_PP_REPEAT_1_174(m,d) BOOST_PP_REPEAT_1_173(m, d) m(2, 173, d)
+#define BOOST_PP_REPEAT_1_175(m,d) BOOST_PP_REPEAT_1_174(m, d) m(2, 174, d)
+#define BOOST_PP_REPEAT_1_176(m,d) BOOST_PP_REPEAT_1_175(m, d) m(2, 175, d)
+#define BOOST_PP_REPEAT_1_177(m,d) BOOST_PP_REPEAT_1_176(m, d) m(2, 176, d)
+#define BOOST_PP_REPEAT_1_178(m,d) BOOST_PP_REPEAT_1_177(m, d) m(2, 177, d)
+#define BOOST_PP_REPEAT_1_179(m,d) BOOST_PP_REPEAT_1_178(m, d) m(2, 178, d)
+#define BOOST_PP_REPEAT_1_180(m,d) BOOST_PP_REPEAT_1_179(m, d) m(2, 179, d)
+#define BOOST_PP_REPEAT_1_181(m,d) BOOST_PP_REPEAT_1_180(m, d) m(2, 180, d)
+#define BOOST_PP_REPEAT_1_182(m,d) BOOST_PP_REPEAT_1_181(m, d) m(2, 181, d)
+#define BOOST_PP_REPEAT_1_183(m,d) BOOST_PP_REPEAT_1_182(m, d) m(2, 182, d)
+#define BOOST_PP_REPEAT_1_184(m,d) BOOST_PP_REPEAT_1_183(m, d) m(2, 183, d)
+#define BOOST_PP_REPEAT_1_185(m,d) BOOST_PP_REPEAT_1_184(m, d) m(2, 184, d)
+#define BOOST_PP_REPEAT_1_186(m,d) BOOST_PP_REPEAT_1_185(m, d) m(2, 185, d)
+#define BOOST_PP_REPEAT_1_187(m,d) BOOST_PP_REPEAT_1_186(m, d) m(2, 186, d)
+#define BOOST_PP_REPEAT_1_188(m,d) BOOST_PP_REPEAT_1_187(m, d) m(2, 187, d)
+#define BOOST_PP_REPEAT_1_189(m,d) BOOST_PP_REPEAT_1_188(m, d) m(2, 188, d)
+#define BOOST_PP_REPEAT_1_190(m,d) BOOST_PP_REPEAT_1_189(m, d) m(2, 189, d)
+#define BOOST_PP_REPEAT_1_191(m,d) BOOST_PP_REPEAT_1_190(m, d) m(2, 190, d)
+#define BOOST_PP_REPEAT_1_192(m,d) BOOST_PP_REPEAT_1_191(m, d) m(2, 191, d)
+#define BOOST_PP_REPEAT_1_193(m,d) BOOST_PP_REPEAT_1_192(m, d) m(2, 192, d)
+#define BOOST_PP_REPEAT_1_194(m,d) BOOST_PP_REPEAT_1_193(m, d) m(2, 193, d)
+#define BOOST_PP_REPEAT_1_195(m,d) BOOST_PP_REPEAT_1_194(m, d) m(2, 194, d)
+#define BOOST_PP_REPEAT_1_196(m,d) BOOST_PP_REPEAT_1_195(m, d) m(2, 195, d)
+#define BOOST_PP_REPEAT_1_197(m,d) BOOST_PP_REPEAT_1_196(m, d) m(2, 196, d)
+#define BOOST_PP_REPEAT_1_198(m,d) BOOST_PP_REPEAT_1_197(m, d) m(2, 197, d)
+#define BOOST_PP_REPEAT_1_199(m,d) BOOST_PP_REPEAT_1_198(m, d) m(2, 198, d)
+#define BOOST_PP_REPEAT_1_200(m,d) BOOST_PP_REPEAT_1_199(m, d) m(2, 199, d)
+#define BOOST_PP_REPEAT_1_201(m,d) BOOST_PP_REPEAT_1_200(m, d) m(2, 200, d)
+#define BOOST_PP_REPEAT_1_202(m,d) BOOST_PP_REPEAT_1_201(m, d) m(2, 201, d)
+#define BOOST_PP_REPEAT_1_203(m,d) BOOST_PP_REPEAT_1_202(m, d) m(2, 202, d)
+#define BOOST_PP_REPEAT_1_204(m,d) BOOST_PP_REPEAT_1_203(m, d) m(2, 203, d)
+#define BOOST_PP_REPEAT_1_205(m,d) BOOST_PP_REPEAT_1_204(m, d) m(2, 204, d)
+#define BOOST_PP_REPEAT_1_206(m,d) BOOST_PP_REPEAT_1_205(m, d) m(2, 205, d)
+#define BOOST_PP_REPEAT_1_207(m,d) BOOST_PP_REPEAT_1_206(m, d) m(2, 206, d)
+#define BOOST_PP_REPEAT_1_208(m,d) BOOST_PP_REPEAT_1_207(m, d) m(2, 207, d)
+#define BOOST_PP_REPEAT_1_209(m,d) BOOST_PP_REPEAT_1_208(m, d) m(2, 208, d)
+#define BOOST_PP_REPEAT_1_210(m,d) BOOST_PP_REPEAT_1_209(m, d) m(2, 209, d)
+#define BOOST_PP_REPEAT_1_211(m,d) BOOST_PP_REPEAT_1_210(m, d) m(2, 210, d)
+#define BOOST_PP_REPEAT_1_212(m,d) BOOST_PP_REPEAT_1_211(m, d) m(2, 211, d)
+#define BOOST_PP_REPEAT_1_213(m,d) BOOST_PP_REPEAT_1_212(m, d) m(2, 212, d)
+#define BOOST_PP_REPEAT_1_214(m,d) BOOST_PP_REPEAT_1_213(m, d) m(2, 213, d)
+#define BOOST_PP_REPEAT_1_215(m,d) BOOST_PP_REPEAT_1_214(m, d) m(2, 214, d)
+#define BOOST_PP_REPEAT_1_216(m,d) BOOST_PP_REPEAT_1_215(m, d) m(2, 215, d)
+#define BOOST_PP_REPEAT_1_217(m,d) BOOST_PP_REPEAT_1_216(m, d) m(2, 216, d)
+#define BOOST_PP_REPEAT_1_218(m,d) BOOST_PP_REPEAT_1_217(m, d) m(2, 217, d)
+#define BOOST_PP_REPEAT_1_219(m,d) BOOST_PP_REPEAT_1_218(m, d) m(2, 218, d)
+#define BOOST_PP_REPEAT_1_220(m,d) BOOST_PP_REPEAT_1_219(m, d) m(2, 219, d)
+#define BOOST_PP_REPEAT_1_221(m,d) BOOST_PP_REPEAT_1_220(m, d) m(2, 220, d)
+#define BOOST_PP_REPEAT_1_222(m,d) BOOST_PP_REPEAT_1_221(m, d) m(2, 221, d)
+#define BOOST_PP_REPEAT_1_223(m,d) BOOST_PP_REPEAT_1_222(m, d) m(2, 222, d)
+#define BOOST_PP_REPEAT_1_224(m,d) BOOST_PP_REPEAT_1_223(m, d) m(2, 223, d)
+#define BOOST_PP_REPEAT_1_225(m,d) BOOST_PP_REPEAT_1_224(m, d) m(2, 224, d)
+#define BOOST_PP_REPEAT_1_226(m,d) BOOST_PP_REPEAT_1_225(m, d) m(2, 225, d)
+#define BOOST_PP_REPEAT_1_227(m,d) BOOST_PP_REPEAT_1_226(m, d) m(2, 226, d)
+#define BOOST_PP_REPEAT_1_228(m,d) BOOST_PP_REPEAT_1_227(m, d) m(2, 227, d)
+#define BOOST_PP_REPEAT_1_229(m,d) BOOST_PP_REPEAT_1_228(m, d) m(2, 228, d)
+#define BOOST_PP_REPEAT_1_230(m,d) BOOST_PP_REPEAT_1_229(m, d) m(2, 229, d)
+#define BOOST_PP_REPEAT_1_231(m,d) BOOST_PP_REPEAT_1_230(m, d) m(2, 230, d)
+#define BOOST_PP_REPEAT_1_232(m,d) BOOST_PP_REPEAT_1_231(m, d) m(2, 231, d)
+#define BOOST_PP_REPEAT_1_233(m,d) BOOST_PP_REPEAT_1_232(m, d) m(2, 232, d)
+#define BOOST_PP_REPEAT_1_234(m,d) BOOST_PP_REPEAT_1_233(m, d) m(2, 233, d)
+#define BOOST_PP_REPEAT_1_235(m,d) BOOST_PP_REPEAT_1_234(m, d) m(2, 234, d)
+#define BOOST_PP_REPEAT_1_236(m,d) BOOST_PP_REPEAT_1_235(m, d) m(2, 235, d)
+#define BOOST_PP_REPEAT_1_237(m,d) BOOST_PP_REPEAT_1_236(m, d) m(2, 236, d)
+#define BOOST_PP_REPEAT_1_238(m,d) BOOST_PP_REPEAT_1_237(m, d) m(2, 237, d)
+#define BOOST_PP_REPEAT_1_239(m,d) BOOST_PP_REPEAT_1_238(m, d) m(2, 238, d)
+#define BOOST_PP_REPEAT_1_240(m,d) BOOST_PP_REPEAT_1_239(m, d) m(2, 239, d)
+#define BOOST_PP_REPEAT_1_241(m,d) BOOST_PP_REPEAT_1_240(m, d) m(2, 240, d)
+#define BOOST_PP_REPEAT_1_242(m,d) BOOST_PP_REPEAT_1_241(m, d) m(2, 241, d)
+#define BOOST_PP_REPEAT_1_243(m,d) BOOST_PP_REPEAT_1_242(m, d) m(2, 242, d)
+#define BOOST_PP_REPEAT_1_244(m,d) BOOST_PP_REPEAT_1_243(m, d) m(2, 243, d)
+#define BOOST_PP_REPEAT_1_245(m,d) BOOST_PP_REPEAT_1_244(m, d) m(2, 244, d)
+#define BOOST_PP_REPEAT_1_246(m,d) BOOST_PP_REPEAT_1_245(m, d) m(2, 245, d)
+#define BOOST_PP_REPEAT_1_247(m,d) BOOST_PP_REPEAT_1_246(m, d) m(2, 246, d)
+#define BOOST_PP_REPEAT_1_248(m,d) BOOST_PP_REPEAT_1_247(m, d) m(2, 247, d)
+#define BOOST_PP_REPEAT_1_249(m,d) BOOST_PP_REPEAT_1_248(m, d) m(2, 248, d)
+#define BOOST_PP_REPEAT_1_250(m,d) BOOST_PP_REPEAT_1_249(m, d) m(2, 249, d)
+#define BOOST_PP_REPEAT_1_251(m,d) BOOST_PP_REPEAT_1_250(m, d) m(2, 250, d)
+#define BOOST_PP_REPEAT_1_252(m,d) BOOST_PP_REPEAT_1_251(m, d) m(2, 251, d)
+#define BOOST_PP_REPEAT_1_253(m,d) BOOST_PP_REPEAT_1_252(m, d) m(2, 252, d)
+#define BOOST_PP_REPEAT_1_254(m,d) BOOST_PP_REPEAT_1_253(m, d) m(2, 253, d)
+#define BOOST_PP_REPEAT_1_255(m,d) BOOST_PP_REPEAT_1_254(m, d) m(2, 254, d)
+#define BOOST_PP_REPEAT_1_256(m,d) BOOST_PP_REPEAT_1_255(m, d) m(2, 255, d)
+
+#define BOOST_PP_REPEAT_2_0(m,d) 
+#define BOOST_PP_REPEAT_2_1(m,d) m(3, 0, d)
+#define BOOST_PP_REPEAT_2_2(m,d) BOOST_PP_REPEAT_2_1(m, d) m(3, 1, d)
+#define BOOST_PP_REPEAT_2_3(m,d) BOOST_PP_REPEAT_2_2(m, d) m(3, 2, d)
+#define BOOST_PP_REPEAT_2_4(m,d) BOOST_PP_REPEAT_2_3(m, d) m(3, 3, d)
+#define BOOST_PP_REPEAT_2_5(m,d) BOOST_PP_REPEAT_2_4(m, d) m(3, 4, d)
+#define BOOST_PP_REPEAT_2_6(m,d) BOOST_PP_REPEAT_2_5(m, d) m(3, 5, d)
+#define BOOST_PP_REPEAT_2_7(m,d) BOOST_PP_REPEAT_2_6(m, d) m(3, 6, d)
+#define BOOST_PP_REPEAT_2_8(m,d) BOOST_PP_REPEAT_2_7(m, d) m(3, 7, d)
+#define BOOST_PP_REPEAT_2_9(m,d) BOOST_PP_REPEAT_2_8(m, d) m(3, 8, d)
+#define BOOST_PP_REPEAT_2_10(m,d) BOOST_PP_REPEAT_2_9(m, d) m(3, 9, d)
+#define BOOST_PP_REPEAT_2_11(m,d) BOOST_PP_REPEAT_2_10(m, d) m(3, 10, d)
+#define BOOST_PP_REPEAT_2_12(m,d) BOOST_PP_REPEAT_2_11(m, d) m(3, 11, d)
+#define BOOST_PP_REPEAT_2_13(m,d) BOOST_PP_REPEAT_2_12(m, d) m(3, 12, d)
+#define BOOST_PP_REPEAT_2_14(m,d) BOOST_PP_REPEAT_2_13(m, d) m(3, 13, d)
+#define BOOST_PP_REPEAT_2_15(m,d) BOOST_PP_REPEAT_2_14(m, d) m(3, 14, d)
+#define BOOST_PP_REPEAT_2_16(m,d) BOOST_PP_REPEAT_2_15(m, d) m(3, 15, d)
+#define BOOST_PP_REPEAT_2_17(m,d) BOOST_PP_REPEAT_2_16(m, d) m(3, 16, d)
+#define BOOST_PP_REPEAT_2_18(m,d) BOOST_PP_REPEAT_2_17(m, d) m(3, 17, d)
+#define BOOST_PP_REPEAT_2_19(m,d) BOOST_PP_REPEAT_2_18(m, d) m(3, 18, d)
+#define BOOST_PP_REPEAT_2_20(m,d) BOOST_PP_REPEAT_2_19(m, d) m(3, 19, d)
+#define BOOST_PP_REPEAT_2_21(m,d) BOOST_PP_REPEAT_2_20(m, d) m(3, 20, d)
+#define BOOST_PP_REPEAT_2_22(m,d) BOOST_PP_REPEAT_2_21(m, d) m(3, 21, d)
+#define BOOST_PP_REPEAT_2_23(m,d) BOOST_PP_REPEAT_2_22(m, d) m(3, 22, d)
+#define BOOST_PP_REPEAT_2_24(m,d) BOOST_PP_REPEAT_2_23(m, d) m(3, 23, d)
+#define BOOST_PP_REPEAT_2_25(m,d) BOOST_PP_REPEAT_2_24(m, d) m(3, 24, d)
+#define BOOST_PP_REPEAT_2_26(m,d) BOOST_PP_REPEAT_2_25(m, d) m(3, 25, d)
+#define BOOST_PP_REPEAT_2_27(m,d) BOOST_PP_REPEAT_2_26(m, d) m(3, 26, d)
+#define BOOST_PP_REPEAT_2_28(m,d) BOOST_PP_REPEAT_2_27(m, d) m(3, 27, d)
+#define BOOST_PP_REPEAT_2_29(m,d) BOOST_PP_REPEAT_2_28(m, d) m(3, 28, d)
+#define BOOST_PP_REPEAT_2_30(m,d) BOOST_PP_REPEAT_2_29(m, d) m(3, 29, d)
+#define BOOST_PP_REPEAT_2_31(m,d) BOOST_PP_REPEAT_2_30(m, d) m(3, 30, d)
+#define BOOST_PP_REPEAT_2_32(m,d) BOOST_PP_REPEAT_2_31(m, d) m(3, 31, d)
+#define BOOST_PP_REPEAT_2_33(m,d) BOOST_PP_REPEAT_2_32(m, d) m(3, 32, d)
+#define BOOST_PP_REPEAT_2_34(m,d) BOOST_PP_REPEAT_2_33(m, d) m(3, 33, d)
+#define BOOST_PP_REPEAT_2_35(m,d) BOOST_PP_REPEAT_2_34(m, d) m(3, 34, d)
+#define BOOST_PP_REPEAT_2_36(m,d) BOOST_PP_REPEAT_2_35(m, d) m(3, 35, d)
+#define BOOST_PP_REPEAT_2_37(m,d) BOOST_PP_REPEAT_2_36(m, d) m(3, 36, d)
+#define BOOST_PP_REPEAT_2_38(m,d) BOOST_PP_REPEAT_2_37(m, d) m(3, 37, d)
+#define BOOST_PP_REPEAT_2_39(m,d) BOOST_PP_REPEAT_2_38(m, d) m(3, 38, d)
+#define BOOST_PP_REPEAT_2_40(m,d) BOOST_PP_REPEAT_2_39(m, d) m(3, 39, d)
+#define BOOST_PP_REPEAT_2_41(m,d) BOOST_PP_REPEAT_2_40(m, d) m(3, 40, d)
+#define BOOST_PP_REPEAT_2_42(m,d) BOOST_PP_REPEAT_2_41(m, d) m(3, 41, d)
+#define BOOST_PP_REPEAT_2_43(m,d) BOOST_PP_REPEAT_2_42(m, d) m(3, 42, d)
+#define BOOST_PP_REPEAT_2_44(m,d) BOOST_PP_REPEAT_2_43(m, d) m(3, 43, d)
+#define BOOST_PP_REPEAT_2_45(m,d) BOOST_PP_REPEAT_2_44(m, d) m(3, 44, d)
+#define BOOST_PP_REPEAT_2_46(m,d) BOOST_PP_REPEAT_2_45(m, d) m(3, 45, d)
+#define BOOST_PP_REPEAT_2_47(m,d) BOOST_PP_REPEAT_2_46(m, d) m(3, 46, d)
+#define BOOST_PP_REPEAT_2_48(m,d) BOOST_PP_REPEAT_2_47(m, d) m(3, 47, d)
+#define BOOST_PP_REPEAT_2_49(m,d) BOOST_PP_REPEAT_2_48(m, d) m(3, 48, d)
+#define BOOST_PP_REPEAT_2_50(m,d) BOOST_PP_REPEAT_2_49(m, d) m(3, 49, d)
+#define BOOST_PP_REPEAT_2_51(m,d) BOOST_PP_REPEAT_2_50(m, d) m(3, 50, d)
+#define BOOST_PP_REPEAT_2_52(m,d) BOOST_PP_REPEAT_2_51(m, d) m(3, 51, d)
+#define BOOST_PP_REPEAT_2_53(m,d) BOOST_PP_REPEAT_2_52(m, d) m(3, 52, d)
+#define BOOST_PP_REPEAT_2_54(m,d) BOOST_PP_REPEAT_2_53(m, d) m(3, 53, d)
+#define BOOST_PP_REPEAT_2_55(m,d) BOOST_PP_REPEAT_2_54(m, d) m(3, 54, d)
+#define BOOST_PP_REPEAT_2_56(m,d) BOOST_PP_REPEAT_2_55(m, d) m(3, 55, d)
+#define BOOST_PP_REPEAT_2_57(m,d) BOOST_PP_REPEAT_2_56(m, d) m(3, 56, d)
+#define BOOST_PP_REPEAT_2_58(m,d) BOOST_PP_REPEAT_2_57(m, d) m(3, 57, d)
+#define BOOST_PP_REPEAT_2_59(m,d) BOOST_PP_REPEAT_2_58(m, d) m(3, 58, d)
+#define BOOST_PP_REPEAT_2_60(m,d) BOOST_PP_REPEAT_2_59(m, d) m(3, 59, d)
+#define BOOST_PP_REPEAT_2_61(m,d) BOOST_PP_REPEAT_2_60(m, d) m(3, 60, d)
+#define BOOST_PP_REPEAT_2_62(m,d) BOOST_PP_REPEAT_2_61(m, d) m(3, 61, d)
+#define BOOST_PP_REPEAT_2_63(m,d) BOOST_PP_REPEAT_2_62(m, d) m(3, 62, d)
+#define BOOST_PP_REPEAT_2_64(m,d) BOOST_PP_REPEAT_2_63(m, d) m(3, 63, d)
+#define BOOST_PP_REPEAT_2_65(m,d) BOOST_PP_REPEAT_2_64(m, d) m(3, 64, d)
+#define BOOST_PP_REPEAT_2_66(m,d) BOOST_PP_REPEAT_2_65(m, d) m(3, 65, d)
+#define BOOST_PP_REPEAT_2_67(m,d) BOOST_PP_REPEAT_2_66(m, d) m(3, 66, d)
+#define BOOST_PP_REPEAT_2_68(m,d) BOOST_PP_REPEAT_2_67(m, d) m(3, 67, d)
+#define BOOST_PP_REPEAT_2_69(m,d) BOOST_PP_REPEAT_2_68(m, d) m(3, 68, d)
+#define BOOST_PP_REPEAT_2_70(m,d) BOOST_PP_REPEAT_2_69(m, d) m(3, 69, d)
+#define BOOST_PP_REPEAT_2_71(m,d) BOOST_PP_REPEAT_2_70(m, d) m(3, 70, d)
+#define BOOST_PP_REPEAT_2_72(m,d) BOOST_PP_REPEAT_2_71(m, d) m(3, 71, d)
+#define BOOST_PP_REPEAT_2_73(m,d) BOOST_PP_REPEAT_2_72(m, d) m(3, 72, d)
+#define BOOST_PP_REPEAT_2_74(m,d) BOOST_PP_REPEAT_2_73(m, d) m(3, 73, d)
+#define BOOST_PP_REPEAT_2_75(m,d) BOOST_PP_REPEAT_2_74(m, d) m(3, 74, d)
+#define BOOST_PP_REPEAT_2_76(m,d) BOOST_PP_REPEAT_2_75(m, d) m(3, 75, d)
+#define BOOST_PP_REPEAT_2_77(m,d) BOOST_PP_REPEAT_2_76(m, d) m(3, 76, d)
+#define BOOST_PP_REPEAT_2_78(m,d) BOOST_PP_REPEAT_2_77(m, d) m(3, 77, d)
+#define BOOST_PP_REPEAT_2_79(m,d) BOOST_PP_REPEAT_2_78(m, d) m(3, 78, d)
+#define BOOST_PP_REPEAT_2_80(m,d) BOOST_PP_REPEAT_2_79(m, d) m(3, 79, d)
+#define BOOST_PP_REPEAT_2_81(m,d) BOOST_PP_REPEAT_2_80(m, d) m(3, 80, d)
+#define BOOST_PP_REPEAT_2_82(m,d) BOOST_PP_REPEAT_2_81(m, d) m(3, 81, d)
+#define BOOST_PP_REPEAT_2_83(m,d) BOOST_PP_REPEAT_2_82(m, d) m(3, 82, d)
+#define BOOST_PP_REPEAT_2_84(m,d) BOOST_PP_REPEAT_2_83(m, d) m(3, 83, d)
+#define BOOST_PP_REPEAT_2_85(m,d) BOOST_PP_REPEAT_2_84(m, d) m(3, 84, d)
+#define BOOST_PP_REPEAT_2_86(m,d) BOOST_PP_REPEAT_2_85(m, d) m(3, 85, d)
+#define BOOST_PP_REPEAT_2_87(m,d) BOOST_PP_REPEAT_2_86(m, d) m(3, 86, d)
+#define BOOST_PP_REPEAT_2_88(m,d) BOOST_PP_REPEAT_2_87(m, d) m(3, 87, d)
+#define BOOST_PP_REPEAT_2_89(m,d) BOOST_PP_REPEAT_2_88(m, d) m(3, 88, d)
+#define BOOST_PP_REPEAT_2_90(m,d) BOOST_PP_REPEAT_2_89(m, d) m(3, 89, d)
+#define BOOST_PP_REPEAT_2_91(m,d) BOOST_PP_REPEAT_2_90(m, d) m(3, 90, d)
+#define BOOST_PP_REPEAT_2_92(m,d) BOOST_PP_REPEAT_2_91(m, d) m(3, 91, d)
+#define BOOST_PP_REPEAT_2_93(m,d) BOOST_PP_REPEAT_2_92(m, d) m(3, 92, d)
+#define BOOST_PP_REPEAT_2_94(m,d) BOOST_PP_REPEAT_2_93(m, d) m(3, 93, d)
+#define BOOST_PP_REPEAT_2_95(m,d) BOOST_PP_REPEAT_2_94(m, d) m(3, 94, d)
+#define BOOST_PP_REPEAT_2_96(m,d) BOOST_PP_REPEAT_2_95(m, d) m(3, 95, d)
+#define BOOST_PP_REPEAT_2_97(m,d) BOOST_PP_REPEAT_2_96(m, d) m(3, 96, d)
+#define BOOST_PP_REPEAT_2_98(m,d) BOOST_PP_REPEAT_2_97(m, d) m(3, 97, d)
+#define BOOST_PP_REPEAT_2_99(m,d) BOOST_PP_REPEAT_2_98(m, d) m(3, 98, d)
+#define BOOST_PP_REPEAT_2_100(m,d) BOOST_PP_REPEAT_2_99(m, d) m(3, 99, d)
+#define BOOST_PP_REPEAT_2_101(m,d) BOOST_PP_REPEAT_2_100(m, d) m(3, 100, d)
+#define BOOST_PP_REPEAT_2_102(m,d) BOOST_PP_REPEAT_2_101(m, d) m(3, 101, d)
+#define BOOST_PP_REPEAT_2_103(m,d) BOOST_PP_REPEAT_2_102(m, d) m(3, 102, d)
+#define BOOST_PP_REPEAT_2_104(m,d) BOOST_PP_REPEAT_2_103(m, d) m(3, 103, d)
+#define BOOST_PP_REPEAT_2_105(m,d) BOOST_PP_REPEAT_2_104(m, d) m(3, 104, d)
+#define BOOST_PP_REPEAT_2_106(m,d) BOOST_PP_REPEAT_2_105(m, d) m(3, 105, d)
+#define BOOST_PP_REPEAT_2_107(m,d) BOOST_PP_REPEAT_2_106(m, d) m(3, 106, d)
+#define BOOST_PP_REPEAT_2_108(m,d) BOOST_PP_REPEAT_2_107(m, d) m(3, 107, d)
+#define BOOST_PP_REPEAT_2_109(m,d) BOOST_PP_REPEAT_2_108(m, d) m(3, 108, d)
+#define BOOST_PP_REPEAT_2_110(m,d) BOOST_PP_REPEAT_2_109(m, d) m(3, 109, d)
+#define BOOST_PP_REPEAT_2_111(m,d) BOOST_PP_REPEAT_2_110(m, d) m(3, 110, d)
+#define BOOST_PP_REPEAT_2_112(m,d) BOOST_PP_REPEAT_2_111(m, d) m(3, 111, d)
+#define BOOST_PP_REPEAT_2_113(m,d) BOOST_PP_REPEAT_2_112(m, d) m(3, 112, d)
+#define BOOST_PP_REPEAT_2_114(m,d) BOOST_PP_REPEAT_2_113(m, d) m(3, 113, d)
+#define BOOST_PP_REPEAT_2_115(m,d) BOOST_PP_REPEAT_2_114(m, d) m(3, 114, d)
+#define BOOST_PP_REPEAT_2_116(m,d) BOOST_PP_REPEAT_2_115(m, d) m(3, 115, d)
+#define BOOST_PP_REPEAT_2_117(m,d) BOOST_PP_REPEAT_2_116(m, d) m(3, 116, d)
+#define BOOST_PP_REPEAT_2_118(m,d) BOOST_PP_REPEAT_2_117(m, d) m(3, 117, d)
+#define BOOST_PP_REPEAT_2_119(m,d) BOOST_PP_REPEAT_2_118(m, d) m(3, 118, d)
+#define BOOST_PP_REPEAT_2_120(m,d) BOOST_PP_REPEAT_2_119(m, d) m(3, 119, d)
+#define BOOST_PP_REPEAT_2_121(m,d) BOOST_PP_REPEAT_2_120(m, d) m(3, 120, d)
+#define BOOST_PP_REPEAT_2_122(m,d) BOOST_PP_REPEAT_2_121(m, d) m(3, 121, d)
+#define BOOST_PP_REPEAT_2_123(m,d) BOOST_PP_REPEAT_2_122(m, d) m(3, 122, d)
+#define BOOST_PP_REPEAT_2_124(m,d) BOOST_PP_REPEAT_2_123(m, d) m(3, 123, d)
+#define BOOST_PP_REPEAT_2_125(m,d) BOOST_PP_REPEAT_2_124(m, d) m(3, 124, d)
+#define BOOST_PP_REPEAT_2_126(m,d) BOOST_PP_REPEAT_2_125(m, d) m(3, 125, d)
+#define BOOST_PP_REPEAT_2_127(m,d) BOOST_PP_REPEAT_2_126(m, d) m(3, 126, d)
+#define BOOST_PP_REPEAT_2_128(m,d) BOOST_PP_REPEAT_2_127(m, d) m(3, 127, d)
+#define BOOST_PP_REPEAT_2_129(m,d) BOOST_PP_REPEAT_2_128(m, d) m(3, 128, d)
+#define BOOST_PP_REPEAT_2_130(m,d) BOOST_PP_REPEAT_2_129(m, d) m(3, 129, d)
+#define BOOST_PP_REPEAT_2_131(m,d) BOOST_PP_REPEAT_2_130(m, d) m(3, 130, d)
+#define BOOST_PP_REPEAT_2_132(m,d) BOOST_PP_REPEAT_2_131(m, d) m(3, 131, d)
+#define BOOST_PP_REPEAT_2_133(m,d) BOOST_PP_REPEAT_2_132(m, d) m(3, 132, d)
+#define BOOST_PP_REPEAT_2_134(m,d) BOOST_PP_REPEAT_2_133(m, d) m(3, 133, d)
+#define BOOST_PP_REPEAT_2_135(m,d) BOOST_PP_REPEAT_2_134(m, d) m(3, 134, d)
+#define BOOST_PP_REPEAT_2_136(m,d) BOOST_PP_REPEAT_2_135(m, d) m(3, 135, d)
+#define BOOST_PP_REPEAT_2_137(m,d) BOOST_PP_REPEAT_2_136(m, d) m(3, 136, d)
+#define BOOST_PP_REPEAT_2_138(m,d) BOOST_PP_REPEAT_2_137(m, d) m(3, 137, d)
+#define BOOST_PP_REPEAT_2_139(m,d) BOOST_PP_REPEAT_2_138(m, d) m(3, 138, d)
+#define BOOST_PP_REPEAT_2_140(m,d) BOOST_PP_REPEAT_2_139(m, d) m(3, 139, d)
+#define BOOST_PP_REPEAT_2_141(m,d) BOOST_PP_REPEAT_2_140(m, d) m(3, 140, d)
+#define BOOST_PP_REPEAT_2_142(m,d) BOOST_PP_REPEAT_2_141(m, d) m(3, 141, d)
+#define BOOST_PP_REPEAT_2_143(m,d) BOOST_PP_REPEAT_2_142(m, d) m(3, 142, d)
+#define BOOST_PP_REPEAT_2_144(m,d) BOOST_PP_REPEAT_2_143(m, d) m(3, 143, d)
+#define BOOST_PP_REPEAT_2_145(m,d) BOOST_PP_REPEAT_2_144(m, d) m(3, 144, d)
+#define BOOST_PP_REPEAT_2_146(m,d) BOOST_PP_REPEAT_2_145(m, d) m(3, 145, d)
+#define BOOST_PP_REPEAT_2_147(m,d) BOOST_PP_REPEAT_2_146(m, d) m(3, 146, d)
+#define BOOST_PP_REPEAT_2_148(m,d) BOOST_PP_REPEAT_2_147(m, d) m(3, 147, d)
+#define BOOST_PP_REPEAT_2_149(m,d) BOOST_PP_REPEAT_2_148(m, d) m(3, 148, d)
+#define BOOST_PP_REPEAT_2_150(m,d) BOOST_PP_REPEAT_2_149(m, d) m(3, 149, d)
+#define BOOST_PP_REPEAT_2_151(m,d) BOOST_PP_REPEAT_2_150(m, d) m(3, 150, d)
+#define BOOST_PP_REPEAT_2_152(m,d) BOOST_PP_REPEAT_2_151(m, d) m(3, 151, d)
+#define BOOST_PP_REPEAT_2_153(m,d) BOOST_PP_REPEAT_2_152(m, d) m(3, 152, d)
+#define BOOST_PP_REPEAT_2_154(m,d) BOOST_PP_REPEAT_2_153(m, d) m(3, 153, d)
+#define BOOST_PP_REPEAT_2_155(m,d) BOOST_PP_REPEAT_2_154(m, d) m(3, 154, d)
+#define BOOST_PP_REPEAT_2_156(m,d) BOOST_PP_REPEAT_2_155(m, d) m(3, 155, d)
+#define BOOST_PP_REPEAT_2_157(m,d) BOOST_PP_REPEAT_2_156(m, d) m(3, 156, d)
+#define BOOST_PP_REPEAT_2_158(m,d) BOOST_PP_REPEAT_2_157(m, d) m(3, 157, d)
+#define BOOST_PP_REPEAT_2_159(m,d) BOOST_PP_REPEAT_2_158(m, d) m(3, 158, d)
+#define BOOST_PP_REPEAT_2_160(m,d) BOOST_PP_REPEAT_2_159(m, d) m(3, 159, d)
+#define BOOST_PP_REPEAT_2_161(m,d) BOOST_PP_REPEAT_2_160(m, d) m(3, 160, d)
+#define BOOST_PP_REPEAT_2_162(m,d) BOOST_PP_REPEAT_2_161(m, d) m(3, 161, d)
+#define BOOST_PP_REPEAT_2_163(m,d) BOOST_PP_REPEAT_2_162(m, d) m(3, 162, d)
+#define BOOST_PP_REPEAT_2_164(m,d) BOOST_PP_REPEAT_2_163(m, d) m(3, 163, d)
+#define BOOST_PP_REPEAT_2_165(m,d) BOOST_PP_REPEAT_2_164(m, d) m(3, 164, d)
+#define BOOST_PP_REPEAT_2_166(m,d) BOOST_PP_REPEAT_2_165(m, d) m(3, 165, d)
+#define BOOST_PP_REPEAT_2_167(m,d) BOOST_PP_REPEAT_2_166(m, d) m(3, 166, d)
+#define BOOST_PP_REPEAT_2_168(m,d) BOOST_PP_REPEAT_2_167(m, d) m(3, 167, d)
+#define BOOST_PP_REPEAT_2_169(m,d) BOOST_PP_REPEAT_2_168(m, d) m(3, 168, d)
+#define BOOST_PP_REPEAT_2_170(m,d) BOOST_PP_REPEAT_2_169(m, d) m(3, 169, d)
+#define BOOST_PP_REPEAT_2_171(m,d) BOOST_PP_REPEAT_2_170(m, d) m(3, 170, d)
+#define BOOST_PP_REPEAT_2_172(m,d) BOOST_PP_REPEAT_2_171(m, d) m(3, 171, d)
+#define BOOST_PP_REPEAT_2_173(m,d) BOOST_PP_REPEAT_2_172(m, d) m(3, 172, d)
+#define BOOST_PP_REPEAT_2_174(m,d) BOOST_PP_REPEAT_2_173(m, d) m(3, 173, d)
+#define BOOST_PP_REPEAT_2_175(m,d) BOOST_PP_REPEAT_2_174(m, d) m(3, 174, d)
+#define BOOST_PP_REPEAT_2_176(m,d) BOOST_PP_REPEAT_2_175(m, d) m(3, 175, d)
+#define BOOST_PP_REPEAT_2_177(m,d) BOOST_PP_REPEAT_2_176(m, d) m(3, 176, d)
+#define BOOST_PP_REPEAT_2_178(m,d) BOOST_PP_REPEAT_2_177(m, d) m(3, 177, d)
+#define BOOST_PP_REPEAT_2_179(m,d) BOOST_PP_REPEAT_2_178(m, d) m(3, 178, d)
+#define BOOST_PP_REPEAT_2_180(m,d) BOOST_PP_REPEAT_2_179(m, d) m(3, 179, d)
+#define BOOST_PP_REPEAT_2_181(m,d) BOOST_PP_REPEAT_2_180(m, d) m(3, 180, d)
+#define BOOST_PP_REPEAT_2_182(m,d) BOOST_PP_REPEAT_2_181(m, d) m(3, 181, d)
+#define BOOST_PP_REPEAT_2_183(m,d) BOOST_PP_REPEAT_2_182(m, d) m(3, 182, d)
+#define BOOST_PP_REPEAT_2_184(m,d) BOOST_PP_REPEAT_2_183(m, d) m(3, 183, d)
+#define BOOST_PP_REPEAT_2_185(m,d) BOOST_PP_REPEAT_2_184(m, d) m(3, 184, d)
+#define BOOST_PP_REPEAT_2_186(m,d) BOOST_PP_REPEAT_2_185(m, d) m(3, 185, d)
+#define BOOST_PP_REPEAT_2_187(m,d) BOOST_PP_REPEAT_2_186(m, d) m(3, 186, d)
+#define BOOST_PP_REPEAT_2_188(m,d) BOOST_PP_REPEAT_2_187(m, d) m(3, 187, d)
+#define BOOST_PP_REPEAT_2_189(m,d) BOOST_PP_REPEAT_2_188(m, d) m(3, 188, d)
+#define BOOST_PP_REPEAT_2_190(m,d) BOOST_PP_REPEAT_2_189(m, d) m(3, 189, d)
+#define BOOST_PP_REPEAT_2_191(m,d) BOOST_PP_REPEAT_2_190(m, d) m(3, 190, d)
+#define BOOST_PP_REPEAT_2_192(m,d) BOOST_PP_REPEAT_2_191(m, d) m(3, 191, d)
+#define BOOST_PP_REPEAT_2_193(m,d) BOOST_PP_REPEAT_2_192(m, d) m(3, 192, d)
+#define BOOST_PP_REPEAT_2_194(m,d) BOOST_PP_REPEAT_2_193(m, d) m(3, 193, d)
+#define BOOST_PP_REPEAT_2_195(m,d) BOOST_PP_REPEAT_2_194(m, d) m(3, 194, d)
+#define BOOST_PP_REPEAT_2_196(m,d) BOOST_PP_REPEAT_2_195(m, d) m(3, 195, d)
+#define BOOST_PP_REPEAT_2_197(m,d) BOOST_PP_REPEAT_2_196(m, d) m(3, 196, d)
+#define BOOST_PP_REPEAT_2_198(m,d) BOOST_PP_REPEAT_2_197(m, d) m(3, 197, d)
+#define BOOST_PP_REPEAT_2_199(m,d) BOOST_PP_REPEAT_2_198(m, d) m(3, 198, d)
+#define BOOST_PP_REPEAT_2_200(m,d) BOOST_PP_REPEAT_2_199(m, d) m(3, 199, d)
+#define BOOST_PP_REPEAT_2_201(m,d) BOOST_PP_REPEAT_2_200(m, d) m(3, 200, d)
+#define BOOST_PP_REPEAT_2_202(m,d) BOOST_PP_REPEAT_2_201(m, d) m(3, 201, d)
+#define BOOST_PP_REPEAT_2_203(m,d) BOOST_PP_REPEAT_2_202(m, d) m(3, 202, d)
+#define BOOST_PP_REPEAT_2_204(m,d) BOOST_PP_REPEAT_2_203(m, d) m(3, 203, d)
+#define BOOST_PP_REPEAT_2_205(m,d) BOOST_PP_REPEAT_2_204(m, d) m(3, 204, d)
+#define BOOST_PP_REPEAT_2_206(m,d) BOOST_PP_REPEAT_2_205(m, d) m(3, 205, d)
+#define BOOST_PP_REPEAT_2_207(m,d) BOOST_PP_REPEAT_2_206(m, d) m(3, 206, d)
+#define BOOST_PP_REPEAT_2_208(m,d) BOOST_PP_REPEAT_2_207(m, d) m(3, 207, d)
+#define BOOST_PP_REPEAT_2_209(m,d) BOOST_PP_REPEAT_2_208(m, d) m(3, 208, d)
+#define BOOST_PP_REPEAT_2_210(m,d) BOOST_PP_REPEAT_2_209(m, d) m(3, 209, d)
+#define BOOST_PP_REPEAT_2_211(m,d) BOOST_PP_REPEAT_2_210(m, d) m(3, 210, d)
+#define BOOST_PP_REPEAT_2_212(m,d) BOOST_PP_REPEAT_2_211(m, d) m(3, 211, d)
+#define BOOST_PP_REPEAT_2_213(m,d) BOOST_PP_REPEAT_2_212(m, d) m(3, 212, d)
+#define BOOST_PP_REPEAT_2_214(m,d) BOOST_PP_REPEAT_2_213(m, d) m(3, 213, d)
+#define BOOST_PP_REPEAT_2_215(m,d) BOOST_PP_REPEAT_2_214(m, d) m(3, 214, d)
+#define BOOST_PP_REPEAT_2_216(m,d) BOOST_PP_REPEAT_2_215(m, d) m(3, 215, d)
+#define BOOST_PP_REPEAT_2_217(m,d) BOOST_PP_REPEAT_2_216(m, d) m(3, 216, d)
+#define BOOST_PP_REPEAT_2_218(m,d) BOOST_PP_REPEAT_2_217(m, d) m(3, 217, d)
+#define BOOST_PP_REPEAT_2_219(m,d) BOOST_PP_REPEAT_2_218(m, d) m(3, 218, d)
+#define BOOST_PP_REPEAT_2_220(m,d) BOOST_PP_REPEAT_2_219(m, d) m(3, 219, d)
+#define BOOST_PP_REPEAT_2_221(m,d) BOOST_PP_REPEAT_2_220(m, d) m(3, 220, d)
+#define BOOST_PP_REPEAT_2_222(m,d) BOOST_PP_REPEAT_2_221(m, d) m(3, 221, d)
+#define BOOST_PP_REPEAT_2_223(m,d) BOOST_PP_REPEAT_2_222(m, d) m(3, 222, d)
+#define BOOST_PP_REPEAT_2_224(m,d) BOOST_PP_REPEAT_2_223(m, d) m(3, 223, d)
+#define BOOST_PP_REPEAT_2_225(m,d) BOOST_PP_REPEAT_2_224(m, d) m(3, 224, d)
+#define BOOST_PP_REPEAT_2_226(m,d) BOOST_PP_REPEAT_2_225(m, d) m(3, 225, d)
+#define BOOST_PP_REPEAT_2_227(m,d) BOOST_PP_REPEAT_2_226(m, d) m(3, 226, d)
+#define BOOST_PP_REPEAT_2_228(m,d) BOOST_PP_REPEAT_2_227(m, d) m(3, 227, d)
+#define BOOST_PP_REPEAT_2_229(m,d) BOOST_PP_REPEAT_2_228(m, d) m(3, 228, d)
+#define BOOST_PP_REPEAT_2_230(m,d) BOOST_PP_REPEAT_2_229(m, d) m(3, 229, d)
+#define BOOST_PP_REPEAT_2_231(m,d) BOOST_PP_REPEAT_2_230(m, d) m(3, 230, d)
+#define BOOST_PP_REPEAT_2_232(m,d) BOOST_PP_REPEAT_2_231(m, d) m(3, 231, d)
+#define BOOST_PP_REPEAT_2_233(m,d) BOOST_PP_REPEAT_2_232(m, d) m(3, 232, d)
+#define BOOST_PP_REPEAT_2_234(m,d) BOOST_PP_REPEAT_2_233(m, d) m(3, 233, d)
+#define BOOST_PP_REPEAT_2_235(m,d) BOOST_PP_REPEAT_2_234(m, d) m(3, 234, d)
+#define BOOST_PP_REPEAT_2_236(m,d) BOOST_PP_REPEAT_2_235(m, d) m(3, 235, d)
+#define BOOST_PP_REPEAT_2_237(m,d) BOOST_PP_REPEAT_2_236(m, d) m(3, 236, d)
+#define BOOST_PP_REPEAT_2_238(m,d) BOOST_PP_REPEAT_2_237(m, d) m(3, 237, d)
+#define BOOST_PP_REPEAT_2_239(m,d) BOOST_PP_REPEAT_2_238(m, d) m(3, 238, d)
+#define BOOST_PP_REPEAT_2_240(m,d) BOOST_PP_REPEAT_2_239(m, d) m(3, 239, d)
+#define BOOST_PP_REPEAT_2_241(m,d) BOOST_PP_REPEAT_2_240(m, d) m(3, 240, d)
+#define BOOST_PP_REPEAT_2_242(m,d) BOOST_PP_REPEAT_2_241(m, d) m(3, 241, d)
+#define BOOST_PP_REPEAT_2_243(m,d) BOOST_PP_REPEAT_2_242(m, d) m(3, 242, d)
+#define BOOST_PP_REPEAT_2_244(m,d) BOOST_PP_REPEAT_2_243(m, d) m(3, 243, d)
+#define BOOST_PP_REPEAT_2_245(m,d) BOOST_PP_REPEAT_2_244(m, d) m(3, 244, d)
+#define BOOST_PP_REPEAT_2_246(m,d) BOOST_PP_REPEAT_2_245(m, d) m(3, 245, d)
+#define BOOST_PP_REPEAT_2_247(m,d) BOOST_PP_REPEAT_2_246(m, d) m(3, 246, d)
+#define BOOST_PP_REPEAT_2_248(m,d) BOOST_PP_REPEAT_2_247(m, d) m(3, 247, d)
+#define BOOST_PP_REPEAT_2_249(m,d) BOOST_PP_REPEAT_2_248(m, d) m(3, 248, d)
+#define BOOST_PP_REPEAT_2_250(m,d) BOOST_PP_REPEAT_2_249(m, d) m(3, 249, d)
+#define BOOST_PP_REPEAT_2_251(m,d) BOOST_PP_REPEAT_2_250(m, d) m(3, 250, d)
+#define BOOST_PP_REPEAT_2_252(m,d) BOOST_PP_REPEAT_2_251(m, d) m(3, 251, d)
+#define BOOST_PP_REPEAT_2_253(m,d) BOOST_PP_REPEAT_2_252(m, d) m(3, 252, d)
+#define BOOST_PP_REPEAT_2_254(m,d) BOOST_PP_REPEAT_2_253(m, d) m(3, 253, d)
+#define BOOST_PP_REPEAT_2_255(m,d) BOOST_PP_REPEAT_2_254(m, d) m(3, 254, d)
+#define BOOST_PP_REPEAT_2_256(m,d) BOOST_PP_REPEAT_2_255(m, d) m(3, 255, d)
+
+#define BOOST_PP_REPEAT_3_0(m,d) 
+#define BOOST_PP_REPEAT_3_1(m,d) m(4, 0, d)
+#define BOOST_PP_REPEAT_3_2(m,d) BOOST_PP_REPEAT_3_1(m, d) m(4, 1, d)
+#define BOOST_PP_REPEAT_3_3(m,d) BOOST_PP_REPEAT_3_2(m, d) m(4, 2, d)
+#define BOOST_PP_REPEAT_3_4(m,d) BOOST_PP_REPEAT_3_3(m, d) m(4, 3, d)
+#define BOOST_PP_REPEAT_3_5(m,d) BOOST_PP_REPEAT_3_4(m, d) m(4, 4, d)
+#define BOOST_PP_REPEAT_3_6(m,d) BOOST_PP_REPEAT_3_5(m, d) m(4, 5, d)
+#define BOOST_PP_REPEAT_3_7(m,d) BOOST_PP_REPEAT_3_6(m, d) m(4, 6, d)
+#define BOOST_PP_REPEAT_3_8(m,d) BOOST_PP_REPEAT_3_7(m, d) m(4, 7, d)
+#define BOOST_PP_REPEAT_3_9(m,d) BOOST_PP_REPEAT_3_8(m, d) m(4, 8, d)
+#define BOOST_PP_REPEAT_3_10(m,d) BOOST_PP_REPEAT_3_9(m, d) m(4, 9, d)
+#define BOOST_PP_REPEAT_3_11(m,d) BOOST_PP_REPEAT_3_10(m, d) m(4, 10, d)
+#define BOOST_PP_REPEAT_3_12(m,d) BOOST_PP_REPEAT_3_11(m, d) m(4, 11, d)
+#define BOOST_PP_REPEAT_3_13(m,d) BOOST_PP_REPEAT_3_12(m, d) m(4, 12, d)
+#define BOOST_PP_REPEAT_3_14(m,d) BOOST_PP_REPEAT_3_13(m, d) m(4, 13, d)
+#define BOOST_PP_REPEAT_3_15(m,d) BOOST_PP_REPEAT_3_14(m, d) m(4, 14, d)
+#define BOOST_PP_REPEAT_3_16(m,d) BOOST_PP_REPEAT_3_15(m, d) m(4, 15, d)
+#define BOOST_PP_REPEAT_3_17(m,d) BOOST_PP_REPEAT_3_16(m, d) m(4, 16, d)
+#define BOOST_PP_REPEAT_3_18(m,d) BOOST_PP_REPEAT_3_17(m, d) m(4, 17, d)
+#define BOOST_PP_REPEAT_3_19(m,d) BOOST_PP_REPEAT_3_18(m, d) m(4, 18, d)
+#define BOOST_PP_REPEAT_3_20(m,d) BOOST_PP_REPEAT_3_19(m, d) m(4, 19, d)
+#define BOOST_PP_REPEAT_3_21(m,d) BOOST_PP_REPEAT_3_20(m, d) m(4, 20, d)
+#define BOOST_PP_REPEAT_3_22(m,d) BOOST_PP_REPEAT_3_21(m, d) m(4, 21, d)
+#define BOOST_PP_REPEAT_3_23(m,d) BOOST_PP_REPEAT_3_22(m, d) m(4, 22, d)
+#define BOOST_PP_REPEAT_3_24(m,d) BOOST_PP_REPEAT_3_23(m, d) m(4, 23, d)
+#define BOOST_PP_REPEAT_3_25(m,d) BOOST_PP_REPEAT_3_24(m, d) m(4, 24, d)
+#define BOOST_PP_REPEAT_3_26(m,d) BOOST_PP_REPEAT_3_25(m, d) m(4, 25, d)
+#define BOOST_PP_REPEAT_3_27(m,d) BOOST_PP_REPEAT_3_26(m, d) m(4, 26, d)
+#define BOOST_PP_REPEAT_3_28(m,d) BOOST_PP_REPEAT_3_27(m, d) m(4, 27, d)
+#define BOOST_PP_REPEAT_3_29(m,d) BOOST_PP_REPEAT_3_28(m, d) m(4, 28, d)
+#define BOOST_PP_REPEAT_3_30(m,d) BOOST_PP_REPEAT_3_29(m, d) m(4, 29, d)
+#define BOOST_PP_REPEAT_3_31(m,d) BOOST_PP_REPEAT_3_30(m, d) m(4, 30, d)
+#define BOOST_PP_REPEAT_3_32(m,d) BOOST_PP_REPEAT_3_31(m, d) m(4, 31, d)
+#define BOOST_PP_REPEAT_3_33(m,d) BOOST_PP_REPEAT_3_32(m, d) m(4, 32, d)
+#define BOOST_PP_REPEAT_3_34(m,d) BOOST_PP_REPEAT_3_33(m, d) m(4, 33, d)
+#define BOOST_PP_REPEAT_3_35(m,d) BOOST_PP_REPEAT_3_34(m, d) m(4, 34, d)
+#define BOOST_PP_REPEAT_3_36(m,d) BOOST_PP_REPEAT_3_35(m, d) m(4, 35, d)
+#define BOOST_PP_REPEAT_3_37(m,d) BOOST_PP_REPEAT_3_36(m, d) m(4, 36, d)
+#define BOOST_PP_REPEAT_3_38(m,d) BOOST_PP_REPEAT_3_37(m, d) m(4, 37, d)
+#define BOOST_PP_REPEAT_3_39(m,d) BOOST_PP_REPEAT_3_38(m, d) m(4, 38, d)
+#define BOOST_PP_REPEAT_3_40(m,d) BOOST_PP_REPEAT_3_39(m, d) m(4, 39, d)
+#define BOOST_PP_REPEAT_3_41(m,d) BOOST_PP_REPEAT_3_40(m, d) m(4, 40, d)
+#define BOOST_PP_REPEAT_3_42(m,d) BOOST_PP_REPEAT_3_41(m, d) m(4, 41, d)
+#define BOOST_PP_REPEAT_3_43(m,d) BOOST_PP_REPEAT_3_42(m, d) m(4, 42, d)
+#define BOOST_PP_REPEAT_3_44(m,d) BOOST_PP_REPEAT_3_43(m, d) m(4, 43, d)
+#define BOOST_PP_REPEAT_3_45(m,d) BOOST_PP_REPEAT_3_44(m, d) m(4, 44, d)
+#define BOOST_PP_REPEAT_3_46(m,d) BOOST_PP_REPEAT_3_45(m, d) m(4, 45, d)
+#define BOOST_PP_REPEAT_3_47(m,d) BOOST_PP_REPEAT_3_46(m, d) m(4, 46, d)
+#define BOOST_PP_REPEAT_3_48(m,d) BOOST_PP_REPEAT_3_47(m, d) m(4, 47, d)
+#define BOOST_PP_REPEAT_3_49(m,d) BOOST_PP_REPEAT_3_48(m, d) m(4, 48, d)
+#define BOOST_PP_REPEAT_3_50(m,d) BOOST_PP_REPEAT_3_49(m, d) m(4, 49, d)
+#define BOOST_PP_REPEAT_3_51(m,d) BOOST_PP_REPEAT_3_50(m, d) m(4, 50, d)
+#define BOOST_PP_REPEAT_3_52(m,d) BOOST_PP_REPEAT_3_51(m, d) m(4, 51, d)
+#define BOOST_PP_REPEAT_3_53(m,d) BOOST_PP_REPEAT_3_52(m, d) m(4, 52, d)
+#define BOOST_PP_REPEAT_3_54(m,d) BOOST_PP_REPEAT_3_53(m, d) m(4, 53, d)
+#define BOOST_PP_REPEAT_3_55(m,d) BOOST_PP_REPEAT_3_54(m, d) m(4, 54, d)
+#define BOOST_PP_REPEAT_3_56(m,d) BOOST_PP_REPEAT_3_55(m, d) m(4, 55, d)
+#define BOOST_PP_REPEAT_3_57(m,d) BOOST_PP_REPEAT_3_56(m, d) m(4, 56, d)
+#define BOOST_PP_REPEAT_3_58(m,d) BOOST_PP_REPEAT_3_57(m, d) m(4, 57, d)
+#define BOOST_PP_REPEAT_3_59(m,d) BOOST_PP_REPEAT_3_58(m, d) m(4, 58, d)
+#define BOOST_PP_REPEAT_3_60(m,d) BOOST_PP_REPEAT_3_59(m, d) m(4, 59, d)
+#define BOOST_PP_REPEAT_3_61(m,d) BOOST_PP_REPEAT_3_60(m, d) m(4, 60, d)
+#define BOOST_PP_REPEAT_3_62(m,d) BOOST_PP_REPEAT_3_61(m, d) m(4, 61, d)
+#define BOOST_PP_REPEAT_3_63(m,d) BOOST_PP_REPEAT_3_62(m, d) m(4, 62, d)
+#define BOOST_PP_REPEAT_3_64(m,d) BOOST_PP_REPEAT_3_63(m, d) m(4, 63, d)
+#define BOOST_PP_REPEAT_3_65(m,d) BOOST_PP_REPEAT_3_64(m, d) m(4, 64, d)
+#define BOOST_PP_REPEAT_3_66(m,d) BOOST_PP_REPEAT_3_65(m, d) m(4, 65, d)
+#define BOOST_PP_REPEAT_3_67(m,d) BOOST_PP_REPEAT_3_66(m, d) m(4, 66, d)
+#define BOOST_PP_REPEAT_3_68(m,d) BOOST_PP_REPEAT_3_67(m, d) m(4, 67, d)
+#define BOOST_PP_REPEAT_3_69(m,d) BOOST_PP_REPEAT_3_68(m, d) m(4, 68, d)
+#define BOOST_PP_REPEAT_3_70(m,d) BOOST_PP_REPEAT_3_69(m, d) m(4, 69, d)
+#define BOOST_PP_REPEAT_3_71(m,d) BOOST_PP_REPEAT_3_70(m, d) m(4, 70, d)
+#define BOOST_PP_REPEAT_3_72(m,d) BOOST_PP_REPEAT_3_71(m, d) m(4, 71, d)
+#define BOOST_PP_REPEAT_3_73(m,d) BOOST_PP_REPEAT_3_72(m, d) m(4, 72, d)
+#define BOOST_PP_REPEAT_3_74(m,d) BOOST_PP_REPEAT_3_73(m, d) m(4, 73, d)
+#define BOOST_PP_REPEAT_3_75(m,d) BOOST_PP_REPEAT_3_74(m, d) m(4, 74, d)
+#define BOOST_PP_REPEAT_3_76(m,d) BOOST_PP_REPEAT_3_75(m, d) m(4, 75, d)
+#define BOOST_PP_REPEAT_3_77(m,d) BOOST_PP_REPEAT_3_76(m, d) m(4, 76, d)
+#define BOOST_PP_REPEAT_3_78(m,d) BOOST_PP_REPEAT_3_77(m, d) m(4, 77, d)
+#define BOOST_PP_REPEAT_3_79(m,d) BOOST_PP_REPEAT_3_78(m, d) m(4, 78, d)
+#define BOOST_PP_REPEAT_3_80(m,d) BOOST_PP_REPEAT_3_79(m, d) m(4, 79, d)
+#define BOOST_PP_REPEAT_3_81(m,d) BOOST_PP_REPEAT_3_80(m, d) m(4, 80, d)
+#define BOOST_PP_REPEAT_3_82(m,d) BOOST_PP_REPEAT_3_81(m, d) m(4, 81, d)
+#define BOOST_PP_REPEAT_3_83(m,d) BOOST_PP_REPEAT_3_82(m, d) m(4, 82, d)
+#define BOOST_PP_REPEAT_3_84(m,d) BOOST_PP_REPEAT_3_83(m, d) m(4, 83, d)
+#define BOOST_PP_REPEAT_3_85(m,d) BOOST_PP_REPEAT_3_84(m, d) m(4, 84, d)
+#define BOOST_PP_REPEAT_3_86(m,d) BOOST_PP_REPEAT_3_85(m, d) m(4, 85, d)
+#define BOOST_PP_REPEAT_3_87(m,d) BOOST_PP_REPEAT_3_86(m, d) m(4, 86, d)
+#define BOOST_PP_REPEAT_3_88(m,d) BOOST_PP_REPEAT_3_87(m, d) m(4, 87, d)
+#define BOOST_PP_REPEAT_3_89(m,d) BOOST_PP_REPEAT_3_88(m, d) m(4, 88, d)
+#define BOOST_PP_REPEAT_3_90(m,d) BOOST_PP_REPEAT_3_89(m, d) m(4, 89, d)
+#define BOOST_PP_REPEAT_3_91(m,d) BOOST_PP_REPEAT_3_90(m, d) m(4, 90, d)
+#define BOOST_PP_REPEAT_3_92(m,d) BOOST_PP_REPEAT_3_91(m, d) m(4, 91, d)
+#define BOOST_PP_REPEAT_3_93(m,d) BOOST_PP_REPEAT_3_92(m, d) m(4, 92, d)
+#define BOOST_PP_REPEAT_3_94(m,d) BOOST_PP_REPEAT_3_93(m, d) m(4, 93, d)
+#define BOOST_PP_REPEAT_3_95(m,d) BOOST_PP_REPEAT_3_94(m, d) m(4, 94, d)
+#define BOOST_PP_REPEAT_3_96(m,d) BOOST_PP_REPEAT_3_95(m, d) m(4, 95, d)
+#define BOOST_PP_REPEAT_3_97(m,d) BOOST_PP_REPEAT_3_96(m, d) m(4, 96, d)
+#define BOOST_PP_REPEAT_3_98(m,d) BOOST_PP_REPEAT_3_97(m, d) m(4, 97, d)
+#define BOOST_PP_REPEAT_3_99(m,d) BOOST_PP_REPEAT_3_98(m, d) m(4, 98, d)
+#define BOOST_PP_REPEAT_3_100(m,d) BOOST_PP_REPEAT_3_99(m, d) m(4, 99, d)
+#define BOOST_PP_REPEAT_3_101(m,d) BOOST_PP_REPEAT_3_100(m, d) m(4, 100, d)
+#define BOOST_PP_REPEAT_3_102(m,d) BOOST_PP_REPEAT_3_101(m, d) m(4, 101, d)
+#define BOOST_PP_REPEAT_3_103(m,d) BOOST_PP_REPEAT_3_102(m, d) m(4, 102, d)
+#define BOOST_PP_REPEAT_3_104(m,d) BOOST_PP_REPEAT_3_103(m, d) m(4, 103, d)
+#define BOOST_PP_REPEAT_3_105(m,d) BOOST_PP_REPEAT_3_104(m, d) m(4, 104, d)
+#define BOOST_PP_REPEAT_3_106(m,d) BOOST_PP_REPEAT_3_105(m, d) m(4, 105, d)
+#define BOOST_PP_REPEAT_3_107(m,d) BOOST_PP_REPEAT_3_106(m, d) m(4, 106, d)
+#define BOOST_PP_REPEAT_3_108(m,d) BOOST_PP_REPEAT_3_107(m, d) m(4, 107, d)
+#define BOOST_PP_REPEAT_3_109(m,d) BOOST_PP_REPEAT_3_108(m, d) m(4, 108, d)
+#define BOOST_PP_REPEAT_3_110(m,d) BOOST_PP_REPEAT_3_109(m, d) m(4, 109, d)
+#define BOOST_PP_REPEAT_3_111(m,d) BOOST_PP_REPEAT_3_110(m, d) m(4, 110, d)
+#define BOOST_PP_REPEAT_3_112(m,d) BOOST_PP_REPEAT_3_111(m, d) m(4, 111, d)
+#define BOOST_PP_REPEAT_3_113(m,d) BOOST_PP_REPEAT_3_112(m, d) m(4, 112, d)
+#define BOOST_PP_REPEAT_3_114(m,d) BOOST_PP_REPEAT_3_113(m, d) m(4, 113, d)
+#define BOOST_PP_REPEAT_3_115(m,d) BOOST_PP_REPEAT_3_114(m, d) m(4, 114, d)
+#define BOOST_PP_REPEAT_3_116(m,d) BOOST_PP_REPEAT_3_115(m, d) m(4, 115, d)
+#define BOOST_PP_REPEAT_3_117(m,d) BOOST_PP_REPEAT_3_116(m, d) m(4, 116, d)
+#define BOOST_PP_REPEAT_3_118(m,d) BOOST_PP_REPEAT_3_117(m, d) m(4, 117, d)
+#define BOOST_PP_REPEAT_3_119(m,d) BOOST_PP_REPEAT_3_118(m, d) m(4, 118, d)
+#define BOOST_PP_REPEAT_3_120(m,d) BOOST_PP_REPEAT_3_119(m, d) m(4, 119, d)
+#define BOOST_PP_REPEAT_3_121(m,d) BOOST_PP_REPEAT_3_120(m, d) m(4, 120, d)
+#define BOOST_PP_REPEAT_3_122(m,d) BOOST_PP_REPEAT_3_121(m, d) m(4, 121, d)
+#define BOOST_PP_REPEAT_3_123(m,d) BOOST_PP_REPEAT_3_122(m, d) m(4, 122, d)
+#define BOOST_PP_REPEAT_3_124(m,d) BOOST_PP_REPEAT_3_123(m, d) m(4, 123, d)
+#define BOOST_PP_REPEAT_3_125(m,d) BOOST_PP_REPEAT_3_124(m, d) m(4, 124, d)
+#define BOOST_PP_REPEAT_3_126(m,d) BOOST_PP_REPEAT_3_125(m, d) m(4, 125, d)
+#define BOOST_PP_REPEAT_3_127(m,d) BOOST_PP_REPEAT_3_126(m, d) m(4, 126, d)
+#define BOOST_PP_REPEAT_3_128(m,d) BOOST_PP_REPEAT_3_127(m, d) m(4, 127, d)
+#define BOOST_PP_REPEAT_3_129(m,d) BOOST_PP_REPEAT_3_128(m, d) m(4, 128, d)
+#define BOOST_PP_REPEAT_3_130(m,d) BOOST_PP_REPEAT_3_129(m, d) m(4, 129, d)
+#define BOOST_PP_REPEAT_3_131(m,d) BOOST_PP_REPEAT_3_130(m, d) m(4, 130, d)
+#define BOOST_PP_REPEAT_3_132(m,d) BOOST_PP_REPEAT_3_131(m, d) m(4, 131, d)
+#define BOOST_PP_REPEAT_3_133(m,d) BOOST_PP_REPEAT_3_132(m, d) m(4, 132, d)
+#define BOOST_PP_REPEAT_3_134(m,d) BOOST_PP_REPEAT_3_133(m, d) m(4, 133, d)
+#define BOOST_PP_REPEAT_3_135(m,d) BOOST_PP_REPEAT_3_134(m, d) m(4, 134, d)
+#define BOOST_PP_REPEAT_3_136(m,d) BOOST_PP_REPEAT_3_135(m, d) m(4, 135, d)
+#define BOOST_PP_REPEAT_3_137(m,d) BOOST_PP_REPEAT_3_136(m, d) m(4, 136, d)
+#define BOOST_PP_REPEAT_3_138(m,d) BOOST_PP_REPEAT_3_137(m, d) m(4, 137, d)
+#define BOOST_PP_REPEAT_3_139(m,d) BOOST_PP_REPEAT_3_138(m, d) m(4, 138, d)
+#define BOOST_PP_REPEAT_3_140(m,d) BOOST_PP_REPEAT_3_139(m, d) m(4, 139, d)
+#define BOOST_PP_REPEAT_3_141(m,d) BOOST_PP_REPEAT_3_140(m, d) m(4, 140, d)
+#define BOOST_PP_REPEAT_3_142(m,d) BOOST_PP_REPEAT_3_141(m, d) m(4, 141, d)
+#define BOOST_PP_REPEAT_3_143(m,d) BOOST_PP_REPEAT_3_142(m, d) m(4, 142, d)
+#define BOOST_PP_REPEAT_3_144(m,d) BOOST_PP_REPEAT_3_143(m, d) m(4, 143, d)
+#define BOOST_PP_REPEAT_3_145(m,d) BOOST_PP_REPEAT_3_144(m, d) m(4, 144, d)
+#define BOOST_PP_REPEAT_3_146(m,d) BOOST_PP_REPEAT_3_145(m, d) m(4, 145, d)
+#define BOOST_PP_REPEAT_3_147(m,d) BOOST_PP_REPEAT_3_146(m, d) m(4, 146, d)
+#define BOOST_PP_REPEAT_3_148(m,d) BOOST_PP_REPEAT_3_147(m, d) m(4, 147, d)
+#define BOOST_PP_REPEAT_3_149(m,d) BOOST_PP_REPEAT_3_148(m, d) m(4, 148, d)
+#define BOOST_PP_REPEAT_3_150(m,d) BOOST_PP_REPEAT_3_149(m, d) m(4, 149, d)
+#define BOOST_PP_REPEAT_3_151(m,d) BOOST_PP_REPEAT_3_150(m, d) m(4, 150, d)
+#define BOOST_PP_REPEAT_3_152(m,d) BOOST_PP_REPEAT_3_151(m, d) m(4, 151, d)
+#define BOOST_PP_REPEAT_3_153(m,d) BOOST_PP_REPEAT_3_152(m, d) m(4, 152, d)
+#define BOOST_PP_REPEAT_3_154(m,d) BOOST_PP_REPEAT_3_153(m, d) m(4, 153, d)
+#define BOOST_PP_REPEAT_3_155(m,d) BOOST_PP_REPEAT_3_154(m, d) m(4, 154, d)
+#define BOOST_PP_REPEAT_3_156(m,d) BOOST_PP_REPEAT_3_155(m, d) m(4, 155, d)
+#define BOOST_PP_REPEAT_3_157(m,d) BOOST_PP_REPEAT_3_156(m, d) m(4, 156, d)
+#define BOOST_PP_REPEAT_3_158(m,d) BOOST_PP_REPEAT_3_157(m, d) m(4, 157, d)
+#define BOOST_PP_REPEAT_3_159(m,d) BOOST_PP_REPEAT_3_158(m, d) m(4, 158, d)
+#define BOOST_PP_REPEAT_3_160(m,d) BOOST_PP_REPEAT_3_159(m, d) m(4, 159, d)
+#define BOOST_PP_REPEAT_3_161(m,d) BOOST_PP_REPEAT_3_160(m, d) m(4, 160, d)
+#define BOOST_PP_REPEAT_3_162(m,d) BOOST_PP_REPEAT_3_161(m, d) m(4, 161, d)
+#define BOOST_PP_REPEAT_3_163(m,d) BOOST_PP_REPEAT_3_162(m, d) m(4, 162, d)
+#define BOOST_PP_REPEAT_3_164(m,d) BOOST_PP_REPEAT_3_163(m, d) m(4, 163, d)
+#define BOOST_PP_REPEAT_3_165(m,d) BOOST_PP_REPEAT_3_164(m, d) m(4, 164, d)
+#define BOOST_PP_REPEAT_3_166(m,d) BOOST_PP_REPEAT_3_165(m, d) m(4, 165, d)
+#define BOOST_PP_REPEAT_3_167(m,d) BOOST_PP_REPEAT_3_166(m, d) m(4, 166, d)
+#define BOOST_PP_REPEAT_3_168(m,d) BOOST_PP_REPEAT_3_167(m, d) m(4, 167, d)
+#define BOOST_PP_REPEAT_3_169(m,d) BOOST_PP_REPEAT_3_168(m, d) m(4, 168, d)
+#define BOOST_PP_REPEAT_3_170(m,d) BOOST_PP_REPEAT_3_169(m, d) m(4, 169, d)
+#define BOOST_PP_REPEAT_3_171(m,d) BOOST_PP_REPEAT_3_170(m, d) m(4, 170, d)
+#define BOOST_PP_REPEAT_3_172(m,d) BOOST_PP_REPEAT_3_171(m, d) m(4, 171, d)
+#define BOOST_PP_REPEAT_3_173(m,d) BOOST_PP_REPEAT_3_172(m, d) m(4, 172, d)
+#define BOOST_PP_REPEAT_3_174(m,d) BOOST_PP_REPEAT_3_173(m, d) m(4, 173, d)
+#define BOOST_PP_REPEAT_3_175(m,d) BOOST_PP_REPEAT_3_174(m, d) m(4, 174, d)
+#define BOOST_PP_REPEAT_3_176(m,d) BOOST_PP_REPEAT_3_175(m, d) m(4, 175, d)
+#define BOOST_PP_REPEAT_3_177(m,d) BOOST_PP_REPEAT_3_176(m, d) m(4, 176, d)
+#define BOOST_PP_REPEAT_3_178(m,d) BOOST_PP_REPEAT_3_177(m, d) m(4, 177, d)
+#define BOOST_PP_REPEAT_3_179(m,d) BOOST_PP_REPEAT_3_178(m, d) m(4, 178, d)
+#define BOOST_PP_REPEAT_3_180(m,d) BOOST_PP_REPEAT_3_179(m, d) m(4, 179, d)
+#define BOOST_PP_REPEAT_3_181(m,d) BOOST_PP_REPEAT_3_180(m, d) m(4, 180, d)
+#define BOOST_PP_REPEAT_3_182(m,d) BOOST_PP_REPEAT_3_181(m, d) m(4, 181, d)
+#define BOOST_PP_REPEAT_3_183(m,d) BOOST_PP_REPEAT_3_182(m, d) m(4, 182, d)
+#define BOOST_PP_REPEAT_3_184(m,d) BOOST_PP_REPEAT_3_183(m, d) m(4, 183, d)
+#define BOOST_PP_REPEAT_3_185(m,d) BOOST_PP_REPEAT_3_184(m, d) m(4, 184, d)
+#define BOOST_PP_REPEAT_3_186(m,d) BOOST_PP_REPEAT_3_185(m, d) m(4, 185, d)
+#define BOOST_PP_REPEAT_3_187(m,d) BOOST_PP_REPEAT_3_186(m, d) m(4, 186, d)
+#define BOOST_PP_REPEAT_3_188(m,d) BOOST_PP_REPEAT_3_187(m, d) m(4, 187, d)
+#define BOOST_PP_REPEAT_3_189(m,d) BOOST_PP_REPEAT_3_188(m, d) m(4, 188, d)
+#define BOOST_PP_REPEAT_3_190(m,d) BOOST_PP_REPEAT_3_189(m, d) m(4, 189, d)
+#define BOOST_PP_REPEAT_3_191(m,d) BOOST_PP_REPEAT_3_190(m, d) m(4, 190, d)
+#define BOOST_PP_REPEAT_3_192(m,d) BOOST_PP_REPEAT_3_191(m, d) m(4, 191, d)
+#define BOOST_PP_REPEAT_3_193(m,d) BOOST_PP_REPEAT_3_192(m, d) m(4, 192, d)
+#define BOOST_PP_REPEAT_3_194(m,d) BOOST_PP_REPEAT_3_193(m, d) m(4, 193, d)
+#define BOOST_PP_REPEAT_3_195(m,d) BOOST_PP_REPEAT_3_194(m, d) m(4, 194, d)
+#define BOOST_PP_REPEAT_3_196(m,d) BOOST_PP_REPEAT_3_195(m, d) m(4, 195, d)
+#define BOOST_PP_REPEAT_3_197(m,d) BOOST_PP_REPEAT_3_196(m, d) m(4, 196, d)
+#define BOOST_PP_REPEAT_3_198(m,d) BOOST_PP_REPEAT_3_197(m, d) m(4, 197, d)
+#define BOOST_PP_REPEAT_3_199(m,d) BOOST_PP_REPEAT_3_198(m, d) m(4, 198, d)
+#define BOOST_PP_REPEAT_3_200(m,d) BOOST_PP_REPEAT_3_199(m, d) m(4, 199, d)
+#define BOOST_PP_REPEAT_3_201(m,d) BOOST_PP_REPEAT_3_200(m, d) m(4, 200, d)
+#define BOOST_PP_REPEAT_3_202(m,d) BOOST_PP_REPEAT_3_201(m, d) m(4, 201, d)
+#define BOOST_PP_REPEAT_3_203(m,d) BOOST_PP_REPEAT_3_202(m, d) m(4, 202, d)
+#define BOOST_PP_REPEAT_3_204(m,d) BOOST_PP_REPEAT_3_203(m, d) m(4, 203, d)
+#define BOOST_PP_REPEAT_3_205(m,d) BOOST_PP_REPEAT_3_204(m, d) m(4, 204, d)
+#define BOOST_PP_REPEAT_3_206(m,d) BOOST_PP_REPEAT_3_205(m, d) m(4, 205, d)
+#define BOOST_PP_REPEAT_3_207(m,d) BOOST_PP_REPEAT_3_206(m, d) m(4, 206, d)
+#define BOOST_PP_REPEAT_3_208(m,d) BOOST_PP_REPEAT_3_207(m, d) m(4, 207, d)
+#define BOOST_PP_REPEAT_3_209(m,d) BOOST_PP_REPEAT_3_208(m, d) m(4, 208, d)
+#define BOOST_PP_REPEAT_3_210(m,d) BOOST_PP_REPEAT_3_209(m, d) m(4, 209, d)
+#define BOOST_PP_REPEAT_3_211(m,d) BOOST_PP_REPEAT_3_210(m, d) m(4, 210, d)
+#define BOOST_PP_REPEAT_3_212(m,d) BOOST_PP_REPEAT_3_211(m, d) m(4, 211, d)
+#define BOOST_PP_REPEAT_3_213(m,d) BOOST_PP_REPEAT_3_212(m, d) m(4, 212, d)
+#define BOOST_PP_REPEAT_3_214(m,d) BOOST_PP_REPEAT_3_213(m, d) m(4, 213, d)
+#define BOOST_PP_REPEAT_3_215(m,d) BOOST_PP_REPEAT_3_214(m, d) m(4, 214, d)
+#define BOOST_PP_REPEAT_3_216(m,d) BOOST_PP_REPEAT_3_215(m, d) m(4, 215, d)
+#define BOOST_PP_REPEAT_3_217(m,d) BOOST_PP_REPEAT_3_216(m, d) m(4, 216, d)
+#define BOOST_PP_REPEAT_3_218(m,d) BOOST_PP_REPEAT_3_217(m, d) m(4, 217, d)
+#define BOOST_PP_REPEAT_3_219(m,d) BOOST_PP_REPEAT_3_218(m, d) m(4, 218, d)
+#define BOOST_PP_REPEAT_3_220(m,d) BOOST_PP_REPEAT_3_219(m, d) m(4, 219, d)
+#define BOOST_PP_REPEAT_3_221(m,d) BOOST_PP_REPEAT_3_220(m, d) m(4, 220, d)
+#define BOOST_PP_REPEAT_3_222(m,d) BOOST_PP_REPEAT_3_221(m, d) m(4, 221, d)
+#define BOOST_PP_REPEAT_3_223(m,d) BOOST_PP_REPEAT_3_222(m, d) m(4, 222, d)
+#define BOOST_PP_REPEAT_3_224(m,d) BOOST_PP_REPEAT_3_223(m, d) m(4, 223, d)
+#define BOOST_PP_REPEAT_3_225(m,d) BOOST_PP_REPEAT_3_224(m, d) m(4, 224, d)
+#define BOOST_PP_REPEAT_3_226(m,d) BOOST_PP_REPEAT_3_225(m, d) m(4, 225, d)
+#define BOOST_PP_REPEAT_3_227(m,d) BOOST_PP_REPEAT_3_226(m, d) m(4, 226, d)
+#define BOOST_PP_REPEAT_3_228(m,d) BOOST_PP_REPEAT_3_227(m, d) m(4, 227, d)
+#define BOOST_PP_REPEAT_3_229(m,d) BOOST_PP_REPEAT_3_228(m, d) m(4, 228, d)
+#define BOOST_PP_REPEAT_3_230(m,d) BOOST_PP_REPEAT_3_229(m, d) m(4, 229, d)
+#define BOOST_PP_REPEAT_3_231(m,d) BOOST_PP_REPEAT_3_230(m, d) m(4, 230, d)
+#define BOOST_PP_REPEAT_3_232(m,d) BOOST_PP_REPEAT_3_231(m, d) m(4, 231, d)
+#define BOOST_PP_REPEAT_3_233(m,d) BOOST_PP_REPEAT_3_232(m, d) m(4, 232, d)
+#define BOOST_PP_REPEAT_3_234(m,d) BOOST_PP_REPEAT_3_233(m, d) m(4, 233, d)
+#define BOOST_PP_REPEAT_3_235(m,d) BOOST_PP_REPEAT_3_234(m, d) m(4, 234, d)
+#define BOOST_PP_REPEAT_3_236(m,d) BOOST_PP_REPEAT_3_235(m, d) m(4, 235, d)
+#define BOOST_PP_REPEAT_3_237(m,d) BOOST_PP_REPEAT_3_236(m, d) m(4, 236, d)
+#define BOOST_PP_REPEAT_3_238(m,d) BOOST_PP_REPEAT_3_237(m, d) m(4, 237, d)
+#define BOOST_PP_REPEAT_3_239(m,d) BOOST_PP_REPEAT_3_238(m, d) m(4, 238, d)
+#define BOOST_PP_REPEAT_3_240(m,d) BOOST_PP_REPEAT_3_239(m, d) m(4, 239, d)
+#define BOOST_PP_REPEAT_3_241(m,d) BOOST_PP_REPEAT_3_240(m, d) m(4, 240, d)
+#define BOOST_PP_REPEAT_3_242(m,d) BOOST_PP_REPEAT_3_241(m, d) m(4, 241, d)
+#define BOOST_PP_REPEAT_3_243(m,d) BOOST_PP_REPEAT_3_242(m, d) m(4, 242, d)
+#define BOOST_PP_REPEAT_3_244(m,d) BOOST_PP_REPEAT_3_243(m, d) m(4, 243, d)
+#define BOOST_PP_REPEAT_3_245(m,d) BOOST_PP_REPEAT_3_244(m, d) m(4, 244, d)
+#define BOOST_PP_REPEAT_3_246(m,d) BOOST_PP_REPEAT_3_245(m, d) m(4, 245, d)
+#define BOOST_PP_REPEAT_3_247(m,d) BOOST_PP_REPEAT_3_246(m, d) m(4, 246, d)
+#define BOOST_PP_REPEAT_3_248(m,d) BOOST_PP_REPEAT_3_247(m, d) m(4, 247, d)
+#define BOOST_PP_REPEAT_3_249(m,d) BOOST_PP_REPEAT_3_248(m, d) m(4, 248, d)
+#define BOOST_PP_REPEAT_3_250(m,d) BOOST_PP_REPEAT_3_249(m, d) m(4, 249, d)
+#define BOOST_PP_REPEAT_3_251(m,d) BOOST_PP_REPEAT_3_250(m, d) m(4, 250, d)
+#define BOOST_PP_REPEAT_3_252(m,d) BOOST_PP_REPEAT_3_251(m, d) m(4, 251, d)
+#define BOOST_PP_REPEAT_3_253(m,d) BOOST_PP_REPEAT_3_252(m, d) m(4, 252, d)
+#define BOOST_PP_REPEAT_3_254(m,d) BOOST_PP_REPEAT_3_253(m, d) m(4, 253, d)
+#define BOOST_PP_REPEAT_3_255(m,d) BOOST_PP_REPEAT_3_254(m, d) m(4, 254, d)
+#define BOOST_PP_REPEAT_3_256(m,d) BOOST_PP_REPEAT_3_255(m, d) m(4, 255, d)
+# 23 "/usr/include/boost/preprocessor/repetition/enum.hpp" 2 3 4
+# 32 "/usr/include/boost/preprocessor/repetition/enum.hpp" 3 4
+#define BOOST_PP_ENUM BOOST_PP_CAT(BOOST_PP_ENUM_, BOOST_PP_AUTO_REC(BOOST_PP_REPEAT_P, 4))
+
+
+#define BOOST_PP_ENUM_1(c,m,d) BOOST_PP_REPEAT_1(c, BOOST_PP_ENUM_M_1, (m, d))
+#define BOOST_PP_ENUM_2(c,m,d) BOOST_PP_REPEAT_2(c, BOOST_PP_ENUM_M_2, (m, d))
+#define BOOST_PP_ENUM_3(c,m,d) BOOST_PP_REPEAT_3(c, BOOST_PP_ENUM_M_3, (m, d))
+# 47 "/usr/include/boost/preprocessor/repetition/enum.hpp" 3 4
+#define BOOST_PP_ENUM_4(c,m,d) BOOST_PP_ERROR(0x0003)
+
+
+#define BOOST_PP_ENUM_M_1(z,n,md) BOOST_PP_ENUM_M_1_IM(z, n, BOOST_PP_TUPLE_REM_2 md)
+#define BOOST_PP_ENUM_M_2(z,n,md) BOOST_PP_ENUM_M_2_IM(z, n, BOOST_PP_TUPLE_REM_2 md)
+#define BOOST_PP_ENUM_M_3(z,n,md) BOOST_PP_ENUM_M_3_IM(z, n, BOOST_PP_TUPLE_REM_2 md)
+#define BOOST_PP_ENUM_M_1_IM(z,n,im) BOOST_PP_ENUM_M_1_I(z, n, im)
+#define BOOST_PP_ENUM_M_2_IM(z,n,im) BOOST_PP_ENUM_M_2_I(z, n, im)
+#define BOOST_PP_ENUM_M_3_IM(z,n,im) BOOST_PP_ENUM_M_3_I(z, n, im)
+
+
+
+
+
+
+#define BOOST_PP_ENUM_M_1_I(z,n,m,d) BOOST_PP_COMMA_IF(n) m(z, n, d)
+#define BOOST_PP_ENUM_M_2_I(z,n,m,d) BOOST_PP_COMMA_IF(n) m(z, n, d)
+#define BOOST_PP_ENUM_M_3_I(z,n,m,d) BOOST_PP_COMMA_IF(n) m(z, n, d)
+# 16 "/usr/include/boost/preprocessor/enum.hpp" 2 3 4
+# 21 "/usr/include/boost/function/detail/prologue.hpp" 2 3 4
+# 1 "/usr/include/boost/preprocessor/enum_params.hpp" 1 3 4
+# 13 "/usr/include/boost/preprocessor/enum_params.hpp" 3 4
+#define BOOST_PREPROCESSOR_ENUM_PARAMS_HPP 
+
+# 1 "/usr/include/boost/preprocessor/repetition/enum_params.hpp" 1 3 4
+# 15 "/usr/include/boost/preprocessor/repetition/enum_params.hpp" 3 4
+#define BOOST_PREPROCESSOR_REPETITION_ENUM_PARAMS_HPP 
+# 24 "/usr/include/boost/preprocessor/repetition/enum_params.hpp" 3 4
+#define BOOST_PP_ENUM_PARAMS(count,param) BOOST_PP_REPEAT(count, BOOST_PP_ENUM_PARAMS_M, param)
+
+
+
+
+
+#define BOOST_PP_ENUM_PARAMS_M(z,n,param) BOOST_PP_COMMA_IF(n) param ## n
+
+
+
+
+#define BOOST_PP_ENUM_PARAMS_Z(z,count,param) BOOST_PP_REPEAT_ ## z(count, BOOST_PP_ENUM_PARAMS_M, param)
+# 16 "/usr/include/boost/preprocessor/enum_params.hpp" 2 3 4
+# 22 "/usr/include/boost/function/detail/prologue.hpp" 2 3 4
+
+# 1 "/usr/include/boost/preprocessor/repeat.hpp" 1 3 4
+# 13 "/usr/include/boost/preprocessor/repeat.hpp" 3 4
+#define BOOST_PREPROCESSOR_REPEAT_HPP 
+# 24 "/usr/include/boost/function/detail/prologue.hpp" 2 3 4
+# 1 "/usr/include/boost/preprocessor/inc.hpp" 1 3 4
+# 13 "/usr/include/boost/preprocessor/inc.hpp" 3 4
+#define BOOST_PREPROCESSOR_INC_HPP 
+
+# 1 "/usr/include/boost/preprocessor/arithmetic/inc.hpp" 1 3 4
+# 15 "/usr/include/boost/preprocessor/arithmetic/inc.hpp" 3 4
+#define BOOST_PREPROCESSOR_ARITHMETIC_INC_HPP 
+
+
+
+
+
+
+#define BOOST_PP_INC(x) BOOST_PP_INC_I(x)
+
+
+
+
+
+#define BOOST_PP_INC_I(x) BOOST_PP_INC_ ## x
+
+#define BOOST_PP_INC_0 1
+#define BOOST_PP_INC_1 2
+#define BOOST_PP_INC_2 3
+#define BOOST_PP_INC_3 4
+#define BOOST_PP_INC_4 5
+#define BOOST_PP_INC_5 6
+#define BOOST_PP_INC_6 7
+#define BOOST_PP_INC_7 8
+#define BOOST_PP_INC_8 9
+#define BOOST_PP_INC_9 10
+#define BOOST_PP_INC_10 11
+#define BOOST_PP_INC_11 12
+#define BOOST_PP_INC_12 13
+#define BOOST_PP_INC_13 14
+#define BOOST_PP_INC_14 15
+#define BOOST_PP_INC_15 16
+#define BOOST_PP_INC_16 17
+#define BOOST_PP_INC_17 18
+#define BOOST_PP_INC_18 19
+#define BOOST_PP_INC_19 20
+#define BOOST_PP_INC_20 21
+#define BOOST_PP_INC_21 22
+#define BOOST_PP_INC_22 23
+#define BOOST_PP_INC_23 24
+#define BOOST_PP_INC_24 25
+#define BOOST_PP_INC_25 26
+#define BOOST_PP_INC_26 27
+#define BOOST_PP_INC_27 28
+#define BOOST_PP_INC_28 29
+#define BOOST_PP_INC_29 30
+#define BOOST_PP_INC_30 31
+#define BOOST_PP_INC_31 32
+#define BOOST_PP_INC_32 33
+#define BOOST_PP_INC_33 34
+#define BOOST_PP_INC_34 35
+#define BOOST_PP_INC_35 36
+#define BOOST_PP_INC_36 37
+#define BOOST_PP_INC_37 38
+#define BOOST_PP_INC_38 39
+#define BOOST_PP_INC_39 40
+#define BOOST_PP_INC_40 41
+#define BOOST_PP_INC_41 42
+#define BOOST_PP_INC_42 43
+#define BOOST_PP_INC_43 44
+#define BOOST_PP_INC_44 45
+#define BOOST_PP_INC_45 46
+#define BOOST_PP_INC_46 47
+#define BOOST_PP_INC_47 48
+#define BOOST_PP_INC_48 49
+#define BOOST_PP_INC_49 50
+#define BOOST_PP_INC_50 51
+#define BOOST_PP_INC_51 52
+#define BOOST_PP_INC_52 53
+#define BOOST_PP_INC_53 54
+#define BOOST_PP_INC_54 55
+#define BOOST_PP_INC_55 56
+#define BOOST_PP_INC_56 57
+#define BOOST_PP_INC_57 58
+#define BOOST_PP_INC_58 59
+#define BOOST_PP_INC_59 60
+#define BOOST_PP_INC_60 61
+#define BOOST_PP_INC_61 62
+#define BOOST_PP_INC_62 63
+#define BOOST_PP_INC_63 64
+#define BOOST_PP_INC_64 65
+#define BOOST_PP_INC_65 66
+#define BOOST_PP_INC_66 67
+#define BOOST_PP_INC_67 68
+#define BOOST_PP_INC_68 69
+#define BOOST_PP_INC_69 70
+#define BOOST_PP_INC_70 71
+#define BOOST_PP_INC_71 72
+#define BOOST_PP_INC_72 73
+#define BOOST_PP_INC_73 74
+#define BOOST_PP_INC_74 75
+#define BOOST_PP_INC_75 76
+#define BOOST_PP_INC_76 77
+#define BOOST_PP_INC_77 78
+#define BOOST_PP_INC_78 79
+#define BOOST_PP_INC_79 80
+#define BOOST_PP_INC_80 81
+#define BOOST_PP_INC_81 82
+#define BOOST_PP_INC_82 83
+#define BOOST_PP_INC_83 84
+#define BOOST_PP_INC_84 85
+#define BOOST_PP_INC_85 86
+#define BOOST_PP_INC_86 87
+#define BOOST_PP_INC_87 88
+#define BOOST_PP_INC_88 89
+#define BOOST_PP_INC_89 90
+#define BOOST_PP_INC_90 91
+#define BOOST_PP_INC_91 92
+#define BOOST_PP_INC_92 93
+#define BOOST_PP_INC_93 94
+#define BOOST_PP_INC_94 95
+#define BOOST_PP_INC_95 96
+#define BOOST_PP_INC_96 97
+#define BOOST_PP_INC_97 98
+#define BOOST_PP_INC_98 99
+#define BOOST_PP_INC_99 100
+#define BOOST_PP_INC_100 101
+#define BOOST_PP_INC_101 102
+#define BOOST_PP_INC_102 103
+#define BOOST_PP_INC_103 104
+#define BOOST_PP_INC_104 105
+#define BOOST_PP_INC_105 106
+#define BOOST_PP_INC_106 107
+#define BOOST_PP_INC_107 108
+#define BOOST_PP_INC_108 109
+#define BOOST_PP_INC_109 110
+#define BOOST_PP_INC_110 111
+#define BOOST_PP_INC_111 112
+#define BOOST_PP_INC_112 113
+#define BOOST_PP_INC_113 114
+#define BOOST_PP_INC_114 115
+#define BOOST_PP_INC_115 116
+#define BOOST_PP_INC_116 117
+#define BOOST_PP_INC_117 118
+#define BOOST_PP_INC_118 119
+#define BOOST_PP_INC_119 120
+#define BOOST_PP_INC_120 121
+#define BOOST_PP_INC_121 122
+#define BOOST_PP_INC_122 123
+#define BOOST_PP_INC_123 124
+#define BOOST_PP_INC_124 125
+#define BOOST_PP_INC_125 126
+#define BOOST_PP_INC_126 127
+#define BOOST_PP_INC_127 128
+#define BOOST_PP_INC_128 129
+#define BOOST_PP_INC_129 130
+#define BOOST_PP_INC_130 131
+#define BOOST_PP_INC_131 132
+#define BOOST_PP_INC_132 133
+#define BOOST_PP_INC_133 134
+#define BOOST_PP_INC_134 135
+#define BOOST_PP_INC_135 136
+#define BOOST_PP_INC_136 137
+#define BOOST_PP_INC_137 138
+#define BOOST_PP_INC_138 139
+#define BOOST_PP_INC_139 140
+#define BOOST_PP_INC_140 141
+#define BOOST_PP_INC_141 142
+#define BOOST_PP_INC_142 143
+#define BOOST_PP_INC_143 144
+#define BOOST_PP_INC_144 145
+#define BOOST_PP_INC_145 146
+#define BOOST_PP_INC_146 147
+#define BOOST_PP_INC_147 148
+#define BOOST_PP_INC_148 149
+#define BOOST_PP_INC_149 150
+#define BOOST_PP_INC_150 151
+#define BOOST_PP_INC_151 152
+#define BOOST_PP_INC_152 153
+#define BOOST_PP_INC_153 154
+#define BOOST_PP_INC_154 155
+#define BOOST_PP_INC_155 156
+#define BOOST_PP_INC_156 157
+#define BOOST_PP_INC_157 158
+#define BOOST_PP_INC_158 159
+#define BOOST_PP_INC_159 160
+#define BOOST_PP_INC_160 161
+#define BOOST_PP_INC_161 162
+#define BOOST_PP_INC_162 163
+#define BOOST_PP_INC_163 164
+#define BOOST_PP_INC_164 165
+#define BOOST_PP_INC_165 166
+#define BOOST_PP_INC_166 167
+#define BOOST_PP_INC_167 168
+#define BOOST_PP_INC_168 169
+#define BOOST_PP_INC_169 170
+#define BOOST_PP_INC_170 171
+#define BOOST_PP_INC_171 172
+#define BOOST_PP_INC_172 173
+#define BOOST_PP_INC_173 174
+#define BOOST_PP_INC_174 175
+#define BOOST_PP_INC_175 176
+#define BOOST_PP_INC_176 177
+#define BOOST_PP_INC_177 178
+#define BOOST_PP_INC_178 179
+#define BOOST_PP_INC_179 180
+#define BOOST_PP_INC_180 181
+#define BOOST_PP_INC_181 182
+#define BOOST_PP_INC_182 183
+#define BOOST_PP_INC_183 184
+#define BOOST_PP_INC_184 185
+#define BOOST_PP_INC_185 186
+#define BOOST_PP_INC_186 187
+#define BOOST_PP_INC_187 188
+#define BOOST_PP_INC_188 189
+#define BOOST_PP_INC_189 190
+#define BOOST_PP_INC_190 191
+#define BOOST_PP_INC_191 192
+#define BOOST_PP_INC_192 193
+#define BOOST_PP_INC_193 194
+#define BOOST_PP_INC_194 195
+#define BOOST_PP_INC_195 196
+#define BOOST_PP_INC_196 197
+#define BOOST_PP_INC_197 198
+#define BOOST_PP_INC_198 199
+#define BOOST_PP_INC_199 200
+#define BOOST_PP_INC_200 201
+#define BOOST_PP_INC_201 202
+#define BOOST_PP_INC_202 203
+#define BOOST_PP_INC_203 204
+#define BOOST_PP_INC_204 205
+#define BOOST_PP_INC_205 206
+#define BOOST_PP_INC_206 207
+#define BOOST_PP_INC_207 208
+#define BOOST_PP_INC_208 209
+#define BOOST_PP_INC_209 210
+#define BOOST_PP_INC_210 211
+#define BOOST_PP_INC_211 212
+#define BOOST_PP_INC_212 213
+#define BOOST_PP_INC_213 214
+#define BOOST_PP_INC_214 215
+#define BOOST_PP_INC_215 216
+#define BOOST_PP_INC_216 217
+#define BOOST_PP_INC_217 218
+#define BOOST_PP_INC_218 219
+#define BOOST_PP_INC_219 220
+#define BOOST_PP_INC_220 221
+#define BOOST_PP_INC_221 222
+#define BOOST_PP_INC_222 223
+#define BOOST_PP_INC_223 224
+#define BOOST_PP_INC_224 225
+#define BOOST_PP_INC_225 226
+#define BOOST_PP_INC_226 227
+#define BOOST_PP_INC_227 228
+#define BOOST_PP_INC_228 229
+#define BOOST_PP_INC_229 230
+#define BOOST_PP_INC_230 231
+#define BOOST_PP_INC_231 232
+#define BOOST_PP_INC_232 233
+#define BOOST_PP_INC_233 234
+#define BOOST_PP_INC_234 235
+#define BOOST_PP_INC_235 236
+#define BOOST_PP_INC_236 237
+#define BOOST_PP_INC_237 238
+#define BOOST_PP_INC_238 239
+#define BOOST_PP_INC_239 240
+#define BOOST_PP_INC_240 241
+#define BOOST_PP_INC_241 242
+#define BOOST_PP_INC_242 243
+#define BOOST_PP_INC_243 244
+#define BOOST_PP_INC_244 245
+#define BOOST_PP_INC_245 246
+#define BOOST_PP_INC_246 247
+#define BOOST_PP_INC_247 248
+#define BOOST_PP_INC_248 249
+#define BOOST_PP_INC_249 250
+#define BOOST_PP_INC_250 251
+#define BOOST_PP_INC_251 252
+#define BOOST_PP_INC_252 253
+#define BOOST_PP_INC_253 254
+#define BOOST_PP_INC_254 255
+#define BOOST_PP_INC_255 256
+#define BOOST_PP_INC_256 256
+# 16 "/usr/include/boost/preprocessor/inc.hpp" 2 3 4
+# 25 "/usr/include/boost/function/detail/prologue.hpp" 2 3 4
+# 14 "/usr/include/boost/function/function_template.hpp" 2 3 4
+# 1 "/usr/include/boost/core/no_exceptions_support.hpp" 1 3 4
+
+#define BOOST_CORE_NO_EXCEPTIONS_SUPPORT_HPP 
+# 27 "/usr/include/boost/core/no_exceptions_support.hpp" 3 4
+#define BOOST_TRY { try
+#define BOOST_CATCH(x) catch(x)
+#define BOOST_RETHROW throw;
+#define BOOST_CATCH_END }
+# 15 "/usr/include/boost/function/function_template.hpp" 2 3 4
+
+
+
+
+
+
+#define BOOST_FUNCTION_TEMPLATE_PARMS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, typename T)
+
+#define BOOST_FUNCTION_TEMPLATE_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, T)
+
+#define BOOST_FUNCTION_PARM(J,I,D) BOOST_PP_CAT(T,I) BOOST_PP_CAT(a,I)
+
+#define BOOST_FUNCTION_PARMS BOOST_PP_ENUM(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_PARM,BOOST_PP_EMPTY)
+
+
+
+
+#define BOOST_FUNCTION_ARG(J,I,D) static_cast<BOOST_PP_CAT(T,I)&&>(BOOST_PP_CAT(a,I))
+#define BOOST_FUNCTION_ARGS BOOST_PP_ENUM(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_ARG,BOOST_PP_EMPTY)
+
+
+#define BOOST_FUNCTION_ARG_TYPE(J,I,D) typedef BOOST_PP_CAT(T,I) BOOST_PP_CAT(BOOST_PP_CAT(arg, BOOST_PP_INC(I)),_type);
+
+
+#define BOOST_FUNCTION_ARG_TYPES BOOST_PP_REPEAT(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_ARG_TYPE,BOOST_PP_EMPTY)
+
+
+
+#define BOOST_FUNCTION_COMMA 
+
+
+
+
+
+#define BOOST_FUNCTION_FUNCTION BOOST_JOIN(function,BOOST_FUNCTION_NUM_ARGS)
+#define BOOST_FUNCTION_FUNCTION_INVOKER BOOST_JOIN(function_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_VOID_FUNCTION_INVOKER BOOST_JOIN(void_function_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_FUNCTION_OBJ_INVOKER BOOST_JOIN(function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER BOOST_JOIN(void_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_FUNCTION_REF_INVOKER BOOST_JOIN(function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER BOOST_JOIN(void_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_MEMBER_INVOKER BOOST_JOIN(function_mem_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_VOID_MEMBER_INVOKER BOOST_JOIN(function_void_mem_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_GET_FUNCTION_INVOKER BOOST_JOIN(get_function_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER BOOST_JOIN(get_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER BOOST_JOIN(get_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_GET_MEMBER_INVOKER BOOST_JOIN(get_member_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_GET_INVOKER BOOST_JOIN(get_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_VTABLE BOOST_JOIN(basic_vtable,BOOST_FUNCTION_NUM_ARGS)
+
+
+#define BOOST_FUNCTION_VOID_RETURN_TYPE void
+#define BOOST_FUNCTION_RETURN(X) X
+
+
+
+
+
+namespace boost {
+  namespace detail {
+    namespace function {
+      template<
+        typename FunctionPtr,
+        typename R
+       
+        >
+      struct function_invoker0
+      {
+        static R invoke(function_buffer& function_ptr
+                        )
+        {
+          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.members.func_ptr);
+          return f();
+        }
+      };
+
+      template<
+        typename FunctionPtr,
+        typename R
+       
+        >
+      struct void_function_invoker0
+      {
+        static void
+        invoke(function_buffer& function_ptr
+               )
+
+        {
+          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.members.func_ptr);
+          f();
+        }
+      };
+
+      template<
+        typename FunctionObj,
+        typename R
+       
+      >
+      struct function_obj_invoker0
+      {
+        static R invoke(function_buffer& function_obj_ptr
+                        )
+
+        {
+          FunctionObj* f;
+          if (function_allows_small_object_optimization<FunctionObj>::value)
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.data);
+          else
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
+          return (*f)();
+        }
+      };
+
+      template<
+        typename FunctionObj,
+        typename R
+       
+      >
+      struct void_function_obj_invoker0
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr
+               )
+
+        {
+          FunctionObj* f;
+          if (function_allows_small_object_optimization<FunctionObj>::value)
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.data);
+          else
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
+          (*f)();
+        }
+      };
+
+      template<
+        typename FunctionObj,
+        typename R
+       
+      >
+      struct function_ref_invoker0
+      {
+        static R invoke(function_buffer& function_obj_ptr
+                        )
+
+        {
+          FunctionObj* f =
+            reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
+          return (*f)();
+        }
+      };
+
+      template<
+        typename FunctionObj,
+        typename R
+       
+      >
+      struct void_function_ref_invoker0
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr
+               )
+
+        {
+          FunctionObj* f =
+            reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
+          (*f)();
+        }
+      };
+# 235 "/usr/include/boost/function/function_template.hpp" 3 4
+      template<
+        typename FunctionPtr,
+        typename R
+       
+      >
+      struct get_function_invoker0
+      {
+        typedef typename conditional<(is_void<R>::value),
+                            void_function_invoker0<
+                            FunctionPtr,
+                            R
+                           
+                          >,
+                          function_invoker0<
+                            FunctionPtr,
+                            R
+                           
+                          >
+                       >::type type;
+      };
+
+      template<
+        typename FunctionObj,
+        typename R
+       
+       >
+      struct get_function_obj_invoker0
+      {
+        typedef typename conditional<(is_void<R>::value),
+                            void_function_obj_invoker0<
+                            FunctionObj,
+                            R
+                           
+                          >,
+                          function_obj_invoker0<
+                            FunctionObj,
+                            R
+                           
+                          >
+                       >::type type;
+      };
+
+      template<
+        typename FunctionObj,
+        typename R
+       
+       >
+      struct get_function_ref_invoker0
+      {
+        typedef typename conditional<(is_void<R>::value),
+                            void_function_ref_invoker0<
+                            FunctionObj,
+                            R
+                           
+                          >,
+                          function_ref_invoker0<
+                            FunctionObj,
+                            R
+                           
+                          >
+                       >::type type;
+      };
+# 331 "/usr/include/boost/function/function_template.hpp" 3 4
+      template<typename Tag>
+      struct get_invoker0 { };
+
+
+      template<>
+      struct get_invoker0<function_ptr_tag>
+      {
+        template<typename FunctionPtr,
+                 typename R >
+        struct apply
+        {
+          typedef typename get_function_invoker0<
+                             FunctionPtr,
+                             R
+                            
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<FunctionPtr> manager_type;
+        };
+
+        template<typename FunctionPtr, typename Allocator,
+                 typename R >
+        struct apply_a
+        {
+          typedef typename get_function_invoker0<
+                             FunctionPtr,
+                             R
+                            
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<FunctionPtr> manager_type;
+        };
+      };
+# 403 "/usr/include/boost/function/function_template.hpp" 3 4
+      template<>
+      struct get_invoker0<function_obj_tag>
+      {
+        template<typename FunctionObj,
+                 typename R >
+        struct apply
+        {
+          typedef typename get_function_obj_invoker0<
+                             FunctionObj,
+                             R
+                            
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<FunctionObj> manager_type;
+        };
+
+        template<typename FunctionObj, typename Allocator,
+                 typename R >
+        struct apply_a
+        {
+          typedef typename get_function_obj_invoker0<
+                             FunctionObj,
+                             R
+                            
+                           >::type
+            invoker_type;
+
+          typedef functor_manager_a<FunctionObj, Allocator> manager_type;
+        };
+      };
+
+
+      template<>
+      struct get_invoker0<function_obj_ref_tag>
+      {
+        template<typename RefWrapper,
+                 typename R >
+        struct apply
+        {
+          typedef typename get_function_ref_invoker0<
+                             typename RefWrapper::type,
+                             R
+                            
+                           >::type
+            invoker_type;
+
+          typedef reference_manager<typename RefWrapper::type> manager_type;
+        };
+
+        template<typename RefWrapper, typename Allocator,
+                 typename R >
+        struct apply_a
+        {
+          typedef typename get_function_ref_invoker0<
+                             typename RefWrapper::type,
+                             R
+                            
+                           >::type
+            invoker_type;
+
+          typedef reference_manager<typename RefWrapper::type> manager_type;
+        };
+      };
+# 476 "/usr/include/boost/function/function_template.hpp" 3 4
+      template<typename R >
+      struct basic_vtable0
+      {
+
+        typedef R result_type;
+
+
+
+
+        typedef result_type (*invoker_type)(function_buffer&
+                                           
+                                            );
+
+        template<typename F>
+        bool assign_to(F f, function_buffer& functor) const
+        {
+          typedef typename get_function_tag<F>::type tag;
+          return assign_to(f, functor, tag());
+        }
+        template<typename F,typename Allocator>
+        bool assign_to_a(F f, function_buffer& functor, Allocator a) const
+        {
+          typedef typename get_function_tag<F>::type tag;
+          return assign_to_a(f, functor, a, tag());
+        }
+
+        void clear(function_buffer& functor) const
+        {
+          if (base.manager)
+            base.manager(functor, functor, destroy_functor_tag);
+        }
+
+      private:
+
+        template<typename FunctionPtr>
+        bool
+        assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag) const
+        {
+          this->clear(functor);
+          if (f) {
+
+
+            functor.members.func_ptr = reinterpret_cast<void (*)()>(f);
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionPtr,typename Allocator>
+        bool
+        assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const
+        {
+          return assign_to(f,functor,function_ptr_tag());
+        }
+# 563 "/usr/include/boost/function/function_template.hpp" 3 4
+        template<typename FunctionObj>
+        void
+        assign_functor(FunctionObj f, function_buffer& functor, true_type) const
+        {
+          new (reinterpret_cast<void*>(functor.data)) FunctionObj(f);
+        }
+        template<typename FunctionObj,typename Allocator>
+        void
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, true_type) const
+        {
+          assign_functor(f,functor,true_type());
+        }
+
+
+        template<typename FunctionObj>
+        void
+        assign_functor(FunctionObj f, function_buffer& functor, false_type) const
+        {
+          functor.members.obj_ptr = new FunctionObj(f);
+        }
+        template<typename FunctionObj,typename Allocator>
+        void
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, false_type) const
+        {
+          typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;
+
+
+
+
+
+          using wrapper_allocator_type = typename std::allocator_traits<Allocator>::template rebind_alloc<functor_wrapper_type>;
+          using wrapper_allocator_pointer_type = typename std::allocator_traits<wrapper_allocator_type>::pointer;
+
+          wrapper_allocator_type wrapper_allocator(a);
+          wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
+
+
+
+          std::allocator_traits<wrapper_allocator_type>::construct(wrapper_allocator, copy, functor_wrapper_type(f,a));
+
+          functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
+          functor.members.obj_ptr = new_f;
+        }
+
+        template<typename FunctionObj>
+        bool
+        assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) const
+        {
+          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
+            assign_functor(f, functor,
+                           integral_constant<bool, (function_allows_small_object_optimization<FunctionObj>::value)>());
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionObj,typename Allocator>
+        bool
+        assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag) const
+        {
+          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
+            assign_functor_a(f, functor, a,
+                           integral_constant<bool, (function_allows_small_object_optimization<FunctionObj>::value)>());
+            return true;
+          } else {
+            return false;
+          }
+        }
+
+
+        template<typename FunctionObj>
+        bool
+        assign_to(const reference_wrapper<FunctionObj>& f,
+                  function_buffer& functor, function_obj_ref_tag) const
+        {
+          functor.members.obj_ref.obj_ptr = (void *)(f.get_pointer());
+          functor.members.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
+          functor.members.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
+          return true;
+        }
+        template<typename FunctionObj,typename Allocator>
+        bool
+        assign_to_a(const reference_wrapper<FunctionObj>& f,
+                  function_buffer& functor, Allocator, function_obj_ref_tag) const
+        {
+          return assign_to(f,functor,function_obj_ref_tag());
+        }
+
+      public:
+        vtable_base base;
+        invoker_type invoker;
+      };
+    }
+  }
+
+  template<
+    typename R
+   
+  >
+  class function0 : public function_base
+  {
+  public:
+
+    typedef R result_type;
+
+
+
+
+
+  private:
+    typedef boost::detail::function::basic_vtable0<
+              R >
+      vtable_type;
+
+    vtable_type* get_vtable() const {
+      return reinterpret_cast<vtable_type*>(
+               reinterpret_cast<std::size_t>(vtable) & ~static_cast<std::size_t>(0x01));
+    }
+
+    struct clear_type {};
+
+  public:
+    static const int args = 0;
+
+
+    template<typename Args>
+    struct sig
+    {
+      typedef result_type type;
+    };
+# 701 "/usr/include/boost/function/function_template.hpp" 3 4
+    static const int arity = 0;
+   
+
+    typedef function0 self_type;
+
+    function0() = default;
+
+
+
+    template<typename Functor>
+    function0(Functor f
+
+                            ,typename boost::enable_if_<
+                             !(is_integral<Functor>::value),
+                                        int>::type = 0
+
+                            ) :
+      function_base()
+    {
+      this->assign_to(f);
+    }
+    template<typename Functor,typename Allocator>
+    function0(Functor f, Allocator a
+
+                            ,typename boost::enable_if_<
+                              !(is_integral<Functor>::value),
+                                        int>::type = 0
+
+                            ) :
+      function_base()
+    {
+      this->assign_to_a(f,a);
+    }
+
+
+    function0(clear_type*) : function_base() { }
+
+
+
+
+
+
+
+    function0(const function0& f) : function_base()
+    {
+      this->assign_to_own(f);
+    }
+
+
+    function0(function0&& f) : function_base()
+    {
+      this->move_assign(f);
+    }
+
+
+    ~function0() { clear(); }
+
+    result_type operator()() const
+    {
+      if (this->empty())
+        boost::throw_exception(bad_function_call());
+
+      return get_vtable()->invoker
+               (this->functor );
+    }
+
+
+
+
+
+
+    template<typename Functor>
+
+    typename boost::enable_if_<
+                  !(is_integral<Functor>::value),
+               function0&>::type
+
+
+
+    operator=(Functor f)
+    {
+      this->clear();
+      { try {
+        this->assign_to(f);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+      return *this;
+    }
+    template<typename Functor,typename Allocator>
+    void assign(Functor f, Allocator a)
+    {
+      this->clear();
+      { try{
+        this->assign_to_a(f,a);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+    }
+
+
+    function0& operator=(clear_type*)
+    {
+      this->clear();
+      return *this;
+    }
+# 821 "/usr/include/boost/function/function_template.hpp" 3 4
+    function0& operator=(const function0& f)
+    {
+      if (&f == this)
+        return *this;
+
+      this->clear();
+      { try {
+        this->assign_to_own(f);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+      return *this;
+    }
+
+
+
+    function0& operator=(function0&& f)
+    {
+      if (&f == this)
+        return *this;
+
+      this->clear();
+      { try {
+        this->move_assign(f);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+      return *this;
+    }
+
+
+    void swap(function0& other)
+    {
+      if (&other == this)
+        return;
+
+      function0 tmp;
+      tmp.move_assign(*this);
+      this->move_assign(other);
+      other.move_assign(tmp);
+    }
+
+
+    void clear()
+    {
+      if (vtable) {
+        if (!this->has_trivial_copy_and_destroy())
+          get_vtable()->clear(this->functor);
+        vtable = 0;
+      }
+    }
+
+
+
+
+
+  private:
+    struct dummy {
+      void nonnull() {}
+    };
+
+    typedef void (dummy::*safe_bool)();
+
+  public:
+    operator safe_bool () const
+      { return (this->empty())? 0 : &dummy::nonnull; }
+
+    bool operator!() const
+      { return this->empty(); }
+
+
+  private:
+    void assign_to_own(const function0& f)
+    {
+      if (!f.empty()) {
+        this->vtable = f.vtable;
+        if (this->has_trivial_copy_and_destroy())
+
+
+          std::memcpy(this->functor.data, f.functor.data, sizeof(boost::detail::function::function_buffer));
+        else
+          get_vtable()->base.manager(f.functor, this->functor,
+                                     boost::detail::function::clone_functor_tag);
+      }
+    }
+
+    template<typename Functor>
+    void assign_to(Functor f)
+    {
+      using boost::detail::function::vtable_base;
+
+      typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
+      typedef boost::detail::function::get_invoker0<tag> get_invoker;
+      typedef typename get_invoker::
+                         template apply<Functor, R
+                        >
+        handler_type;
+
+      typedef typename handler_type::invoker_type invoker_type;
+      typedef typename handler_type::manager_type manager_type;
+
+
+
+
+
+      static const vtable_type stored_vtable =
+        { { &manager_type::manage }, &invoker_type::invoke };
+
+      if (stored_vtable.assign_to(f, functor)) {
+        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
+
+        if (boost::has_trivial_copy_constructor<Functor>::value &&
+            boost::has_trivial_destructor<Functor>::value &&
+            boost::detail::function::function_allows_small_object_optimization<Functor>::value)
+          value |= static_cast<std::size_t>(0x01);
+        vtable = reinterpret_cast<boost::detail::function::vtable_base *>(value);
+      } else
+        vtable = 0;
+    }
+
+    template<typename Functor,typename Allocator>
+    void assign_to_a(Functor f,Allocator a)
+    {
+      using boost::detail::function::vtable_base;
+
+      typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
+      typedef boost::detail::function::get_invoker0<tag> get_invoker;
+      typedef typename get_invoker::
+                         template apply_a<Functor, Allocator, R
+                         >
+        handler_type;
+
+      typedef typename handler_type::invoker_type invoker_type;
+      typedef typename handler_type::manager_type manager_type;
+
+
+
+
+
+      static const vtable_type stored_vtable =
+        { { &manager_type::manage }, &invoker_type::invoke };
+
+      if (stored_vtable.assign_to_a(f, functor, a)) {
+        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
+
+        if (boost::has_trivial_copy_constructor<Functor>::value &&
+            boost::has_trivial_destructor<Functor>::value &&
+            boost::detail::function::function_allows_small_object_optimization<Functor>::value)
+          value |= static_cast<std::size_t>(0x01);
+        vtable = reinterpret_cast<boost::detail::function::vtable_base *>(value);
+      } else
+        vtable = 0;
+    }
+
+
+
+
+    void move_assign(function0& f)
+    {
+      if (&f == this)
+        return;
+
+      { try {
+        if (!f.empty()) {
+          this->vtable = f.vtable;
+          if (this->has_trivial_copy_and_destroy())
+
+
+            std::memcpy(this->functor.data, f.functor.data, sizeof(this->functor.data));
+          else
+            get_vtable()->base.manager(f.functor, this->functor,
+                                     boost::detail::function::move_functor_tag);
+          f.vtable = 0;
+        } else {
+          clear();
+        }
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+    }
+  };
+
+  template<typename R >
+  inline void swap(function0<
+                     R
+                    
+                   >& f1,
+                   function0<
+                     R
+                    
+                   >& f2)
+  {
+    f1.swap(f2);
+  }
+
+
+template<typename R >
+  void operator==(const function0<
+                          R
+                          >&,
+                  const function0<
+                          R
+                          >&);
+template<typename R >
+  void operator!=(const function0<
+                          R
+                          >&,
+                  const function0<
+                          R
+                          >& );
+
+
+
+
+#define BOOST_FUNCTION_PARTIAL_SPEC R (void)
+
+
+
+
+template<typename R
+         >
+class function<R (void)>
+  : public function0<R >
+{
+  typedef function0<R > base_type;
+  typedef function self_type;
+
+  struct clear_type {};
+
+public:
+
+  function() = default;
+
+  template<typename Functor>
+  function(Functor f
+
+           ,typename boost::enable_if_<
+                          !(is_integral<Functor>::value),
+                       int>::type = 0
+
+           ) :
+    base_type(f)
+  {
+  }
+  template<typename Functor,typename Allocator>
+  function(Functor f, Allocator a
+
+           ,typename boost::enable_if_<
+                           !(is_integral<Functor>::value),
+                       int>::type = 0
+
+           ) :
+    base_type(f,a)
+  {
+  }
+
+
+  function(clear_type*) : base_type() {}
+
+
+  function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}
+
+  function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}
+
+
+
+  function(self_type&& f): base_type(static_cast<base_type&&>(f)){}
+  function(base_type&& f): base_type(static_cast<base_type&&>(f)){}
+
+
+  self_type& operator=(const self_type& f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+
+
+  self_type& operator=(self_type&& f)
+  {
+    self_type(static_cast<self_type&&>(f)).swap(*this);
+    return *this;
+  }
+
+
+  template<typename Functor>
+
+  typename boost::enable_if_<
+                         !(is_integral<Functor>::value),
+                      self_type&>::type
+
+
+
+  operator=(Functor f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+
+
+  self_type& operator=(clear_type*)
+  {
+    this->clear();
+    return *this;
+  }
+
+
+  self_type& operator=(const base_type& f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+
+
+  self_type& operator=(base_type&& f)
+  {
+    self_type(static_cast<base_type&&>(f)).swap(*this);
+    return *this;
+  }
+
+};
+
+#undef BOOST_FUNCTION_PARTIAL_SPEC
+
+
+}
+
+
+#undef BOOST_FUNCTION_VTABLE
+#undef BOOST_FUNCTION_COMMA
+#undef BOOST_FUNCTION_FUNCTION
+#undef BOOST_FUNCTION_FUNCTION_INVOKER
+#undef BOOST_FUNCTION_VOID_FUNCTION_INVOKER
+#undef BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
+#undef BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
+#undef BOOST_FUNCTION_FUNCTION_REF_INVOKER
+#undef BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER
+#undef BOOST_FUNCTION_MEMBER_INVOKER
+#undef BOOST_FUNCTION_VOID_MEMBER_INVOKER
+#undef BOOST_FUNCTION_GET_FUNCTION_INVOKER
+#undef BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
+#undef BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER
+#undef BOOST_FUNCTION_GET_MEM_FUNCTION_INVOKER
+#undef BOOST_FUNCTION_GET_INVOKER
+#undef BOOST_FUNCTION_TEMPLATE_PARMS
+#undef BOOST_FUNCTION_TEMPLATE_ARGS
+#undef BOOST_FUNCTION_PARMS
+#undef BOOST_FUNCTION_PARM
+
+#undef BOOST_FUNCTION_ARG
+
+#undef BOOST_FUNCTION_ARGS
+#undef BOOST_FUNCTION_ARG_TYPE
+#undef BOOST_FUNCTION_ARG_TYPES
+#undef BOOST_FUNCTION_VOID_RETURN_TYPE
+#undef BOOST_FUNCTION_RETURN
+# 16 "/usr/include/boost/function/detail/maybe_include.hpp" 2 3 4
+# 12 "/usr/include/boost/function/function0.hpp" 2 3 4
+#undef BOOST_FUNCTION_NUM_ARGS
+# 29 "/usr/include/boost/test/execution_monitor.hpp" 2 3 4
+
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 31 "/usr/include/boost/test/execution_monitor.hpp" 2 3 4
+# 64 "/usr/include/boost/test/execution_monitor.hpp" 3 4
+# 1 "/usr/include/boost/detail/fenv.hpp" 1 3 4
+# 15 "/usr/include/boost/detail/fenv.hpp" 3 4
+#define BOOST_DETAIL_FENV_HPP 
+# 97 "/usr/include/boost/detail/fenv.hpp" 3 4
+# 1 "/usr/include/c++/10.2.0/fenv.h" 1 3 4
+# 30 "/usr/include/c++/10.2.0/fenv.h" 3 4
+#define _GLIBCXX_FENV_H 1
+
+       
+# 33 "/usr/include/c++/10.2.0/fenv.h" 3
+
+
+
+# 1 "/usr/include/fenv.h" 1 3 4
+# 23 "/usr/include/fenv.h" 3 4
+#define _FENV_H 1
+
+#define __GLIBC_INTERNAL_STARTING_HEADER_IMPLEMENTATION 
+# 1 "/usr/include/bits/libc-header-start.h" 1 3 4
+# 31 "/usr/include/bits/libc-header-start.h" 3 4
+#undef __GLIBC_INTERNAL_STARTING_HEADER_IMPLEMENTATION
+
+
+
+
+
+#undef __GLIBC_USE_LIB_EXT2
+
+
+#define __GLIBC_USE_LIB_EXT2 1
+# 49 "/usr/include/bits/libc-header-start.h" 3 4
+#undef __GLIBC_USE_IEC_60559_BFP_EXT
+
+#define __GLIBC_USE_IEC_60559_BFP_EXT 1
+
+
+
+#undef __GLIBC_USE_IEC_60559_BFP_EXT_C2X
+
+#define __GLIBC_USE_IEC_60559_BFP_EXT_C2X 1
+# 66 "/usr/include/bits/libc-header-start.h" 3 4
+#undef __GLIBC_USE_IEC_60559_FUNCS_EXT
+
+#define __GLIBC_USE_IEC_60559_FUNCS_EXT 1
+
+
+
+#undef __GLIBC_USE_IEC_60559_FUNCS_EXT_C2X
+
+#define __GLIBC_USE_IEC_60559_FUNCS_EXT_C2X 1
+
+
+
+
+
+
+#undef __GLIBC_USE_IEC_60559_TYPES_EXT
+
+#define __GLIBC_USE_IEC_60559_TYPES_EXT 1
+# 27 "/usr/include/fenv.h" 2 3 4
+# 64 "/usr/include/fenv.h" 3 4
+# 1 "/usr/include/bits/fenv.h" 1 3 4
+# 24 "/usr/include/bits/fenv.h" 3 4
+enum
+  {
+    FE_INVALID =
+#define FE_INVALID 0x01
+      0x01,
+    __FE_DENORM = 0x02,
+    FE_DIVBYZERO =
+#define FE_DIVBYZERO 0x04
+      0x04,
+    FE_OVERFLOW =
+#define FE_OVERFLOW 0x08
+      0x08,
+    FE_UNDERFLOW =
+#define FE_UNDERFLOW 0x10
+      0x10,
+    FE_INEXACT =
+#define FE_INEXACT 0x20
+      0x20
+  };
+
+#define FE_ALL_EXCEPT (FE_INEXACT | FE_DIVBYZERO | FE_UNDERFLOW | FE_OVERFLOW | FE_INVALID)
+
+
+
+
+
+enum
+  {
+    FE_TONEAREST =
+#define FE_TONEAREST 0
+      0,
+    FE_DOWNWARD =
+#define FE_DOWNWARD 0x400
+      0x400,
+    FE_UPWARD =
+#define FE_UPWARD 0x800
+      0x800,
+    FE_TOWARDZERO =
+#define FE_TOWARDZERO 0xc00
+      0xc00
+  };
+
+
+
+typedef unsigned short int fexcept_t;
+
+
+
+
+
+
+typedef struct
+  {
+    unsigned short int __control_word;
+    unsigned short int __glibc_reserved1;
+    unsigned short int __status_word;
+    unsigned short int __glibc_reserved2;
+    unsigned short int __tags;
+    unsigned short int __glibc_reserved3;
+    unsigned int __eip;
+    unsigned short int __cs_selector;
+    unsigned int __opcode:11;
+    unsigned int __glibc_reserved4:5;
+    unsigned int __data_offset;
+    unsigned short int __data_selector;
+    unsigned short int __glibc_reserved5;
+
+    unsigned int __mxcsr;
+
+  }
+fenv_t;
+
+
+#define FE_DFL_ENV ((const fenv_t *) -1)
+
+
+
+#define FE_NOMASK_ENV ((const fenv_t *) -2)
+
+
+
+
+typedef struct
+  {
+    unsigned short int __control_word;
+    unsigned short int __glibc_reserved;
+    unsigned int __mxcsr;
+  }
+femode_t;
+
+
+#define FE_DFL_MODE ((const femode_t *) -1L)
+# 65 "/usr/include/fenv.h" 2 3 4
+
+extern "C" {
+
+
+
+
+extern int feclearexcept (int __excepts) throw ();
+
+
+
+extern int fegetexceptflag (fexcept_t *__flagp, int __excepts) throw ();
+
+
+extern int feraiseexcept (int __excepts) throw ();
+
+
+
+
+extern int fesetexcept (int __excepts) throw ();
+
+
+
+
+extern int fesetexceptflag (const fexcept_t *__flagp, int __excepts) throw ();
+
+
+
+extern int fetestexcept (int __excepts) throw ();
+
+
+
+
+extern int fetestexceptflag (const fexcept_t *__flagp, int __excepts) throw ();
+
+
+
+
+
+
+extern int fegetround (void) throw () __attribute__ ((__pure__));
+
+
+extern int fesetround (int __rounding_direction) throw ();
+
+
+
+
+
+
+extern int fegetenv (fenv_t *__envp) throw ();
+
+
+
+
+extern int feholdexcept (fenv_t *__envp) throw ();
+
+
+
+extern int fesetenv (const fenv_t *__envp) throw ();
+
+
+
+
+extern int feupdateenv (const fenv_t *__envp) throw ();
+
+
+
+
+
+
+
+extern int fegetmode (femode_t *__modep) throw ();
+
+
+
+extern int fesetmode (const femode_t *__modep) throw ();
+# 157 "/usr/include/fenv.h" 3 4
+extern int feenableexcept (int __excepts) throw ();
+
+
+
+
+extern int fedisableexcept (int __excepts) throw ();
+
+
+extern int fegetexcept (void) throw ();
+
+
+}
+# 37 "/usr/include/c++/10.2.0/fenv.h" 2 3
+
+
+
+
+
+
+#undef feclearexcept
+#undef fegetexceptflag
+#undef feraiseexcept
+#undef fesetexceptflag
+#undef fetestexcept
+#undef fegetround
+#undef fesetround
+#undef fegetenv
+#undef feholdexcept
+#undef fesetenv
+#undef feupdateenv
+
+namespace std
+{
+
+  using ::fenv_t;
+  using ::fexcept_t;
+
+
+  using ::feclearexcept;
+  using ::fegetexceptflag;
+  using ::feraiseexcept;
+  using ::fesetexceptflag;
+  using ::fetestexcept;
+
+  using ::fegetround;
+  using ::fesetround;
+
+  using ::fegetenv;
+  using ::feholdexcept;
+  using ::fesetenv;
+  using ::feupdateenv;
+}
+# 98 "/usr/include/boost/detail/fenv.hpp" 2 3 4
+# 65 "/usr/include/boost/test/execution_monitor.hpp" 2 3 4
+# 80 "/usr/include/boost/test/execution_monitor.hpp" 3 4
+#define BOOST_TEST_FPE_SUPPORT_WITH_GLIBC_EXTENSIONS__ 
+# 98 "/usr/include/boost/test/execution_monitor.hpp" 3 4
+namespace boost {
+# 179 "/usr/include/boost/test/execution_monitor.hpp" 3 4
+namespace detail {
+
+class translator_holder_base;
+typedef boost::shared_ptr<translator_holder_base> translator_holder_base_ptr;
+
+class __attribute__((__visibility__("default"))) translator_holder_base {
+protected:
+    typedef boost::unit_test::const_string const_string;
+public:
+
+    translator_holder_base( translator_holder_base_ptr next, const_string tag )
+    : m_next( next )
+    , m_tag( std::string() + tag )
+    {
+    }
+
+
+    virtual ~translator_holder_base() {}
+
+
+
+    virtual int operator()( boost::function<int ()> const& F ) = 0;
+
+
+    translator_holder_base_ptr erase( translator_holder_base_ptr this_, const_string tag )
+    {
+        if( m_next )
+            m_next = m_next->erase( m_next, tag );
+
+        return m_tag == tag ? m_next : this_;
+    }
+
+    virtual translator_holder_base_ptr erase( translator_holder_base_ptr this_, std::type_info const& ) = 0;
+    template<typename ExceptionType>
+    translator_holder_base_ptr erase( translator_holder_base_ptr this_, boost::type<ExceptionType>* = 0 )
+    {
+        if( m_next )
+            m_next = m_next->erase<ExceptionType>( m_next );
+
+        return erase( this_, typeid(ExceptionType) );
+    }
+
+
+protected:
+
+    translator_holder_base_ptr m_next;
+    std::string m_tag;
+};
+
+}
+# 241 "/usr/include/boost/test/execution_monitor.hpp" 3 4
+class __attribute__((__visibility__("default"))) execution_exception {
+    typedef boost::unit_test::const_string const_string;
+public:
+# 261 "/usr/include/boost/test/execution_monitor.hpp" 3 4
+    enum error_code {
+        no_error = 0,
+        user_error = 200,
+        cpp_exception_error = 205,
+        system_error = 210,
+        timeout_error = 215,
+        user_fatal_error = 220,
+        system_fatal_error = 225
+    };
+
+
+    struct __attribute__((__visibility__("default"))) location {
+        explicit location( char const* file_name = 0, size_t line_num = 0, char const* func = 0 );
+        explicit location( const_string file_name, size_t line_num = 0, char const* func = 0 );
+
+        const_string m_file_name;
+        size_t m_line_num;
+        const_string m_function;
+    };
+# 288 "/usr/include/boost/test/execution_monitor.hpp" 3 4
+    execution_exception( error_code ec, const_string what_msg, location const& location );
+
+
+
+
+    error_code code() const { return m_error_code; }
+
+    const_string what() const { return m_what; }
+
+    location const& where() const { return m_location; }
+
+
+private:
+
+    error_code m_error_code;
+    const_string m_what;
+    location m_location;
+};
+# 317 "/usr/include/boost/test/execution_monitor.hpp" 3 4
+class __attribute__((__visibility__("default"))) execution_monitor {
+    typedef boost::unit_test::const_string const_string;
+public:
+
+
+    execution_monitor();
+
+
+
+
+
+
+
+    unit_test::readwrite_property<bool> p_catch_system_errors;
+
+
+
+
+
+    unit_test::readwrite_property<bool> p_auto_start_dbg;
+
+
+
+
+
+
+    unit_test::readwrite_property<unsigned long int> p_timeout;
+
+
+
+
+
+
+    unit_test::readwrite_property<bool> p_use_alt_stack;
+
+
+
+
+
+    unit_test::readwrite_property<unsigned> p_detect_fp_exceptions;
+# 371 "/usr/include/boost/test/execution_monitor.hpp" 3 4
+    int execute( boost::function<int ()> const& F );
+
+
+
+
+
+
+    void vexecute( boost::function<void ()> const& F );
+# 399 "/usr/include/boost/test/execution_monitor.hpp" 3 4
+    template<typename ExceptionType, typename ExceptionTranslator>
+    void register_exception_translator( ExceptionTranslator const& tr, const_string tag = const_string(), boost::type<ExceptionType>* = 0 );
+
+
+
+
+
+    void erase_exception_translator( const_string tag )
+    {
+        m_custom_translators = m_custom_translators->erase( m_custom_translators, tag );
+    }
+
+
+
+
+    template<typename ExceptionType>
+    void erase_exception_translator( boost::type<ExceptionType>* = 0 )
+    {
+        m_custom_translators = m_custom_translators->erase<ExceptionType>( m_custom_translators );
+    }
+
+
+
+private:
+
+    int catch_signals( boost::function<int ()> const& F );
+
+
+    detail::translator_holder_base_ptr m_custom_translators;
+    boost::scoped_array<char> m_alt_stack;
+};
+
+
+
+
+
+namespace detail {
+
+template<typename ExceptionType, typename ExceptionTranslator>
+class translator_holder : public translator_holder_base
+{
+public:
+    explicit translator_holder( ExceptionTranslator const& tr, translator_holder_base_ptr& next, const_string tag = const_string() )
+    : translator_holder_base( next, tag ), m_translator( tr ) {}
+
+
+    virtual int operator()( boost::function<int ()> const& F )
+    {
+        try {
+            return m_next ? (*m_next)( F ) : F();
+        }
+        catch( ExceptionType const& e ) {
+            m_translator( e );
+            return boost::exit_exception_failure;
+        }
+    }
+
+    virtual translator_holder_base_ptr erase( translator_holder_base_ptr this_, std::type_info const& ti )
+    {
+        return ti == typeid(ExceptionType) ? m_next : this_;
+    }
+
+
+private:
+
+    ExceptionTranslator m_translator;
+};
+
+}
+
+template<typename ExceptionType, typename ExceptionTranslator>
+void
+execution_monitor::register_exception_translator( ExceptionTranslator const& tr, const_string tag, boost::type<ExceptionType>* )
+{
+    m_custom_translators.reset(
+        new detail::translator_holder<ExceptionType,ExceptionTranslator>( tr, m_custom_translators, tag ) );
+}
+
+
+
+
+
+
+struct execution_aborted {};
+
+
+
+
+
+class system_error {
+public:
+
+    explicit system_error( char const* exp );
+
+    long const p_errno;
+    char const* const p_failed_exp;
+};
+
+
+#define BOOST_TEST_SYS_ASSERT(cond) BOOST_TEST_I_ASSRT( cond, ::boost::system_error( BOOST_STRINGIZE( exp ) ) )
+
+
+
+
+
+namespace fpe {
+
+enum masks {
+    BOOST_FPE_OFF = 0,
+# 528 "/usr/include/boost/test/execution_monitor.hpp" 3 4
+    BOOST_FPE_DIVBYZERO = 0x04,
+
+
+
+
+
+    BOOST_FPE_INEXACT = 0x20,
+
+
+
+
+
+    BOOST_FPE_INVALID = 0x01,
+
+
+
+
+
+    BOOST_FPE_OVERFLOW = 0x08,
+
+
+
+
+
+    BOOST_FPE_UNDERFLOW = 0x10,
+
+
+
+
+
+    BOOST_FPE_ALL = (0x20 | 0x04 | 0x10 | 0x08 | 0x01),
+
+
+
+
+
+    BOOST_FPE_INV = BOOST_FPE_ALL+1
+};
+
+
+
+
+unsigned __attribute__((__visibility__("default"))) enable( unsigned mask );
+unsigned __attribute__((__visibility__("default"))) disable( unsigned mask );
+
+
+
+}
+
+
+
+}
+
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 583 "/usr/include/boost/test/execution_monitor.hpp" 2 3 4
+# 23 "/usr/include/boost/test/impl/compiler_log_formatter.ipp" 2 3 4
+# 1 "/usr/include/boost/test/unit_test_parameters.hpp" 1 3 4
+# 15 "/usr/include/boost/test/unit_test_parameters.hpp" 3 4
+#define BOOST_TEST_UNIT_TEST_PARAMETERS_HPP_071894GER 
+
+
+
+# 1 "/usr/include/boost/test/utils/runtime/argument.hpp" 1 3 4
+# 16 "/usr/include/boost/test/utils/runtime/argument.hpp" 3 4
+#define BOOST_TEST_UTILS_RUNTIME_ARGUMENT_HPP 
+
+
+# 1 "/usr/include/boost/test/utils/runtime/fwd.hpp" 1 3 4
+# 16 "/usr/include/boost/test/utils/runtime/fwd.hpp" 3 4
+#define BOOST_TEST_UTILS_RUNTIME_FWD_HPP 
+
+
+
+
+# 1 "/usr/include/boost/test/utils/basic_cstring/io.hpp" 1 3 4
+# 16 "/usr/include/boost/test/utils/basic_cstring/io.hpp" 3 4
+#define BOOST_TEST_UTILS_BASIC_CSTRING_IO_HPP 
+# 25 "/usr/include/boost/test/utils/basic_cstring/io.hpp" 3 4
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 26 "/usr/include/boost/test/utils/basic_cstring/io.hpp" 2 3 4
+
+
+
+namespace boost {
+
+namespace unit_test {
+# 49 "/usr/include/boost/test/utils/basic_cstring/io.hpp" 3 4
+template<typename CharT1, typename Tr,typename CharT2>
+inline std::basic_ostream<CharT1,Tr>&
+operator<<( std::basic_ostream<CharT1,Tr>& os, basic_cstring<CharT2> const& str )
+{
+    CharT1 const* const beg = reinterpret_cast<CharT1 const*>( str.begin() );
+    CharT1 const* const end = reinterpret_cast<CharT1 const*>( str.end() );
+    os << std::basic_string<CharT1,Tr>( beg, end - beg );
+
+    return os;
+}
+
+
+
+
+
+
+}
+
+}
+
+
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 72 "/usr/include/boost/test/utils/basic_cstring/io.hpp" 2 3 4
+# 22 "/usr/include/boost/test/utils/runtime/fwd.hpp" 2 3 4
+
+
+
+
+
+# 1 "/usr/include/c++/10.2.0/map" 1 3 4
+# 56 "/usr/include/c++/10.2.0/map" 3 4
+#define _GLIBCXX_MAP 1
+
+       
+# 59 "/usr/include/c++/10.2.0/map" 3
+
+# 1 "/usr/include/c++/10.2.0/bits/stl_tree.h" 1 3
+# 59 "/usr/include/c++/10.2.0/bits/stl_tree.h" 3
+#define _STL_TREE_H 1
+
+       
+# 62 "/usr/include/c++/10.2.0/bits/stl_tree.h" 3
+# 75 "/usr/include/c++/10.2.0/bits/stl_tree.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+#define __cpp_lib_generic_associative_lookup 201304
+# 99 "/usr/include/c++/10.2.0/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 "/usr/include/c++/10.2.0/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;
+      }
+
+      friend bool
+      operator==(const _Self& __x, const _Self& __y) noexcept
+      { return __x._M_node == __y._M_node; }
+
+
+      friend bool
+      operator!=(const _Self& __x, const _Self& __y) noexcept
+      { return __x._M_node != __y._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;
+      }
+
+      friend bool
+      operator==(const _Self& __x, const _Self& __y) noexcept
+      { return __x._M_node == __y._M_node; }
+
+
+      friend bool
+      operator!=(const _Self& __x, const _Self& __y) noexcept
+      { return __x._M_node != __y._M_node; }
+
+
+      _Base_ptr _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 _Cmp, typename _SfinaeType>
+    using __has_is_transparent_t
+      = typename __has_is_transparent<_Cmp, _SfinaeType>::type;
+
+
+
+  template<typename _Tree1, typename _Cmp2>
+    struct _Rb_tree_merge_helper { };
+
+
+  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;
+
+    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); }
+# 611 "/usr/include/c++/10.2.0/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;
+
+   explicit
+   _Rb_tree_impl(_Node_allocator&& __a)
+   : _Node_allocator(std::move(__a))
+   { }
+
+   _Rb_tree_impl(_Rb_tree_impl&& __x, _Node_allocator&& __a)
+   : _Node_allocator(std::move(__a)),
+     _Base_key_compare(std::move(__x)),
+     _Rb_tree_header(std::move(__x))
+   { }
+
+   _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 _Key&
+      _S_key(_Const_Link_type __x)
+      {
+
+
+
+ static_assert(__is_invocable<_Compare&, const _Key&, const _Key&>{},
+        "comparison object must be invocable "
+        "with two arguments of key type");
+
+
+
+ if constexpr (__is_invocable<_Compare&, const _Key&, const _Key&>{})
+   static_assert(
+       is_invocable_v<const _Compare&, const _Key&, const _Key&>,
+       "comparison object must be invocable as const");
+
+
+
+ return _KeyOfValue()(*__x->_M_valptr());
+      }
+
+      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 _Key&
+      _S_key(_Const_Base_ptr __x)
+      { return _S_key(static_cast<_Const_Link_type>(__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;
+
+
+      using node_type = _Node_handle<_Key, _Val, _Node_allocator>;
+      using insert_return_type = _Node_insert_return<
+ conditional_t<is_same_v<_Key, _Val>, const_iterator, iterator>,
+ node_type>;
+
+
+      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);
+# 889 "/usr/include/c++/10.2.0/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(_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))
+      { }
+
+    private:
+      _Rb_tree(_Rb_tree&& __x, _Node_allocator&& __a, true_type)
+      noexcept(is_nothrow_default_constructible<_Compare>::value)
+      : _M_impl(std::move(__x._M_impl), std::move(__a))
+      { }
+
+      _Rb_tree(_Rb_tree&& __x, _Node_allocator&& __a, false_type)
+      : _M_impl(__x._M_impl._M_key_compare, std::move(__a))
+      {
+ if (__x._M_root() != nullptr)
+   _M_move_data(__x, false_type{});
+      }
+
+    public:
+      _Rb_tree(_Rb_tree&& __x, _Node_allocator&& __a)
+      noexcept( noexcept(
+ _Rb_tree(std::declval<_Rb_tree&&>(), std::declval<_Node_allocator&&>(),
+   std::declval<typename _Alloc_traits::is_always_equal>())) )
+      : _Rb_tree(std::move(__x), std::move(__a),
+   typename _Alloc_traits::is_always_equal{})
+      { }
+
+
+      ~_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()); }
+
+      [[__nodiscard__]] 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);
+
+      template<typename _Iter>
+ using __same_value_type
+   = is_same<value_type, typename iterator_traits<_Iter>::value_type>;
+
+      template<typename _InputIterator>
+ __enable_if_t<__same_value_type<_InputIterator>::value>
+ _M_insert_range_unique(_InputIterator __first, _InputIterator __last)
+ {
+   _Alloc_node __an(*this);
+   for (; __first != __last; ++__first)
+     _M_insert_unique_(end(), *__first, __an);
+ }
+
+      template<typename _InputIterator>
+ __enable_if_t<!__same_value_type<_InputIterator>::value>
+ _M_insert_range_unique(_InputIterator __first, _InputIterator __last)
+ {
+   for (; __first != __last; ++__first)
+     _M_emplace_unique(*__first);
+ }
+
+      template<typename _InputIterator>
+ __enable_if_t<__same_value_type<_InputIterator>::value>
+ _M_insert_range_equal(_InputIterator __first, _InputIterator __last)
+ {
+   _Alloc_node __an(*this);
+   for (; __first != __last; ++__first)
+     _M_insert_equal_(end(), *__first, __an);
+ }
+
+      template<typename _InputIterator>
+ __enable_if_t<!__same_value_type<_InputIterator>::value>
+ _M_insert_range_equal(_InputIterator __first, _InputIterator __last)
+ {
+   _Alloc_node __an(*this);
+   for (; __first != __last; ++__first)
+     _M_emplace_equal(*__first);
+ }
+# 1186 "/usr/include/c++/10.2.0/bits/stl_tree.h" 3
+    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;
+      }
+# 1235 "/usr/include/c++/10.2.0/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();
+      }
+# 1258 "/usr/include/c++/10.2.0/bits/stl_tree.h" 3
+      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 = __has_is_transparent_t<_Compare, _Kt>>
+ 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 = __has_is_transparent_t<_Compare, _Kt>>
+ 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 = __has_is_transparent_t<_Compare, _Kt>>
+ 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 = __has_is_transparent_t<_Compare, _Kt>>
+ 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 = __has_is_transparent_t<_Compare, _Kt>>
+ 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 = __has_is_transparent_t<_Compare, _Kt>>
+ 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 = __has_is_transparent_t<_Compare, _Kt>>
+ 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 = __has_is_transparent_t<_Compare, _Kt>>
+ 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 = __has_is_transparent_t<_Compare, _Kt>>
+ 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, true_type)
+      { _M_impl._M_move_data(__x._M_impl); }
+
+
+
+      void
+      _M_move_data(_Rb_tree&, false_type);
+
+
+      void
+      _M_move_assign(_Rb_tree&, true_type);
+
+
+
+      void
+      _M_move_assign(_Rb_tree&, false_type);
+
+
+
+    public:
+
+      insert_return_type
+      _M_reinsert_node_unique(node_type&& __nh)
+      {
+ insert_return_type __ret;
+ if (__nh.empty())
+   __ret.position = end();
+ else
+   {
+     ;
+
+     auto __res = _M_get_insert_unique_pos(__nh._M_key());
+     if (__res.second)
+       {
+  __ret.position
+    = _M_insert_node(__res.first, __res.second, __nh._M_ptr);
+  __nh._M_ptr = nullptr;
+  __ret.inserted = true;
+       }
+     else
+       {
+  __ret.node = std::move(__nh);
+  __ret.position = iterator(__res.first);
+  __ret.inserted = false;
+       }
+   }
+ return __ret;
+      }
+
+
+      iterator
+      _M_reinsert_node_equal(node_type&& __nh)
+      {
+ iterator __ret;
+ if (__nh.empty())
+   __ret = end();
+ else
+   {
+     ;
+     auto __res = _M_get_insert_equal_pos(__nh._M_key());
+     if (__res.second)
+       __ret = _M_insert_node(__res.first, __res.second, __nh._M_ptr);
+     else
+       __ret = _M_insert_equal_lower_node(__nh._M_ptr);
+     __nh._M_ptr = nullptr;
+   }
+ return __ret;
+      }
+
+
+      iterator
+      _M_reinsert_node_hint_unique(const_iterator __hint, node_type&& __nh)
+      {
+ iterator __ret;
+ if (__nh.empty())
+   __ret = end();
+ else
+   {
+     ;
+     auto __res = _M_get_insert_hint_unique_pos(__hint, __nh._M_key());
+     if (__res.second)
+       {
+  __ret = _M_insert_node(__res.first, __res.second, __nh._M_ptr);
+  __nh._M_ptr = nullptr;
+       }
+     else
+       __ret = iterator(__res.first);
+   }
+ return __ret;
+      }
+
+
+      iterator
+      _M_reinsert_node_hint_equal(const_iterator __hint, node_type&& __nh)
+      {
+ iterator __ret;
+ if (__nh.empty())
+   __ret = end();
+ else
+   {
+     ;
+     auto __res = _M_get_insert_hint_equal_pos(__hint, __nh._M_key());
+     if (__res.second)
+       __ret = _M_insert_node(__res.first, __res.second, __nh._M_ptr);
+     else
+       __ret = _M_insert_equal_lower_node(__nh._M_ptr);
+     __nh._M_ptr = nullptr;
+   }
+ return __ret;
+      }
+
+
+      node_type
+      extract(const_iterator __pos)
+      {
+ auto __ptr = _Rb_tree_rebalance_for_erase(
+     __pos._M_const_cast()._M_node, _M_impl._M_header);
+ --_M_impl._M_node_count;
+ return { static_cast<_Link_type>(__ptr), _M_get_Node_allocator() };
+      }
+
+
+      node_type
+      extract(const key_type& __k)
+      {
+ node_type __nh;
+ auto __pos = find(__k);
+ if (__pos != end())
+   __nh = extract(const_iterator(__pos));
+ return __nh;
+      }
+
+      template<typename _Compare2>
+ using _Compatible_tree
+   = _Rb_tree<_Key, _Val, _KeyOfValue, _Compare2, _Alloc>;
+
+      template<typename, typename>
+ friend class _Rb_tree_merge_helper;
+
+
+      template<typename _Compare2>
+ void
+ _M_merge_unique(_Compatible_tree<_Compare2>& __src) noexcept
+ {
+   using _Merge_helper = _Rb_tree_merge_helper<_Rb_tree, _Compare2>;
+   for (auto __i = __src.begin(), __end = __src.end(); __i != __end;)
+     {
+       auto __pos = __i++;
+       auto __res = _M_get_insert_unique_pos(_KeyOfValue()(*__pos));
+       if (__res.second)
+  {
+    auto& __src_impl = _Merge_helper::_S_get_impl(__src);
+    auto __ptr = _Rb_tree_rebalance_for_erase(
+        __pos._M_node, __src_impl._M_header);
+    --__src_impl._M_node_count;
+    _M_insert_node(__res.first, __res.second,
+     static_cast<_Link_type>(__ptr));
+  }
+     }
+ }
+
+
+      template<typename _Compare2>
+ void
+ _M_merge_equal(_Compatible_tree<_Compare2>& __src) noexcept
+ {
+   using _Merge_helper = _Rb_tree_merge_helper<_Rb_tree, _Compare2>;
+   for (auto __i = __src.begin(), __end = __src.end(); __i != __end;)
+     {
+       auto __pos = __i++;
+       auto __res = _M_get_insert_equal_pos(_KeyOfValue()(*__pos));
+       if (__res.second)
+  {
+    auto& __src_impl = _Merge_helper::_S_get_impl(__src);
+    auto __ptr = _Rb_tree_rebalance_for_erase(
+        __pos._M_node, __src_impl._M_header);
+    --__src_impl._M_node_count;
+    _M_insert_node(__res.first, __res.second,
+     static_cast<_Link_type>(__ptr));
+  }
+     }
+ }
+
+
+      friend bool
+      operator==(const _Rb_tree& __x, const _Rb_tree& __y)
+      {
+ return __x.size() == __y.size()
+   && std::equal(__x.begin(), __x.end(), __y.begin());
+      }
+# 1627 "/usr/include/c++/10.2.0/bits/stl_tree.h" 3
+      friend bool
+      operator<(const _Rb_tree& __x, const _Rb_tree& __y)
+      {
+ return std::lexicographical_compare(__x.begin(), __x.end(),
+         __y.begin(), __y.end());
+      }
+
+      friend bool __attribute__ ((__deprecated__))
+      operator!=(const _Rb_tree& __x, const _Rb_tree& __y)
+      { return !(__x == __y); }
+
+      friend bool __attribute__ ((__deprecated__))
+      operator>(const _Rb_tree& __x, const _Rb_tree& __y)
+      { return __y < __x; }
+
+      friend bool __attribute__ ((__deprecated__))
+      operator<=(const _Rb_tree& __x, const _Rb_tree& __y)
+      { return !(__y < __x); }
+
+      friend bool __attribute__ ((__deprecated__))
+      operator>=(const _Rb_tree& __x, const _Rb_tree& __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>
+    void
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _M_move_data(_Rb_tree& __x, false_type)
+    {
+      if (_M_get_Node_allocator() == __x._M_get_Node_allocator())
+ _M_move_data(__x, 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, 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(__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 _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>
+    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;
+    }
+
+
+
+  template<typename _Key, typename _Val, typename _Sel, typename _Cmp1,
+    typename _Alloc, typename _Cmp2>
+    struct _Rb_tree_merge_helper<_Rb_tree<_Key, _Val, _Sel, _Cmp1, _Alloc>,
+     _Cmp2>
+    {
+    private:
+      friend class _Rb_tree<_Key, _Val, _Sel, _Cmp1, _Alloc>;
+
+      static auto&
+      _S_get_impl(_Rb_tree<_Key, _Val, _Sel, _Cmp2, _Alloc>& __tree)
+      { return __tree._M_impl; }
+    };
+
+
+
+}
+# 61 "/usr/include/c++/10.2.0/map" 2 3
+# 1 "/usr/include/c++/10.2.0/bits/stl_map.h" 1 3
+# 57 "/usr/include/c++/10.2.0/bits/stl_map.h" 3
+#define _STL_MAP_H 1
+# 66 "/usr/include/c++/10.2.0/bits/stl_map.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+  template <typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    class multimap;
+# 98 "/usr/include/c++/10.2.0/bits/stl_map.h" 3
+  template <typename _Key, typename _Tp, typename _Compare = std::less<_Key>,
+     typename _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
+    class map
+    {
+    public:
+      typedef _Key key_type;
+      typedef _Tp mapped_type;
+      typedef std::pair<const _Key, _Tp> value_type;
+      typedef _Compare key_compare;
+      typedef _Alloc allocator_type;
+
+    private:
+# 123 "/usr/include/c++/10.2.0/bits/stl_map.h" 3
+      static_assert(is_same<typename _Alloc::value_type, value_type>::value,
+   "std::map must have the same value_type as its allocator");
+
+
+
+    public:
+      class value_compare
+      : public std::binary_function<value_type, value_type, bool>
+      {
+ friend class map<_Key, _Tp, _Compare, _Alloc>;
+      protected:
+ _Compare comp;
+
+ value_compare(_Compare __c)
+ : comp(__c) { }
+
+      public:
+ bool operator()(const value_type& __x, const value_type& __y) const
+ { return comp(__x.first, __y.first); }
+      };
+
+    private:
+
+      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
+ rebind<value_type>::other _Pair_alloc_type;
+
+      typedef _Rb_tree<key_type, value_type, _Select1st<value_type>,
+         key_compare, _Pair_alloc_type> _Rep_type;
+
+
+      _Rep_type _M_t;
+
+      typedef __gnu_cxx::__alloc_traits<_Pair_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::iterator iterator;
+      typedef typename _Rep_type::const_iterator const_iterator;
+      typedef typename _Rep_type::size_type size_type;
+      typedef typename _Rep_type::difference_type difference_type;
+      typedef typename _Rep_type::reverse_iterator reverse_iterator;
+      typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
+
+
+      using node_type = typename _Rep_type::node_type;
+      using insert_return_type = typename _Rep_type::insert_return_type;
+# 185 "/usr/include/c++/10.2.0/bits/stl_map.h" 3
+      map() = default;
+
+
+
+
+
+
+
+      explicit
+      map(const _Compare& __comp,
+   const allocator_type& __a = allocator_type())
+      : _M_t(__comp, _Pair_alloc_type(__a)) { }
+# 207 "/usr/include/c++/10.2.0/bits/stl_map.h" 3
+      map(const map&) = default;
+
+
+
+
+
+
+
+      map(map&&) = default;
+# 228 "/usr/include/c++/10.2.0/bits/stl_map.h" 3
+      map(initializer_list<value_type> __l,
+   const _Compare& __comp = _Compare(),
+   const allocator_type& __a = allocator_type())
+      : _M_t(__comp, _Pair_alloc_type(__a))
+      { _M_t._M_insert_range_unique(__l.begin(), __l.end()); }
+
+
+      explicit
+      map(const allocator_type& __a)
+      : _M_t(_Pair_alloc_type(__a)) { }
+
+
+      map(const map& __m, const allocator_type& __a)
+      : _M_t(__m._M_t, _Pair_alloc_type(__a)) { }
+
+
+      map(map&& __m, const allocator_type& __a)
+      noexcept(is_nothrow_copy_constructible<_Compare>::value
+        && _Alloc_traits::_S_always_equal())
+      : _M_t(std::move(__m._M_t), _Pair_alloc_type(__a)) { }
+
+
+      map(initializer_list<value_type> __l, const allocator_type& __a)
+      : _M_t(_Pair_alloc_type(__a))
+      { _M_t._M_insert_range_unique(__l.begin(), __l.end()); }
+
+
+      template<typename _InputIterator>
+ map(_InputIterator __first, _InputIterator __last,
+     const allocator_type& __a)
+ : _M_t(_Pair_alloc_type(__a))
+ { _M_t._M_insert_range_unique(__first, __last); }
+# 272 "/usr/include/c++/10.2.0/bits/stl_map.h" 3
+      template<typename _InputIterator>
+ map(_InputIterator __first, _InputIterator __last)
+ : _M_t()
+ { _M_t._M_insert_range_unique(__first, __last); }
+# 289 "/usr/include/c++/10.2.0/bits/stl_map.h" 3
+      template<typename _InputIterator>
+ map(_InputIterator __first, _InputIterator __last,
+     const _Compare& __comp,
+     const allocator_type& __a = allocator_type())
+ : _M_t(__comp, _Pair_alloc_type(__a))
+ { _M_t._M_insert_range_unique(__first, __last); }
+
+
+
+
+
+
+
+      ~map() = default;
+# 318 "/usr/include/c++/10.2.0/bits/stl_map.h" 3
+      map&
+      operator=(const map&) = default;
+
+
+      map&
+      operator=(map&&) = default;
+# 336 "/usr/include/c++/10.2.0/bits/stl_map.h" 3
+      map&
+      operator=(initializer_list<value_type> __l)
+      {
+ _M_t._M_assign_unique(__l.begin(), __l.end());
+ return *this;
+      }
+
+
+
+      allocator_type
+      get_allocator() const noexcept
+      { return allocator_type(_M_t.get_allocator()); }
+
+
+
+
+
+
+
+      iterator
+      begin() noexcept
+      { return _M_t.begin(); }
+
+
+
+
+
+
+      const_iterator
+      begin() const noexcept
+      { return _M_t.begin(); }
+
+
+
+
+
+
+      iterator
+      end() noexcept
+      { return _M_t.end(); }
+
+
+
+
+
+
+      const_iterator
+      end() const noexcept
+      { return _M_t.end(); }
+
+
+
+
+
+
+      reverse_iterator
+      rbegin() noexcept
+      { return _M_t.rbegin(); }
+
+
+
+
+
+
+      const_reverse_iterator
+      rbegin() const noexcept
+      { return _M_t.rbegin(); }
+
+
+
+
+
+
+      reverse_iterator
+      rend() noexcept
+      { return _M_t.rend(); }
+
+
+
+
+
+
+      const_reverse_iterator
+      rend() const noexcept
+      { return _M_t.rend(); }
+
+
+
+
+
+
+
+      const_iterator
+      cbegin() const noexcept
+      { return _M_t.begin(); }
+
+
+
+
+
+
+      const_iterator
+      cend() const noexcept
+      { return _M_t.end(); }
+
+
+
+
+
+
+      const_reverse_iterator
+      crbegin() const noexcept
+      { return _M_t.rbegin(); }
+
+
+
+
+
+
+      const_reverse_iterator
+      crend() const noexcept
+      { return _M_t.rend(); }
+
+
+
+
+
+
+      [[__nodiscard__]] 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(); }
+# 491 "/usr/include/c++/10.2.0/bits/stl_map.h" 3
+      mapped_type&
+      operator[](const key_type& __k)
+      {
+
+
+
+ iterator __i = lower_bound(__k);
+
+ if (__i == end() || key_comp()(__k, (*__i).first))
+
+   __i = _M_t._M_emplace_hint_unique(__i, std::piecewise_construct,
+         std::tuple<const key_type&>(__k),
+         std::tuple<>());
+
+
+
+ return (*__i).second;
+      }
+
+
+      mapped_type&
+      operator[](key_type&& __k)
+      {
+
+
+
+ iterator __i = lower_bound(__k);
+
+ if (__i == end() || key_comp()(__k, (*__i).first))
+   __i = _M_t._M_emplace_hint_unique(__i, std::piecewise_construct,
+     std::forward_as_tuple(std::move(__k)),
+     std::tuple<>());
+ return (*__i).second;
+      }
+# 536 "/usr/include/c++/10.2.0/bits/stl_map.h" 3
+      mapped_type&
+      at(const key_type& __k)
+      {
+ iterator __i = lower_bound(__k);
+ if (__i == end() || key_comp()(__k, (*__i).first))
+   __throw_out_of_range(("map::at"));
+ return (*__i).second;
+      }
+
+      const mapped_type&
+      at(const key_type& __k) const
+      {
+ const_iterator __i = lower_bound(__k);
+ if (__i == end() || key_comp()(__k, (*__i).first))
+   __throw_out_of_range(("map::at"));
+ return (*__i).second;
+      }
+# 574 "/usr/include/c++/10.2.0/bits/stl_map.h" 3
+      template<typename... _Args>
+ std::pair<iterator, bool>
+ emplace(_Args&&... __args)
+ { return _M_t._M_emplace_unique(std::forward<_Args>(__args)...); }
+# 604 "/usr/include/c++/10.2.0/bits/stl_map.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)...);
+ }
+
+
+
+
+      node_type
+      extract(const_iterator __pos)
+      {
+ ;
+ return _M_t.extract(__pos);
+      }
+
+
+      node_type
+      extract(const key_type& __x)
+      { return _M_t.extract(__x); }
+
+
+      insert_return_type
+      insert(node_type&& __nh)
+      { return _M_t._M_reinsert_node_unique(std::move(__nh)); }
+
+
+      iterator
+      insert(const_iterator __hint, node_type&& __nh)
+      { return _M_t._M_reinsert_node_hint_unique(__hint, std::move(__nh)); }
+
+      template<typename, typename>
+ friend class std::_Rb_tree_merge_helper;
+
+      template<typename _Cmp2>
+ void
+ merge(map<_Key, _Tp, _Cmp2, _Alloc>& __source)
+ {
+   using _Merge_helper = _Rb_tree_merge_helper<map, _Cmp2>;
+   _M_t._M_merge_unique(_Merge_helper::_S_get_tree(__source));
+ }
+
+      template<typename _Cmp2>
+ void
+ merge(map<_Key, _Tp, _Cmp2, _Alloc>&& __source)
+ { merge(__source); }
+
+      template<typename _Cmp2>
+ void
+ merge(multimap<_Key, _Tp, _Cmp2, _Alloc>& __source)
+ {
+   using _Merge_helper = _Rb_tree_merge_helper<map, _Cmp2>;
+   _M_t._M_merge_unique(_Merge_helper::_S_get_tree(__source));
+ }
+
+      template<typename _Cmp2>
+ void
+ merge(multimap<_Key, _Tp, _Cmp2, _Alloc>&& __source)
+ { merge(__source); }
+
+
+
+#define __cpp_lib_map_try_emplace 201411
+# 689 "/usr/include/c++/10.2.0/bits/stl_map.h" 3
+      template <typename... _Args>
+ pair<iterator, bool>
+ try_emplace(const key_type& __k, _Args&&... __args)
+ {
+   iterator __i = lower_bound(__k);
+   if (__i == end() || key_comp()(__k, (*__i).first))
+     {
+       __i = emplace_hint(__i, std::piecewise_construct,
+     std::forward_as_tuple(__k),
+     std::forward_as_tuple(
+       std::forward<_Args>(__args)...));
+       return {__i, true};
+     }
+   return {__i, false};
+ }
+
+
+      template <typename... _Args>
+ pair<iterator, bool>
+ try_emplace(key_type&& __k, _Args&&... __args)
+ {
+   iterator __i = lower_bound(__k);
+   if (__i == end() || key_comp()(__k, (*__i).first))
+     {
+       __i = emplace_hint(__i, std::piecewise_construct,
+     std::forward_as_tuple(std::move(__k)),
+     std::forward_as_tuple(
+       std::forward<_Args>(__args)...));
+       return {__i, true};
+     }
+   return {__i, false};
+ }
+# 749 "/usr/include/c++/10.2.0/bits/stl_map.h" 3
+      template <typename... _Args>
+ iterator
+ try_emplace(const_iterator __hint, const key_type& __k,
+      _Args&&... __args)
+ {
+   iterator __i;
+   auto __true_hint = _M_t._M_get_insert_hint_unique_pos(__hint, __k);
+   if (__true_hint.second)
+     __i = emplace_hint(iterator(__true_hint.second),
+          std::piecewise_construct,
+          std::forward_as_tuple(__k),
+          std::forward_as_tuple(
+     std::forward<_Args>(__args)...));
+   else
+     __i = iterator(__true_hint.first);
+   return __i;
+ }
+
+
+      template <typename... _Args>
+ iterator
+ try_emplace(const_iterator __hint, key_type&& __k, _Args&&... __args)
+ {
+   iterator __i;
+   auto __true_hint = _M_t._M_get_insert_hint_unique_pos(__hint, __k);
+   if (__true_hint.second)
+     __i = emplace_hint(iterator(__true_hint.second),
+          std::piecewise_construct,
+          std::forward_as_tuple(std::move(__k)),
+          std::forward_as_tuple(
+     std::forward<_Args>(__args)...));
+   else
+     __i = iterator(__true_hint.first);
+   return __i;
+ }
+# 802 "/usr/include/c++/10.2.0/bits/stl_map.h" 3
+      std::pair<iterator, bool>
+      insert(const value_type& __x)
+      { return _M_t._M_insert_unique(__x); }
+
+
+
+
+      std::pair<iterator, bool>
+      insert(value_type&& __x)
+      { return _M_t._M_insert_unique(std::move(__x)); }
+
+      template<typename _Pair>
+ __enable_if_t<is_constructible<value_type, _Pair>::value,
+        pair<iterator, bool>>
+ insert(_Pair&& __x)
+ { return _M_t._M_emplace_unique(std::forward<_Pair>(__x)); }
+# 829 "/usr/include/c++/10.2.0/bits/stl_map.h" 3
+      void
+      insert(std::initializer_list<value_type> __list)
+      { insert(__list.begin(), __list.end()); }
+# 858 "/usr/include/c++/10.2.0/bits/stl_map.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)); }
+
+      template<typename _Pair>
+ __enable_if_t<is_constructible<value_type, _Pair>::value, iterator>
+ insert(const_iterator __position, _Pair&& __x)
+ {
+   return _M_t._M_emplace_hint_unique(__position,
+          std::forward<_Pair>(__x));
+ }
+# 891 "/usr/include/c++/10.2.0/bits/stl_map.h" 3
+      template<typename _InputIterator>
+ void
+ insert(_InputIterator __first, _InputIterator __last)
+ { _M_t._M_insert_range_unique(__first, __last); }
+# 916 "/usr/include/c++/10.2.0/bits/stl_map.h" 3
+      template <typename _Obj>
+ pair<iterator, bool>
+ insert_or_assign(const key_type& __k, _Obj&& __obj)
+ {
+   iterator __i = lower_bound(__k);
+   if (__i == end() || key_comp()(__k, (*__i).first))
+     {
+       __i = emplace_hint(__i, std::piecewise_construct,
+     std::forward_as_tuple(__k),
+     std::forward_as_tuple(
+       std::forward<_Obj>(__obj)));
+       return {__i, true};
+     }
+   (*__i).second = std::forward<_Obj>(__obj);
+   return {__i, false};
+ }
+
+
+      template <typename _Obj>
+ pair<iterator, bool>
+ insert_or_assign(key_type&& __k, _Obj&& __obj)
+ {
+   iterator __i = lower_bound(__k);
+   if (__i == end() || key_comp()(__k, (*__i).first))
+     {
+       __i = emplace_hint(__i, std::piecewise_construct,
+     std::forward_as_tuple(std::move(__k)),
+     std::forward_as_tuple(
+       std::forward<_Obj>(__obj)));
+       return {__i, true};
+     }
+   (*__i).second = std::forward<_Obj>(__obj);
+   return {__i, false};
+ }
+# 971 "/usr/include/c++/10.2.0/bits/stl_map.h" 3
+      template <typename _Obj>
+ iterator
+ insert_or_assign(const_iterator __hint,
+    const key_type& __k, _Obj&& __obj)
+ {
+   iterator __i;
+   auto __true_hint = _M_t._M_get_insert_hint_unique_pos(__hint, __k);
+   if (__true_hint.second)
+     {
+       return emplace_hint(iterator(__true_hint.second),
+      std::piecewise_construct,
+      std::forward_as_tuple(__k),
+      std::forward_as_tuple(
+        std::forward<_Obj>(__obj)));
+     }
+   __i = iterator(__true_hint.first);
+   (*__i).second = std::forward<_Obj>(__obj);
+   return __i;
+ }
+
+
+      template <typename _Obj>
+ iterator
+ insert_or_assign(const_iterator __hint, key_type&& __k, _Obj&& __obj)
+ {
+   iterator __i;
+   auto __true_hint = _M_t._M_get_insert_hint_unique_pos(__hint, __k);
+   if (__true_hint.second)
+     {
+       return emplace_hint(iterator(__true_hint.second),
+      std::piecewise_construct,
+      std::forward_as_tuple(std::move(__k)),
+      std::forward_as_tuple(
+        std::forward<_Obj>(__obj)));
+     }
+   __i = iterator(__true_hint.first);
+   (*__i).second = std::forward<_Obj>(__obj);
+   return __i;
+ }
+# 1030 "/usr/include/c++/10.2.0/bits/stl_map.h" 3
+      iterator
+      erase(const_iterator __position)
+      { return _M_t.erase(__position); }
+
+
+      __attribute ((__abi_tag__ ("cxx11")))
+      iterator
+      erase(iterator __position)
+      { return _M_t.erase(__position); }
+# 1067 "/usr/include/c++/10.2.0/bits/stl_map.h" 3
+      size_type
+      erase(const key_type& __x)
+      { return _M_t.erase(__x); }
+# 1087 "/usr/include/c++/10.2.0/bits/stl_map.h" 3
+      iterator
+      erase(const_iterator __first, const_iterator __last)
+      { return _M_t.erase(__first, __last); }
+# 1121 "/usr/include/c++/10.2.0/bits/stl_map.h" 3
+      void
+      swap(map& __x)
+      noexcept(__is_nothrow_swappable<_Compare>::value)
+      { _M_t.swap(__x._M_t); }
+
+
+
+
+
+
+
+      void
+      clear() noexcept
+      { _M_t.clear(); }
+
+
+
+
+
+
+      key_compare
+      key_comp() const
+      { return _M_t.key_comp(); }
+
+
+
+
+
+      value_compare
+      value_comp() const
+      { return value_compare(_M_t.key_comp()); }
+# 1168 "/usr/include/c++/10.2.0/bits/stl_map.h" 3
+      iterator
+      find(const key_type& __x)
+      { return _M_t.find(__x); }
+
+
+      template<typename _Kt>
+ auto
+ find(const _Kt& __x) -> decltype(_M_t._M_find_tr(__x))
+ { return _M_t._M_find_tr(__x); }
+# 1193 "/usr/include/c++/10.2.0/bits/stl_map.h" 3
+      const_iterator
+      find(const key_type& __x) const
+      { return _M_t.find(__x); }
+
+
+      template<typename _Kt>
+ auto
+ find(const _Kt& __x) const -> decltype(_M_t._M_find_tr(__x))
+ { return _M_t._M_find_tr(__x); }
+# 1214 "/usr/include/c++/10.2.0/bits/stl_map.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); }
+# 1257 "/usr/include/c++/10.2.0/bits/stl_map.h" 3
+      iterator
+      lower_bound(const key_type& __x)
+      { 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)); }
+# 1282 "/usr/include/c++/10.2.0/bits/stl_map.h" 3
+      const_iterator
+      lower_bound(const key_type& __x) const
+      { return _M_t.lower_bound(__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)); }
+# 1302 "/usr/include/c++/10.2.0/bits/stl_map.h" 3
+      iterator
+      upper_bound(const key_type& __x)
+      { 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)); }
+# 1322 "/usr/include/c++/10.2.0/bits/stl_map.h" 3
+      const_iterator
+      upper_bound(const key_type& __x) const
+      { return _M_t.upper_bound(__x); }
+
+
+      template<typename _Kt>
+ auto
+ upper_bound(const _Kt& __x) const
+ -> decltype(const_iterator(_M_t._M_upper_bound_tr(__x)))
+ { return const_iterator(_M_t._M_upper_bound_tr(__x)); }
+# 1351 "/usr/include/c++/10.2.0/bits/stl_map.h" 3
+      std::pair<iterator, iterator>
+      equal_range(const key_type& __x)
+      { 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)); }
+# 1380 "/usr/include/c++/10.2.0/bits/stl_map.h" 3
+      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) const
+ -> decltype(pair<const_iterator, const_iterator>(
+       _M_t._M_equal_range_tr(__x)))
+ {
+   return pair<const_iterator, const_iterator>(
+       _M_t._M_equal_range_tr(__x));
+ }
+
+
+
+      template<typename _K1, typename _T1, typename _C1, typename _A1>
+ friend bool
+ operator==(const map<_K1, _T1, _C1, _A1>&,
+     const map<_K1, _T1, _C1, _A1>&);
+
+
+
+
+
+
+
+      template<typename _K1, typename _T1, typename _C1, typename _A1>
+ friend bool
+ operator<(const map<_K1, _T1, _C1, _A1>&,
+    const map<_K1, _T1, _C1, _A1>&);
+
+    };
+
+
+
+
+  template<typename _InputIterator,
+    typename _Compare = less<__iter_key_t<_InputIterator>>,
+    typename _Allocator = allocator<__iter_to_alloc_t<_InputIterator>>,
+    typename = _RequireInputIter<_InputIterator>,
+    typename = _RequireNotAllocator<_Compare>,
+    typename = _RequireAllocator<_Allocator>>
+    map(_InputIterator, _InputIterator,
+ _Compare = _Compare(), _Allocator = _Allocator())
+    -> map<__iter_key_t<_InputIterator>, __iter_val_t<_InputIterator>,
+    _Compare, _Allocator>;
+
+  template<typename _Key, typename _Tp, typename _Compare = less<_Key>,
+    typename _Allocator = allocator<pair<const _Key, _Tp>>,
+    typename = _RequireNotAllocator<_Compare>,
+    typename = _RequireAllocator<_Allocator>>
+    map(initializer_list<pair<_Key, _Tp>>,
+ _Compare = _Compare(), _Allocator = _Allocator())
+    -> map<_Key, _Tp, _Compare, _Allocator>;
+
+  template <typename _InputIterator, typename _Allocator,
+     typename = _RequireInputIter<_InputIterator>,
+     typename = _RequireAllocator<_Allocator>>
+    map(_InputIterator, _InputIterator, _Allocator)
+    -> map<__iter_key_t<_InputIterator>, __iter_val_t<_InputIterator>,
+    less<__iter_key_t<_InputIterator>>, _Allocator>;
+
+  template<typename _Key, typename _Tp, typename _Allocator,
+    typename = _RequireAllocator<_Allocator>>
+    map(initializer_list<pair<_Key, _Tp>>, _Allocator)
+    -> map<_Key, _Tp, less<_Key>, _Allocator>;
+# 1461 "/usr/include/c++/10.2.0/bits/stl_map.h" 3
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline bool
+    operator==(const map<_Key, _Tp, _Compare, _Alloc>& __x,
+        const map<_Key, _Tp, _Compare, _Alloc>& __y)
+    { return __x._M_t == __y._M_t; }
+# 1499 "/usr/include/c++/10.2.0/bits/stl_map.h" 3
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline bool
+    operator<(const map<_Key, _Tp, _Compare, _Alloc>& __x,
+       const map<_Key, _Tp, _Compare, _Alloc>& __y)
+    { return __x._M_t < __y._M_t; }
+
+
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline bool
+    operator!=(const map<_Key, _Tp, _Compare, _Alloc>& __x,
+        const map<_Key, _Tp, _Compare, _Alloc>& __y)
+    { return !(__x == __y); }
+
+
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline bool
+    operator>(const map<_Key, _Tp, _Compare, _Alloc>& __x,
+       const map<_Key, _Tp, _Compare, _Alloc>& __y)
+    { return __y < __x; }
+
+
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline bool
+    operator<=(const map<_Key, _Tp, _Compare, _Alloc>& __x,
+        const map<_Key, _Tp, _Compare, _Alloc>& __y)
+    { return !(__y < __x); }
+
+
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline bool
+    operator>=(const map<_Key, _Tp, _Compare, _Alloc>& __x,
+        const map<_Key, _Tp, _Compare, _Alloc>& __y)
+    { return !(__x < __y); }
+
+
+
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline void
+    swap(map<_Key, _Tp, _Compare, _Alloc>& __x,
+  map<_Key, _Tp, _Compare, _Alloc>& __y)
+    noexcept(noexcept(__x.swap(__y)))
+    { __x.swap(__y); }
+
+
+
+
+
+  template<typename _Key, typename _Val, typename _Cmp1, typename _Alloc,
+    typename _Cmp2>
+    struct
+    _Rb_tree_merge_helper<std::map<_Key, _Val, _Cmp1, _Alloc>,
+     _Cmp2>
+    {
+    private:
+      friend class std::map<_Key, _Val, _Cmp1, _Alloc>;
+
+      static auto&
+      _S_get_tree(std::map<_Key, _Val, _Cmp2, _Alloc>& __map)
+      { return __map._M_t; }
+
+      static auto&
+      _S_get_tree(std::multimap<_Key, _Val, _Cmp2, _Alloc>& __map)
+      { return __map._M_t; }
+    };
+
+
+
+}
+# 62 "/usr/include/c++/10.2.0/map" 2 3
+# 1 "/usr/include/c++/10.2.0/bits/stl_multimap.h" 1 3
+# 57 "/usr/include/c++/10.2.0/bits/stl_multimap.h" 3
+#define _STL_MULTIMAP_H 1
+
+
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+  template <typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    class map;
+# 96 "/usr/include/c++/10.2.0/bits/stl_multimap.h" 3
+  template <typename _Key, typename _Tp,
+     typename _Compare = std::less<_Key>,
+     typename _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
+    class multimap
+    {
+    public:
+      typedef _Key key_type;
+      typedef _Tp mapped_type;
+      typedef std::pair<const _Key, _Tp> value_type;
+      typedef _Compare key_compare;
+      typedef _Alloc allocator_type;
+
+    private:
+# 122 "/usr/include/c++/10.2.0/bits/stl_multimap.h" 3
+      static_assert(is_same<typename _Alloc::value_type, value_type>::value,
+   "std::multimap must have the same value_type as its allocator");
+
+
+
+    public:
+      class value_compare
+      : public std::binary_function<value_type, value_type, bool>
+      {
+ friend class multimap<_Key, _Tp, _Compare, _Alloc>;
+      protected:
+ _Compare comp;
+
+ value_compare(_Compare __c)
+ : comp(__c) { }
+
+      public:
+ bool operator()(const value_type& __x, const value_type& __y) const
+ { return comp(__x.first, __y.first); }
+      };
+
+    private:
+
+      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
+ rebind<value_type>::other _Pair_alloc_type;
+
+      typedef _Rb_tree<key_type, value_type, _Select1st<value_type>,
+         key_compare, _Pair_alloc_type> _Rep_type;
+
+      _Rep_type _M_t;
+
+      typedef __gnu_cxx::__alloc_traits<_Pair_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::iterator iterator;
+      typedef typename _Rep_type::const_iterator const_iterator;
+      typedef typename _Rep_type::size_type size_type;
+      typedef typename _Rep_type::difference_type difference_type;
+      typedef typename _Rep_type::reverse_iterator reverse_iterator;
+      typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
+
+
+      using node_type = typename _Rep_type::node_type;
+# 182 "/usr/include/c++/10.2.0/bits/stl_multimap.h" 3
+      multimap() = default;
+
+
+
+
+
+
+
+      explicit
+      multimap(const _Compare& __comp,
+        const allocator_type& __a = allocator_type())
+      : _M_t(__comp, _Pair_alloc_type(__a)) { }
+# 204 "/usr/include/c++/10.2.0/bits/stl_multimap.h" 3
+      multimap(const multimap&) = default;
+# 213 "/usr/include/c++/10.2.0/bits/stl_multimap.h" 3
+      multimap(multimap&&) = default;
+# 225 "/usr/include/c++/10.2.0/bits/stl_multimap.h" 3
+      multimap(initializer_list<value_type> __l,
+        const _Compare& __comp = _Compare(),
+        const allocator_type& __a = allocator_type())
+      : _M_t(__comp, _Pair_alloc_type(__a))
+      { _M_t._M_insert_range_equal(__l.begin(), __l.end()); }
+
+
+      explicit
+      multimap(const allocator_type& __a)
+      : _M_t(_Pair_alloc_type(__a)) { }
+
+
+      multimap(const multimap& __m, const allocator_type& __a)
+      : _M_t(__m._M_t, _Pair_alloc_type(__a)) { }
+
+
+      multimap(multimap&& __m, const allocator_type& __a)
+      noexcept(is_nothrow_copy_constructible<_Compare>::value
+        && _Alloc_traits::_S_always_equal())
+      : _M_t(std::move(__m._M_t), _Pair_alloc_type(__a)) { }
+
+
+      multimap(initializer_list<value_type> __l, const allocator_type& __a)
+      : _M_t(_Pair_alloc_type(__a))
+      { _M_t._M_insert_range_equal(__l.begin(), __l.end()); }
+
+
+      template<typename _InputIterator>
+ multimap(_InputIterator __first, _InputIterator __last,
+   const allocator_type& __a)
+ : _M_t(_Pair_alloc_type(__a))
+ { _M_t._M_insert_range_equal(__first, __last); }
+# 268 "/usr/include/c++/10.2.0/bits/stl_multimap.h" 3
+      template<typename _InputIterator>
+ multimap(_InputIterator __first, _InputIterator __last)
+ : _M_t()
+ { _M_t._M_insert_range_equal(__first, __last); }
+# 284 "/usr/include/c++/10.2.0/bits/stl_multimap.h" 3
+      template<typename _InputIterator>
+ multimap(_InputIterator __first, _InputIterator __last,
+   const _Compare& __comp,
+   const allocator_type& __a = allocator_type())
+ : _M_t(__comp, _Pair_alloc_type(__a))
+ { _M_t._M_insert_range_equal(__first, __last); }
+
+
+
+
+
+
+
+      ~multimap() = default;
+# 313 "/usr/include/c++/10.2.0/bits/stl_multimap.h" 3
+      multimap&
+      operator=(const multimap&) = default;
+
+
+      multimap&
+      operator=(multimap&&) = default;
+# 331 "/usr/include/c++/10.2.0/bits/stl_multimap.h" 3
+      multimap&
+      operator=(initializer_list<value_type> __l)
+      {
+ _M_t._M_assign_equal(__l.begin(), __l.end());
+ return *this;
+      }
+
+
+
+      allocator_type
+      get_allocator() const noexcept
+      { return allocator_type(_M_t.get_allocator()); }
+
+
+
+
+
+
+
+      iterator
+      begin() noexcept
+      { return _M_t.begin(); }
+
+
+
+
+
+
+      const_iterator
+      begin() const noexcept
+      { return _M_t.begin(); }
+
+
+
+
+
+
+      iterator
+      end() noexcept
+      { return _M_t.end(); }
+
+
+
+
+
+
+      const_iterator
+      end() const noexcept
+      { return _M_t.end(); }
+
+
+
+
+
+
+      reverse_iterator
+      rbegin() noexcept
+      { return _M_t.rbegin(); }
+
+
+
+
+
+
+      const_reverse_iterator
+      rbegin() const noexcept
+      { return _M_t.rbegin(); }
+
+
+
+
+
+
+      reverse_iterator
+      rend() noexcept
+      { return _M_t.rend(); }
+
+
+
+
+
+
+      const_reverse_iterator
+      rend() const noexcept
+      { return _M_t.rend(); }
+
+
+
+
+
+
+
+      const_iterator
+      cbegin() const noexcept
+      { return _M_t.begin(); }
+
+
+
+
+
+
+      const_iterator
+      cend() const noexcept
+      { return _M_t.end(); }
+
+
+
+
+
+
+      const_reverse_iterator
+      crbegin() const noexcept
+      { return _M_t.rbegin(); }
+
+
+
+
+
+
+      const_reverse_iterator
+      crend() const noexcept
+      { return _M_t.rend(); }
+
+
+
+
+      [[__nodiscard__]] 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(); }
+# 489 "/usr/include/c++/10.2.0/bits/stl_multimap.h" 3
+      template<typename... _Args>
+ iterator
+ emplace(_Args&&... __args)
+ { return _M_t._M_emplace_equal(std::forward<_Args>(__args)...); }
+# 516 "/usr/include/c++/10.2.0/bits/stl_multimap.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)...);
+ }
+# 538 "/usr/include/c++/10.2.0/bits/stl_multimap.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)); }
+
+      template<typename _Pair>
+ __enable_if_t<is_constructible<value_type, _Pair>::value, iterator>
+ insert(_Pair&& __x)
+ { return _M_t._M_emplace_equal(std::forward<_Pair>(__x)); }
+# 577 "/usr/include/c++/10.2.0/bits/stl_multimap.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)); }
+
+      template<typename _Pair>
+ __enable_if_t<is_constructible<value_type, _Pair&&>::value, iterator>
+ insert(const_iterator __position, _Pair&& __x)
+ {
+   return _M_t._M_emplace_hint_equal(__position,
+         std::forward<_Pair>(__x));
+ }
+# 611 "/usr/include/c++/10.2.0/bits/stl_multimap.h" 3
+      template<typename _InputIterator>
+ void
+ insert(_InputIterator __first, _InputIterator __last)
+ { _M_t._M_insert_range_equal(__first, __last); }
+# 624 "/usr/include/c++/10.2.0/bits/stl_multimap.h" 3
+      void
+      insert(initializer_list<value_type> __l)
+      { this->insert(__l.begin(), __l.end()); }
+
+
+
+
+      node_type
+      extract(const_iterator __pos)
+      {
+ ;
+ return _M_t.extract(__pos);
+      }
+
+
+      node_type
+      extract(const key_type& __x)
+      { return _M_t.extract(__x); }
+
+
+      iterator
+      insert(node_type&& __nh)
+      { return _M_t._M_reinsert_node_equal(std::move(__nh)); }
+
+
+      iterator
+      insert(const_iterator __hint, node_type&& __nh)
+      { return _M_t._M_reinsert_node_hint_equal(__hint, std::move(__nh)); }
+
+      template<typename, typename>
+ friend class std::_Rb_tree_merge_helper;
+
+      template<typename _Cmp2>
+ void
+ merge(multimap<_Key, _Tp, _Cmp2, _Alloc>& __source)
+ {
+   using _Merge_helper = _Rb_tree_merge_helper<multimap, _Cmp2>;
+   _M_t._M_merge_equal(_Merge_helper::_S_get_tree(__source));
+ }
+
+      template<typename _Cmp2>
+ void
+ merge(multimap<_Key, _Tp, _Cmp2, _Alloc>&& __source)
+ { merge(__source); }
+
+      template<typename _Cmp2>
+ void
+ merge(map<_Key, _Tp, _Cmp2, _Alloc>& __source)
+ {
+   using _Merge_helper = _Rb_tree_merge_helper<multimap, _Cmp2>;
+   _M_t._M_merge_equal(_Merge_helper::_S_get_tree(__source));
+ }
+
+      template<typename _Cmp2>
+ void
+ merge(map<_Key, _Tp, _Cmp2, _Alloc>&& __source)
+ { merge(__source); }
+# 701 "/usr/include/c++/10.2.0/bits/stl_multimap.h" 3
+      iterator
+      erase(const_iterator __position)
+      { return _M_t.erase(__position); }
+
+
+      __attribute ((__abi_tag__ ("cxx11")))
+      iterator
+      erase(iterator __position)
+      { return _M_t.erase(__position); }
+# 738 "/usr/include/c++/10.2.0/bits/stl_multimap.h" 3
+      size_type
+      erase(const key_type& __x)
+      { return _M_t.erase(__x); }
+# 759 "/usr/include/c++/10.2.0/bits/stl_multimap.h" 3
+      iterator
+      erase(const_iterator __first, const_iterator __last)
+      { return _M_t.erase(__first, __last); }
+# 796 "/usr/include/c++/10.2.0/bits/stl_multimap.h" 3
+      void
+      swap(multimap& __x)
+      noexcept(__is_nothrow_swappable<_Compare>::value)
+      { _M_t.swap(__x._M_t); }
+
+
+
+
+
+
+
+      void
+      clear() noexcept
+      { _M_t.clear(); }
+
+
+
+
+
+
+      key_compare
+      key_comp() const
+      { return _M_t.key_comp(); }
+
+
+
+
+
+      value_compare
+      value_comp() const
+      { return value_compare(_M_t.key_comp()); }
+# 842 "/usr/include/c++/10.2.0/bits/stl_multimap.h" 3
+      iterator
+      find(const key_type& __x)
+      { return _M_t.find(__x); }
+
+
+      template<typename _Kt>
+ auto
+ find(const _Kt& __x) -> decltype(_M_t._M_find_tr(__x))
+ { return _M_t._M_find_tr(__x); }
+# 866 "/usr/include/c++/10.2.0/bits/stl_multimap.h" 3
+      const_iterator
+      find(const key_type& __x) const
+      { return _M_t.find(__x); }
+
+
+      template<typename _Kt>
+ auto
+ find(const _Kt& __x) const -> decltype(_M_t._M_find_tr(__x))
+ { return _M_t._M_find_tr(__x); }
+# 884 "/usr/include/c++/10.2.0/bits/stl_multimap.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); }
+# 927 "/usr/include/c++/10.2.0/bits/stl_multimap.h" 3
+      iterator
+      lower_bound(const key_type& __x)
+      { 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)); }
+# 952 "/usr/include/c++/10.2.0/bits/stl_multimap.h" 3
+      const_iterator
+      lower_bound(const key_type& __x) const
+      { return _M_t.lower_bound(__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)); }
+# 972 "/usr/include/c++/10.2.0/bits/stl_multimap.h" 3
+      iterator
+      upper_bound(const key_type& __x)
+      { 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)); }
+# 992 "/usr/include/c++/10.2.0/bits/stl_multimap.h" 3
+      const_iterator
+      upper_bound(const key_type& __x) const
+      { return _M_t.upper_bound(__x); }
+
+
+      template<typename _Kt>
+ auto
+ upper_bound(const _Kt& __x) const
+ -> decltype(const_iterator(_M_t._M_upper_bound_tr(__x)))
+ { return const_iterator(_M_t._M_upper_bound_tr(__x)); }
+# 1019 "/usr/include/c++/10.2.0/bits/stl_multimap.h" 3
+      std::pair<iterator, iterator>
+      equal_range(const key_type& __x)
+      { 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)); }
+# 1046 "/usr/include/c++/10.2.0/bits/stl_multimap.h" 3
+      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) const
+ -> decltype(pair<const_iterator, const_iterator>(
+       _M_t._M_equal_range_tr(__x)))
+ {
+   return pair<const_iterator, const_iterator>(
+       _M_t._M_equal_range_tr(__x));
+ }
+
+
+
+      template<typename _K1, typename _T1, typename _C1, typename _A1>
+ friend bool
+ operator==(const multimap<_K1, _T1, _C1, _A1>&,
+     const multimap<_K1, _T1, _C1, _A1>&);
+
+
+
+
+
+
+
+      template<typename _K1, typename _T1, typename _C1, typename _A1>
+ friend bool
+ operator<(const multimap<_K1, _T1, _C1, _A1>&,
+    const multimap<_K1, _T1, _C1, _A1>&);
+
+  };
+
+
+
+  template<typename _InputIterator,
+    typename _Compare = less<__iter_key_t<_InputIterator>>,
+    typename _Allocator = allocator<__iter_to_alloc_t<_InputIterator>>,
+    typename = _RequireInputIter<_InputIterator>,
+    typename = _RequireNotAllocator<_Compare>,
+    typename = _RequireAllocator<_Allocator>>
+    multimap(_InputIterator, _InputIterator,
+      _Compare = _Compare(), _Allocator = _Allocator())
+    -> multimap<__iter_key_t<_InputIterator>, __iter_val_t<_InputIterator>,
+  _Compare, _Allocator>;
+
+  template<typename _Key, typename _Tp, typename _Compare = less<_Key>,
+    typename _Allocator = allocator<pair<const _Key, _Tp>>,
+    typename = _RequireNotAllocator<_Compare>,
+    typename = _RequireAllocator<_Allocator>>
+    multimap(initializer_list<pair<_Key, _Tp>>,
+      _Compare = _Compare(), _Allocator = _Allocator())
+    -> multimap<_Key, _Tp, _Compare, _Allocator>;
+
+  template<typename _InputIterator, typename _Allocator,
+    typename = _RequireInputIter<_InputIterator>,
+    typename = _RequireAllocator<_Allocator>>
+    multimap(_InputIterator, _InputIterator, _Allocator)
+    -> multimap<__iter_key_t<_InputIterator>, __iter_val_t<_InputIterator>,
+  less<__iter_key_t<_InputIterator>>, _Allocator>;
+
+  template<typename _Key, typename _Tp, typename _Allocator,
+    typename = _RequireAllocator<_Allocator>>
+    multimap(initializer_list<pair<_Key, _Tp>>, _Allocator)
+    -> multimap<_Key, _Tp, less<_Key>, _Allocator>;
+# 1126 "/usr/include/c++/10.2.0/bits/stl_multimap.h" 3
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline bool
+    operator==(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
+        const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
+    { return __x._M_t == __y._M_t; }
+# 1164 "/usr/include/c++/10.2.0/bits/stl_multimap.h" 3
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline bool
+    operator<(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
+       const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
+    { return __x._M_t < __y._M_t; }
+
+
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline bool
+    operator!=(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
+        const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
+    { return !(__x == __y); }
+
+
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline bool
+    operator>(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
+       const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
+    { return __y < __x; }
+
+
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline bool
+    operator<=(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
+        const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
+    { return !(__y < __x); }
+
+
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline bool
+    operator>=(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
+        const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
+    { return !(__x < __y); }
+
+
+
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline void
+    swap(multimap<_Key, _Tp, _Compare, _Alloc>& __x,
+  multimap<_Key, _Tp, _Compare, _Alloc>& __y)
+    noexcept(noexcept(__x.swap(__y)))
+    { __x.swap(__y); }
+
+
+
+
+
+  template<typename _Key, typename _Val, typename _Cmp1, typename _Alloc,
+    typename _Cmp2>
+    struct
+    _Rb_tree_merge_helper<std::multimap<_Key, _Val, _Cmp1, _Alloc>,
+     _Cmp2>
+    {
+    private:
+      friend class std::multimap<_Key, _Val, _Cmp1, _Alloc>;
+
+      static auto&
+      _S_get_tree(std::map<_Key, _Val, _Cmp2, _Alloc>& __map)
+      { return __map._M_t; }
+
+      static auto&
+      _S_get_tree(std::multimap<_Key, _Val, _Cmp2, _Alloc>& __map)
+      { return __map._M_t; }
+    };
+
+
+
+}
+# 63 "/usr/include/c++/10.2.0/map" 2 3
+# 71 "/usr/include/c++/10.2.0/map" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  namespace pmr
+  {
+    template<typename _Tp> class polymorphic_allocator;
+    template<typename _Key, typename _Tp, typename _Cmp = std::less<_Key>>
+      using map
+ = std::map<_Key, _Tp, _Cmp,
+     polymorphic_allocator<pair<const _Key, _Tp>>>;
+    template<typename _Key, typename _Tp, typename _Cmp = std::less<_Key>>
+      using multimap
+ = std::multimap<_Key, _Tp, _Cmp,
+   polymorphic_allocator<pair<const _Key, _Tp>>>;
+  }
+
+}
+# 28 "/usr/include/boost/test/utils/runtime/fwd.hpp" 2 3 4
+
+namespace boost {
+namespace runtime {
+
+typedef unit_test::const_string cstring;
+
+class argument;
+typedef shared_ptr<argument> argument_ptr;
+
+template<typename T> class typed_argument;
+
+class basic_param;
+typedef shared_ptr<basic_param> basic_param_ptr;
+
+}
+}
+# 20 "/usr/include/boost/test/utils/runtime/argument.hpp" 2 3 4
+# 1 "/usr/include/boost/test/utils/runtime/errors.hpp" 1 3 4
+# 16 "/usr/include/boost/test/utils/runtime/errors.hpp" 3 4
+#define BOOST_TEST_UTILS_RUNTIME_INIT_ERROR_HPP 
+
+
+
+
+
+# 1 "/usr/include/boost/test/utils/string_cast.hpp" 1 3 4
+# 16 "/usr/include/boost/test/utils/string_cast.hpp" 3 4
+#define BOOST_TEST_UTILS_STRING_CAST_HPP 
+
+
+
+
+
+# 1 "/usr/include/c++/10.2.0/sstream" 1 3 4
+# 34 "/usr/include/c++/10.2.0/sstream" 3 4
+#define _GLIBCXX_SSTREAM 1
+
+       
+# 37 "/usr/include/c++/10.2.0/sstream" 3
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+namespace __cxx11 {
+# 64 "/usr/include/c++/10.2.0/sstream" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    class basic_stringbuf : public basic_streambuf<_CharT, _Traits>
+    {
+      struct __xfer_bufptrs;
+    public:
+
+      typedef _CharT char_type;
+      typedef _Traits traits_type;
+
+
+      typedef _Alloc allocator_type;
+      typedef typename traits_type::int_type int_type;
+      typedef typename traits_type::pos_type pos_type;
+      typedef typename traits_type::off_type off_type;
+
+      typedef basic_streambuf<char_type, traits_type> __streambuf_type;
+      typedef basic_string<char_type, _Traits, _Alloc> __string_type;
+      typedef typename __string_type::size_type __size_type;
+
+    protected:
+
+      ios_base::openmode _M_mode;
+
+
+      __string_type _M_string;
+
+    public:
+# 99 "/usr/include/c++/10.2.0/sstream" 3
+      basic_stringbuf()
+      : __streambuf_type(), _M_mode(ios_base::in | ios_base::out), _M_string()
+      { }
+# 110 "/usr/include/c++/10.2.0/sstream" 3
+      explicit
+      basic_stringbuf(ios_base::openmode __mode)
+      : __streambuf_type(), _M_mode(__mode), _M_string()
+      { }
+# 123 "/usr/include/c++/10.2.0/sstream" 3
+      explicit
+      basic_stringbuf(const __string_type& __str,
+        ios_base::openmode __mode = ios_base::in | ios_base::out)
+      : __streambuf_type(), _M_mode(),
+ _M_string(__str.data(), __str.size(), __str.get_allocator())
+      { _M_stringbuf_init(__mode); }
+
+
+      basic_stringbuf(const basic_stringbuf&) = delete;
+
+      basic_stringbuf(basic_stringbuf&& __rhs)
+      : basic_stringbuf(std::move(__rhs), __xfer_bufptrs(__rhs, this))
+      { __rhs._M_sync(const_cast<char_type*>(__rhs._M_string.data()), 0, 0); }
+
+
+
+      basic_stringbuf&
+      operator=(const basic_stringbuf&) = delete;
+
+      basic_stringbuf&
+      operator=(basic_stringbuf&& __rhs)
+      {
+ __xfer_bufptrs __st{__rhs, this};
+ const __streambuf_type& __base = __rhs;
+ __streambuf_type::operator=(__base);
+ this->pubimbue(__rhs.getloc());
+ _M_mode = __rhs._M_mode;
+ _M_string = std::move(__rhs._M_string);
+ __rhs._M_sync(const_cast<char_type*>(__rhs._M_string.data()), 0, 0);
+ return *this;
+      }
+
+      void
+      swap(basic_stringbuf& __rhs)
+      {
+ __xfer_bufptrs __l_st{*this, std::__addressof(__rhs)};
+ __xfer_bufptrs __r_st{__rhs, this};
+ __streambuf_type& __base = __rhs;
+ __streambuf_type::swap(__base);
+ __rhs.pubimbue(this->pubimbue(__rhs.getloc()));
+ std::swap(_M_mode, __rhs._M_mode);
+ std::swap(_M_string, __rhs._M_string);
+      }
+# 177 "/usr/include/c++/10.2.0/sstream" 3
+      __string_type
+      str() const
+      {
+ __string_type __ret(_M_string.get_allocator());
+ if (this->pptr())
+   {
+
+     if (this->pptr() > this->egptr())
+       __ret.assign(this->pbase(), this->pptr());
+     else
+       __ret.assign(this->pbase(), this->egptr());
+   }
+ else
+   __ret = _M_string;
+ return __ret;
+      }
+# 201 "/usr/include/c++/10.2.0/sstream" 3
+      void
+      str(const __string_type& __s)
+      {
+
+
+ _M_string.assign(__s.data(), __s.size());
+ _M_stringbuf_init(_M_mode);
+      }
+
+    protected:
+
+      void
+      _M_stringbuf_init(ios_base::openmode __mode)
+      {
+ _M_mode = __mode;
+ __size_type __len = 0;
+ if (_M_mode & (ios_base::ate | ios_base::app))
+   __len = _M_string.size();
+ _M_sync(const_cast<char_type*>(_M_string.data()), 0, __len);
+      }
+
+      virtual streamsize
+      showmanyc()
+      {
+ streamsize __ret = -1;
+ if (_M_mode & ios_base::in)
+   {
+     _M_update_egptr();
+     __ret = this->egptr() - this->gptr();
+   }
+ return __ret;
+      }
+
+      virtual int_type
+      underflow();
+
+      virtual int_type
+      pbackfail(int_type __c = traits_type::eof());
+
+      virtual int_type
+      overflow(int_type __c = traits_type::eof());
+# 254 "/usr/include/c++/10.2.0/sstream" 3
+      virtual __streambuf_type*
+      setbuf(char_type* __s, streamsize __n)
+      {
+ if (__s && __n >= 0)
+   {
+
+
+
+
+
+
+     _M_string.clear();
+
+
+     _M_sync(__s, __n, 0);
+   }
+ return this;
+      }
+
+      virtual pos_type
+      seekoff(off_type __off, ios_base::seekdir __way,
+       ios_base::openmode __mode = ios_base::in | ios_base::out);
+
+      virtual pos_type
+      seekpos(pos_type __sp,
+       ios_base::openmode __mode = ios_base::in | ios_base::out);
+
+
+
+
+      void
+      _M_sync(char_type* __base, __size_type __i, __size_type __o);
+
+
+
+      void
+      _M_update_egptr()
+      {
+ const bool __testin = _M_mode & ios_base::in;
+ if (this->pptr() && this->pptr() > this->egptr())
+   {
+     if (__testin)
+       this->setg(this->eback(), this->gptr(), this->pptr());
+     else
+       this->setg(this->pptr(), this->pptr(), this->pptr());
+   }
+      }
+
+
+
+      void
+      _M_pbump(char_type* __pbeg, char_type* __pend, off_type __off);
+
+    private:
+
+
+
+
+      struct __xfer_bufptrs
+      {
+ __xfer_bufptrs(const basic_stringbuf& __from, basic_stringbuf* __to)
+ : _M_to{__to}, _M_goff{-1, -1, -1}, _M_poff{-1, -1, -1}
+ {
+   const _CharT* const __str = __from._M_string.data();
+   const _CharT* __end = nullptr;
+   if (__from.eback())
+     {
+       _M_goff[0] = __from.eback() - __str;
+       _M_goff[1] = __from.gptr() - __str;
+       _M_goff[2] = __from.egptr() - __str;
+       __end = __from.egptr();
+     }
+   if (__from.pbase())
+     {
+       _M_poff[0] = __from.pbase() - __str;
+       _M_poff[1] = __from.pptr() - __from.pbase();
+       _M_poff[2] = __from.epptr() - __str;
+       if (__from.pptr() > __end)
+  __end = __from.pptr();
+     }
+
+
+   if (__end)
+     {
+
+
+       auto& __mut_from = const_cast<basic_stringbuf&>(__from);
+       __mut_from._M_string._M_length(__end - __str);
+     }
+ }
+
+ ~__xfer_bufptrs()
+ {
+   char_type* __str = const_cast<char_type*>(_M_to->_M_string.data());
+   if (_M_goff[0] != -1)
+     _M_to->setg(__str+_M_goff[0], __str+_M_goff[1], __str+_M_goff[2]);
+   if (_M_poff[0] != -1)
+     _M_to->_M_pbump(__str+_M_poff[0], __str+_M_poff[2], _M_poff[1]);
+ }
+
+ basic_stringbuf* _M_to;
+ off_type _M_goff[3];
+ off_type _M_poff[3];
+      };
+# 368 "/usr/include/c++/10.2.0/sstream" 3
+      basic_stringbuf(basic_stringbuf&& __rhs, __xfer_bufptrs&&)
+      : __streambuf_type(static_cast<const __streambuf_type&>(__rhs)),
+      _M_mode(__rhs._M_mode), _M_string(std::move(__rhs._M_string))
+      { }
+
+    };
+# 391 "/usr/include/c++/10.2.0/sstream" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    class basic_istringstream : public basic_istream<_CharT, _Traits>
+    {
+    public:
+
+      typedef _CharT char_type;
+      typedef _Traits traits_type;
+
+
+      typedef _Alloc allocator_type;
+      typedef typename traits_type::int_type int_type;
+      typedef typename traits_type::pos_type pos_type;
+      typedef typename traits_type::off_type off_type;
+
+
+      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
+      typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type;
+      typedef basic_istream<char_type, traits_type> __istream_type;
+
+    private:
+      __stringbuf_type _M_stringbuf;
+
+    public:
+# 425 "/usr/include/c++/10.2.0/sstream" 3
+      basic_istringstream()
+      : __istream_type(), _M_stringbuf(ios_base::in)
+      { this->init(&_M_stringbuf); }
+# 441 "/usr/include/c++/10.2.0/sstream" 3
+      explicit
+      basic_istringstream(ios_base::openmode __mode)
+      : __istream_type(), _M_stringbuf(__mode | ios_base::in)
+      { this->init(&_M_stringbuf); }
+# 459 "/usr/include/c++/10.2.0/sstream" 3
+      explicit
+      basic_istringstream(const __string_type& __str,
+     ios_base::openmode __mode = ios_base::in)
+      : __istream_type(), _M_stringbuf(__str, __mode | ios_base::in)
+      { this->init(&_M_stringbuf); }
+
+
+
+
+
+
+
+      ~basic_istringstream()
+      { }
+
+
+      basic_istringstream(const basic_istringstream&) = delete;
+
+      basic_istringstream(basic_istringstream&& __rhs)
+      : __istream_type(std::move(__rhs)),
+      _M_stringbuf(std::move(__rhs._M_stringbuf))
+      { __istream_type::set_rdbuf(&_M_stringbuf); }
+
+
+
+      basic_istringstream&
+      operator=(const basic_istringstream&) = delete;
+
+      basic_istringstream&
+      operator=(basic_istringstream&& __rhs)
+      {
+ __istream_type::operator=(std::move(__rhs));
+ _M_stringbuf = std::move(__rhs._M_stringbuf);
+ return *this;
+      }
+
+      void
+      swap(basic_istringstream& __rhs)
+      {
+ __istream_type::swap(__rhs);
+ _M_stringbuf.swap(__rhs._M_stringbuf);
+      }
+# 510 "/usr/include/c++/10.2.0/sstream" 3
+      __stringbuf_type*
+      rdbuf() const
+      { return const_cast<__stringbuf_type*>(&_M_stringbuf); }
+
+
+
+
+
+      __string_type
+      str() const
+      { return _M_stringbuf.str(); }
+
+
+
+
+
+
+
+      void
+      str(const __string_type& __s)
+      { _M_stringbuf.str(__s); }
+    };
+# 549 "/usr/include/c++/10.2.0/sstream" 3
+  template <typename _CharT, typename _Traits, typename _Alloc>
+    class basic_ostringstream : public basic_ostream<_CharT, _Traits>
+    {
+    public:
+
+      typedef _CharT char_type;
+      typedef _Traits traits_type;
+
+
+      typedef _Alloc allocator_type;
+      typedef typename traits_type::int_type int_type;
+      typedef typename traits_type::pos_type pos_type;
+      typedef typename traits_type::off_type off_type;
+
+
+      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
+      typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type;
+      typedef basic_ostream<char_type, traits_type> __ostream_type;
+
+    private:
+      __stringbuf_type _M_stringbuf;
+
+    public:
+# 583 "/usr/include/c++/10.2.0/sstream" 3
+      basic_ostringstream()
+      : __ostream_type(), _M_stringbuf(ios_base::out)
+      { this->init(&_M_stringbuf); }
+# 599 "/usr/include/c++/10.2.0/sstream" 3
+      explicit
+      basic_ostringstream(ios_base::openmode __mode)
+      : __ostream_type(), _M_stringbuf(__mode | ios_base::out)
+      { this->init(&_M_stringbuf); }
+# 617 "/usr/include/c++/10.2.0/sstream" 3
+      explicit
+      basic_ostringstream(const __string_type& __str,
+     ios_base::openmode __mode = ios_base::out)
+      : __ostream_type(), _M_stringbuf(__str, __mode | ios_base::out)
+      { this->init(&_M_stringbuf); }
+
+
+
+
+
+
+
+      ~basic_ostringstream()
+      { }
+
+
+      basic_ostringstream(const basic_ostringstream&) = delete;
+
+      basic_ostringstream(basic_ostringstream&& __rhs)
+      : __ostream_type(std::move(__rhs)),
+      _M_stringbuf(std::move(__rhs._M_stringbuf))
+      { __ostream_type::set_rdbuf(&_M_stringbuf); }
+
+
+
+      basic_ostringstream&
+      operator=(const basic_ostringstream&) = delete;
+
+      basic_ostringstream&
+      operator=(basic_ostringstream&& __rhs)
+      {
+ __ostream_type::operator=(std::move(__rhs));
+ _M_stringbuf = std::move(__rhs._M_stringbuf);
+ return *this;
+      }
+
+      void
+      swap(basic_ostringstream& __rhs)
+      {
+ __ostream_type::swap(__rhs);
+ _M_stringbuf.swap(__rhs._M_stringbuf);
+      }
+# 668 "/usr/include/c++/10.2.0/sstream" 3
+      __stringbuf_type*
+      rdbuf() const
+      { return const_cast<__stringbuf_type*>(&_M_stringbuf); }
+
+
+
+
+
+      __string_type
+      str() const
+      { return _M_stringbuf.str(); }
+
+
+
+
+
+
+
+      void
+      str(const __string_type& __s)
+      { _M_stringbuf.str(__s); }
+    };
+# 707 "/usr/include/c++/10.2.0/sstream" 3
+  template <typename _CharT, typename _Traits, typename _Alloc>
+    class basic_stringstream : public basic_iostream<_CharT, _Traits>
+    {
+    public:
+
+      typedef _CharT char_type;
+      typedef _Traits traits_type;
+
+
+      typedef _Alloc allocator_type;
+      typedef typename traits_type::int_type int_type;
+      typedef typename traits_type::pos_type pos_type;
+      typedef typename traits_type::off_type off_type;
+
+
+      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
+      typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type;
+      typedef basic_iostream<char_type, traits_type> __iostream_type;
+
+    private:
+      __stringbuf_type _M_stringbuf;
+
+    public:
+# 741 "/usr/include/c++/10.2.0/sstream" 3
+      basic_stringstream()
+      : __iostream_type(), _M_stringbuf(ios_base::out | ios_base::in)
+      { this->init(&_M_stringbuf); }
+# 755 "/usr/include/c++/10.2.0/sstream" 3
+      explicit
+      basic_stringstream(ios_base::openmode __m)
+      : __iostream_type(), _M_stringbuf(__m)
+      { this->init(&_M_stringbuf); }
+# 771 "/usr/include/c++/10.2.0/sstream" 3
+      explicit
+      basic_stringstream(const __string_type& __str,
+    ios_base::openmode __m = ios_base::out | ios_base::in)
+      : __iostream_type(), _M_stringbuf(__str, __m)
+      { this->init(&_M_stringbuf); }
+
+
+
+
+
+
+
+      ~basic_stringstream()
+      { }
+
+
+      basic_stringstream(const basic_stringstream&) = delete;
+
+      basic_stringstream(basic_stringstream&& __rhs)
+      : __iostream_type(std::move(__rhs)),
+      _M_stringbuf(std::move(__rhs._M_stringbuf))
+      { __iostream_type::set_rdbuf(&_M_stringbuf); }
+
+
+
+      basic_stringstream&
+      operator=(const basic_stringstream&) = delete;
+
+      basic_stringstream&
+      operator=(basic_stringstream&& __rhs)
+      {
+ __iostream_type::operator=(std::move(__rhs));
+ _M_stringbuf = std::move(__rhs._M_stringbuf);
+ return *this;
+      }
+
+      void
+      swap(basic_stringstream& __rhs)
+      {
+ __iostream_type::swap(__rhs);
+ _M_stringbuf.swap(__rhs._M_stringbuf);
+      }
+# 822 "/usr/include/c++/10.2.0/sstream" 3
+      __stringbuf_type*
+      rdbuf() const
+      { return const_cast<__stringbuf_type*>(&_M_stringbuf); }
+
+
+
+
+
+      __string_type
+      str() const
+      { return _M_stringbuf.str(); }
+
+
+
+
+
+
+
+      void
+      str(const __string_type& __s)
+      { _M_stringbuf.str(__s); }
+    };
+
+
+
+  template <class _CharT, class _Traits, class _Allocator>
+    inline void
+    swap(basic_stringbuf<_CharT, _Traits, _Allocator>& __x,
+  basic_stringbuf<_CharT, _Traits, _Allocator>& __y)
+    { __x.swap(__y); }
+
+
+  template <class _CharT, class _Traits, class _Allocator>
+    inline void
+    swap(basic_istringstream<_CharT, _Traits, _Allocator>& __x,
+  basic_istringstream<_CharT, _Traits, _Allocator>& __y)
+    { __x.swap(__y); }
+
+
+  template <class _CharT, class _Traits, class _Allocator>
+    inline void
+    swap(basic_ostringstream<_CharT, _Traits, _Allocator>& __x,
+  basic_ostringstream<_CharT, _Traits, _Allocator>& __y)
+    { __x.swap(__y); }
+
+
+  template <class _CharT, class _Traits, class _Allocator>
+    inline void
+    swap(basic_stringstream<_CharT, _Traits, _Allocator>& __x,
+  basic_stringstream<_CharT, _Traits, _Allocator>& __y)
+    { __x.swap(__y); }
+
+
+}
+
+}
+
+# 1 "/usr/include/c++/10.2.0/bits/sstream.tcc" 1 3
+# 35 "/usr/include/c++/10.2.0/bits/sstream.tcc" 3
+#define _SSTREAM_TCC 1
+
+       
+# 38 "/usr/include/c++/10.2.0/bits/sstream.tcc" 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  template <class _CharT, class _Traits, class _Alloc>
+    typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
+    basic_stringbuf<_CharT, _Traits, _Alloc>::
+    pbackfail(int_type __c)
+    {
+      int_type __ret = traits_type::eof();
+      if (this->eback() < this->gptr())
+ {
+
+
+   const bool __testeof = traits_type::eq_int_type(__c, __ret);
+   if (!__testeof)
+     {
+       const bool __testeq = traits_type::eq(traits_type::
+          to_char_type(__c),
+          this->gptr()[-1]);
+       const bool __testout = this->_M_mode & ios_base::out;
+       if (__testeq || __testout)
+  {
+    this->gbump(-1);
+    if (!__testeq)
+      *this->gptr() = traits_type::to_char_type(__c);
+    __ret = __c;
+  }
+     }
+   else
+     {
+       this->gbump(-1);
+       __ret = traits_type::not_eof(__c);
+     }
+ }
+      return __ret;
+    }
+
+  template <class _CharT, class _Traits, class _Alloc>
+    typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
+    basic_stringbuf<_CharT, _Traits, _Alloc>::
+    overflow(int_type __c)
+    {
+      const bool __testout = this->_M_mode & ios_base::out;
+      if (__builtin_expect(!__testout, false))
+ return traits_type::eof();
+
+      const bool __testeof = traits_type::eq_int_type(__c, traits_type::eof());
+      if (__builtin_expect(__testeof, false))
+ return traits_type::not_eof(__c);
+
+      const __size_type __capacity = _M_string.capacity();
+
+
+      if ((this->epptr() - this->pbase()) < __capacity)
+ {
+
+   char_type* __base = const_cast<char_type*>(_M_string.data());
+   _M_pbump(__base, __base + __capacity, this->pptr() - this->pbase());
+   if (_M_mode & ios_base::in)
+     {
+       const __size_type __nget = this->gptr() - this->eback();
+       const __size_type __eget = this->egptr() - this->eback();
+       this->setg(__base, __base + __nget, __base + __eget + 1);
+     }
+   *this->pptr() = traits_type::to_char_type(__c);
+   this->pbump(1);
+   return __c;
+ }
+
+
+      const __size_type __max_size = _M_string.max_size();
+      const bool __testput = this->pptr() < this->epptr();
+      if (__builtin_expect(!__testput && __capacity == __max_size, false))
+ return traits_type::eof();
+
+
+
+      const char_type __conv = traits_type::to_char_type(__c);
+      if (!__testput)
+ {
+# 129 "/usr/include/c++/10.2.0/bits/sstream.tcc" 3
+   const __size_type __opt_len = std::max(__size_type(2 * __capacity),
+       __size_type(512));
+   const __size_type __len = std::min(__opt_len, __max_size);
+   __string_type __tmp(_M_string.get_allocator());
+   __tmp.reserve(__len);
+   if (this->pbase())
+     __tmp.assign(this->pbase(), this->epptr() - this->pbase());
+   __tmp.push_back(__conv);
+   _M_string.swap(__tmp);
+   _M_sync(const_cast<char_type*>(_M_string.data()),
+    this->gptr() - this->eback(), this->pptr() - this->pbase());
+ }
+      else
+ *this->pptr() = __conv;
+      this->pbump(1);
+      return __c;
+    }
+
+  template <class _CharT, class _Traits, class _Alloc>
+    typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
+    basic_stringbuf<_CharT, _Traits, _Alloc>::
+    underflow()
+    {
+      int_type __ret = traits_type::eof();
+      const bool __testin = this->_M_mode & ios_base::in;
+      if (__testin)
+ {
+
+   _M_update_egptr();
+
+   if (this->gptr() < this->egptr())
+     __ret = traits_type::to_int_type(*this->gptr());
+ }
+      return __ret;
+    }
+
+  template <class _CharT, class _Traits, class _Alloc>
+    typename basic_stringbuf<_CharT, _Traits, _Alloc>::pos_type
+    basic_stringbuf<_CharT, _Traits, _Alloc>::
+    seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __mode)
+    {
+      pos_type __ret = pos_type(off_type(-1));
+      bool __testin = (ios_base::in & this->_M_mode & __mode) != 0;
+      bool __testout = (ios_base::out & this->_M_mode & __mode) != 0;
+      const bool __testboth = __testin && __testout && __way != ios_base::cur;
+      __testin &= !(__mode & ios_base::out);
+      __testout &= !(__mode & ios_base::in);
+
+
+
+      const char_type* __beg = __testin ? this->eback() : this->pbase();
+      if ((__beg || !__off) && (__testin || __testout || __testboth))
+ {
+   _M_update_egptr();
+
+   off_type __newoffi = __off;
+   off_type __newoffo = __newoffi;
+   if (__way == ios_base::cur)
+     {
+       __newoffi += this->gptr() - __beg;
+       __newoffo += this->pptr() - __beg;
+     }
+   else if (__way == ios_base::end)
+     __newoffo = __newoffi += this->egptr() - __beg;
+
+   if ((__testin || __testboth)
+       && __newoffi >= 0
+       && this->egptr() - __beg >= __newoffi)
+     {
+       this->setg(this->eback(), this->eback() + __newoffi,
+    this->egptr());
+       __ret = pos_type(__newoffi);
+     }
+   if ((__testout || __testboth)
+       && __newoffo >= 0
+       && this->egptr() - __beg >= __newoffo)
+     {
+       _M_pbump(this->pbase(), this->epptr(), __newoffo);
+       __ret = pos_type(__newoffo);
+     }
+ }
+      return __ret;
+    }
+
+  template <class _CharT, class _Traits, class _Alloc>
+    typename basic_stringbuf<_CharT, _Traits, _Alloc>::pos_type
+    basic_stringbuf<_CharT, _Traits, _Alloc>::
+    seekpos(pos_type __sp, ios_base::openmode __mode)
+    {
+      pos_type __ret = pos_type(off_type(-1));
+      const bool __testin = (ios_base::in & this->_M_mode & __mode) != 0;
+      const bool __testout = (ios_base::out & this->_M_mode & __mode) != 0;
+
+      const char_type* __beg = __testin ? this->eback() : this->pbase();
+      if ((__beg || !off_type(__sp)) && (__testin || __testout))
+ {
+   _M_update_egptr();
+
+   const off_type __pos(__sp);
+   const bool __testpos = (0 <= __pos
+      && __pos <= this->egptr() - __beg);
+   if (__testpos)
+     {
+       if (__testin)
+  this->setg(this->eback(), this->eback() + __pos,
+      this->egptr());
+       if (__testout)
+  _M_pbump(this->pbase(), this->epptr(), __pos);
+       __ret = __sp;
+     }
+ }
+      return __ret;
+    }
+
+  template <class _CharT, class _Traits, class _Alloc>
+    void
+    basic_stringbuf<_CharT, _Traits, _Alloc>::
+    _M_sync(char_type* __base, __size_type __i, __size_type __o)
+    {
+      const bool __testin = _M_mode & ios_base::in;
+      const bool __testout = _M_mode & ios_base::out;
+      char_type* __endg = __base + _M_string.size();
+      char_type* __endp = __base + _M_string.capacity();
+
+      if (__base != _M_string.data())
+ {
+
+   __endg += __i;
+   __i = 0;
+   __endp = __endg;
+ }
+
+      if (__testin)
+ this->setg(__base, __base + __i, __endg);
+      if (__testout)
+ {
+   _M_pbump(__base, __endp, __o);
+
+
+
+   if (!__testin)
+     this->setg(__endg, __endg, __endg);
+ }
+    }
+
+  template <class _CharT, class _Traits, class _Alloc>
+    void
+    basic_stringbuf<_CharT, _Traits, _Alloc>::
+    _M_pbump(char_type* __pbeg, char_type* __pend, off_type __off)
+    {
+      this->setp(__pbeg, __pend);
+      while (__off > __gnu_cxx::__numeric_traits<int>::__max)
+ {
+   this->pbump(__gnu_cxx::__numeric_traits<int>::__max);
+   __off -= __gnu_cxx::__numeric_traits<int>::__max;
+ }
+      this->pbump(__off);
+    }
+
+
+
+
+  extern template class basic_stringbuf<char>;
+  extern template class basic_istringstream<char>;
+  extern template class basic_ostringstream<char>;
+  extern template class basic_stringstream<char>;
+
+
+  extern template class basic_stringbuf<wchar_t>;
+  extern template class basic_istringstream<wchar_t>;
+  extern template class basic_ostringstream<wchar_t>;
+  extern template class basic_stringstream<wchar_t>;
+
+
+
+
+}
+# 880 "/usr/include/c++/10.2.0/sstream" 2 3
+# 23 "/usr/include/boost/test/utils/string_cast.hpp" 2 3 4
+
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 25 "/usr/include/boost/test/utils/string_cast.hpp" 2 3 4
+
+
+
+namespace boost {
+namespace unit_test {
+namespace utils {
+
+
+
+
+
+template<typename T>
+inline std::string
+string_cast( T const& t )
+{
+    std::ostringstream buff;
+    buff << t;
+    return buff.str();
+}
+
+
+
+
+
+
+
+template<typename T>
+inline bool
+string_as( const_string str, T& res )
+{
+    std::istringstream buff( std::string( str.begin(), str.end() ) );
+    buff >> res;
+
+    return !buff.fail() && buff.eof();
+}
+
+
+
+}
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 68 "/usr/include/boost/test/utils/string_cast.hpp" 2 3 4
+# 23 "/usr/include/boost/test/utils/runtime/errors.hpp" 2 3 4
+# 31 "/usr/include/boost/test/utils/runtime/errors.hpp" 3 4
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 32 "/usr/include/boost/test/utils/runtime/errors.hpp" 2 3 4
+
+namespace boost {
+namespace runtime {
+
+
+
+
+
+class __attribute__((__visibility__("default"))) param_error : public std::exception {
+public:
+    ~param_error() noexcept {}
+
+    virtual const char * what() const noexcept
+    {
+        return msg.c_str();
+    }
+
+    cstring param_name;
+    std::string msg;
+
+protected:
+    explicit param_error( cstring param_name_ ) : param_name( param_name_) {}
+};
+
+
+
+class __attribute__((__visibility__("default"))) init_error : public param_error {
+protected:
+    explicit init_error( cstring param_name ) : param_error( param_name ) {}
+    ~init_error() noexcept {}
+};
+
+class __attribute__((__visibility__("default"))) input_error : public param_error {
+protected:
+    explicit input_error( cstring param_name ) : param_error( param_name ) {}
+    ~input_error() noexcept {}
+};
+
+
+
+template<typename Derived, typename Base>
+class __attribute__((__visibility__("default"))) specific_param_error : public Base {
+protected:
+    explicit specific_param_error( cstring param_name ) : Base( param_name ) {}
+    ~specific_param_error() noexcept {}
+
+public:
+
+
+
+
+
+
+    Derived operator<<(char const* val) &&
+    {
+        this->msg.append( val );
+
+        return static_cast<Derived&&>(*this);
+    }
+
+
+
+    template<typename T>
+    Derived operator<<(T const& val) &&
+    {
+        this->msg.append( unit_test::utils::string_cast( val ) );
+
+        return static_cast<Derived&&>(*this);
+    }
+# 127 "/usr/include/boost/test/utils/runtime/errors.hpp" 3 4
+};
+
+
+
+
+
+
+
+#define SPECIFIC_EX_TYPE(type,base) class BOOST_SYMBOL_VISIBLE type : public specific_param_error<type,base> { public: explicit type( cstring param_name = cstring() ) : specific_param_error<type,base>( param_name ) {} }
+# 144 "/usr/include/boost/test/utils/runtime/errors.hpp" 3 4
+class __attribute__((__visibility__("default"))) invalid_cla_id : public specific_param_error<invalid_cla_id,init_error> { public: explicit invalid_cla_id( cstring param_name = cstring() ) : specific_param_error<invalid_cla_id,init_error>( param_name ) {} };
+class __attribute__((__visibility__("default"))) duplicate_param : public specific_param_error<duplicate_param,init_error> { public: explicit duplicate_param( cstring param_name = cstring() ) : specific_param_error<duplicate_param,init_error>( param_name ) {} };
+class __attribute__((__visibility__("default"))) conflicting_param : public specific_param_error<conflicting_param,init_error> { public: explicit conflicting_param( cstring param_name = cstring() ) : specific_param_error<conflicting_param,init_error>( param_name ) {} };
+class __attribute__((__visibility__("default"))) unknown_param : public specific_param_error<unknown_param,init_error> { public: explicit unknown_param( cstring param_name = cstring() ) : specific_param_error<unknown_param,init_error>( param_name ) {} };
+class __attribute__((__visibility__("default"))) access_to_missing_argument : public specific_param_error<access_to_missing_argument,init_error> { public: explicit access_to_missing_argument( cstring param_name = cstring() ) : specific_param_error<access_to_missing_argument,init_error>( param_name ) {} };
+class __attribute__((__visibility__("default"))) arg_type_mismatch : public specific_param_error<arg_type_mismatch,init_error> { public: explicit arg_type_mismatch( cstring param_name = cstring() ) : specific_param_error<arg_type_mismatch,init_error>( param_name ) {} };
+class __attribute__((__visibility__("default"))) invalid_param_spec : public specific_param_error<invalid_param_spec,init_error> { public: explicit invalid_param_spec( cstring param_name = cstring() ) : specific_param_error<invalid_param_spec,init_error>( param_name ) {} };
+
+class __attribute__((__visibility__("default"))) format_error : public specific_param_error<format_error,input_error> { public: explicit format_error( cstring param_name = cstring() ) : specific_param_error<format_error,input_error>( param_name ) {} };
+class __attribute__((__visibility__("default"))) duplicate_arg : public specific_param_error<duplicate_arg,input_error> { public: explicit duplicate_arg( cstring param_name = cstring() ) : specific_param_error<duplicate_arg,input_error>( param_name ) {} };
+class __attribute__((__visibility__("default"))) missing_req_arg : public specific_param_error<missing_req_arg,input_error> { public: explicit missing_req_arg( cstring param_name = cstring() ) : specific_param_error<missing_req_arg,input_error>( param_name ) {} };
+
+#undef SPECIFIC_EX_TYPE
+
+class __attribute__((__visibility__("default"))) ambiguous_param : public specific_param_error<ambiguous_param, input_error> {
+public:
+
+    explicit ambiguous_param( std::vector<cstring>&& amb_candidates )
+    : specific_param_error<ambiguous_param,input_error>( "" )
+    , m_amb_candidates( std::move( amb_candidates ) ) {}
+
+
+
+
+
+    ~ambiguous_param() noexcept {}
+
+    std::vector<cstring> m_amb_candidates;
+};
+
+class __attribute__((__visibility__("default"))) unrecognized_param : public specific_param_error<unrecognized_param, input_error> {
+public:
+
+    explicit unrecognized_param( std::vector<cstring>&& type_candidates )
+    : specific_param_error<unrecognized_param,input_error>( "" )
+    , m_typo_candidates( std::move( type_candidates ) ) {}
+
+
+
+
+
+    ~unrecognized_param() noexcept {}
+
+    std::vector<cstring> m_typo_candidates;
+};
+
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 194 "/usr/include/boost/test/utils/runtime/errors.hpp" 2 3 4
+# 21 "/usr/include/boost/test/utils/runtime/argument.hpp" 2 3 4
+
+
+
+# 1 "/usr/include/boost/test/utils/rtti.hpp" 1 3 4
+# 16 "/usr/include/boost/test/utils/rtti.hpp" 3 4
+#define BOOST_TEST_UTILS_RTTI_HPP 
+
+
+
+
+
+namespace boost {
+namespace rtti {
+
+
+
+
+
+typedef std::ptrdiff_t id_t;
+
+namespace rtti_detail {
+
+template<typename T>
+struct __attribute__((__visibility__("default"))) rttid_holder {
+    static id_t id() { return reinterpret_cast<id_t>( &inst() ); }
+
+private:
+    struct rttid {};
+
+    static rttid const& inst() { static rttid s_inst; return s_inst; }
+};
+
+}
+
+
+
+template<typename T>
+__attribute__((__visibility__("default"))) inline id_t
+type_id()
+{
+    return rtti_detail::rttid_holder<T>::id();
+}
+
+
+
+#define BOOST_RTTI_SWITCH(type_id_) if( ::boost::rtti::id_t switch_by_id = type_id_ )
+#define BOOST_RTTI_CASE(type) if( switch_by_id == ::boost::rtti::type_id<type>() )
+
+
+
+}
+}
+# 25 "/usr/include/boost/test/utils/runtime/argument.hpp" 2 3 4
+# 1 "/usr/include/boost/test/utils/basic_cstring/compare.hpp" 1 3 4
+# 16 "/usr/include/boost/test/utils/basic_cstring/compare.hpp" 3 4
+#define BOOST_TEST_UTILS_BASIC_CSTRING_COMPARE_HPP 
+
+
+
+
+
+
+# 1 "/usr/include/c++/10.2.0/cctype" 1 3 4
+# 39 "/usr/include/c++/10.2.0/cctype" 3 4
+       
+# 40 "/usr/include/c++/10.2.0/cctype" 3
+# 24 "/usr/include/boost/test/utils/basic_cstring/compare.hpp" 2 3 4
+
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 26 "/usr/include/boost/test/utils/basic_cstring/compare.hpp" 2 3 4
+
+
+
+
+
+
+
+namespace boost {
+
+namespace unit_test {
+
+
+
+
+
+namespace ut_detail {
+
+template<class CharT>
+struct case_ins
+{
+    static bool eq( CharT c1, CharT c2 ) { return (std::toupper)( c1 ) == (std::toupper)( c2 ); }
+    static bool lt( CharT c1, CharT c2 ) { return (std::toupper)( c1 ) < (std::toupper)( c2 ); }
+
+    static int compare( CharT const* s1, CharT const* s2, std::size_t n )
+    {
+        for( std::size_t i = 0; i < n; ++i ) {
+            if( !eq( s1[i], s2[i] ) )
+                return lt( s1[i], s2[i] ) ? -1 : 1;
+        }
+        return 0;
+    }
+};
+
+}
+
+
+
+
+
+template<class CharT>
+inline bool
+case_ins_eq( basic_cstring<CharT> x, basic_cstring<CharT> y )
+{
+    return x.size() == y.size() && ut_detail::case_ins<CharT>::compare( x.begin(), y.begin(), x.size() ) == 0;
+}
+
+
+
+
+
+
+
+template<class CharT>
+class case_ins_less
+{
+public:
+    typedef bool result_type;
+    typedef basic_cstring<CharT> first_argument_type;
+    typedef basic_cstring<CharT> second_argument_type;
+
+    bool operator()( basic_cstring<CharT> x, basic_cstring<CharT> y ) const
+    {
+        return x.size() != y.size()
+                ? x.size() < y.size()
+                : ut_detail::case_ins<CharT>::compare( x.begin(), y.begin(), x.size() ) < 0;
+    }
+};
+
+
+
+
+
+
+
+template<class CharT>
+inline bool
+operator <( boost::unit_test::basic_cstring<CharT> const& x,
+            boost::unit_test::basic_cstring<CharT> const& y )
+{
+    typedef typename boost::unit_test::basic_cstring<CharT>::traits_type traits_type;
+    return x.size() != y.size()
+            ? x.size() < y.size()
+            : traits_type::compare( x.begin(), y.begin(), x.size() ) < 0;
+}
+
+
+
+template<class CharT>
+inline bool
+operator <=( boost::unit_test::basic_cstring<CharT> const& x,
+            boost::unit_test::basic_cstring<CharT> const& y )
+{
+    return !(y < x);
+}
+
+
+
+template<class CharT>
+inline bool
+operator >( boost::unit_test::basic_cstring<CharT> const& x,
+            boost::unit_test::basic_cstring<CharT> const& y )
+{
+    return y < x;
+}
+
+
+
+template<class CharT>
+inline bool
+operator >=( boost::unit_test::basic_cstring<CharT> const& x,
+            boost::unit_test::basic_cstring<CharT> const& y )
+{
+    return !(x < y);
+}
+
+
+
+}
+
+}
+
+
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 150 "/usr/include/boost/test/utils/basic_cstring/compare.hpp" 2 3 4
+# 26 "/usr/include/boost/test/utils/runtime/argument.hpp" 2 3 4
+
+
+
+# 1 "/usr/include/c++/10.2.0/cassert" 1 3 4
+# 41 "/usr/include/c++/10.2.0/cassert" 3 4
+       
+# 42 "/usr/include/c++/10.2.0/cassert" 3
+
+
+# 1 "/usr/include/assert.h" 1 3 4
+# 24 "/usr/include/assert.h" 3 4
+#undef _ASSERT_H
+#undef assert
+#undef __ASSERT_VOID_CAST
+
+
+#undef assert_perror
+
+
+
+
+#define _ASSERT_H 1
+
+
+
+#define __ASSERT_VOID_CAST static_cast<void>
+# 64 "/usr/include/assert.h" 3 4
+extern "C" {
+
+
+extern void __assert_fail (const char *__assertion, const char *__file,
+      unsigned int __line, const char *__function)
+     throw () __attribute__ ((__noreturn__));
+
+
+extern void __assert_perror_fail (int __errnum, const char *__file,
+      unsigned int __line, const char *__function)
+     throw () __attribute__ ((__noreturn__));
+
+
+
+
+extern void __assert (const char *__assertion, const char *__file, int __line)
+     throw () __attribute__ ((__noreturn__));
+
+
+}
+
+
+
+
+
+#define assert(expr) (static_cast <bool> (expr) ? void (0) : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
+# 114 "/usr/include/assert.h" 3 4
+#define assert_perror(errnum) (!(errnum) ? __ASSERT_VOID_CAST (0) : __assert_perror_fail ((errnum), __FILE__, __LINE__, __ASSERT_FUNCTION))
+# 126 "/usr/include/assert.h" 3 4
+#define __ASSERT_FUNCTION __extension__ __PRETTY_FUNCTION__
+# 45 "/usr/include/c++/10.2.0/cassert" 2 3
+# 30 "/usr/include/boost/test/utils/runtime/argument.hpp" 2 3 4
+
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 32 "/usr/include/boost/test/utils/runtime/argument.hpp" 2 3 4
+
+namespace boost {
+namespace runtime {
+
+
+
+
+
+class argument {
+public:
+
+    argument( rtti::id_t value_type )
+    : p_value_type( value_type )
+    {}
+
+
+    virtual ~argument() {}
+
+
+    rtti::id_t const p_value_type;
+};
+
+
+
+
+
+template<typename T>
+class typed_argument : public argument {
+public:
+
+    explicit typed_argument( T const& v )
+    : argument( rtti::type_id<T>() )
+    , p_value( v )
+    {}
+
+    unit_test::readwrite_property<T> p_value;
+};
+
+
+
+
+
+class arguments_store {
+public:
+    typedef std::map<cstring, argument_ptr> storage_type;
+
+
+    std::size_t size() const { return m_arguments.size(); }
+
+
+    void clear() { m_arguments.clear(); }
+
+
+    bool has( cstring parameter_name ) const
+    {
+        return m_arguments.find( parameter_name ) != m_arguments.end();
+    }
+
+
+    template<typename T>
+    T const& get( cstring parameter_name ) const {
+        return const_cast<arguments_store*>(this)->get<T>( parameter_name );
+    }
+
+    template<typename T>
+    T& get( cstring parameter_name ) {
+        storage_type::const_iterator found = m_arguments.find( parameter_name );
+        if( found != m_arguments.end() ) {} else unit_test::ut_detail::throw_exception( access_to_missing_argument() << "There is no argument provided for parameter " << parameter_name )
+
+
+                                                   ;
+
+        argument_ptr arg = found->second;
+
+        if( arg->p_value_type == rtti::type_id<T>() ) {} else unit_test::ut_detail::throw_exception( arg_type_mismatch() << "Access with invalid type for argument corresponding to parameter " << parameter_name )
+
+
+                                                   ;
+
+        return static_cast<typed_argument<T>&>( *arg ).p_value.value;
+    }
+
+
+    template<typename T>
+    void set( cstring parameter_name, T const& value )
+    {
+        m_arguments[parameter_name] = argument_ptr( new typed_argument<T>( value ) );
+    }
+
+private:
+
+    storage_type m_arguments;
+};
+
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 130 "/usr/include/boost/test/utils/runtime/argument.hpp" 2 3 4
+# 20 "/usr/include/boost/test/unit_test_parameters.hpp" 2 3 4
+# 1 "/usr/include/boost/make_shared.hpp" 1 3 4
+
+#define BOOST_MAKE_SHARED_HPP_INCLUDED 
+# 14 "/usr/include/boost/make_shared.hpp" 3 4
+# 1 "/usr/include/boost/smart_ptr/make_shared.hpp" 1 3 4
+
+#define BOOST_SMART_PTR_MAKE_SHARED_HPP_INCLUDED 
+# 14 "/usr/include/boost/smart_ptr/make_shared.hpp" 3 4
+# 1 "/usr/include/boost/smart_ptr/make_shared_object.hpp" 1 3 4
+
+#define BOOST_SMART_PTR_MAKE_SHARED_OBJECT_HPP_INCLUDED 
+# 15 "/usr/include/boost/smart_ptr/make_shared_object.hpp" 3 4
+# 1 "/usr/include/boost/move/core.hpp" 1 3 4
+# 17 "/usr/include/boost/move/core.hpp" 3 4
+#define BOOST_MOVE_CORE_HPP 
+
+
+
+
+
+
+         
+
+
+# 1 "/usr/include/boost/move/detail/config_begin.hpp" 1 3 4
+# 28 "/usr/include/boost/move/core.hpp" 2 3 4
+# 1 "/usr/include/boost/move/detail/workaround.hpp" 1 3 4
+# 12 "/usr/include/boost/move/detail/workaround.hpp" 3 4
+#define BOOST_MOVE_DETAIL_WORKAROUND_HPP 
+
+
+
+
+
+
+         
+
+
+
+#define BOOST_MOVE_PERFECT_FORWARDING 
+
+
+
+
+
+#define BOOST_MOVE_HAS_FEATURE(x) 0
+
+
+
+
+
+
+
+#define BOOST_MOVE_IMPDEF(TYPE) TYPE
+#define BOOST_MOVE_SEEDOC(TYPE) TYPE
+#define BOOST_MOVE_DOC0PTR(TYPE) TYPE
+#define BOOST_MOVE_DOC1ST(TYPE1,TYPE2) TYPE2
+#define BOOST_MOVE_I ,
+#define BOOST_MOVE_DOCIGN(T1) T1
+# 66 "/usr/include/boost/move/detail/workaround.hpp" 3 4
+#define BOOST_MOVE_FORCEINLINE BOOST_FORCEINLINE
+# 29 "/usr/include/boost/move/core.hpp" 2 3 4
+# 44 "/usr/include/boost/move/core.hpp" 3 4
+#define BOOST_MOVE_IMPL_NO_COPY_CTOR_OR_ASSIGN(TYPE) public: TYPE(TYPE const &) = delete; TYPE& operator=(TYPE const &) = delete; public: typedef int boost_move_no_copy_constructor_or_assign; private:
+# 292 "/usr/include/boost/move/core.hpp" 3 4
+#define BOOST_MOVABLE_BUT_NOT_COPYABLE(TYPE) BOOST_MOVE_IMPL_NO_COPY_CTOR_OR_ASSIGN(TYPE) public: typedef int boost_move_emulation_t; private:
+# 302 "/usr/include/boost/move/core.hpp" 3 4
+#define BOOST_COPYABLE_AND_MOVABLE(TYPE) 
+
+
+
+#define BOOST_COPYABLE_AND_MOVABLE_ALT(TYPE) 
+
+
+
+   namespace boost {
+
+
+
+
+   template<class T>
+   struct has_move_emulation_enabled
+   {
+      static const bool value = false;
+   };
+
+   template<class T>
+   struct has_move_emulation_disabled
+   {
+      static const bool value = true;
+   };
+
+   }
+
+
+
+
+#define BOOST_RV_REF(TYPE) TYPE &&
+# 342 "/usr/include/boost/move/core.hpp" 3 4
+#define BOOST_RV_REF_BEG 
+# 352 "/usr/include/boost/move/core.hpp" 3 4
+#define BOOST_RV_REF_END &&
+
+
+
+
+
+#define BOOST_RV_REF_BEG_IF_CXX11 BOOST_RV_REF_BEG
+
+
+
+
+
+#define BOOST_RV_REF_END_IF_CXX11 BOOST_RV_REF_END
+
+
+
+
+
+#define BOOST_COPY_ASSIGN_REF(TYPE) const TYPE &
+
+
+
+
+
+#define BOOST_FWD_REF(TYPE) TYPE &&
+
+
+
+
+
+#define BOOST_RV_REF_2_TEMPL_ARGS(TYPE,ARG1,ARG2) TYPE<ARG1, ARG2> &&
+
+
+
+#define BOOST_RV_REF_3_TEMPL_ARGS(TYPE,ARG1,ARG2,ARG3) TYPE<ARG1, ARG2, ARG3> &&
+
+
+
+#define BOOST_COPY_ASSIGN_REF_BEG const
+
+
+
+#define BOOST_COPY_ASSIGN_REF_END &
+
+
+
+#define BOOST_COPY_ASSIGN_REF_2_TEMPL_ARGS(TYPE,ARG1,ARG2) const TYPE<ARG1, ARG2> &
+
+
+
+#define BOOST_COPY_ASSIGN_REF_3_TEMPL_ARGS(TYPE,ARG1,ARG2,ARG3) const TYPE<ARG1, ARG2, ARG3>&
+
+
+
+#define BOOST_CATCH_CONST_RLVALUE(TYPE) const TYPE &
+# 434 "/usr/include/boost/move/core.hpp" 3 4
+#define BOOST_MOVE_RET(RET_TYPE,REF) REF
+# 479 "/usr/include/boost/move/core.hpp" 3 4
+#define BOOST_MOVE_BASE(BASE_TYPE,ARG) ::boost::move((BASE_TYPE&)(ARG))
+
+
+
+   namespace boost {
+   namespace move_detail {
+
+   template< class T> struct forward_type { typedef T type; };
+
+   }}
+
+
+
+# 1 "/usr/include/boost/move/detail/config_end.hpp" 1 3 4
+# 493 "/usr/include/boost/move/core.hpp" 2 3 4
+# 16 "/usr/include/boost/smart_ptr/make_shared_object.hpp" 2 3 4
+# 1 "/usr/include/boost/move/utility_core.hpp" 1 3 4
+# 18 "/usr/include/boost/move/utility_core.hpp" 3 4
+#define BOOST_MOVE_MOVE_UTILITY_CORE_HPP 
+
+
+
+
+
+
+         
+
+
+# 1 "/usr/include/boost/move/detail/config_begin.hpp" 1 3 4
+# 29 "/usr/include/boost/move/utility_core.hpp" 2 3 4
+
+
+# 1 "/usr/include/boost/move/detail/meta_utils.hpp" 1 3 4
+# 15 "/usr/include/boost/move/detail/meta_utils.hpp" 3 4
+#define BOOST_MOVE_DETAIL_META_UTILS_HPP 
+
+
+         
+
+# 1 "/usr/include/boost/move/detail/config_begin.hpp" 1 3 4
+# 21 "/usr/include/boost/move/detail/meta_utils.hpp" 2 3 4
+
+# 1 "/usr/include/boost/move/detail/meta_utils_core.hpp" 1 3 4
+# 15 "/usr/include/boost/move/detail/meta_utils_core.hpp" 3 4
+#define BOOST_MOVE_DETAIL_META_UTILS_CORE_HPP 
+
+
+
+
+
+
+         
+
+
+
+
+namespace boost {
+namespace move_detail {
+
+template<typename T>
+struct voider { typedef void type; };
+
+
+
+
+template<bool C, typename T1, typename T2>
+struct if_c
+{
+   typedef T1 type;
+};
+
+template<typename T1, typename T2>
+struct if_c<false,T1,T2>
+{
+   typedef T2 type;
+};
+
+
+
+
+template<typename T1, typename T2, typename T3>
+struct if_ : if_c<0 != T1::value, T2, T3>
+{};
+
+
+
+
+struct enable_if_nat{};
+
+template <bool B, class T = enable_if_nat>
+struct enable_if_c
+{
+   typedef T type;
+};
+
+template <class T>
+struct enable_if_c<false, T> {};
+
+
+
+
+template <class Cond, class T = enable_if_nat>
+struct enable_if : enable_if_c<Cond::value, T> {};
+
+
+
+
+template <bool B, class T = enable_if_nat>
+struct disable_if_c
+   : enable_if_c<!B, T>
+{};
+
+
+
+
+template <class Cond, class T = enable_if_nat>
+struct disable_if : enable_if_c<!Cond::value, T> {};
+
+
+
+
+template<class T, T v>
+struct integral_constant
+{
+   static const T value = v;
+   typedef T value_type;
+   typedef integral_constant<T, v> type;
+
+     operator T() const { return value; }
+   T operator()() const { return value; }
+};
+
+typedef integral_constant<bool, true > true_type;
+typedef integral_constant<bool, false > false_type;
+
+
+
+
+
+template<class T, class U>
+struct is_same
+{
+   static const bool value = false;
+};
+
+template<class T>
+struct is_same<T, T>
+{
+   static const bool value = true;
+};
+
+
+
+
+template <class T, class U, class R = enable_if_nat>
+struct enable_if_same : enable_if<is_same<T, U>, R> {};
+
+
+
+
+template <class T, class U, class R = enable_if_nat>
+struct disable_if_same : disable_if<is_same<T, U>, R> {};
+
+}
+}
+# 23 "/usr/include/boost/move/detail/meta_utils.hpp" 2 3 4
+
+
+
+
+namespace boost {
+
+
+template <class T> class rv;
+
+namespace move_detail {
+
+
+
+
+template<class T, class U>
+struct is_different
+{
+   static const bool value = !is_same<T, U>::value;
+};
+
+
+
+
+template<class F, class Param>
+struct apply
+{
+   typedef typename F::template apply<Param>::type type;
+};
+
+
+
+
+
+template< bool C_ >
+struct bool_ : integral_constant<bool, C_>
+{
+     operator bool() const { return C_; }
+   bool operator()() const { return C_; }
+};
+
+typedef bool_<true> true_;
+typedef bool_<false> false_;
+
+
+
+
+struct nat{};
+struct nat2{};
+struct nat3{};
+
+
+
+
+typedef char yes_type;
+
+struct no_type
+{
+   char _[2];
+};
+
+
+
+
+template <class T> struct natify{};
+
+
+
+
+template<class T>
+struct remove_reference
+{
+   typedef T type;
+};
+
+template<class T>
+struct remove_reference<T&>
+{
+   typedef T type;
+};
+
+
+
+template<class T>
+struct remove_reference<T&&>
+{
+   typedef T type;
+};
+# 137 "/usr/include/boost/move/detail/meta_utils.hpp" 3 4
+template< class T > struct remove_pointer { typedef T type; };
+template< class T > struct remove_pointer<T*> { typedef T type; };
+template< class T > struct remove_pointer<T* const> { typedef T type; };
+template< class T > struct remove_pointer<T* volatile> { typedef T type; };
+template< class T > struct remove_pointer<T* const volatile> { typedef T type; };
+
+
+
+
+template< class T >
+struct add_pointer
+{
+   typedef typename remove_reference<T>::type* type;
+};
+
+
+
+
+template<class T>
+struct add_const
+{
+   typedef const T type;
+};
+
+template<class T>
+struct add_const<T&>
+{
+   typedef const T& type;
+};
+
+
+
+template<class T>
+struct add_const<T&&>
+{
+   typedef T&& type;
+};
+
+
+
+
+
+
+template<class T>
+struct add_lvalue_reference
+{ typedef T& type; };
+
+template<class T> struct add_lvalue_reference<T&> { typedef T& type; };
+template<> struct add_lvalue_reference<void> { typedef void type; };
+template<> struct add_lvalue_reference<const void> { typedef const void type; };
+template<> struct add_lvalue_reference<volatile void> { typedef volatile void type; };
+template<> struct add_lvalue_reference<const volatile void>{ typedef const volatile void type; };
+
+template<class T>
+struct add_const_lvalue_reference
+{
+   typedef typename remove_reference<T>::type t_unreferenced;
+   typedef typename add_const<t_unreferenced>::type t_unreferenced_const;
+   typedef typename add_lvalue_reference
+      <t_unreferenced_const>::type type;
+};
+
+
+
+
+template<class T>
+struct is_lvalue_reference
+{
+    static const bool value = false;
+};
+
+template<class T>
+struct is_lvalue_reference<T&>
+{
+    static const bool value = true;
+};
+
+
+
+
+
+template <class T>
+struct identity
+{
+   typedef T type;
+   typedef typename add_const_lvalue_reference<T>::type reference;
+   reference operator()(reference t)
+   { return t; }
+};
+
+
+
+
+template<class T>
+struct is_class_or_union
+{
+   struct twochar { char dummy[2]; };
+   template <class U>
+   static char is_class_or_union_tester(void(U::*)(void));
+   template <class U>
+   static twochar is_class_or_union_tester(...);
+   static const bool value = sizeof(is_class_or_union_tester<T>(0)) == sizeof(char);
+};
+
+
+
+
+template<class T>
+struct addr_impl_ref
+{
+   T & v_;
+   inline __attribute__ ((__always_inline__)) addr_impl_ref( T & v ): v_( v ) {}
+   inline __attribute__ ((__always_inline__)) operator T& () const { return v_; }
+
+   private:
+   addr_impl_ref & operator=(const addr_impl_ref &);
+};
+
+template<class T>
+struct addressof_impl
+{
+   inline __attribute__ ((__always_inline__)) static T * f( T & v, long )
+   {
+      return reinterpret_cast<T*>(
+         &const_cast<char&>(reinterpret_cast<const volatile char &>(v)));
+   }
+
+   inline __attribute__ ((__always_inline__)) static T * f( T * v, int )
+   { return v; }
+};
+
+template<class T>
+inline __attribute__ ((__always_inline__)) T * addressof( T & v )
+{
+   return ::boost::move_detail::addressof_impl<T>::f
+      ( ::boost::move_detail::addr_impl_ref<T>( v ), 0 );
+}
+
+
+
+
+template <class T>
+struct has_pointer_type
+{
+   struct two { char c[2]; };
+   template <class U> static two test(...);
+   template <class U> static char test(typename U::pointer* = 0);
+   static const bool value = sizeof(test<T>(0)) == 1;
+};
+# 302 "/usr/include/boost/move/detail/meta_utils.hpp" 3 4
+template <class T, class U>
+class is_convertible
+{
+   typedef typename add_lvalue_reference<T>::type t_reference;
+   typedef char true_t;
+   class false_t { char dummy[2]; };
+   static false_t dispatch(...);
+   static true_t dispatch(U);
+   static t_reference trigger();
+   public:
+   static const bool value = sizeof(dispatch(trigger())) == sizeof(true_t);
+};
+
+
+
+template <class T, class U, bool IsSame = is_same<T, U>::value>
+struct is_same_or_convertible
+   : is_convertible<T, U>
+{};
+
+template <class T, class U>
+struct is_same_or_convertible<T, U, true>
+{
+   static const bool value = true;
+};
+
+template<
+      bool C
+    , typename F1
+    , typename F2
+    >
+struct eval_if_c
+    : if_c<C,F1,F2>::type
+{};
+
+template<
+      typename C
+    , typename T1
+    , typename T2
+    >
+struct eval_if
+    : if_<C,T1,T2>::type
+{};
+
+
+
+
+
+
+template<class T, class U, class R = void>
+struct enable_if_convertible
+   : enable_if< is_convertible<T, U>, R>
+{};
+
+template<class T, class U, class R = void>
+struct disable_if_convertible
+   : disable_if< is_convertible<T, U>, R>
+{};
+
+template<class T, class U, class R = void>
+struct enable_if_same_or_convertible
+   : enable_if< is_same_or_convertible<T, U>, R>
+{};
+
+template<class T, class U, class R = void>
+struct disable_if_same_or_convertible
+   : disable_if< is_same_or_convertible<T, U>, R>
+{};
+
+
+
+
+
+
+template<bool, class B = true_, class C = true_, class D = true_>
+struct and_impl
+   : and_impl<B::value, C, D>
+{};
+
+template<>
+struct and_impl<true, true_, true_, true_>
+{
+   static const bool value = true;
+};
+
+template<class B, class C, class D>
+struct and_impl<false, B, C, D>
+{
+   static const bool value = false;
+};
+
+template<class A, class B, class C = true_, class D = true_>
+struct and_
+   : and_impl<A::value, B, C, D>
+{};
+
+
+
+
+
+
+template<bool, class B = false_, class C = false_, class D = false_>
+struct or_impl
+   : or_impl<B::value, C, D>
+{};
+
+template<>
+struct or_impl<false, false_, false_, false_>
+{
+   static const bool value = false;
+};
+
+template<class B, class C, class D>
+struct or_impl<true, B, C, D>
+{
+   static const bool value = true;
+};
+
+template<class A, class B, class C = false_, class D = false_>
+struct or_
+   : or_impl<A::value, B, C, D>
+{};
+
+
+
+
+
+
+template<class T>
+struct not_
+{
+   static const bool value = !T::value;
+};
+
+
+
+
+
+
+
+template<class R, class A, class B, class C = true_, class D = true_>
+struct enable_if_and
+   : enable_if_c< and_<A, B, C, D>::value, R>
+{};
+
+template<class R, class A, class B, class C = true_, class D = true_>
+struct disable_if_and
+   : disable_if_c< and_<A, B, C, D>::value, R>
+{};
+
+template<class R, class A, class B, class C = false_, class D = false_>
+struct enable_if_or
+   : enable_if_c< or_<A, B, C, D>::value, R>
+{};
+
+template<class R, class A, class B, class C = false_, class D = false_>
+struct disable_if_or
+   : disable_if_c< or_<A, B, C, D>::value, R>
+{};
+
+
+
+
+
+
+template<class T>
+struct has_move_emulation_enabled_impl
+   : is_convertible< T, ::boost::rv<T>& >
+{};
+
+template<class T>
+struct has_move_emulation_enabled_impl<T&>
+{ static const bool value = false; };
+
+template<class T>
+struct has_move_emulation_enabled_impl< ::boost::rv<T> >
+{ static const bool value = false; };
+
+
+
+
+
+
+
+template <class T>
+struct is_rv_impl
+{ static const bool value = false; };
+
+template <class T>
+struct is_rv_impl< rv<T> >
+{ static const bool value = true; };
+
+template <class T>
+struct is_rv_impl< const rv<T> >
+{ static const bool value = true; };
+
+
+
+template< class T >
+struct is_rvalue_reference
+{ static const bool value = false; };
+
+
+
+template< class T >
+struct is_rvalue_reference< T&& >
+{ static const bool value = true; };
+# 524 "/usr/include/boost/move/detail/meta_utils.hpp" 3 4
+template< class T >
+struct add_rvalue_reference
+{ typedef T&& type; };
+# 555 "/usr/include/boost/move/detail/meta_utils.hpp" 3 4
+template< class T > struct remove_rvalue_reference { typedef T type; };
+
+
+   template< class T > struct remove_rvalue_reference< T&& > { typedef T type; };
+# 582 "/usr/include/boost/move/detail/meta_utils.hpp" 3 4
+}
+}
+
+# 1 "/usr/include/boost/move/detail/config_end.hpp" 1 3 4
+# 586 "/usr/include/boost/move/detail/meta_utils.hpp" 2 3 4
+# 32 "/usr/include/boost/move/utility_core.hpp" 2 3 4
+# 174 "/usr/include/boost/move/utility_core.hpp" 3 4
+      namespace boost {
+
+
+
+
+
+
+
+      template<class T>
+      struct enable_move_utility_emulation
+      {
+         static const bool value = false;
+      };
+# 211 "/usr/include/boost/move/utility_core.hpp" 3 4
+         template <class T>
+         inline __attribute__ ((__always_inline__)) typename ::boost::move_detail::remove_reference<T>::type && move(T&& t) noexcept
+         { return static_cast<typename ::boost::move_detail::remove_reference<T>::type &&>(t); }
+# 247 "/usr/include/boost/move/utility_core.hpp" 3 4
+         template <class T>
+         inline __attribute__ ((__always_inline__)) T&& forward(typename ::boost::move_detail::remove_reference<T>::type& t) noexcept
+         { return static_cast<T&&>(t); }
+
+         template <class T>
+         inline __attribute__ ((__always_inline__)) T&& forward(typename ::boost::move_detail::remove_reference<T>::type&& t) noexcept
+         {
+
+            static_assert(!boost::move_detail::is_lvalue_reference<T>::value, "!boost::move_detail::is_lvalue_reference<T>::value");
+            return static_cast<T&&>(t);
+         }
+# 282 "/usr/include/boost/move/utility_core.hpp" 3 4
+         template <class T>
+         inline __attribute__ ((__always_inline__)) T&& move_if_not_lvalue_reference(typename ::boost::move_detail::remove_reference<T>::type& t) noexcept
+         { return static_cast<T&&>(t); }
+
+         template <class T>
+         inline __attribute__ ((__always_inline__)) T&& move_if_not_lvalue_reference(typename ::boost::move_detail::remove_reference<T>::type&& t) noexcept
+         {
+
+            static_assert(!boost::move_detail::is_lvalue_reference<T>::value, "!boost::move_detail::is_lvalue_reference<T>::value");
+            return static_cast<T&&>(t);
+         }
+
+
+
+      }
+
+
+
+
+
+
+
+namespace boost{
+namespace move_detail{
+
+template <typename T>
+typename boost::move_detail::add_rvalue_reference<T>::type declval();
+
+}
+}
+
+
+
+
+# 1 "/usr/include/boost/move/detail/config_end.hpp" 1 3 4
+# 317 "/usr/include/boost/move/utility_core.hpp" 2 3 4
+# 17 "/usr/include/boost/smart_ptr/make_shared_object.hpp" 2 3 4
+
+# 1 "/usr/include/boost/smart_ptr/detail/sp_forward.hpp" 1 3 4
+
+#define BOOST_SMART_PTR_DETAIL_SP_FORWARD_HPP_INCLUDED 
+# 20 "/usr/include/boost/smart_ptr/detail/sp_forward.hpp" 3 4
+namespace boost
+{
+
+namespace detail
+{
+# 39 "/usr/include/boost/smart_ptr/detail/sp_forward.hpp" 3 4
+template< class T > T&& sp_forward( T & t ) noexcept
+{
+    return static_cast< T&& >( t );
+}
+
+
+
+
+
+}
+
+}
+# 19 "/usr/include/boost/smart_ptr/make_shared_object.hpp" 2 3 4
+
+# 1 "/usr/include/boost/type_traits/type_with_alignment.hpp" 1 3 4
+# 9 "/usr/include/boost/type_traits/type_with_alignment.hpp" 3 4
+#define BOOST_TT_TYPE_WITH_ALIGNMENT_INCLUDED 
+# 27 "/usr/include/boost/type_traits/type_with_alignment.hpp" 3 4
+namespace boost {
+
+   namespace detail{
+
+      union max_align
+      {
+         char c;
+         short s;
+         int i;
+         long l;
+
+         boost::long_long_type ll;
+
+
+         boost::int128_type i128;
+
+         float f;
+         double d;
+         long double ld;
+
+
+
+      };
+
+template <std::size_t Target, bool check> struct long_double_alignment{ typedef long double type; };
+template <std::size_t Target> struct long_double_alignment<Target, false>{ typedef boost::detail::max_align type; };
+
+template <std::size_t Target, bool check> struct double_alignment{ typedef double type; };
+template <std::size_t Target> struct double_alignment<Target, false>{ typedef typename long_double_alignment<Target, boost::alignment_of<long double>::value >= Target>::type type; };
+
+
+template <std::size_t Target, bool check> struct long_long_alignment{ typedef boost::long_long_type type; };
+template <std::size_t Target> struct long_long_alignment<Target, false>{ typedef typename double_alignment<Target, boost::alignment_of<double>::value >= Target>::type type; };
+
+
+template <std::size_t Target, bool check> struct long_alignment{ typedef long type; };
+
+template <std::size_t Target> struct long_alignment<Target, false>{ typedef typename long_long_alignment<Target, boost::alignment_of<boost::long_long_type>::value >= Target>::type type; };
+
+
+
+
+template <std::size_t Target, bool check> struct int_alignment{ typedef int type; };
+template <std::size_t Target> struct int_alignment<Target, false>{ typedef typename long_alignment<Target, boost::alignment_of<long>::value >= Target>::type type; };
+
+template <std::size_t Target, bool check> struct short_alignment{ typedef short type; };
+template <std::size_t Target> struct short_alignment<Target, false>{ typedef typename int_alignment<Target, boost::alignment_of<int>::value >= Target>::type type; };
+
+template <std::size_t Target, bool check> struct char_alignment{ typedef char type; };
+template <std::size_t Target> struct char_alignment<Target, false>{ typedef typename short_alignment<Target, boost::alignment_of<short>::value >= Target>::type type; };
+
+}
+
+template <std::size_t Align>
+struct type_with_alignment
+{
+   typedef typename boost::detail::char_alignment<Align, boost::alignment_of<char>::value >= Align>::type type;
+};
+
+
+namespace tt_align_ns {
+struct __attribute__((__aligned__(2))) a2 {};
+struct __attribute__((__aligned__(4))) a4 {};
+struct __attribute__((__aligned__(8))) a8 {};
+struct __attribute__((__aligned__(16))) a16 {};
+struct __attribute__((__aligned__(32))) a32 {};
+struct __attribute__((__aligned__(64))) a64 {};
+struct __attribute__((__aligned__(128))) a128 {};
+}
+
+template<> struct type_with_alignment<1> { public: typedef char type; };
+template<> struct type_with_alignment<2> { public: typedef tt_align_ns::a2 type; };
+template<> struct type_with_alignment<4> { public: typedef tt_align_ns::a4 type; };
+template<> struct type_with_alignment<8> { public: typedef tt_align_ns::a8 type; };
+template<> struct type_with_alignment<16> { public: typedef tt_align_ns::a16 type; };
+template<> struct type_with_alignment<32> { public: typedef tt_align_ns::a32 type; };
+template<> struct type_with_alignment<64> { public: typedef tt_align_ns::a64 type; };
+template<> struct type_with_alignment<128> { public: typedef tt_align_ns::a128 type; };
+
+template<> struct is_pod< ::boost::tt_align_ns::a2> : public true_type{};
+template<> struct is_pod< ::boost::tt_align_ns::a4> : public true_type{};
+template<> struct is_pod< ::boost::tt_align_ns::a8> : public true_type{};
+template<> struct is_pod< ::boost::tt_align_ns::a16> : public true_type{};
+template<> struct is_pod< ::boost::tt_align_ns::a32> : public true_type{};
+template<> struct is_pod< ::boost::tt_align_ns::a64> : public true_type{};
+template<> struct is_pod< ::boost::tt_align_ns::a128> : public true_type{};
+# 252 "/usr/include/boost/type_traits/type_with_alignment.hpp" 3 4
+}
+# 21 "/usr/include/boost/smart_ptr/make_shared_object.hpp" 2 3 4
+
+
+
+
+namespace boost
+{
+
+namespace detail
+{
+
+template< std::size_t N, std::size_t A > struct sp_aligned_storage
+{
+    union type
+    {
+        char data_[ N ];
+        typename boost::type_with_alignment< A >::type align_;
+    };
+};
+
+template< class T > class sp_ms_deleter
+{
+private:
+
+    typedef typename sp_aligned_storage< sizeof( T ), ::boost::alignment_of< T >::value >::type storage_type;
+
+    bool initialized_;
+    storage_type storage_;
+
+private:
+
+    void destroy() noexcept
+    {
+        if( initialized_ )
+        {
+
+
+
+            T * p = reinterpret_cast< T* >( storage_.data_ );
+            p->~T();
+
+
+
+
+
+
+
+            initialized_ = false;
+        }
+    }
+
+public:
+
+    sp_ms_deleter() noexcept : initialized_( false )
+    {
+    }
+
+    template<class A> explicit sp_ms_deleter( A const & ) noexcept : initialized_( false )
+    {
+    }
+
+
+    sp_ms_deleter( sp_ms_deleter const & ) noexcept : initialized_( false )
+    {
+    }
+
+    ~sp_ms_deleter() noexcept
+    {
+        destroy();
+    }
+
+    void operator()( T * ) noexcept
+    {
+        destroy();
+    }
+
+    static void operator_fn( T* ) noexcept
+    {
+    }
+
+    void * address() noexcept
+    {
+        return storage_.data_;
+    }
+
+    void set_initialized() noexcept
+    {
+        initialized_ = true;
+    }
+};
+
+template< class T, class A > class sp_as_deleter
+{
+private:
+
+    typedef typename sp_aligned_storage< sizeof( T ), ::boost::alignment_of< T >::value >::type storage_type;
+
+    storage_type storage_;
+    A a_;
+    bool initialized_;
+
+private:
+
+    void destroy() noexcept
+    {
+        if( initialized_ )
+        {
+            T * p = reinterpret_cast< T* >( storage_.data_ );
+
+
+
+            std::allocator_traits<A>::destroy( a_, p );
+
+
+
+
+
+
+
+            initialized_ = false;
+        }
+    }
+
+public:
+
+    sp_as_deleter( A const & a ) noexcept : a_( a ), initialized_( false )
+    {
+    }
+
+
+    sp_as_deleter( sp_as_deleter const & r ) noexcept : a_( r.a_), initialized_( false )
+    {
+    }
+
+    ~sp_as_deleter() noexcept
+    {
+        destroy();
+    }
+
+    void operator()( T * ) noexcept
+    {
+        destroy();
+    }
+
+    static void operator_fn( T* ) noexcept
+    {
+    }
+
+    void * address() noexcept
+    {
+        return storage_.data_;
+    }
+
+    void set_initialized() noexcept
+    {
+        initialized_ = true;
+    }
+};
+
+template< class T > struct sp_if_not_array
+{
+    typedef boost::shared_ptr< T > type;
+};
+
+
+
+template< class T > struct sp_if_not_array< T[] >
+{
+};
+
+
+
+template< class T, std::size_t N > struct sp_if_not_array< T[N] >
+{
+};
+
+
+
+
+
+}
+
+
+#define BOOST_SP_MSD(T) boost::detail::sp_inplace_tag< boost::detail::sp_ms_deleter< T > >()
+
+
+
+
+
+
+template< class T > typename boost::detail::sp_if_not_array< T >::type make_shared_noinit()
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_inplace_tag< boost::detail::sp_ms_deleter< T > >() );
+
+    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T;
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+template< class T, class A > typename boost::detail::sp_if_not_array< T >::type allocate_shared_noinit( A const & a )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_inplace_tag< boost::detail::sp_ms_deleter< T > >(), a );
+
+    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T;
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+
+
+
+
+template< class T, class... Args > typename boost::detail::sp_if_not_array< T >::type make_shared( Args && ... args )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_inplace_tag< boost::detail::sp_ms_deleter< T > >() );
+
+    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T( boost::detail::sp_forward<Args>( args )... );
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+template< class T, class A, class... Args > typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, Args && ... args )
+{
+
+
+    typedef typename std::allocator_traits<A>::template rebind_alloc<T> A2;
+    A2 a2( a );
+
+    typedef boost::detail::sp_as_deleter< T, A2 > D;
+
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_inplace_tag<D>(), a2 );
+# 284 "/usr/include/boost/smart_ptr/make_shared_object.hpp" 3 4
+    D * pd = static_cast< D* >( pt._internal_get_untyped_deleter() );
+    void * pv = pd->address();
+
+
+
+    std::allocator_traits<A2>::construct( a2, static_cast< T* >( pv ), boost::detail::sp_forward<Args>( args )... );
+
+
+
+
+
+
+
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+# 797 "/usr/include/boost/smart_ptr/make_shared_object.hpp" 3 4
+#undef BOOST_SP_MSD
+
+}
+# 15 "/usr/include/boost/smart_ptr/make_shared.hpp" 2 3 4
+
+
+# 1 "/usr/include/boost/smart_ptr/make_shared_array.hpp" 1 3 4
+# 9 "/usr/include/boost/smart_ptr/make_shared_array.hpp" 3 4
+#define BOOST_SMART_PTR_MAKE_SHARED_ARRAY_HPP 
+
+# 1 "/usr/include/boost/core/default_allocator.hpp" 1 3 4
+# 9 "/usr/include/boost/core/default_allocator.hpp" 3 4
+#define BOOST_CORE_DEFAULT_ALLOCATOR_HPP 
+
+
+
+# 1 "/usr/include/c++/10.2.0/climits" 1 3 4
+# 39 "/usr/include/c++/10.2.0/climits" 3 4
+       
+# 40 "/usr/include/c++/10.2.0/climits" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include-fixed/limits.h" 1 3 4
+# 43 "/usr/include/c++/10.2.0/climits" 2 3
+# 14 "/usr/include/boost/core/default_allocator.hpp" 2 3 4
+
+
+
+
+
+namespace boost {
+
+
+
+
+
+namespace default_ {
+
+struct true_type {
+    typedef bool value_type;
+    typedef true_type type;
+
+    static const bool value = true;
+
+    constexpr operator bool() const noexcept {
+        return true;
+    }
+
+    constexpr bool operator()() const noexcept {
+        return true;
+    }
+};
+
+template<class T>
+struct add_reference {
+    typedef T& type;
+};
+
+template<>
+struct add_reference<void> {
+    typedef void type;
+};
+
+template<>
+struct add_reference<const void> {
+    typedef const void type;
+};
+
+template<class T>
+struct default_allocator {
+    typedef T value_type;
+    typedef T* pointer;
+    typedef const T* const_pointer;
+    typedef typename add_reference<T>::type reference;
+    typedef typename add_reference<const T>::type const_reference;
+    typedef std::size_t size_type;
+    typedef std::ptrdiff_t difference_type;
+    typedef true_type propagate_on_container_move_assignment;
+    typedef true_type is_always_equal;
+
+    template<class U>
+    struct rebind {
+        typedef default_allocator<U> other;
+    };
+
+
+    default_allocator() = default;
+
+
+
+
+    template<class U>
+    constexpr default_allocator(const default_allocator<U>&)
+        noexcept { }
+
+
+    constexpr std::size_t max_size() const noexcept {
+        return (9223372036854775807L) < (18446744073709551615UL) / sizeof(T)
+            ? (9223372036854775807L) : (18446744073709551615UL) / sizeof(T);
+    }
+
+
+
+
+
+
+
+    T* allocate(std::size_t n) {
+        if (n > max_size()) {
+            throw std::bad_alloc();
+        }
+        return static_cast<T*>(::operator new(sizeof(T) * n));
+    }
+
+    void deallocate(T* p, std::size_t) {
+        ::operator delete(p);
+    }
+# 134 "/usr/include/boost/core/default_allocator.hpp" 3 4
+};
+
+template<class T, class U>
+constexpr inline bool
+operator==(const default_allocator<T>&,
+    const default_allocator<U>&) noexcept
+{
+    return true;
+}
+
+template<class T, class U>
+constexpr inline bool
+operator!=(const default_allocator<T>&,
+    const default_allocator<U>&) noexcept
+{
+    return false;
+}
+
+}
+
+using default_::default_allocator;
+
+}
+# 12 "/usr/include/boost/smart_ptr/make_shared_array.hpp" 2 3 4
+# 1 "/usr/include/boost/smart_ptr/allocate_shared_array.hpp" 1 3 4
+# 9 "/usr/include/boost/smart_ptr/allocate_shared_array.hpp" 3 4
+#define BOOST_SMART_PTR_ALLOCATE_SHARED_ARRAY_HPP 
+
+# 1 "/usr/include/boost/core/alloc_construct.hpp" 1 3 4
+# 9 "/usr/include/boost/core/alloc_construct.hpp" 3 4
+#define BOOST_CORE_ALLOC_CONSTRUCT_HPP 
+
+# 1 "/usr/include/boost/core/noinit_adaptor.hpp" 1 3 4
+# 9 "/usr/include/boost/core/noinit_adaptor.hpp" 3 4
+#define BOOST_CORE_NOINIT_ADAPTOR_HPP 
+# 20 "/usr/include/boost/core/noinit_adaptor.hpp" 3 4
+namespace boost {
+
+template<class A>
+struct noinit_adaptor
+    : A {
+    template<class U>
+    struct rebind {
+
+        typedef noinit_adaptor<typename std::allocator_traits<A>::template
+            rebind_alloc<U> > other;
+
+
+
+    };
+
+    noinit_adaptor()
+        : A() { }
+
+
+    template<class U>
+    noinit_adaptor(U&& u) noexcept
+        : A(std::forward<U>(u)) { }
+
+
+
+
+
+
+    template<class U>
+    noinit_adaptor(const noinit_adaptor<U>& u) noexcept
+        : A(static_cast<const U&>(u)) { }
+
+    template<class U>
+    void construct(U* p) {
+        ::new((void*)p) U;
+    }
+
+
+
+    template<class U, class V, class... Args>
+    void construct(U* p, V&& v, Args&&... args) {
+        ::new((void*)p) U(std::forward<V>(v), std::forward<Args>(args)...);
+    }
+# 81 "/usr/include/boost/core/noinit_adaptor.hpp" 3 4
+    template<class U>
+    void destroy(U* p) {
+        p->~U();
+    }
+};
+
+template<class T, class U>
+inline bool
+operator==(const noinit_adaptor<T>& lhs,
+    const noinit_adaptor<U>& rhs) noexcept
+{
+    return static_cast<const T&>(lhs) == static_cast<const U&>(rhs);
+}
+
+template<class T, class U>
+inline bool
+operator!=(const noinit_adaptor<T>& lhs,
+    const noinit_adaptor<U>& rhs) noexcept
+{
+    return !(lhs == rhs);
+}
+
+template<class A>
+inline noinit_adaptor<A>
+noinit_adapt(const A& a) noexcept
+{
+    return noinit_adaptor<A>(a);
+}
+
+}
+# 12 "/usr/include/boost/core/alloc_construct.hpp" 2 3 4
+
+namespace boost {
+
+
+template<class A, class T>
+inline void
+alloc_destroy(A& a, T* p)
+{
+    std::allocator_traits<A>::destroy(a, p);
+}
+
+template<class A, class T>
+inline void
+alloc_destroy_n(A& a, T* p, std::size_t n)
+{
+    while (n > 0) {
+        std::allocator_traits<A>::destroy(a, p + --n);
+    }
+}
+# 49 "/usr/include/boost/core/alloc_construct.hpp" 3 4
+namespace detail {
+
+template<class A, class T>
+class alloc_destroyer {
+public:
+    alloc_destroyer(A& a, T* p) noexcept
+        : a_(a),
+          p_(p),
+          n_(0) { }
+
+    ~alloc_destroyer() {
+        boost::alloc_destroy_n(a_, p_, n_);
+    }
+
+    std::size_t& size() noexcept {
+        return n_;
+    }
+
+private:
+    alloc_destroyer(const alloc_destroyer&);
+    alloc_destroyer& operator=(const alloc_destroyer&);
+
+    A& a_;
+    T* p_;
+    std::size_t n_;
+};
+
+}
+
+
+template<class A, class T>
+inline void
+alloc_construct(A& a, T* p)
+{
+    std::allocator_traits<A>::construct(a, p);
+}
+
+
+
+template<class A, class T, class U, class... V>
+inline void
+alloc_construct(A& a, T* p, U&& u, V&&... v)
+{
+    std::allocator_traits<A>::construct(a, p, std::forward<U>(u),
+        std::forward<V>(v)...);
+}
+# 119 "/usr/include/boost/core/alloc_construct.hpp" 3 4
+template<class A, class T>
+inline void
+alloc_construct_n(A& a, T* p, std::size_t n)
+{
+    detail::alloc_destroyer<A, T> hold(a, p);
+    for (std::size_t& i = hold.size(); i < n; ++i) {
+        std::allocator_traits<A>::construct(a, p + i);
+    }
+    hold.size() = 0;
+}
+
+template<class A, class T>
+inline void
+alloc_construct_n(A& a, T* p, std::size_t n, const T* l, std::size_t m)
+{
+    detail::alloc_destroyer<A, T> hold(a, p);
+    for (std::size_t& i = hold.size(); i < n; ++i) {
+        std::allocator_traits<A>::construct(a, p + i, l[i % m]);
+    }
+    hold.size() = 0;
+}
+
+template<class A, class T, class I>
+inline void
+alloc_construct_n(A& a, T* p, std::size_t n, I b)
+{
+    detail::alloc_destroyer<A, T> hold(a, p);
+    for (std::size_t& i = hold.size(); i < n; void(++i), void(++b)) {
+        std::allocator_traits<A>::construct(a, p + i, *b);
+    }
+    hold.size() = 0;
+}
+# 243 "/usr/include/boost/core/alloc_construct.hpp" 3 4
+}
+# 12 "/usr/include/boost/smart_ptr/allocate_shared_array.hpp" 2 3 4
+# 1 "/usr/include/boost/core/first_scalar.hpp" 1 3 4
+# 9 "/usr/include/boost/core/first_scalar.hpp" 3 4
+#define BOOST_CORE_FIRST_SCALAR_HPP 
+
+
+
+
+namespace boost {
+namespace detail {
+
+template<class T>
+struct make_scalar {
+    typedef T type;
+};
+
+template<class T, std::size_t N>
+struct make_scalar<T[N]> {
+    typedef typename make_scalar<T>::type type;
+};
+
+}
+
+template<class T>
+constexpr inline T*
+first_scalar(T* p) noexcept
+{
+    return p;
+}
+
+template<class T, std::size_t N>
+constexpr inline typename detail::make_scalar<T>::type*
+first_scalar(T (*p)[N]) noexcept
+{
+    return boost::first_scalar(&(*p)[0]);
+}
+
+}
+# 13 "/usr/include/boost/smart_ptr/allocate_shared_array.hpp" 2 3 4
+
+
+
+# 1 "/usr/include/boost/type_traits/extent.hpp" 1 3 4
+# 11 "/usr/include/boost/type_traits/extent.hpp" 3 4
+#define BOOST_TT_EXTENT_HPP_INCLUDED 
+
+
+
+
+
+namespace boost {
+
+namespace detail{
+# 30 "/usr/include/boost/type_traits/extent.hpp" 3 4
+template <class T, std::size_t N>
+struct extent_imp
+{
+   static const std::size_t value = 0;
+};
+
+template <class T, std::size_t R, std::size_t N>
+struct extent_imp<T[R], N>
+{
+   static const std::size_t value = (::boost::detail::extent_imp<T, N-1>::value);
+};
+
+template <class T, std::size_t R, std::size_t N>
+struct extent_imp<T const[R], N>
+{
+   static const std::size_t value = (::boost::detail::extent_imp<T, N-1>::value);
+};
+
+template <class T, std::size_t R, std::size_t N>
+struct extent_imp<T volatile[R], N>
+{
+   static const std::size_t value = (::boost::detail::extent_imp<T, N-1>::value);
+};
+
+template <class T, std::size_t R, std::size_t N>
+struct extent_imp<T const volatile[R], N>
+{
+   static const std::size_t value = (::boost::detail::extent_imp<T, N-1>::value);
+};
+
+template <class T, std::size_t R>
+struct extent_imp<T[R],0>
+{
+   static const std::size_t value = R;
+};
+
+template <class T, std::size_t R>
+struct extent_imp<T const[R], 0>
+{
+   static const std::size_t value = R;
+};
+
+template <class T, std::size_t R>
+struct extent_imp<T volatile[R], 0>
+{
+   static const std::size_t value = R;
+};
+
+template <class T, std::size_t R>
+struct extent_imp<T const volatile[R], 0>
+{
+   static const std::size_t value = R;
+};
+
+
+template <class T, std::size_t N>
+struct extent_imp<T[], N>
+{
+   static const std::size_t value = (::boost::detail::extent_imp<T, N-1>::value);
+};
+template <class T, std::size_t N>
+struct extent_imp<T const[], N>
+{
+   static const std::size_t value = (::boost::detail::extent_imp<T, N-1>::value);
+};
+template <class T, std::size_t N>
+struct extent_imp<T volatile[], N>
+{
+   static const std::size_t value = (::boost::detail::extent_imp<T, N-1>::value);
+};
+template <class T, std::size_t N>
+struct extent_imp<T const volatile[], N>
+{
+   static const std::size_t value = (::boost::detail::extent_imp<T, N-1>::value);
+};
+template <class T>
+struct extent_imp<T[], 0>
+{
+   static const std::size_t value = 0;
+};
+template <class T>
+struct extent_imp<T const[], 0>
+{
+   static const std::size_t value = 0;
+};
+template <class T>
+struct extent_imp<T volatile[], 0>
+{
+   static const std::size_t value = 0;
+};
+template <class T>
+struct extent_imp<T const volatile[], 0>
+{
+   static const std::size_t value = 0;
+};
+
+
+
+
+}
+
+template <class T, std::size_t N = 0>
+struct extent
+   : public ::boost::integral_constant<std::size_t, ::boost::detail::extent_imp<T,N>::value>
+{
+};
+
+}
+# 17 "/usr/include/boost/smart_ptr/allocate_shared_array.hpp" 2 3 4
+# 1 "/usr/include/boost/type_traits/is_bounded_array.hpp" 1 3 4
+# 11 "/usr/include/boost/type_traits/is_bounded_array.hpp" 3 4
+#define BOOST_TT_IS_BOUNDED_ARRAY_HPP_INCLUDED 
+
+
+
+
+namespace boost {
+
+template<class T>
+struct is_bounded_array
+    : false_type { };
+
+
+template<class T, std::size_t N>
+struct is_bounded_array<T[N]>
+    : true_type { };
+
+template<class T, std::size_t N>
+struct is_bounded_array<const T[N]>
+    : true_type { };
+
+template<class T, std::size_t N>
+struct is_bounded_array<volatile T[N]>
+    : true_type { };
+
+template<class T, std::size_t N>
+struct is_bounded_array<const volatile T[N]>
+    : true_type { };
+
+
+}
+# 18 "/usr/include/boost/smart_ptr/allocate_shared_array.hpp" 2 3 4
+# 1 "/usr/include/boost/type_traits/is_unbounded_array.hpp" 1 3 4
+# 11 "/usr/include/boost/type_traits/is_unbounded_array.hpp" 3 4
+#define BOOST_TT_IS_UNBOUNDED_ARRAY_HPP_INCLUDED 
+
+
+
+namespace boost {
+
+template<class T>
+struct is_unbounded_array
+    : false_type { };
+
+
+template<class T>
+struct is_unbounded_array<T[]>
+    : true_type { };
+
+template<class T>
+struct is_unbounded_array<const T[]>
+    : true_type { };
+
+template<class T>
+struct is_unbounded_array<volatile T[]>
+    : true_type { };
+
+template<class T>
+struct is_unbounded_array<const volatile T[]>
+    : true_type { };
+
+
+}
+# 19 "/usr/include/boost/smart_ptr/allocate_shared_array.hpp" 2 3 4
+
+# 1 "/usr/include/boost/type_traits/remove_extent.hpp" 1 3 4
+# 10 "/usr/include/boost/type_traits/remove_extent.hpp" 3 4
+#define BOOST_TT_REMOVE_EXTENT_HPP_INCLUDED 
+
+
+
+
+
+namespace boost {
+
+template <class T> struct remove_extent{ typedef T type; };
+
+
+template <typename T, std::size_t N> struct remove_extent<T[N]> { typedef T type; };
+template <typename T, std::size_t N> struct remove_extent<T const[N]> { typedef T const type; };
+template <typename T, std::size_t N> struct remove_extent<T volatile [N]> { typedef T volatile type; };
+template <typename T, std::size_t N> struct remove_extent<T const volatile [N]> { typedef T const volatile type; };
+
+template <typename T> struct remove_extent<T[]> { typedef T type; };
+template <typename T> struct remove_extent<T const[]> { typedef T const type; };
+template <typename T> struct remove_extent<T volatile[]> { typedef T volatile type; };
+template <typename T> struct remove_extent<T const volatile[]> { typedef T const volatile type; };
+
+
+
+
+
+   template <class T> using remove_extent_t = typename remove_extent<T>::type;
+
+
+
+}
+# 21 "/usr/include/boost/smart_ptr/allocate_shared_array.hpp" 2 3 4
+
+
+namespace boost {
+namespace detail {
+
+template<class T>
+struct sp_array_element {
+    typedef typename boost::remove_cv<typename
+        boost::remove_extent<T>::type>::type type;
+};
+
+template<class T>
+struct sp_array_count {
+    enum {
+        value = 1
+    };
+};
+
+template<class T, std::size_t N>
+struct sp_array_count<T[N]> {
+    enum {
+        value = N * sp_array_count<T>::value
+    };
+};
+
+template<std::size_t N, std::size_t M>
+struct sp_max_size {
+    enum {
+        value = N < M ? M : N
+    };
+};
+
+template<std::size_t N, std::size_t M>
+struct sp_align_up {
+    enum {
+        value = (N + M - 1) & ~(M - 1)
+    };
+};
+
+
+template<class A, class T>
+struct sp_bind_allocator {
+    typedef typename std::allocator_traits<A>::template rebind_alloc<T> type;
+};
+
+
+
+
+
+
+
+template<class T>
+constexpr inline std::size_t
+sp_objects(std::size_t size) noexcept
+{
+    return (size + sizeof(T) - 1) / sizeof(T);
+}
+
+template<class A>
+class sp_array_state {
+public:
+    typedef A type;
+
+    template<class U>
+    sp_array_state(const U& _allocator, std::size_t _size) noexcept
+        : allocator_(_allocator),
+          size_(_size) { }
+
+    A& allocator() noexcept {
+        return allocator_;
+    }
+
+    std::size_t size() const noexcept {
+        return size_;
+    }
+
+private:
+    A allocator_;
+    std::size_t size_;
+};
+
+template<class A, std::size_t N>
+class sp_size_array_state {
+public:
+    typedef A type;
+
+    template<class U>
+    sp_size_array_state(const U& _allocator, std::size_t) noexcept
+        : allocator_(_allocator) { }
+
+    A& allocator() noexcept {
+        return allocator_;
+    }
+
+    constexpr std::size_t size() const noexcept {
+        return N;
+    }
+
+private:
+    A allocator_;
+};
+
+template<class T, class U>
+struct sp_array_alignment {
+    enum {
+        value = sp_max_size<boost::alignment_of<T>::value,
+            boost::alignment_of<U>::value>::value
+    };
+};
+
+template<class T, class U>
+struct sp_array_offset {
+    enum {
+        value = sp_align_up<sizeof(T), sp_array_alignment<T, U>::value>::value
+    };
+};
+
+template<class U, class T>
+inline U*
+sp_array_start(T* base) noexcept
+{
+    enum {
+        size = sp_array_offset<T, U>::value
+    };
+    return reinterpret_cast<U*>(reinterpret_cast<char*>(base) + size);
+}
+
+template<class A, class T>
+class sp_array_creator {
+    typedef typename A::value_type element;
+
+    enum {
+        offset = sp_array_offset<T, element>::value
+    };
+
+    typedef typename boost::type_with_alignment<sp_array_alignment<T,
+        element>::value>::type type;
+
+public:
+    template<class U>
+    sp_array_creator(const U& other, std::size_t size) noexcept
+        : other_(other),
+          size_(sp_objects<type>(offset + sizeof(element) * size)) { }
+
+    T* create() {
+        return reinterpret_cast<T*>(other_.allocate(size_));
+    }
+
+    void destroy(T* base) {
+        other_.deallocate(reinterpret_cast<type*>(base), size_);
+    }
+
+private:
+    typename sp_bind_allocator<A, type>::type other_;
+    std::size_t size_;
+};
+
+template<class T>
+class __attribute__((__visibility__("default"))) sp_array_base
+    : public sp_counted_base {
+    typedef typename T::type allocator;
+
+public:
+    typedef typename allocator::value_type type;
+
+    template<class A>
+    sp_array_base(const A& other, type* start, std::size_t size)
+        : state_(other, size) {
+        boost::alloc_construct_n(state_.allocator(),
+            boost::first_scalar(start),
+            state_.size() * sp_array_count<type>::value);
+    }
+
+    template<class A, class U>
+    sp_array_base(const A& other, type* start, std::size_t size, const U& list)
+        : state_(other, size) {
+        enum {
+            count = sp_array_count<type>::value
+        };
+        boost::alloc_construct_n(state_.allocator(),
+            boost::first_scalar(start), state_.size() * count,
+            boost::first_scalar(&list), count);
+    }
+
+    T& state() noexcept {
+        return state_;
+    }
+
+    virtual void dispose() noexcept {
+        boost::alloc_destroy_n(state_.allocator(),
+            boost::first_scalar(sp_array_start<type>(this)),
+            state_.size() * sp_array_count<type>::value);
+    }
+
+    virtual void destroy() noexcept {
+        sp_array_creator<allocator, sp_array_base> other(state_.allocator(),
+            state_.size());
+        this->~sp_array_base();
+        other.destroy(this);
+    }
+
+    virtual void* get_deleter(const sp_typeinfo_&) noexcept {
+        return 0;
+    }
+
+    virtual void* get_local_deleter(const sp_typeinfo_&) noexcept {
+        return 0;
+    }
+
+    virtual void* get_untyped_deleter() noexcept {
+        return 0;
+    }
+
+private:
+    T state_;
+};
+
+template<class A, class T>
+struct sp_array_result {
+public:
+    template<class U>
+    sp_array_result(const U& other, std::size_t size)
+        : creator_(other, size),
+          result_(creator_.create()) { }
+
+    ~sp_array_result() {
+        if (result_) {
+            creator_.destroy(result_);
+        }
+    }
+
+    T* get() const noexcept {
+        return result_;
+    }
+
+    void release() noexcept {
+        result_ = 0;
+    }
+
+private:
+    sp_array_result(const sp_array_result&);
+    sp_array_result& operator=(const sp_array_result&);
+
+    sp_array_creator<A, T> creator_;
+    T* result_;
+};
+
+}
+
+template<class T, class A>
+inline typename enable_if_<is_unbounded_array<T>::value, shared_ptr<T> >::type
+allocate_shared(const A& allocator, std::size_t count)
+{
+    typedef typename detail::sp_array_element<T>::type element;
+    typedef typename detail::sp_bind_allocator<A, element>::type other;
+    typedef detail::sp_array_state<other> state;
+    typedef detail::sp_array_base<state> base;
+    detail::sp_array_result<other, base> result(allocator, count);
+    base* node = result.get();
+    element* start = detail::sp_array_start<element>(node);
+    ::new(static_cast<void*>(node)) base(allocator, start, count);
+    result.release();
+    return shared_ptr<T>(detail::sp_internal_constructor_tag(), start,
+        detail::shared_count(static_cast<detail::sp_counted_base*>(node)));
+}
+
+template<class T, class A>
+inline typename enable_if_<is_bounded_array<T>::value, shared_ptr<T> >::type
+allocate_shared(const A& allocator)
+{
+    enum {
+        count = extent<T>::value
+    };
+    typedef typename detail::sp_array_element<T>::type element;
+    typedef typename detail::sp_bind_allocator<A, element>::type other;
+    typedef detail::sp_size_array_state<other, extent<T>::value> state;
+    typedef detail::sp_array_base<state> base;
+    detail::sp_array_result<other, base> result(allocator, count);
+    base* node = result.get();
+    element* start = detail::sp_array_start<element>(node);
+    ::new(static_cast<void*>(node)) base(allocator, start, count);
+    result.release();
+    return shared_ptr<T>(detail::sp_internal_constructor_tag(), start,
+        detail::shared_count(static_cast<detail::sp_counted_base*>(node)));
+}
+
+template<class T, class A>
+inline typename enable_if_<is_unbounded_array<T>::value, shared_ptr<T> >::type
+allocate_shared(const A& allocator, std::size_t count,
+    const typename remove_extent<T>::type& value)
+{
+    typedef typename detail::sp_array_element<T>::type element;
+    typedef typename detail::sp_bind_allocator<A, element>::type other;
+    typedef detail::sp_array_state<other> state;
+    typedef detail::sp_array_base<state> base;
+    detail::sp_array_result<other, base> result(allocator, count);
+    base* node = result.get();
+    element* start = detail::sp_array_start<element>(node);
+    ::new(static_cast<void*>(node)) base(allocator, start, count, value);
+    result.release();
+    return shared_ptr<T>(detail::sp_internal_constructor_tag(), start,
+        detail::shared_count(static_cast<detail::sp_counted_base*>(node)));
+}
+
+template<class T, class A>
+inline typename enable_if_<is_bounded_array<T>::value, shared_ptr<T> >::type
+allocate_shared(const A& allocator,
+    const typename remove_extent<T>::type& value)
+{
+    enum {
+        count = extent<T>::value
+    };
+    typedef typename detail::sp_array_element<T>::type element;
+    typedef typename detail::sp_bind_allocator<A, element>::type other;
+    typedef detail::sp_size_array_state<other, extent<T>::value> state;
+    typedef detail::sp_array_base<state> base;
+    detail::sp_array_result<other, base> result(allocator, count);
+    base* node = result.get();
+    element* start = detail::sp_array_start<element>(node);
+    ::new(static_cast<void*>(node)) base(allocator, start, count, value);
+    result.release();
+    return shared_ptr<T>(detail::sp_internal_constructor_tag(), start,
+        detail::shared_count(static_cast<detail::sp_counted_base*>(node)));
+}
+
+template<class T, class A>
+inline typename enable_if_<is_unbounded_array<T>::value, shared_ptr<T> >::type
+allocate_shared_noinit(const A& allocator, std::size_t count)
+{
+    return boost::allocate_shared<T>(boost::noinit_adapt(allocator), count);
+}
+
+template<class T, class A>
+inline typename enable_if_<is_bounded_array<T>::value, shared_ptr<T> >::type
+allocate_shared_noinit(const A& allocator)
+{
+    return boost::allocate_shared<T>(boost::noinit_adapt(allocator));
+}
+
+}
+# 13 "/usr/include/boost/smart_ptr/make_shared_array.hpp" 2 3 4
+
+namespace boost {
+
+template<class T>
+inline typename enable_if_<is_bounded_array<T>::value, shared_ptr<T> >::type
+make_shared()
+{
+    return boost::allocate_shared<T>(boost::default_allocator<typename
+        detail::sp_array_element<T>::type>());
+}
+
+template<class T>
+inline typename enable_if_<is_bounded_array<T>::value, shared_ptr<T> >::type
+make_shared(const typename remove_extent<T>::type& value)
+{
+    return boost::allocate_shared<T>(boost::default_allocator<typename
+        detail::sp_array_element<T>::type>(), value);
+}
+
+template<class T>
+inline typename enable_if_<is_unbounded_array<T>::value, shared_ptr<T> >::type
+make_shared(std::size_t size)
+{
+    return boost::allocate_shared<T>(boost::default_allocator<typename
+        detail::sp_array_element<T>::type>(), size);
+}
+
+template<class T>
+inline typename enable_if_<is_unbounded_array<T>::value, shared_ptr<T> >::type
+make_shared(std::size_t size, const typename remove_extent<T>::type& value)
+{
+    return boost::allocate_shared<T>(boost::default_allocator<typename
+        detail::sp_array_element<T>::type>(), size, value);
+}
+
+template<class T>
+inline typename enable_if_<is_bounded_array<T>::value, shared_ptr<T> >::type
+make_shared_noinit()
+{
+    return boost::allocate_shared_noinit<T>(boost::default_allocator<typename
+        detail::sp_array_element<T>::type>());
+}
+
+template<class T>
+inline typename enable_if_<is_unbounded_array<T>::value, shared_ptr<T> >::type
+make_shared_noinit(std::size_t size)
+{
+    return boost::allocate_shared_noinit<T>(boost::default_allocator<typename
+        detail::sp_array_element<T>::type>(), size);
+}
+
+}
+# 18 "/usr/include/boost/smart_ptr/make_shared.hpp" 2 3 4
+# 15 "/usr/include/boost/make_shared.hpp" 2 3 4
+# 21 "/usr/include/boost/test/unit_test_parameters.hpp" 2 3 4
+
+
+# 1 "/usr/include/boost/function/function0.hpp" 1 3 4
+# 10 "/usr/include/boost/function/function0.hpp" 3 4
+#define BOOST_FUNCTION_NUM_ARGS 0
+# 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
+# 11 "/usr/include/boost/function/detail/maybe_include.hpp" 3 4
+#undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#define BOOST_FUNCTION_MAX_ARGS_DEFINED 0
+# 12 "/usr/include/boost/function/function0.hpp" 2 3 4
+#undef BOOST_FUNCTION_NUM_ARGS
+# 24 "/usr/include/boost/test/unit_test_parameters.hpp" 2 3 4
+
+
+
+# 1 "/usr/include/c++/10.2.0/fstream" 1 3 4
+# 34 "/usr/include/c++/10.2.0/fstream" 3 4
+#define _GLIBCXX_FSTREAM 1
+
+       
+# 37 "/usr/include/c++/10.2.0/fstream" 3
+
+
+
+# 1 "/usr/include/c++/10.2.0/bits/codecvt.h" 1 3
+# 37 "/usr/include/c++/10.2.0/bits/codecvt.h" 3
+#define _CODECVT_H 1
+
+       
+# 40 "/usr/include/c++/10.2.0/bits/codecvt.h" 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+  class codecvt_base
+  {
+  public:
+    enum result
+    {
+      ok,
+      partial,
+      error,
+      noconv
+    };
+  };
+# 67 "/usr/include/c++/10.2.0/bits/codecvt.h" 3
+  template<typename _InternT, typename _ExternT, typename _StateT>
+    class __codecvt_abstract_base
+    : public locale::facet, public codecvt_base
+    {
+    public:
+
+      typedef codecvt_base::result result;
+      typedef _InternT intern_type;
+      typedef _ExternT extern_type;
+      typedef _StateT state_type;
+# 115 "/usr/include/c++/10.2.0/bits/codecvt.h" 3
+      result
+      out(state_type& __state, const intern_type* __from,
+   const intern_type* __from_end, const intern_type*& __from_next,
+   extern_type* __to, extern_type* __to_end,
+   extern_type*& __to_next) const
+      {
+ return this->do_out(__state, __from, __from_end, __from_next,
+       __to, __to_end, __to_next);
+      }
+# 154 "/usr/include/c++/10.2.0/bits/codecvt.h" 3
+      result
+      unshift(state_type& __state, extern_type* __to, extern_type* __to_end,
+       extern_type*& __to_next) const
+      { return this->do_unshift(__state, __to,__to_end,__to_next); }
+# 195 "/usr/include/c++/10.2.0/bits/codecvt.h" 3
+      result
+      in(state_type& __state, const extern_type* __from,
+  const extern_type* __from_end, const extern_type*& __from_next,
+  intern_type* __to, intern_type* __to_end,
+  intern_type*& __to_next) const
+      {
+ return this->do_in(__state, __from, __from_end, __from_next,
+      __to, __to_end, __to_next);
+      }
+
+      int
+      encoding() const throw()
+      { return this->do_encoding(); }
+
+      bool
+      always_noconv() const throw()
+      { return this->do_always_noconv(); }
+
+      int
+      length(state_type& __state, const extern_type* __from,
+      const extern_type* __end, size_t __max) const
+      { return this->do_length(__state, __from, __end, __max); }
+
+      int
+      max_length() const throw()
+      { return this->do_max_length(); }
+
+    protected:
+      explicit
+      __codecvt_abstract_base(size_t __refs = 0) : locale::facet(__refs) { }
+
+      virtual
+      ~__codecvt_abstract_base() { }
+# 236 "/usr/include/c++/10.2.0/bits/codecvt.h" 3
+      virtual result
+      do_out(state_type& __state, const intern_type* __from,
+      const intern_type* __from_end, const intern_type*& __from_next,
+      extern_type* __to, extern_type* __to_end,
+      extern_type*& __to_next) const = 0;
+
+      virtual result
+      do_unshift(state_type& __state, extern_type* __to,
+   extern_type* __to_end, extern_type*& __to_next) const = 0;
+
+      virtual result
+      do_in(state_type& __state, const extern_type* __from,
+     const extern_type* __from_end, const extern_type*& __from_next,
+     intern_type* __to, intern_type* __to_end,
+     intern_type*& __to_next) const = 0;
+
+      virtual int
+      do_encoding() const throw() = 0;
+
+      virtual bool
+      do_always_noconv() const throw() = 0;
+
+      virtual int
+      do_length(state_type&, const extern_type* __from,
+  const extern_type* __end, size_t __max) const = 0;
+
+      virtual int
+      do_max_length() const throw() = 0;
+    };
+# 273 "/usr/include/c++/10.2.0/bits/codecvt.h" 3
+   template<typename _InternT, typename _ExternT, typename _StateT>
+    class codecvt
+    : public __codecvt_abstract_base<_InternT, _ExternT, _StateT>
+    {
+    public:
+
+      typedef codecvt_base::result result;
+      typedef _InternT intern_type;
+      typedef _ExternT extern_type;
+      typedef _StateT state_type;
+
+    protected:
+      __c_locale _M_c_locale_codecvt;
+
+    public:
+      static locale::id id;
+
+      explicit
+      codecvt(size_t __refs = 0)
+      : __codecvt_abstract_base<_InternT, _ExternT, _StateT> (__refs),
+ _M_c_locale_codecvt(0)
+      { }
+
+      explicit
+      codecvt(__c_locale __cloc, size_t __refs = 0);
+
+    protected:
+      virtual
+      ~codecvt() { }
+
+      virtual result
+      do_out(state_type& __state, const intern_type* __from,
+      const intern_type* __from_end, const intern_type*& __from_next,
+      extern_type* __to, extern_type* __to_end,
+      extern_type*& __to_next) const;
+
+      virtual result
+      do_unshift(state_type& __state, extern_type* __to,
+   extern_type* __to_end, extern_type*& __to_next) const;
+
+      virtual result
+      do_in(state_type& __state, const extern_type* __from,
+     const extern_type* __from_end, const extern_type*& __from_next,
+     intern_type* __to, intern_type* __to_end,
+     intern_type*& __to_next) const;
+
+      virtual int
+      do_encoding() const throw();
+
+      virtual bool
+      do_always_noconv() const throw();
+
+      virtual int
+      do_length(state_type&, const extern_type* __from,
+  const extern_type* __end, size_t __max) const;
+
+      virtual int
+      do_max_length() const throw();
+    };
+
+  template<typename _InternT, typename _ExternT, typename _StateT>
+    locale::id codecvt<_InternT, _ExternT, _StateT>::id;
+
+
+  template<>
+    class codecvt<char, char, mbstate_t>
+    : public __codecvt_abstract_base<char, char, mbstate_t>
+    {
+      friend class messages<char>;
+
+    public:
+
+      typedef char intern_type;
+      typedef char extern_type;
+      typedef mbstate_t state_type;
+
+    protected:
+      __c_locale _M_c_locale_codecvt;
+
+    public:
+      static locale::id id;
+
+      explicit
+      codecvt(size_t __refs = 0);
+
+      explicit
+      codecvt(__c_locale __cloc, size_t __refs = 0);
+
+    protected:
+      virtual
+      ~codecvt();
+
+      virtual result
+      do_out(state_type& __state, const intern_type* __from,
+      const intern_type* __from_end, const intern_type*& __from_next,
+      extern_type* __to, extern_type* __to_end,
+      extern_type*& __to_next) const;
+
+      virtual result
+      do_unshift(state_type& __state, extern_type* __to,
+   extern_type* __to_end, extern_type*& __to_next) const;
+
+      virtual result
+      do_in(state_type& __state, const extern_type* __from,
+     const extern_type* __from_end, const extern_type*& __from_next,
+     intern_type* __to, intern_type* __to_end,
+     intern_type*& __to_next) const;
+
+      virtual int
+      do_encoding() const throw();
+
+      virtual bool
+      do_always_noconv() const throw();
+
+      virtual int
+      do_length(state_type&, const extern_type* __from,
+  const extern_type* __end, size_t __max) const;
+
+      virtual int
+      do_max_length() const throw();
+  };
+
+
+
+
+
+
+  template<>
+    class codecvt<wchar_t, char, mbstate_t>
+    : public __codecvt_abstract_base<wchar_t, char, mbstate_t>
+    {
+      friend class messages<wchar_t>;
+
+    public:
+
+      typedef wchar_t intern_type;
+      typedef char extern_type;
+      typedef mbstate_t state_type;
+
+    protected:
+      __c_locale _M_c_locale_codecvt;
+
+    public:
+      static locale::id id;
+
+      explicit
+      codecvt(size_t __refs = 0);
+
+      explicit
+      codecvt(__c_locale __cloc, size_t __refs = 0);
+
+    protected:
+      virtual
+      ~codecvt();
+
+      virtual result
+      do_out(state_type& __state, const intern_type* __from,
+      const intern_type* __from_end, const intern_type*& __from_next,
+      extern_type* __to, extern_type* __to_end,
+      extern_type*& __to_next) const;
+
+      virtual result
+      do_unshift(state_type& __state,
+   extern_type* __to, extern_type* __to_end,
+   extern_type*& __to_next) const;
+
+      virtual result
+      do_in(state_type& __state,
+      const extern_type* __from, const extern_type* __from_end,
+      const extern_type*& __from_next,
+      intern_type* __to, intern_type* __to_end,
+      intern_type*& __to_next) const;
+
+      virtual
+      int do_encoding() const throw();
+
+      virtual
+      bool do_always_noconv() const throw();
+
+      virtual
+      int do_length(state_type&, const extern_type* __from,
+      const extern_type* __end, size_t __max) const;
+
+      virtual int
+      do_max_length() const throw();
+    };
+
+
+
+
+
+
+
+  template<>
+    class codecvt<char16_t, char, mbstate_t>
+    : public __codecvt_abstract_base<char16_t, char, mbstate_t>
+    {
+    public:
+
+      typedef char16_t intern_type;
+      typedef char extern_type;
+      typedef mbstate_t state_type;
+
+    public:
+      static locale::id id;
+
+      explicit
+      codecvt(size_t __refs = 0)
+      : __codecvt_abstract_base<char16_t, char, mbstate_t>(__refs) { }
+
+    protected:
+      virtual
+      ~codecvt();
+
+      virtual result
+      do_out(state_type& __state, const intern_type* __from,
+      const intern_type* __from_end, const intern_type*& __from_next,
+      extern_type* __to, extern_type* __to_end,
+      extern_type*& __to_next) const;
+
+      virtual result
+      do_unshift(state_type& __state,
+   extern_type* __to, extern_type* __to_end,
+   extern_type*& __to_next) const;
+
+      virtual result
+      do_in(state_type& __state,
+      const extern_type* __from, const extern_type* __from_end,
+      const extern_type*& __from_next,
+      intern_type* __to, intern_type* __to_end,
+      intern_type*& __to_next) const;
+
+      virtual
+      int do_encoding() const throw();
+
+      virtual
+      bool do_always_noconv() const throw();
+
+      virtual
+      int do_length(state_type&, const extern_type* __from,
+      const extern_type* __end, size_t __max) const;
+
+      virtual int
+      do_max_length() const throw();
+    };
+
+
+
+
+
+  template<>
+    class codecvt<char32_t, char, mbstate_t>
+    : public __codecvt_abstract_base<char32_t, char, mbstate_t>
+    {
+    public:
+
+      typedef char32_t intern_type;
+      typedef char extern_type;
+      typedef mbstate_t state_type;
+
+    public:
+      static locale::id id;
+
+      explicit
+      codecvt(size_t __refs = 0)
+      : __codecvt_abstract_base<char32_t, char, mbstate_t>(__refs) { }
+
+    protected:
+      virtual
+      ~codecvt();
+
+      virtual result
+      do_out(state_type& __state, const intern_type* __from,
+      const intern_type* __from_end, const intern_type*& __from_next,
+      extern_type* __to, extern_type* __to_end,
+      extern_type*& __to_next) const;
+
+      virtual result
+      do_unshift(state_type& __state,
+   extern_type* __to, extern_type* __to_end,
+   extern_type*& __to_next) const;
+
+      virtual result
+      do_in(state_type& __state,
+      const extern_type* __from, const extern_type* __from_end,
+      const extern_type*& __from_next,
+      intern_type* __to, intern_type* __to_end,
+      intern_type*& __to_next) const;
+
+      virtual
+      int do_encoding() const throw();
+
+      virtual
+      bool do_always_noconv() const throw();
+
+      virtual
+      int do_length(state_type&, const extern_type* __from,
+      const extern_type* __end, size_t __max) const;
+
+      virtual int
+      do_max_length() const throw();
+    };
+# 695 "/usr/include/c++/10.2.0/bits/codecvt.h" 3
+  template<typename _InternT, typename _ExternT, typename _StateT>
+    class codecvt_byname : public codecvt<_InternT, _ExternT, _StateT>
+    {
+    public:
+      explicit
+      codecvt_byname(const char* __s, size_t __refs = 0)
+      : codecvt<_InternT, _ExternT, _StateT>(__refs)
+      {
+ if (__builtin_strcmp(__s, "C") != 0
+     && __builtin_strcmp(__s, "POSIX") != 0)
+   {
+     this->_S_destroy_c_locale(this->_M_c_locale_codecvt);
+     this->_S_create_c_locale(this->_M_c_locale_codecvt, __s);
+   }
+      }
+
+
+      explicit
+      codecvt_byname(const string& __s, size_t __refs = 0)
+      : codecvt_byname(__s.c_str(), __refs) { }
+
+
+    protected:
+      virtual
+      ~codecvt_byname() { }
+    };
+
+
+  template<>
+    class codecvt_byname<char16_t, char, mbstate_t>
+    : public codecvt<char16_t, char, mbstate_t>
+    {
+    public:
+      explicit
+      codecvt_byname(const char*, size_t __refs = 0)
+      : codecvt<char16_t, char, mbstate_t>(__refs) { }
+
+      explicit
+      codecvt_byname(const string& __s, size_t __refs = 0)
+      : codecvt_byname(__s.c_str(), __refs) { }
+
+    protected:
+      virtual
+      ~codecvt_byname() { }
+    };
+
+  template<>
+    class codecvt_byname<char32_t, char, mbstate_t>
+    : public codecvt<char32_t, char, mbstate_t>
+    {
+    public:
+      explicit
+      codecvt_byname(const char*, size_t __refs = 0)
+      : codecvt<char32_t, char, mbstate_t>(__refs) { }
+
+      explicit
+      codecvt_byname(const string& __s, size_t __refs = 0)
+      : codecvt_byname(__s.c_str(), __refs) { }
+
+    protected:
+      virtual
+      ~codecvt_byname() { }
+    };
+# 802 "/usr/include/c++/10.2.0/bits/codecvt.h" 3
+  extern template class codecvt_byname<char, char, mbstate_t>;
+
+  extern template
+    const codecvt<char, char, mbstate_t>&
+    use_facet<codecvt<char, char, mbstate_t> >(const locale&);
+
+  extern template
+    bool
+    has_facet<codecvt<char, char, mbstate_t> >(const locale&);
+
+
+  extern template class codecvt_byname<wchar_t, char, mbstate_t>;
+
+  extern template
+    const codecvt<wchar_t, char, mbstate_t>&
+    use_facet<codecvt<wchar_t, char, mbstate_t> >(const locale&);
+
+  extern template
+    bool
+    has_facet<codecvt<wchar_t, char, mbstate_t> >(const locale&);
+
+
+
+  extern template class codecvt_byname<char16_t, char, mbstate_t>;
+  extern template class codecvt_byname<char32_t, char, mbstate_t>;
+# 837 "/usr/include/c++/10.2.0/bits/codecvt.h" 3
+
+}
+# 41 "/usr/include/c++/10.2.0/fstream" 2 3
+# 1 "/usr/include/c++/10.2.0/cstdio" 1 3
+# 39 "/usr/include/c++/10.2.0/cstdio" 3
+       
+# 40 "/usr/include/c++/10.2.0/cstdio" 3
+# 42 "/usr/include/c++/10.2.0/fstream" 2 3
+# 1 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/basic_file.h" 1 3
+# 35 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/basic_file.h" 3
+#define _GLIBCXX_BASIC_FILE_STDIO_H 1
+
+       
+# 38 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/basic_file.h" 3
+
+
+# 1 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++io.h" 1 3
+# 33 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++io.h" 3
+#define _GLIBCXX_CXX_IO_H 1
+
+# 1 "/usr/include/c++/10.2.0/cstdio" 1 3
+# 39 "/usr/include/c++/10.2.0/cstdio" 3
+       
+# 40 "/usr/include/c++/10.2.0/cstdio" 3
+# 36 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++io.h" 2 3
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  typedef __gthread_mutex_t __c_lock;
+
+
+  typedef FILE __c_file;
+
+
+}
+# 41 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/basic_file.h" 2 3
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+  template<typename _CharT>
+    class __basic_file;
+
+
+  template<>
+    class __basic_file<char>
+    {
+
+      __c_file* _M_cfile;
+
+
+      bool _M_cfile_created;
+
+    public:
+      __basic_file(__c_lock* __lock = 0) throw ();
+
+
+      __basic_file(__basic_file&& __rv, __c_lock* = 0) noexcept
+      : _M_cfile(__rv._M_cfile), _M_cfile_created(__rv._M_cfile_created)
+      {
+ __rv._M_cfile = nullptr;
+ __rv._M_cfile_created = false;
+      }
+
+      __basic_file& operator=(const __basic_file&) = delete;
+      __basic_file& operator=(__basic_file&&) = delete;
+
+      void
+      swap(__basic_file& __f) noexcept
+      {
+ std::swap(_M_cfile, __f._M_cfile);
+ std::swap(_M_cfile_created, __f._M_cfile_created);
+      }
+
+
+      __basic_file*
+      open(const char* __name, ios_base::openmode __mode, int __prot = 0664);
+
+
+
+
+
+
+      __basic_file*
+      sys_open(__c_file* __file, ios_base::openmode);
+
+      __basic_file*
+      sys_open(int __fd, ios_base::openmode __mode) throw ();
+
+      __basic_file*
+      close();
+
+      __attribute__ ((__pure__)) bool
+      is_open() const throw ();
+
+      __attribute__ ((__pure__)) int
+      fd() throw ();
+
+      __attribute__ ((__pure__)) __c_file*
+      file() throw ();
+
+      ~__basic_file();
+
+      streamsize
+      xsputn(const char* __s, streamsize __n);
+
+      streamsize
+      xsputn_2(const char* __s1, streamsize __n1,
+        const char* __s2, streamsize __n2);
+
+      streamsize
+      xsgetn(char* __s, streamsize __n);
+
+      streamoff
+      seekoff(streamoff __off, ios_base::seekdir __way) throw ();
+
+      int
+      sync();
+
+      streamsize
+      showmanyc();
+    };
+
+
+}
+# 43 "/usr/include/c++/10.2.0/fstream" 2 3
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+  template<typename _Path, typename _Result = _Path, typename _Path2
+    = decltype(std::declval<_Path&>().make_preferred().filename())>
+    using _If_fs_path = enable_if_t<is_same_v<_Path, _Path2>, _Result>;
+# 79 "/usr/include/c++/10.2.0/fstream" 3
+  template<typename _CharT, typename _Traits>
+    class basic_filebuf : public basic_streambuf<_CharT, _Traits>
+    {
+
+      template<typename _Tp>
+ using __chk_state = __and_<is_copy_assignable<_Tp>,
+       is_copy_constructible<_Tp>,
+       is_default_constructible<_Tp>>;
+
+      static_assert(__chk_state<typename _Traits::state_type>::value,
+      "state_type must be CopyAssignable, CopyConstructible"
+      " and DefaultConstructible");
+
+      static_assert(is_same<typename _Traits::pos_type,
+       fpos<typename _Traits::state_type>>::value,
+      "pos_type must be fpos<state_type>");
+
+    public:
+
+      typedef _CharT char_type;
+      typedef _Traits traits_type;
+      typedef typename traits_type::int_type int_type;
+      typedef typename traits_type::pos_type pos_type;
+      typedef typename traits_type::off_type off_type;
+
+      typedef basic_streambuf<char_type, traits_type> __streambuf_type;
+      typedef basic_filebuf<char_type, traits_type> __filebuf_type;
+      typedef __basic_file<char> __file_type;
+      typedef typename traits_type::state_type __state_type;
+      typedef codecvt<char_type, char, __state_type> __codecvt_type;
+
+      friend class ios_base;
+
+    protected:
+
+
+      __c_lock _M_lock;
+
+
+      __file_type _M_file;
+
+
+      ios_base::openmode _M_mode;
+
+
+      __state_type _M_state_beg;
+
+
+
+
+      __state_type _M_state_cur;
+
+
+
+      __state_type _M_state_last;
+
+
+      char_type* _M_buf;
+
+
+
+
+
+
+      size_t _M_buf_size;
+
+
+      bool _M_buf_allocated;
+# 155 "/usr/include/c++/10.2.0/fstream" 3
+      bool _M_reading;
+      bool _M_writing;
+
+
+
+
+
+
+
+      char_type _M_pback;
+      char_type* _M_pback_cur_save;
+      char_type* _M_pback_end_save;
+      bool _M_pback_init;
+
+
+
+      const __codecvt_type* _M_codecvt;
+
+
+
+
+
+
+      char* _M_ext_buf;
+
+
+
+
+      streamsize _M_ext_buf_size;
+
+
+
+
+
+
+      const char* _M_ext_next;
+      char* _M_ext_end;
+
+
+
+
+
+
+      void
+      _M_create_pback()
+      {
+ if (!_M_pback_init)
+   {
+     _M_pback_cur_save = this->gptr();
+     _M_pback_end_save = this->egptr();
+     this->setg(&_M_pback, &_M_pback, &_M_pback + 1);
+     _M_pback_init = true;
+   }
+      }
+
+
+
+
+
+
+      void
+      _M_destroy_pback() throw()
+      {
+ if (_M_pback_init)
+   {
+
+     _M_pback_cur_save += this->gptr() != this->eback();
+     this->setg(_M_buf, _M_pback_cur_save, _M_pback_end_save);
+     _M_pback_init = false;
+   }
+      }
+
+    public:
+
+
+
+
+
+
+
+      basic_filebuf();
+
+
+      basic_filebuf(const basic_filebuf&) = delete;
+      basic_filebuf(basic_filebuf&&);
+
+
+
+
+
+      virtual
+      ~basic_filebuf()
+      {
+ try
+   { this->close(); }
+ catch(...)
+   { }
+      }
+
+
+      basic_filebuf& operator=(const basic_filebuf&) = delete;
+      basic_filebuf& operator=(basic_filebuf&&);
+      void swap(basic_filebuf&);
+
+
+
+
+
+
+      bool
+      is_open() const throw()
+      { return _M_file.is_open(); }
+# 309 "/usr/include/c++/10.2.0/fstream" 3
+      __filebuf_type*
+      open(const char* __s, ios_base::openmode __mode);
+# 330 "/usr/include/c++/10.2.0/fstream" 3
+      __filebuf_type*
+      open(const std::string& __s, ios_base::openmode __mode)
+      { return open(__s.c_str(), __mode); }
+# 341 "/usr/include/c++/10.2.0/fstream" 3
+      template<typename _Path>
+ _If_fs_path<_Path, __filebuf_type*>
+ open(const _Path& __s, ios_base::openmode __mode)
+ { return open(__s.c_str(), __mode); }
+# 360 "/usr/include/c++/10.2.0/fstream" 3
+      __filebuf_type*
+      close();
+
+    protected:
+      void
+      _M_allocate_internal_buffer();
+
+      void
+      _M_destroy_internal_buffer() throw();
+
+
+      virtual streamsize
+      showmanyc();
+
+
+
+
+
+
+      virtual int_type
+      underflow();
+
+      virtual int_type
+      pbackfail(int_type __c = _Traits::eof());
+# 392 "/usr/include/c++/10.2.0/fstream" 3
+      virtual int_type
+      overflow(int_type __c = _Traits::eof());
+
+
+
+      bool
+      _M_convert_to_external(char_type*, streamsize);
+# 412 "/usr/include/c++/10.2.0/fstream" 3
+      virtual __streambuf_type*
+      setbuf(char_type* __s, streamsize __n);
+
+      virtual pos_type
+      seekoff(off_type __off, ios_base::seekdir __way,
+       ios_base::openmode __mode = ios_base::in | ios_base::out);
+
+      virtual pos_type
+      seekpos(pos_type __pos,
+       ios_base::openmode __mode = ios_base::in | ios_base::out);
+
+
+      pos_type
+      _M_seek(off_type __off, ios_base::seekdir __way, __state_type __state);
+
+      int
+      _M_get_ext_pos(__state_type &__state);
+
+      virtual int
+      sync();
+
+      virtual void
+      imbue(const locale& __loc);
+
+      virtual streamsize
+      xsgetn(char_type* __s, streamsize __n);
+
+      virtual streamsize
+      xsputn(const char_type* __s, streamsize __n);
+
+
+      bool
+      _M_terminate_output();
+# 458 "/usr/include/c++/10.2.0/fstream" 3
+      void
+      _M_set_buffer(streamsize __off)
+      {
+ const bool __testin = _M_mode & ios_base::in;
+ const bool __testout = (_M_mode & ios_base::out
+    || _M_mode & ios_base::app);
+
+ if (__testin && __off > 0)
+   this->setg(_M_buf, _M_buf, _M_buf + __off);
+ else
+   this->setg(_M_buf, _M_buf, _M_buf);
+
+ if (__testout && __off == 0 && _M_buf_size > 1 )
+   this->setp(_M_buf, _M_buf + _M_buf_size - 1);
+ else
+   this->setp(0, 0);
+      }
+    };
+# 491 "/usr/include/c++/10.2.0/fstream" 3
+  template<typename _CharT, typename _Traits>
+    class basic_ifstream : public basic_istream<_CharT, _Traits>
+    {
+    public:
+
+      typedef _CharT char_type;
+      typedef _Traits traits_type;
+      typedef typename traits_type::int_type int_type;
+      typedef typename traits_type::pos_type pos_type;
+      typedef typename traits_type::off_type off_type;
+
+
+      typedef basic_filebuf<char_type, traits_type> __filebuf_type;
+      typedef basic_istream<char_type, traits_type> __istream_type;
+
+    private:
+      __filebuf_type _M_filebuf;
+
+    public:
+# 518 "/usr/include/c++/10.2.0/fstream" 3
+      basic_ifstream() : __istream_type(), _M_filebuf()
+      { this->init(&_M_filebuf); }
+# 528 "/usr/include/c++/10.2.0/fstream" 3
+      explicit
+      basic_ifstream(const char* __s, ios_base::openmode __mode = ios_base::in)
+      : __istream_type(), _M_filebuf()
+      {
+ this->init(&_M_filebuf);
+ this->open(__s, __mode);
+      }
+# 561 "/usr/include/c++/10.2.0/fstream" 3
+      explicit
+      basic_ifstream(const std::string& __s,
+       ios_base::openmode __mode = ios_base::in)
+      : __istream_type(), _M_filebuf()
+      {
+ this->init(&_M_filebuf);
+ this->open(__s, __mode);
+      }
+# 578 "/usr/include/c++/10.2.0/fstream" 3
+      template<typename _Path, typename _Require = _If_fs_path<_Path>>
+ basic_ifstream(const _Path& __s,
+         ios_base::openmode __mode = ios_base::in)
+ : basic_ifstream(__s.c_str(), __mode)
+ { }
+
+
+      basic_ifstream(const basic_ifstream&) = delete;
+
+      basic_ifstream(basic_ifstream&& __rhs)
+      : __istream_type(std::move(__rhs)),
+      _M_filebuf(std::move(__rhs._M_filebuf))
+      { __istream_type::set_rdbuf(&_M_filebuf); }
+# 599 "/usr/include/c++/10.2.0/fstream" 3
+      ~basic_ifstream()
+      { }
+
+
+
+
+      basic_ifstream&
+      operator=(const basic_ifstream&) = delete;
+
+      basic_ifstream&
+      operator=(basic_ifstream&& __rhs)
+      {
+ __istream_type::operator=(std::move(__rhs));
+ _M_filebuf = std::move(__rhs._M_filebuf);
+ return *this;
+      }
+
+      void
+      swap(basic_ifstream& __rhs)
+      {
+ __istream_type::swap(__rhs);
+ _M_filebuf.swap(__rhs._M_filebuf);
+      }
+# 631 "/usr/include/c++/10.2.0/fstream" 3
+      __filebuf_type*
+      rdbuf() const
+      { return const_cast<__filebuf_type*>(&_M_filebuf); }
+
+
+
+
+
+      bool
+      is_open()
+      { return _M_filebuf.is_open(); }
+
+
+
+      bool
+      is_open() const
+      { return _M_filebuf.is_open(); }
+# 657 "/usr/include/c++/10.2.0/fstream" 3
+      void
+      open(const char* __s, ios_base::openmode __mode = ios_base::in)
+      {
+ if (!_M_filebuf.open(__s, __mode | ios_base::in))
+   this->setstate(ios_base::failbit);
+ else
+
+
+   this->clear();
+      }
+# 696 "/usr/include/c++/10.2.0/fstream" 3
+      void
+      open(const std::string& __s, ios_base::openmode __mode = ios_base::in)
+      {
+ if (!_M_filebuf.open(__s, __mode | ios_base::in))
+   this->setstate(ios_base::failbit);
+ else
+
+
+   this->clear();
+      }
+# 716 "/usr/include/c++/10.2.0/fstream" 3
+      template<typename _Path>
+ _If_fs_path<_Path, void>
+ open(const _Path& __s, ios_base::openmode __mode = ios_base::in)
+ { open(__s.c_str(), __mode); }
+# 729 "/usr/include/c++/10.2.0/fstream" 3
+      void
+      close()
+      {
+ if (!_M_filebuf.close())
+   this->setstate(ios_base::failbit);
+      }
+    };
+# 752 "/usr/include/c++/10.2.0/fstream" 3
+  template<typename _CharT, typename _Traits>
+    class basic_ofstream : public basic_ostream<_CharT,_Traits>
+    {
+    public:
+
+      typedef _CharT char_type;
+      typedef _Traits traits_type;
+      typedef typename traits_type::int_type int_type;
+      typedef typename traits_type::pos_type pos_type;
+      typedef typename traits_type::off_type off_type;
+
+
+      typedef basic_filebuf<char_type, traits_type> __filebuf_type;
+      typedef basic_ostream<char_type, traits_type> __ostream_type;
+
+    private:
+      __filebuf_type _M_filebuf;
+
+    public:
+# 779 "/usr/include/c++/10.2.0/fstream" 3
+      basic_ofstream(): __ostream_type(), _M_filebuf()
+      { this->init(&_M_filebuf); }
+# 789 "/usr/include/c++/10.2.0/fstream" 3
+      explicit
+      basic_ofstream(const char* __s,
+       ios_base::openmode __mode = ios_base::out)
+      : __ostream_type(), _M_filebuf()
+      {
+ this->init(&_M_filebuf);
+ this->open(__s, __mode);
+      }
+# 824 "/usr/include/c++/10.2.0/fstream" 3
+      explicit
+      basic_ofstream(const std::string& __s,
+       ios_base::openmode __mode = ios_base::out)
+      : __ostream_type(), _M_filebuf()
+      {
+ this->init(&_M_filebuf);
+ this->open(__s, __mode);
+      }
+# 841 "/usr/include/c++/10.2.0/fstream" 3
+      template<typename _Path, typename _Require = _If_fs_path<_Path>>
+ basic_ofstream(const _Path& __s,
+         ios_base::openmode __mode = ios_base::out)
+ : basic_ofstream(__s.c_str(), __mode)
+ { }
+
+
+      basic_ofstream(const basic_ofstream&) = delete;
+
+      basic_ofstream(basic_ofstream&& __rhs)
+      : __ostream_type(std::move(__rhs)),
+      _M_filebuf(std::move(__rhs._M_filebuf))
+      { __ostream_type::set_rdbuf(&_M_filebuf); }
+# 862 "/usr/include/c++/10.2.0/fstream" 3
+      ~basic_ofstream()
+      { }
+
+
+
+
+      basic_ofstream&
+      operator=(const basic_ofstream&) = delete;
+
+      basic_ofstream&
+      operator=(basic_ofstream&& __rhs)
+      {
+ __ostream_type::operator=(std::move(__rhs));
+ _M_filebuf = std::move(__rhs._M_filebuf);
+ return *this;
+      }
+
+      void
+      swap(basic_ofstream& __rhs)
+      {
+ __ostream_type::swap(__rhs);
+ _M_filebuf.swap(__rhs._M_filebuf);
+      }
+# 894 "/usr/include/c++/10.2.0/fstream" 3
+      __filebuf_type*
+      rdbuf() const
+      { return const_cast<__filebuf_type*>(&_M_filebuf); }
+
+
+
+
+
+      bool
+      is_open()
+      { return _M_filebuf.is_open(); }
+
+
+
+      bool
+      is_open() const
+      { return _M_filebuf.is_open(); }
+# 920 "/usr/include/c++/10.2.0/fstream" 3
+      void
+      open(const char* __s, ios_base::openmode __mode = ios_base::out)
+      {
+ if (!_M_filebuf.open(__s, __mode | ios_base::out))
+   this->setstate(ios_base::failbit);
+ else
+
+
+   this->clear();
+      }
+# 959 "/usr/include/c++/10.2.0/fstream" 3
+      void
+      open(const std::string& __s, ios_base::openmode __mode = ios_base::out)
+      {
+ if (!_M_filebuf.open(__s, __mode | ios_base::out))
+   this->setstate(ios_base::failbit);
+ else
+
+
+   this->clear();
+      }
+# 979 "/usr/include/c++/10.2.0/fstream" 3
+      template<typename _Path>
+ _If_fs_path<_Path, void>
+ open(const _Path& __s, ios_base::openmode __mode = ios_base::out)
+ { open(__s.c_str(), __mode); }
+# 992 "/usr/include/c++/10.2.0/fstream" 3
+      void
+      close()
+      {
+ if (!_M_filebuf.close())
+   this->setstate(ios_base::failbit);
+      }
+    };
+# 1015 "/usr/include/c++/10.2.0/fstream" 3
+  template<typename _CharT, typename _Traits>
+    class basic_fstream : public basic_iostream<_CharT, _Traits>
+    {
+    public:
+
+      typedef _CharT char_type;
+      typedef _Traits traits_type;
+      typedef typename traits_type::int_type int_type;
+      typedef typename traits_type::pos_type pos_type;
+      typedef typename traits_type::off_type off_type;
+
+
+      typedef basic_filebuf<char_type, traits_type> __filebuf_type;
+      typedef basic_ios<char_type, traits_type> __ios_type;
+      typedef basic_iostream<char_type, traits_type> __iostream_type;
+
+    private:
+      __filebuf_type _M_filebuf;
+
+    public:
+# 1043 "/usr/include/c++/10.2.0/fstream" 3
+      basic_fstream()
+      : __iostream_type(), _M_filebuf()
+      { this->init(&_M_filebuf); }
+
+
+
+
+
+
+      explicit
+      basic_fstream(const char* __s,
+      ios_base::openmode __mode = ios_base::in | ios_base::out)
+      : __iostream_type(0), _M_filebuf()
+      {
+ this->init(&_M_filebuf);
+ this->open(__s, __mode);
+      }
+# 1082 "/usr/include/c++/10.2.0/fstream" 3
+      explicit
+      basic_fstream(const std::string& __s,
+      ios_base::openmode __mode = ios_base::in | ios_base::out)
+      : __iostream_type(0), _M_filebuf()
+      {
+ this->init(&_M_filebuf);
+ this->open(__s, __mode);
+      }
+
+
+
+
+
+
+
+      template<typename _Path, typename _Require = _If_fs_path<_Path>>
+ basic_fstream(const _Path& __s,
+        ios_base::openmode __mode = ios_base::in | ios_base::out)
+ : basic_fstream(__s.c_str(), __mode)
+ { }
+
+
+      basic_fstream(const basic_fstream&) = delete;
+
+      basic_fstream(basic_fstream&& __rhs)
+      : __iostream_type(std::move(__rhs)),
+      _M_filebuf(std::move(__rhs._M_filebuf))
+      { __iostream_type::set_rdbuf(&_M_filebuf); }
+# 1118 "/usr/include/c++/10.2.0/fstream" 3
+      ~basic_fstream()
+      { }
+
+
+
+
+      basic_fstream&
+      operator=(const basic_fstream&) = delete;
+
+      basic_fstream&
+      operator=(basic_fstream&& __rhs)
+      {
+ __iostream_type::operator=(std::move(__rhs));
+ _M_filebuf = std::move(__rhs._M_filebuf);
+ return *this;
+      }
+
+      void
+      swap(basic_fstream& __rhs)
+      {
+ __iostream_type::swap(__rhs);
+ _M_filebuf.swap(__rhs._M_filebuf);
+      }
+# 1150 "/usr/include/c++/10.2.0/fstream" 3
+      __filebuf_type*
+      rdbuf() const
+      { return const_cast<__filebuf_type*>(&_M_filebuf); }
+
+
+
+
+
+      bool
+      is_open()
+      { return _M_filebuf.is_open(); }
+
+
+
+      bool
+      is_open() const
+      { return _M_filebuf.is_open(); }
+# 1176 "/usr/include/c++/10.2.0/fstream" 3
+      void
+      open(const char* __s,
+    ios_base::openmode __mode = ios_base::in | ios_base::out)
+      {
+ if (!_M_filebuf.open(__s, __mode))
+   this->setstate(ios_base::failbit);
+ else
+
+
+   this->clear();
+      }
+# 1217 "/usr/include/c++/10.2.0/fstream" 3
+      void
+      open(const std::string& __s,
+    ios_base::openmode __mode = ios_base::in | ios_base::out)
+      {
+ if (!_M_filebuf.open(__s, __mode))
+   this->setstate(ios_base::failbit);
+ else
+
+
+   this->clear();
+      }
+# 1238 "/usr/include/c++/10.2.0/fstream" 3
+      template<typename _Path>
+ _If_fs_path<_Path, void>
+ open(const _Path& __s,
+      ios_base::openmode __mode = ios_base::in | ios_base::out)
+ { open(__s.c_str(), __mode); }
+# 1252 "/usr/include/c++/10.2.0/fstream" 3
+      void
+      close()
+      {
+ if (!_M_filebuf.close())
+   this->setstate(ios_base::failbit);
+      }
+    };
+
+
+
+  template <class _CharT, class _Traits>
+    inline void
+    swap(basic_filebuf<_CharT, _Traits>& __x,
+  basic_filebuf<_CharT, _Traits>& __y)
+    { __x.swap(__y); }
+
+
+  template <class _CharT, class _Traits>
+    inline void
+    swap(basic_ifstream<_CharT, _Traits>& __x,
+  basic_ifstream<_CharT, _Traits>& __y)
+    { __x.swap(__y); }
+
+
+  template <class _CharT, class _Traits>
+    inline void
+    swap(basic_ofstream<_CharT, _Traits>& __x,
+  basic_ofstream<_CharT, _Traits>& __y)
+    { __x.swap(__y); }
+
+
+  template <class _CharT, class _Traits>
+    inline void
+    swap(basic_fstream<_CharT, _Traits>& __x,
+  basic_fstream<_CharT, _Traits>& __y)
+    { __x.swap(__y); }
+
+
+
+}
+
+# 1 "/usr/include/c++/10.2.0/bits/fstream.tcc" 1 3
+# 35 "/usr/include/c++/10.2.0/bits/fstream.tcc" 3
+#define _FSTREAM_TCC 1
+
+       
+# 38 "/usr/include/c++/10.2.0/bits/fstream.tcc" 3
+
+
+
+# 1 "/usr/include/c++/10.2.0/cerrno" 1 3
+# 39 "/usr/include/c++/10.2.0/cerrno" 3
+       
+# 40 "/usr/include/c++/10.2.0/cerrno" 3
+# 42 "/usr/include/c++/10.2.0/bits/fstream.tcc" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  template<typename _CharT, typename _Traits>
+    void
+    basic_filebuf<_CharT, _Traits>::
+    _M_allocate_internal_buffer()
+    {
+
+
+      if (!_M_buf_allocated && !_M_buf)
+ {
+   _M_buf = new char_type[_M_buf_size];
+   _M_buf_allocated = true;
+ }
+    }
+
+  template<typename _CharT, typename _Traits>
+    void
+    basic_filebuf<_CharT, _Traits>::
+    _M_destroy_internal_buffer() throw()
+    {
+      if (_M_buf_allocated)
+ {
+   delete [] _M_buf;
+   _M_buf = 0;
+   _M_buf_allocated = false;
+ }
+      delete [] _M_ext_buf;
+      _M_ext_buf = 0;
+      _M_ext_buf_size = 0;
+      _M_ext_next = 0;
+      _M_ext_end = 0;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_filebuf<_CharT, _Traits>::
+    basic_filebuf() : __streambuf_type(), _M_lock(), _M_file(&_M_lock),
+    _M_mode(ios_base::openmode(0)), _M_state_beg(), _M_state_cur(),
+    _M_state_last(), _M_buf(0), _M_buf_size(8192),
+    _M_buf_allocated(false), _M_reading(false), _M_writing(false), _M_pback(),
+    _M_pback_cur_save(0), _M_pback_end_save(0), _M_pback_init(false),
+    _M_codecvt(0), _M_ext_buf(0), _M_ext_buf_size(0), _M_ext_next(0),
+    _M_ext_end(0)
+    {
+      if (has_facet<__codecvt_type>(this->_M_buf_locale))
+ _M_codecvt = &use_facet<__codecvt_type>(this->_M_buf_locale);
+    }
+
+
+  template<typename _CharT, typename _Traits>
+    basic_filebuf<_CharT, _Traits>::
+    basic_filebuf(basic_filebuf&& __rhs)
+    : __streambuf_type(__rhs),
+    _M_lock(), _M_file(std::move(__rhs._M_file), &_M_lock),
+    _M_mode(std::__exchange(__rhs._M_mode, ios_base::openmode(0))),
+    _M_state_beg(std::move(__rhs._M_state_beg)),
+    _M_state_cur(std::move(__rhs._M_state_cur)),
+    _M_state_last(std::move(__rhs._M_state_last)),
+    _M_buf(std::__exchange(__rhs._M_buf, nullptr)),
+    _M_buf_size(std::__exchange(__rhs._M_buf_size, 1)),
+    _M_buf_allocated(std::__exchange(__rhs._M_buf_allocated, false)),
+    _M_reading(std::__exchange(__rhs._M_reading, false)),
+    _M_writing(std::__exchange(__rhs._M_writing, false)),
+    _M_pback(__rhs._M_pback),
+    _M_pback_cur_save(std::__exchange(__rhs._M_pback_cur_save, nullptr)),
+    _M_pback_end_save(std::__exchange(__rhs._M_pback_end_save, nullptr)),
+    _M_pback_init(std::__exchange(__rhs._M_pback_init, false)),
+    _M_codecvt(__rhs._M_codecvt),
+    _M_ext_buf(std::__exchange(__rhs._M_ext_buf, nullptr)),
+    _M_ext_buf_size(std::__exchange(__rhs._M_ext_buf_size, 0)),
+    _M_ext_next(std::__exchange(__rhs._M_ext_next, nullptr)),
+    _M_ext_end(std::__exchange(__rhs._M_ext_end, nullptr))
+    {
+      __rhs._M_set_buffer(-1);
+      __rhs._M_state_last = __rhs._M_state_cur = __rhs._M_state_beg;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_filebuf<_CharT, _Traits>&
+    basic_filebuf<_CharT, _Traits>::
+    operator=(basic_filebuf&& __rhs)
+    {
+      this->close();
+      __streambuf_type::operator=(__rhs);
+      _M_file.swap(__rhs._M_file);
+      _M_mode = std::__exchange(__rhs._M_mode, ios_base::openmode(0));
+      _M_state_beg = std::move(__rhs._M_state_beg);
+      _M_state_cur = std::move(__rhs._M_state_cur);
+      _M_state_last = std::move(__rhs._M_state_last);
+      _M_buf = std::__exchange(__rhs._M_buf, nullptr);
+      _M_buf_size = std::__exchange(__rhs._M_buf_size, 1);
+      _M_buf_allocated = std::__exchange(__rhs._M_buf_allocated, false);
+      _M_ext_buf = std::__exchange(__rhs._M_ext_buf, nullptr);
+      _M_ext_buf_size = std::__exchange(__rhs._M_ext_buf_size, 0);
+      _M_ext_next = std::__exchange(__rhs._M_ext_next, nullptr);
+      _M_ext_end = std::__exchange(__rhs._M_ext_end, nullptr);
+      _M_reading = std::__exchange(__rhs._M_reading, false);
+      _M_writing = std::__exchange(__rhs._M_writing, false);
+      _M_pback_cur_save = std::__exchange(__rhs._M_pback_cur_save, nullptr);
+      _M_pback_end_save = std::__exchange(__rhs._M_pback_end_save, nullptr);
+      _M_pback_init = std::__exchange(__rhs._M_pback_init, false);
+      __rhs._M_set_buffer(-1);
+      __rhs._M_state_last = __rhs._M_state_cur = __rhs._M_state_beg;
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    void
+    basic_filebuf<_CharT, _Traits>::
+    swap(basic_filebuf& __rhs)
+    {
+      __streambuf_type::swap(__rhs);
+      _M_file.swap(__rhs._M_file);
+      std::swap(_M_mode, __rhs._M_mode);
+      std::swap(_M_state_beg, __rhs._M_state_beg);
+      std::swap(_M_state_cur, __rhs._M_state_cur);
+      std::swap(_M_state_last, __rhs._M_state_last);
+      std::swap(_M_buf, __rhs._M_buf);
+      std::swap(_M_buf_size, __rhs._M_buf_size);
+      std::swap(_M_buf_allocated, __rhs._M_buf_allocated);
+      std::swap(_M_ext_buf, __rhs._M_ext_buf);
+      std::swap(_M_ext_buf_size, __rhs._M_ext_buf_size);
+      std::swap(_M_ext_next, __rhs._M_ext_next);
+      std::swap(_M_ext_end, __rhs._M_ext_end);
+      std::swap(_M_reading, __rhs._M_reading);
+      std::swap(_M_writing, __rhs._M_writing);
+      std::swap(_M_pback_cur_save, __rhs._M_pback_cur_save);
+      std::swap(_M_pback_end_save, __rhs._M_pback_end_save);
+      std::swap(_M_pback_init, __rhs._M_pback_init);
+    }
+
+
+  template<typename _CharT, typename _Traits>
+    typename basic_filebuf<_CharT, _Traits>::__filebuf_type*
+    basic_filebuf<_CharT, _Traits>::
+    open(const char* __s, ios_base::openmode __mode)
+    {
+      __filebuf_type *__ret = 0;
+      if (!this->is_open())
+ {
+   _M_file.open(__s, __mode);
+   if (this->is_open())
+     {
+       _M_allocate_internal_buffer();
+       _M_mode = __mode;
+
+
+       _M_reading = false;
+       _M_writing = false;
+       _M_set_buffer(-1);
+
+
+       _M_state_last = _M_state_cur = _M_state_beg;
+
+
+       if ((__mode & ios_base::ate)
+    && this->seekoff(0, ios_base::end, __mode)
+    == pos_type(off_type(-1)))
+  this->close();
+       else
+  __ret = this;
+     }
+ }
+      return __ret;
+    }
+# 247 "/usr/include/c++/10.2.0/bits/fstream.tcc" 3
+  template<typename _CharT, typename _Traits>
+    typename basic_filebuf<_CharT, _Traits>::__filebuf_type*
+    basic_filebuf<_CharT, _Traits>::
+    close()
+    {
+      if (!this->is_open())
+ return 0;
+
+      bool __testfail = false;
+      {
+
+ struct __close_sentry
+ {
+   basic_filebuf *__fb;
+   __close_sentry (basic_filebuf *__fbi): __fb(__fbi) { }
+   ~__close_sentry ()
+   {
+     __fb->_M_mode = ios_base::openmode(0);
+     __fb->_M_pback_init = false;
+     __fb->_M_destroy_internal_buffer();
+     __fb->_M_reading = false;
+     __fb->_M_writing = false;
+     __fb->_M_set_buffer(-1);
+     __fb->_M_state_last = __fb->_M_state_cur = __fb->_M_state_beg;
+   }
+ } __cs (this);
+
+ try
+   {
+     if (!_M_terminate_output())
+       __testfail = true;
+   }
+ catch(...)
+   {
+     _M_file.close();
+     throw;
+   }
+      }
+
+      if (!_M_file.close())
+ __testfail = true;
+
+      if (__testfail)
+ return 0;
+      else
+ return this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    streamsize
+    basic_filebuf<_CharT, _Traits>::
+    showmanyc()
+    {
+      streamsize __ret = -1;
+      const bool __testin = _M_mode & ios_base::in;
+      if (__testin && this->is_open())
+ {
+
+
+   __ret = this->egptr() - this->gptr();
+
+
+
+
+
+
+
+   if (__check_facet(_M_codecvt).encoding() >= 0)
+
+     __ret += _M_file.showmanyc() / _M_codecvt->max_length();
+ }
+      return __ret;
+    }
+
+  template<typename _CharT, typename _Traits>
+    typename basic_filebuf<_CharT, _Traits>::int_type
+    basic_filebuf<_CharT, _Traits>::
+    underflow()
+    {
+      int_type __ret = traits_type::eof();
+      const bool __testin = _M_mode & ios_base::in;
+      if (__testin)
+ {
+   if (_M_writing)
+     {
+       if (overflow() == traits_type::eof())
+  return __ret;
+       _M_set_buffer(-1);
+       _M_writing = false;
+     }
+
+
+
+   _M_destroy_pback();
+
+   if (this->gptr() < this->egptr())
+     return traits_type::to_int_type(*this->gptr());
+
+
+   const size_t __buflen = _M_buf_size > 1 ? _M_buf_size - 1 : 1;
+
+
+   bool __got_eof = false;
+
+   streamsize __ilen = 0;
+   codecvt_base::result __r = codecvt_base::ok;
+   if (__check_facet(_M_codecvt).always_noconv())
+     {
+       __ilen = _M_file.xsgetn(reinterpret_cast<char*>(this->eback()),
+          __buflen);
+       if (__ilen == 0)
+  __got_eof = true;
+     }
+   else
+     {
+
+
+       const int __enc = _M_codecvt->encoding();
+       streamsize __blen;
+       streamsize __rlen;
+       if (__enc > 0)
+  __blen = __rlen = __buflen * __enc;
+       else
+  {
+    __blen = __buflen + _M_codecvt->max_length() - 1;
+    __rlen = __buflen;
+  }
+       const streamsize __remainder = _M_ext_end - _M_ext_next;
+       __rlen = __rlen > __remainder ? __rlen - __remainder : 0;
+
+
+
+       if (_M_reading && this->egptr() == this->eback() && __remainder)
+  __rlen = 0;
+
+
+
+       if (_M_ext_buf_size < __blen)
+  {
+    char* __buf = new char[__blen];
+    if (__remainder)
+      __builtin_memcpy(__buf, _M_ext_next, __remainder);
+
+    delete [] _M_ext_buf;
+    _M_ext_buf = __buf;
+    _M_ext_buf_size = __blen;
+  }
+       else if (__remainder)
+  __builtin_memmove(_M_ext_buf, _M_ext_next, __remainder);
+
+       _M_ext_next = _M_ext_buf;
+       _M_ext_end = _M_ext_buf + __remainder;
+       _M_state_last = _M_state_cur;
+
+       do
+  {
+    if (__rlen > 0)
+      {
+
+
+
+        if (_M_ext_end - _M_ext_buf + __rlen > _M_ext_buf_size)
+   {
+     __throw_ios_failure(("basic_filebuf::underflow " "codecvt::max_length() " "is not valid")
+
+                          );
+   }
+        streamsize __elen = _M_file.xsgetn(_M_ext_end, __rlen);
+        if (__elen == 0)
+   __got_eof = true;
+        else if (__elen == -1)
+   break;
+        _M_ext_end += __elen;
+      }
+
+    char_type* __iend = this->eback();
+    if (_M_ext_next < _M_ext_end)
+      __r = _M_codecvt->in(_M_state_cur, _M_ext_next,
+      _M_ext_end, _M_ext_next,
+      this->eback(),
+      this->eback() + __buflen, __iend);
+    if (__r == codecvt_base::noconv)
+      {
+        size_t __avail = _M_ext_end - _M_ext_buf;
+        __ilen = std::min(__avail, __buflen);
+        traits_type::copy(this->eback(),
+     reinterpret_cast<char_type*>
+     (_M_ext_buf), __ilen);
+        _M_ext_next = _M_ext_buf + __ilen;
+      }
+    else
+      __ilen = __iend - this->eback();
+
+
+
+
+    if (__r == codecvt_base::error)
+      break;
+
+    __rlen = 1;
+  }
+       while (__ilen == 0 && !__got_eof);
+     }
+
+   if (__ilen > 0)
+     {
+       _M_set_buffer(__ilen);
+       _M_reading = true;
+       __ret = traits_type::to_int_type(*this->gptr());
+     }
+   else if (__got_eof)
+     {
+
+
+
+       _M_set_buffer(-1);
+       _M_reading = false;
+
+
+       if (__r == codecvt_base::partial)
+  __throw_ios_failure(("basic_filebuf::underflow " "incomplete character in file")
+                                       );
+     }
+   else if (__r == codecvt_base::error)
+     __throw_ios_failure(("basic_filebuf::underflow " "invalid byte sequence in file")
+                                    );
+   else
+     __throw_ios_failure(("basic_filebuf::underflow " "error reading the file")
+                             , (*__errno_location ()));
+ }
+      return __ret;
+    }
+
+  template<typename _CharT, typename _Traits>
+    typename basic_filebuf<_CharT, _Traits>::int_type
+    basic_filebuf<_CharT, _Traits>::
+    pbackfail(int_type __i)
+    {
+      int_type __ret = traits_type::eof();
+      const bool __testin = _M_mode & ios_base::in;
+      if (__testin)
+ {
+   if (_M_writing)
+     {
+       if (overflow() == traits_type::eof())
+  return __ret;
+       _M_set_buffer(-1);
+       _M_writing = false;
+     }
+
+
+   const bool __testpb = _M_pback_init;
+   const bool __testeof = traits_type::eq_int_type(__i, __ret);
+   int_type __tmp;
+   if (this->eback() < this->gptr())
+     {
+       this->gbump(-1);
+       __tmp = traits_type::to_int_type(*this->gptr());
+     }
+   else if (this->seekoff(-1, ios_base::cur) != pos_type(off_type(-1)))
+     {
+       __tmp = this->underflow();
+       if (traits_type::eq_int_type(__tmp, __ret))
+  return __ret;
+     }
+   else
+     {
+
+
+
+
+
+       return __ret;
+     }
+
+
+
+   if (!__testeof && traits_type::eq_int_type(__i, __tmp))
+     __ret = __i;
+   else if (__testeof)
+     __ret = traits_type::not_eof(__i);
+   else if (!__testpb)
+     {
+       _M_create_pback();
+       _M_reading = true;
+       *this->gptr() = traits_type::to_char_type(__i);
+       __ret = __i;
+     }
+ }
+      return __ret;
+    }
+
+  template<typename _CharT, typename _Traits>
+    typename basic_filebuf<_CharT, _Traits>::int_type
+    basic_filebuf<_CharT, _Traits>::
+    overflow(int_type __c)
+    {
+      int_type __ret = traits_type::eof();
+      const bool __testeof = traits_type::eq_int_type(__c, __ret);
+      const bool __testout = (_M_mode & ios_base::out
+         || _M_mode & ios_base::app);
+      if (__testout)
+ {
+          if (_M_reading)
+            {
+              _M_destroy_pback();
+              const int __gptr_off = _M_get_ext_pos(_M_state_last);
+              if (_M_seek(__gptr_off, ios_base::cur, _M_state_last)
+                  == pos_type(off_type(-1)))
+                return __ret;
+            }
+   if (this->pbase() < this->pptr())
+     {
+
+       if (!__testeof)
+  {
+    *this->pptr() = traits_type::to_char_type(__c);
+    this->pbump(1);
+  }
+
+
+
+       if (_M_convert_to_external(this->pbase(),
+      this->pptr() - this->pbase()))
+  {
+    _M_set_buffer(0);
+    __ret = traits_type::not_eof(__c);
+  }
+     }
+   else if (_M_buf_size > 1)
+     {
+
+
+
+       _M_set_buffer(0);
+       _M_writing = true;
+       if (!__testeof)
+  {
+    *this->pptr() = traits_type::to_char_type(__c);
+    this->pbump(1);
+  }
+       __ret = traits_type::not_eof(__c);
+     }
+   else
+     {
+
+       char_type __conv = traits_type::to_char_type(__c);
+       if (__testeof || _M_convert_to_external(&__conv, 1))
+  {
+    _M_writing = true;
+    __ret = traits_type::not_eof(__c);
+  }
+     }
+ }
+      return __ret;
+    }
+
+  template<typename _CharT, typename _Traits>
+    bool
+    basic_filebuf<_CharT, _Traits>::
+    _M_convert_to_external(_CharT* __ibuf, streamsize __ilen)
+    {
+
+      streamsize __elen;
+      streamsize __plen;
+      if (__check_facet(_M_codecvt).always_noconv())
+ {
+   __elen = _M_file.xsputn(reinterpret_cast<char*>(__ibuf), __ilen);
+   __plen = __ilen;
+ }
+      else
+ {
+
+
+   streamsize __blen = __ilen * _M_codecvt->max_length();
+   char* __buf = static_cast<char*>(__builtin_alloca(__blen));
+
+   char* __bend;
+   const char_type* __iend;
+   codecvt_base::result __r;
+   __r = _M_codecvt->out(_M_state_cur, __ibuf, __ibuf + __ilen,
+    __iend, __buf, __buf + __blen, __bend);
+
+   if (__r == codecvt_base::ok || __r == codecvt_base::partial)
+     __blen = __bend - __buf;
+   else if (__r == codecvt_base::noconv)
+     {
+
+       __buf = reinterpret_cast<char*>(__ibuf);
+       __blen = __ilen;
+     }
+   else
+     __throw_ios_failure(("basic_filebuf::_M_convert_to_external " "conversion error")
+                           );
+
+   __elen = _M_file.xsputn(__buf, __blen);
+   __plen = __blen;
+
+
+   if (__r == codecvt_base::partial && __elen == __plen)
+     {
+       const char_type* __iresume = __iend;
+       streamsize __rlen = this->pptr() - __iend;
+       __r = _M_codecvt->out(_M_state_cur, __iresume,
+        __iresume + __rlen, __iend, __buf,
+        __buf + __blen, __bend);
+       if (__r != codecvt_base::error)
+  {
+    __rlen = __bend - __buf;
+    __elen = _M_file.xsputn(__buf, __rlen);
+    __plen = __rlen;
+  }
+       else
+  __throw_ios_failure(("basic_filebuf::_M_convert_to_external " "conversion error")
+                        );
+     }
+ }
+      return __elen == __plen;
+    }
+
+  template<typename _CharT, typename _Traits>
+    streamsize
+    basic_filebuf<_CharT, _Traits>::
+    xsgetn(_CharT* __s, streamsize __n)
+    {
+
+      streamsize __ret = 0;
+      if (_M_pback_init)
+ {
+   if (__n > 0 && this->gptr() == this->eback())
+     {
+       *__s++ = *this->gptr();
+       this->gbump(1);
+       __ret = 1;
+       --__n;
+     }
+   _M_destroy_pback();
+ }
+      else if (_M_writing)
+ {
+   if (overflow() == traits_type::eof())
+     return __ret;
+   _M_set_buffer(-1);
+   _M_writing = false;
+ }
+
+
+
+
+      const bool __testin = _M_mode & ios_base::in;
+      const streamsize __buflen = _M_buf_size > 1 ? _M_buf_size - 1 : 1;
+
+      if (__n > __buflen && __check_facet(_M_codecvt).always_noconv()
+   && __testin)
+ {
+
+   const streamsize __avail = this->egptr() - this->gptr();
+   if (__avail != 0)
+     {
+       traits_type::copy(__s, this->gptr(), __avail);
+       __s += __avail;
+       this->setg(this->eback(), this->gptr() + __avail, this->egptr());
+       __ret += __avail;
+       __n -= __avail;
+     }
+
+
+
+   streamsize __len;
+   for (;;)
+     {
+       __len = _M_file.xsgetn(reinterpret_cast<char*>(__s), __n);
+       if (__len == -1)
+  __throw_ios_failure(("basic_filebuf::xsgetn " "error reading the file")
+                              , (*__errno_location ()));
+       if (__len == 0)
+  break;
+
+       __n -= __len;
+       __ret += __len;
+       if (__n == 0)
+  break;
+
+       __s += __len;
+     }
+
+   if (__n == 0)
+     {
+
+       _M_reading = true;
+     }
+   else if (__len == 0)
+     {
+
+
+
+       _M_set_buffer(-1);
+       _M_reading = false;
+     }
+ }
+      else
+ __ret += __streambuf_type::xsgetn(__s, __n);
+
+      return __ret;
+    }
+
+  template<typename _CharT, typename _Traits>
+    streamsize
+    basic_filebuf<_CharT, _Traits>::
+    xsputn(const _CharT* __s, streamsize __n)
+    {
+      streamsize __ret = 0;
+
+
+
+      const bool __testout = (_M_mode & ios_base::out
+         || _M_mode & ios_base::app);
+      if (__check_facet(_M_codecvt).always_noconv()
+   && __testout && !_M_reading)
+ {
+
+   const streamsize __chunk = 1ul << 10;
+   streamsize __bufavail = this->epptr() - this->pptr();
+
+
+   if (!_M_writing && _M_buf_size > 1)
+     __bufavail = _M_buf_size - 1;
+
+   const streamsize __limit = std::min(__chunk, __bufavail);
+   if (__n >= __limit)
+     {
+       const streamsize __buffill = this->pptr() - this->pbase();
+       const char* __buf = reinterpret_cast<const char*>(this->pbase());
+       __ret = _M_file.xsputn_2(__buf, __buffill,
+           reinterpret_cast<const char*>(__s),
+           __n);
+       if (__ret == __buffill + __n)
+  {
+    _M_set_buffer(0);
+    _M_writing = true;
+  }
+       if (__ret > __buffill)
+  __ret -= __buffill;
+       else
+  __ret = 0;
+     }
+   else
+     __ret = __streambuf_type::xsputn(__s, __n);
+ }
+       else
+  __ret = __streambuf_type::xsputn(__s, __n);
+       return __ret;
+    }
+
+  template<typename _CharT, typename _Traits>
+    typename basic_filebuf<_CharT, _Traits>::__streambuf_type*
+    basic_filebuf<_CharT, _Traits>::
+    setbuf(char_type* __s, streamsize __n)
+    {
+      if (!this->is_open())
+ {
+   if (__s == 0 && __n == 0)
+     _M_buf_size = 1;
+   else if (__s && __n > 0)
+     {
+# 820 "/usr/include/c++/10.2.0/bits/fstream.tcc" 3
+       _M_buf = __s;
+       _M_buf_size = __n;
+     }
+ }
+      return this;
+    }
+
+
+
+
+  template<typename _CharT, typename _Traits>
+    typename basic_filebuf<_CharT, _Traits>::pos_type
+    basic_filebuf<_CharT, _Traits>::
+    seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode)
+    {
+      int __width = 0;
+      if (_M_codecvt)
+ __width = _M_codecvt->encoding();
+      if (__width < 0)
+ __width = 0;
+
+      pos_type __ret = pos_type(off_type(-1));
+      const bool __testfail = __off != 0 && __width <= 0;
+      if (this->is_open() && !__testfail)
+ {
+
+
+
+
+   bool __no_movement = __way == ios_base::cur && __off == 0
+     && (!_M_writing || _M_codecvt->always_noconv());
+
+
+   if (!__no_movement)
+     _M_destroy_pback();
+
+
+
+
+
+
+   __state_type __state = _M_state_beg;
+   off_type __computed_off = __off * __width;
+   if (_M_reading && __way == ios_base::cur)
+     {
+       __state = _M_state_last;
+       __computed_off += _M_get_ext_pos(__state);
+     }
+   if (!__no_movement)
+     __ret = _M_seek(__computed_off, __way, __state);
+   else
+     {
+       if (_M_writing)
+  __computed_off = this->pptr() - this->pbase();
+
+       off_type __file_off = _M_file.seekoff(0, ios_base::cur);
+       if (__file_off != off_type(-1))
+  {
+    __ret = __file_off + __computed_off;
+    __ret.state(__state);
+  }
+     }
+ }
+      return __ret;
+    }
+
+
+
+
+
+  template<typename _CharT, typename _Traits>
+    typename basic_filebuf<_CharT, _Traits>::pos_type
+    basic_filebuf<_CharT, _Traits>::
+    seekpos(pos_type __pos, ios_base::openmode)
+    {
+      pos_type __ret = pos_type(off_type(-1));
+      if (this->is_open())
+ {
+
+   _M_destroy_pback();
+   __ret = _M_seek(off_type(__pos), ios_base::beg, __pos.state());
+ }
+      return __ret;
+    }
+
+  template<typename _CharT, typename _Traits>
+    typename basic_filebuf<_CharT, _Traits>::pos_type
+    basic_filebuf<_CharT, _Traits>::
+    _M_seek(off_type __off, ios_base::seekdir __way, __state_type __state)
+    {
+      pos_type __ret = pos_type(off_type(-1));
+      if (_M_terminate_output())
+ {
+   off_type __file_off = _M_file.seekoff(__off, __way);
+   if (__file_off != off_type(-1))
+     {
+       _M_reading = false;
+       _M_writing = false;
+       _M_ext_next = _M_ext_end = _M_ext_buf;
+       _M_set_buffer(-1);
+       _M_state_cur = __state;
+       __ret = __file_off;
+       __ret.state(_M_state_cur);
+     }
+ }
+      return __ret;
+    }
+
+
+
+
+  template<typename _CharT, typename _Traits>
+    int basic_filebuf<_CharT, _Traits>::
+    _M_get_ext_pos(__state_type& __state)
+    {
+      if (_M_codecvt->always_noconv())
+        return this->gptr() - this->egptr();
+      else
+        {
+
+
+
+          const int __gptr_off =
+            _M_codecvt->length(__state, _M_ext_buf, _M_ext_next,
+                               this->gptr() - this->eback());
+          return _M_ext_buf + __gptr_off - _M_ext_end;
+        }
+    }
+
+  template<typename _CharT, typename _Traits>
+    bool
+    basic_filebuf<_CharT, _Traits>::
+    _M_terminate_output()
+    {
+
+      bool __testvalid = true;
+      if (this->pbase() < this->pptr())
+ {
+   const int_type __tmp = this->overflow();
+   if (traits_type::eq_int_type(__tmp, traits_type::eof()))
+     __testvalid = false;
+ }
+
+
+      if (_M_writing && !__check_facet(_M_codecvt).always_noconv()
+   && __testvalid)
+ {
+
+
+
+   const size_t __blen = 128;
+   char __buf[__blen];
+   codecvt_base::result __r;
+   streamsize __ilen = 0;
+
+   do
+     {
+       char* __next;
+       __r = _M_codecvt->unshift(_M_state_cur, __buf,
+     __buf + __blen, __next);
+       if (__r == codecvt_base::error)
+  __testvalid = false;
+       else if (__r == codecvt_base::ok ||
+         __r == codecvt_base::partial)
+  {
+    __ilen = __next - __buf;
+    if (__ilen > 0)
+      {
+        const streamsize __elen = _M_file.xsputn(__buf, __ilen);
+        if (__elen != __ilen)
+   __testvalid = false;
+      }
+  }
+     }
+   while (__r == codecvt_base::partial && __ilen > 0 && __testvalid);
+
+   if (__testvalid)
+     {
+
+
+
+
+       const int_type __tmp = this->overflow();
+       if (traits_type::eq_int_type(__tmp, traits_type::eof()))
+  __testvalid = false;
+     }
+ }
+      return __testvalid;
+    }
+
+  template<typename _CharT, typename _Traits>
+    int
+    basic_filebuf<_CharT, _Traits>::
+    sync()
+    {
+
+
+      int __ret = 0;
+      if (this->pbase() < this->pptr())
+ {
+   const int_type __tmp = this->overflow();
+   if (traits_type::eq_int_type(__tmp, traits_type::eof()))
+     __ret = -1;
+ }
+      return __ret;
+    }
+
+  template<typename _CharT, typename _Traits>
+    void
+    basic_filebuf<_CharT, _Traits>::
+    imbue(const locale& __loc)
+    {
+      bool __testvalid = true;
+
+      const __codecvt_type* _M_codecvt_tmp = 0;
+      if (__builtin_expect(has_facet<__codecvt_type>(__loc), true))
+ _M_codecvt_tmp = &use_facet<__codecvt_type>(__loc);
+
+      if (this->is_open())
+ {
+
+   if ((_M_reading || _M_writing)
+       && __check_facet(_M_codecvt).encoding() == -1)
+     __testvalid = false;
+   else
+     {
+       if (_M_reading)
+  {
+    if (__check_facet(_M_codecvt).always_noconv())
+      {
+        if (_M_codecvt_tmp
+     && !__check_facet(_M_codecvt_tmp).always_noconv())
+   __testvalid = this->seekoff(0, ios_base::cur, _M_mode)
+                 != pos_type(off_type(-1));
+      }
+    else
+      {
+
+        _M_ext_next = _M_ext_buf
+   + _M_codecvt->length(_M_state_last, _M_ext_buf,
+          _M_ext_next,
+          this->gptr() - this->eback());
+        const streamsize __remainder = _M_ext_end - _M_ext_next;
+        if (__remainder)
+   __builtin_memmove(_M_ext_buf, _M_ext_next, __remainder);
+
+        _M_ext_next = _M_ext_buf;
+        _M_ext_end = _M_ext_buf + __remainder;
+        _M_set_buffer(-1);
+        _M_state_last = _M_state_cur = _M_state_beg;
+      }
+  }
+       else if (_M_writing && (__testvalid = _M_terminate_output()))
+  _M_set_buffer(-1);
+     }
+ }
+
+      if (__testvalid)
+ _M_codecvt = _M_codecvt_tmp;
+      else
+ _M_codecvt = 0;
+    }
+
+
+
+
+  extern template class basic_filebuf<char>;
+  extern template class basic_ifstream<char>;
+  extern template class basic_ofstream<char>;
+  extern template class basic_fstream<char>;
+
+
+  extern template class basic_filebuf<wchar_t>;
+  extern template class basic_ifstream<wchar_t>;
+  extern template class basic_ofstream<wchar_t>;
+  extern template class basic_fstream<wchar_t>;
+
+
+
+
+}
+# 1294 "/usr/include/c++/10.2.0/fstream" 2 3
+# 28 "/usr/include/boost/test/unit_test_parameters.hpp" 2 3 4
+
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 30 "/usr/include/boost/test/unit_test_parameters.hpp" 2 3 4
+
+
+
+namespace boost {
+namespace unit_test {
+namespace runtime_config {
+
+
+
+
+
+
+__attribute__((__visibility__("default"))) extern std::string btrt_auto_start_dbg;
+__attribute__((__visibility__("default"))) extern std::string btrt_break_exec_path;
+__attribute__((__visibility__("default"))) extern std::string btrt_build_info;
+__attribute__((__visibility__("default"))) extern std::string btrt_catch_sys_errors;
+__attribute__((__visibility__("default"))) extern std::string btrt_color_output;
+__attribute__((__visibility__("default"))) extern std::string btrt_detect_fp_except;
+__attribute__((__visibility__("default"))) extern std::string btrt_detect_mem_leaks;
+__attribute__((__visibility__("default"))) extern std::string btrt_list_content;
+__attribute__((__visibility__("default"))) extern std::string btrt_list_labels;
+__attribute__((__visibility__("default"))) extern std::string btrt_log_format;
+__attribute__((__visibility__("default"))) extern std::string btrt_log_level;
+__attribute__((__visibility__("default"))) extern std::string btrt_log_sink;
+__attribute__((__visibility__("default"))) extern std::string btrt_combined_logger;
+__attribute__((__visibility__("default"))) extern std::string btrt_output_format;
+__attribute__((__visibility__("default"))) extern std::string btrt_random_seed;
+__attribute__((__visibility__("default"))) extern std::string btrt_report_format;
+__attribute__((__visibility__("default"))) extern std::string btrt_report_level;
+__attribute__((__visibility__("default"))) extern std::string btrt_report_mem_leaks;
+__attribute__((__visibility__("default"))) extern std::string btrt_report_sink;
+__attribute__((__visibility__("default"))) extern std::string btrt_result_code;
+__attribute__((__visibility__("default"))) extern std::string btrt_run_filters;
+__attribute__((__visibility__("default"))) extern std::string btrt_save_test_pattern;
+__attribute__((__visibility__("default"))) extern std::string btrt_show_progress;
+__attribute__((__visibility__("default"))) extern std::string btrt_use_alt_stack;
+__attribute__((__visibility__("default"))) extern std::string btrt_wait_for_debugger;
+__attribute__((__visibility__("default"))) extern std::string btrt_help;
+__attribute__((__visibility__("default"))) extern std::string btrt_usage;
+__attribute__((__visibility__("default"))) extern std::string btrt_version;
+
+__attribute__((__visibility__("default"))) void init( int& argc, char** argv );
+
+
+
+
+
+
+__attribute__((__visibility__("default"))) runtime::arguments_store const& argument_store();
+
+template<typename T>
+inline T const&
+get( runtime::cstring parameter_name )
+{
+    return argument_store().get<T>( parameter_name );
+}
+
+inline bool has( runtime::cstring parameter_name )
+{
+    return argument_store().has( parameter_name );
+}
+
+
+__attribute__((__visibility__("default"))) bool save_pattern();
+
+
+
+
+
+class stream_holder {
+public:
+
+    explicit stream_holder( std::ostream& default_stream = std::cout )
+    : m_stream( &default_stream )
+    {
+    }
+
+    void setup( const const_string& stream_name,
+                           boost::function<void ()> const &cleaner_callback = boost::function<void ()>() )
+    {
+        if(stream_name.empty())
+            return;
+
+        if( stream_name == "stderr" ) {
+            m_stream = &std::cerr;
+            if(cleaner_callback) {
+                m_cleaner = boost::make_shared<callback_cleaner>(cleaner_callback);
+            }
+            else {
+                m_cleaner.reset();
+            }
+        }
+        else if( stream_name == "stdout" ) {
+            m_stream = &std::cout;
+            if (cleaner_callback) {
+                m_cleaner = boost::make_shared<callback_cleaner>(cleaner_callback);
+            }
+            else {
+                m_cleaner.reset();
+            }
+        }
+        else {
+            m_cleaner = boost::make_shared<callback_cleaner>(cleaner_callback);
+            m_cleaner->m_file.open( std::string(stream_name.begin(), stream_name.end()).c_str() );
+            m_stream = &m_cleaner->m_file;
+        }
+    }
+
+
+    std::ostream& ref() const { return *m_stream; }
+
+private:
+    struct callback_cleaner {
+        callback_cleaner(boost::function<void ()> cleaner_callback)
+        : m_cleaner_callback(cleaner_callback)
+        , m_file() {
+        }
+        ~callback_cleaner() {
+            if( m_cleaner_callback )
+                m_cleaner_callback();
+        }
+        boost::function<void ()> m_cleaner_callback;
+        std::ofstream m_file;
+    };
+
+
+    boost::shared_ptr<callback_cleaner> m_cleaner;
+    std::ostream* m_stream;
+};
+
+}
+}
+}
+
+
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 167 "/usr/include/boost/test/unit_test_parameters.hpp" 2 3 4
+# 24 "/usr/include/boost/test/impl/compiler_log_formatter.ipp" 2 3 4
+
+# 1 "/usr/include/boost/test/tree/test_unit.hpp" 1 3 4
+# 14 "/usr/include/boost/test/tree/test_unit.hpp" 3 4
+#define BOOST_TEST_TREE_TEST_UNIT_HPP_100211GER 
+
+
+
+
+
+
+# 1 "/usr/include/boost/test/tree/decorator.hpp" 1 3 4
+# 16 "/usr/include/boost/test/tree/decorator.hpp" 3 4
+#define BOOST_TEST_TREE_DECORATOR_HPP_091911GER 
+
+
+
+
+
+# 1 "/usr/include/boost/test/tree/fixture.hpp" 1 3 4
+# 13 "/usr/include/boost/test/tree/fixture.hpp" 3 4
+#define BOOST_TEST_TREE_FIXTURE_HPP_100311GER 
+
+
+
+
+
+
+# 1 "/usr/include/boost/scoped_ptr.hpp" 1 3 4
+
+#define BOOST_SCOPED_PTR_HPP_INCLUDED 
+# 13 "/usr/include/boost/scoped_ptr.hpp" 3 4
+# 1 "/usr/include/boost/smart_ptr/scoped_ptr.hpp" 1 3 4
+
+#define BOOST_SMART_PTR_SCOPED_PTR_HPP_INCLUDED 
+# 14 "/usr/include/boost/smart_ptr/scoped_ptr.hpp" 3 4
+# 1 "/usr/include/boost/assert.hpp" 1 3 4
+# 32 "/usr/include/boost/assert.hpp" 3 4
+#undef BOOST_ASSERT
+#undef BOOST_ASSERT_MSG
+#undef BOOST_ASSERT_IS_VOID
+# 58 "/usr/include/boost/assert.hpp" 3 4
+# 1 "/usr/include/assert.h" 1 3 4
+# 24 "/usr/include/assert.h" 3 4
+#undef _ASSERT_H
+#undef assert
+#undef __ASSERT_VOID_CAST
+
+
+#undef assert_perror
+
+
+
+
+#define _ASSERT_H 1
+
+
+
+#define __ASSERT_VOID_CAST static_cast<void>
+# 64 "/usr/include/assert.h" 3 4
+extern "C" {
+
+
+extern void __assert_fail (const char *__assertion, const char *__file,
+      unsigned int __line, const char *__function)
+     throw () __attribute__ ((__noreturn__));
+
+
+extern void __assert_perror_fail (int __errnum, const char *__file,
+      unsigned int __line, const char *__function)
+     throw () __attribute__ ((__noreturn__));
+
+
+
+
+extern void __assert (const char *__assertion, const char *__file, int __line)
+     throw () __attribute__ ((__noreturn__));
+
+
+}
+
+
+
+
+
+#define assert(expr) (static_cast <bool> (expr) ? void (0) : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
+# 114 "/usr/include/assert.h" 3 4
+#define assert_perror(errnum) (!(errnum) ? __ASSERT_VOID_CAST (0) : __assert_perror_fail ((errnum), __FILE__, __LINE__, __ASSERT_FUNCTION))
+# 126 "/usr/include/assert.h" 3 4
+#define __ASSERT_FUNCTION __extension__ __PRETTY_FUNCTION__
+# 59 "/usr/include/boost/assert.hpp" 2 3 4
+
+#define BOOST_ASSERT(expr) assert(expr)
+#define BOOST_ASSERT_MSG(expr,msg) assert((expr)&&(msg))
+# 72 "/usr/include/boost/assert.hpp" 3 4
+#undef BOOST_VERIFY
+#undef BOOST_VERIFY_MSG
+# 82 "/usr/include/boost/assert.hpp" 3 4
+#define BOOST_VERIFY(expr) BOOST_ASSERT(expr)
+#define BOOST_VERIFY_MSG(expr,msg) BOOST_ASSERT_MSG(expr,msg)
+# 15 "/usr/include/boost/smart_ptr/scoped_ptr.hpp" 2 3 4
+# 26 "/usr/include/boost/smart_ptr/scoped_ptr.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+
+namespace boost
+{
+# 47 "/usr/include/boost/smart_ptr/scoped_ptr.hpp" 3 4
+template<class T> class scoped_ptr
+{
+private:
+
+    T * px;
+
+    scoped_ptr(scoped_ptr const &);
+    scoped_ptr & operator=(scoped_ptr const &);
+
+    typedef scoped_ptr<T> this_type;
+
+    void operator==( scoped_ptr const& ) const;
+    void operator!=( scoped_ptr const& ) const;
+
+public:
+
+    typedef T element_type;
+
+    explicit scoped_ptr( T * p = 0 ) noexcept : px( p )
+    {
+
+
+
+    }
+
+
+
+    explicit scoped_ptr( std::auto_ptr<T> p ) noexcept : px( p.release() )
+    {
+
+
+
+    }
+
+
+
+    ~scoped_ptr() noexcept
+    {
+
+
+
+        boost::checked_delete( px );
+    }
+
+    void reset(T * p = 0) noexcept
+    {
+        (static_cast <bool> (p == 0 || p != px) ? void (0) : __assert_fail ("p == 0 || p != px", "/usr/include/boost/smart_ptr/scoped_ptr.hpp", 93, __extension__ __PRETTY_FUNCTION__));
+        this_type(p).swap(*this);
+    }
+
+    T & operator*() const noexcept
+    {
+        (static_cast <bool> (px != 0) ? void (0) : __assert_fail ("px != 0", "/usr/include/boost/smart_ptr/scoped_ptr.hpp", 99, __extension__ __PRETTY_FUNCTION__));
+        return *px;
+    }
+
+    T * operator->() const noexcept
+    {
+        (static_cast <bool> (px != 0) ? void (0) : __assert_fail ("px != 0", "/usr/include/boost/smart_ptr/scoped_ptr.hpp", 105, __extension__ __PRETTY_FUNCTION__));
+        return px;
+    }
+
+    T * get() const noexcept
+    {
+        return px;
+    }
+
+
+# 1 "/usr/include/boost/smart_ptr/detail/operator_bool.hpp" 1 3 4
+# 12 "/usr/include/boost/smart_ptr/detail/operator_bool.hpp" 3 4
+    explicit operator bool () const noexcept
+    {
+        return px != 0;
+    }
+# 61 "/usr/include/boost/smart_ptr/detail/operator_bool.hpp" 3 4
+    bool operator! () const noexcept
+    {
+        return px == 0;
+    }
+# 116 "/usr/include/boost/smart_ptr/scoped_ptr.hpp" 2 3 4
+
+    void swap(scoped_ptr & b) noexcept
+    {
+        T * tmp = b.px;
+        b.px = px;
+        px = tmp;
+    }
+};
+
+
+
+template<class T> inline bool operator==( scoped_ptr<T> const & p, boost::detail::sp_nullptr_t ) noexcept
+{
+    return p.get() == 0;
+}
+
+template<class T> inline bool operator==( boost::detail::sp_nullptr_t, scoped_ptr<T> const & p ) noexcept
+{
+    return p.get() == 0;
+}
+
+template<class T> inline bool operator!=( scoped_ptr<T> const & p, boost::detail::sp_nullptr_t ) noexcept
+{
+    return p.get() != 0;
+}
+
+template<class T> inline bool operator!=( boost::detail::sp_nullptr_t, scoped_ptr<T> const & p ) noexcept
+{
+    return p.get() != 0;
+}
+
+
+
+template<class T> inline void swap(scoped_ptr<T> & a, scoped_ptr<T> & b) noexcept
+{
+    a.swap(b);
+}
+
+
+
+template<class T> inline T * get_pointer(scoped_ptr<T> const & p) noexcept
+{
+    return p.get();
+}
+
+}
+
+
+#pragma GCC diagnostic pop
+# 14 "/usr/include/boost/scoped_ptr.hpp" 2 3 4
+# 21 "/usr/include/boost/test/tree/fixture.hpp" 2 3 4
+# 1 "/usr/include/boost/function/function0.hpp" 1 3 4
+# 10 "/usr/include/boost/function/function0.hpp" 3 4
+#define BOOST_FUNCTION_NUM_ARGS 0
+# 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
+# 11 "/usr/include/boost/function/detail/maybe_include.hpp" 3 4
+#undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#define BOOST_FUNCTION_MAX_ARGS_DEFINED 0
+# 12 "/usr/include/boost/function/function0.hpp" 2 3 4
+#undef BOOST_FUNCTION_NUM_ARGS
+# 22 "/usr/include/boost/test/tree/fixture.hpp" 2 3 4
+# 1 "/usr/include/boost/utility/declval.hpp" 1 3 4
+# 9 "/usr/include/boost/utility/declval.hpp" 3 4
+#define BOOST_UTILITY_DECLVAL_HPP 
+# 23 "/usr/include/boost/test/tree/fixture.hpp" 2 3 4
+
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 25 "/usr/include/boost/test/tree/fixture.hpp" 2 3 4
+
+
+
+namespace boost {
+namespace unit_test {
+
+
+
+
+
+class __attribute__((__visibility__("default"))) test_unit_fixture {
+public:
+    virtual ~test_unit_fixture() {}
+
+
+    virtual void setup() = 0;
+    virtual void teardown() = 0;
+};
+
+typedef shared_ptr<test_unit_fixture> test_unit_fixture_ptr;
+
+
+
+
+
+namespace impl_fixture {
+# 76 "/usr/include/boost/test/tree/fixture.hpp" 3 4
+    template<typename U> struct fixture_detect { typedef char type; };
+    template<typename T>
+    struct has_setup {
+    private:
+        template<typename U> static auto Test(U*) -> typename fixture_detect<decltype(boost::declval<U>().setup())>::type;
+        template<typename U> static int Test(...);
+    public:
+        static const bool value = sizeof(Test<T>(0)) == sizeof(char);
+    };
+
+    template<typename T>
+    struct has_teardown {
+    private:
+        template<typename U> static auto Test(U*) -> typename fixture_detect<decltype(boost::declval<U>().teardown())>::type;
+        template<typename U> static int Test(...);
+    public:
+        static const bool value = sizeof(Test<T>(0)) == sizeof(char);
+    };
+
+
+
+    template <bool has_setup = false>
+    struct call_setup { template <class U> void operator()(U& ) { } };
+
+    template <>
+    struct call_setup<true> { template <class U> void operator()(U& u) { u.setup(); } };
+
+    template <bool has_teardown = false>
+    struct call_teardown { template <class U> void operator()(U& ) { } };
+
+    template <>
+    struct call_teardown<true> { template <class U> void operator()(U& u) { u.teardown(); } };
+}
+
+
+template <class U>
+void setup_conditional(U& u) {
+    return impl_fixture::call_setup<impl_fixture::has_setup<U>::value>()(u);
+}
+
+
+template <class U>
+void teardown_conditional(U& u) {
+    return impl_fixture::call_teardown<impl_fixture::has_teardown<U>::value>()(u);
+}
+
+
+
+
+
+
+template<typename F, typename Arg=void>
+class class_based_fixture : public test_unit_fixture {
+public:
+
+    explicit class_based_fixture( Arg const& arg ) : m_inst(), m_arg( arg ) {}
+
+private:
+
+    virtual void setup() { m_inst.reset( new F( m_arg ) ); setup_conditional(*m_inst); }
+    virtual void teardown() { teardown_conditional(*m_inst); m_inst.reset(); }
+
+
+    scoped_ptr<F> m_inst;
+    Arg m_arg;
+};
+
+
+
+template<typename F>
+class class_based_fixture<F,void> : public test_unit_fixture {
+public:
+
+    class_based_fixture() : m_inst( 0 ) {}
+
+private:
+
+    virtual void setup() { m_inst.reset( new F ); setup_conditional(*m_inst); }
+    virtual void teardown() { teardown_conditional(*m_inst); m_inst.reset(); }
+
+
+    scoped_ptr<F> m_inst;
+};
+
+
+
+
+
+
+
+class function_based_fixture : public test_unit_fixture {
+public:
+
+    function_based_fixture( boost::function<void ()> const& setup_, boost::function<void ()> const& teardown_ )
+    : m_setup( setup_ )
+    , m_teardown( teardown_ )
+    {
+    }
+
+private:
+
+    virtual void setup() { if( m_setup ) m_setup(); }
+    virtual void teardown() { if( m_teardown ) m_teardown(); }
+
+
+    boost::function<void ()> m_setup;
+    boost::function<void ()> m_teardown;
+};
+
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 189 "/usr/include/boost/test/tree/fixture.hpp" 2 3 4
+# 23 "/usr/include/boost/test/tree/decorator.hpp" 2 3 4
+
+# 1 "/usr/include/boost/test/tools/assertion_result.hpp" 1 3 4
+# 13 "/usr/include/boost/test/tools/assertion_result.hpp" 3 4
+#define BOOST_TEST_PREDICATE_RESULT_HPP_012705GER 
+
+
+
+# 1 "/usr/include/boost/test/utils/wrap_stringstream.hpp" 1 3 4
+# 17 "/usr/include/boost/test/utils/wrap_stringstream.hpp" 3 4
+#define BOOST_TEST_UTILS_WRAP_STRINGSTREAM_HPP 
+# 29 "/usr/include/boost/test/utils/wrap_stringstream.hpp" 3 4
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 30 "/usr/include/boost/test/utils/wrap_stringstream.hpp" 2 3 4
+
+
+
+namespace boost {
+
+
+
+
+
+template<typename CharT>
+class basic_wrap_stringstream {
+public:
+
+
+
+
+
+    typedef std::basic_ostringstream<CharT> wrapped_stream;
+
+
+    basic_wrap_stringstream& ref();
+    wrapped_stream& stream();
+    std::basic_string<CharT> const& str();
+
+private:
+
+    wrapped_stream m_stream;
+    std::basic_string<CharT> m_str;
+};
+
+
+
+template <typename CharT, typename T>
+inline basic_wrap_stringstream<CharT>&
+operator<<( basic_wrap_stringstream<CharT>& targ, T const& t )
+{
+    targ.stream() << t;
+    return targ;
+}
+
+
+
+template <typename CharT>
+inline typename basic_wrap_stringstream<CharT>::wrapped_stream&
+basic_wrap_stringstream<CharT>::stream()
+{
+    return m_stream;
+}
+
+
+
+template <typename CharT>
+inline basic_wrap_stringstream<CharT>&
+basic_wrap_stringstream<CharT>::ref()
+{
+    return *this;
+}
+
+
+
+template <typename CharT>
+inline std::basic_string<CharT> const&
+basic_wrap_stringstream<CharT>::str()
+{
+
+
+
+
+
+    m_str = m_stream.str();
+
+
+    return m_str;
+}
+
+
+
+template <typename CharT>
+inline basic_wrap_stringstream<CharT>&
+operator<<( basic_wrap_stringstream<CharT>& targ, basic_wrap_stringstream<CharT>& src )
+{
+    targ << src.str();
+    return targ;
+}
+
+
+
+
+
+template <typename CharT>
+inline basic_wrap_stringstream<CharT>&
+operator<<( basic_wrap_stringstream<CharT>& targ, std::ios_base& ( *man)(std::ios_base&) )
+{
+    targ.stream() << man;
+    return targ;
+}
+
+
+
+template<typename CharT,typename Elem,typename Tr>
+inline basic_wrap_stringstream<CharT>&
+operator<<( basic_wrap_stringstream<CharT>& targ, std::basic_ostream<Elem,Tr>& ( *man)(std::basic_ostream<Elem, Tr>&) )
+{
+    targ.stream() << man;
+    return targ;
+}
+
+
+
+template<typename CharT,typename Elem,typename Tr>
+inline basic_wrap_stringstream<CharT>&
+operator<<( basic_wrap_stringstream<CharT>& targ, std::basic_ios<Elem, Tr>& ( *man)(std::basic_ios<Elem, Tr>&) )
+{
+    targ.stream() << man;
+    return targ;
+}
+# 155 "/usr/include/boost/test/utils/wrap_stringstream.hpp" 3 4
+typedef basic_wrap_stringstream<char> wrap_stringstream;
+typedef basic_wrap_stringstream<wchar_t> wrap_wstringstream;
+
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 161 "/usr/include/boost/test/utils/wrap_stringstream.hpp" 2 3 4
+# 18 "/usr/include/boost/test/tools/assertion_result.hpp" 2 3 4
+# 27 "/usr/include/boost/test/tools/assertion_result.hpp" 3 4
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 28 "/usr/include/boost/test/tools/assertion_result.hpp" 2 3 4
+
+
+
+namespace boost {
+namespace test_tools {
+
+
+
+
+
+
+class __attribute__((__visibility__("default"))) assertion_result {
+
+
+    typedef unit_test::const_string const_string;
+
+
+    struct dummy { void nonnull() {} };
+
+
+    typedef void (dummy::*safe_bool)();
+
+public:
+
+    assertion_result( bool pv_ )
+    : p_predicate_value( pv_ )
+    {}
+
+    template<typename BoolConvertable>
+    assertion_result( BoolConvertable const& pv_ ) : p_predicate_value( !!pv_ ) {}
+
+
+    bool operator!() const { return !p_predicate_value; }
+    void operator=( bool pv_ ) { p_predicate_value.value = pv_; }
+    operator safe_bool() const { return !!p_predicate_value ? &dummy::nonnull : 0; }
+
+
+    class readonly_property65 : public boost::unit_test::readonly_property<bool > { typedef boost::unit_test::readonly_property<bool > base_prop; friend class assertion_result; typedef base_prop::write_param_t write_param_t; public: readonly_property65() {} explicit readonly_property65( write_param_t init_v ) : base_prop( init_v ) {} } p_predicate_value;
+
+
+    bool has_empty_message() const { return !m_message; }
+    wrap_stringstream& message()
+    {
+        if( !m_message )
+            m_message.reset( new wrap_stringstream );
+
+        return *m_message;
+    }
+    const_string message() const { return !m_message ? const_string() : const_string( m_message->str() ); }
+
+private:
+
+    shared_ptr<wrap_stringstream> m_message;
+};
+
+typedef assertion_result predicate_result;
+
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 89 "/usr/include/boost/test/tools/assertion_result.hpp" 2 3 4
+# 25 "/usr/include/boost/test/tree/decorator.hpp" 2 3 4
+
+
+
+
+# 1 "/usr/include/boost/function/function0.hpp" 1 3 4
+# 10 "/usr/include/boost/function/function0.hpp" 3 4
+#define BOOST_FUNCTION_NUM_ARGS 0
+# 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
+# 11 "/usr/include/boost/function/detail/maybe_include.hpp" 3 4
+#undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#define BOOST_FUNCTION_MAX_ARGS_DEFINED 0
+# 12 "/usr/include/boost/function/function0.hpp" 2 3 4
+#undef BOOST_FUNCTION_NUM_ARGS
+# 30 "/usr/include/boost/test/tree/decorator.hpp" 2 3 4
+# 1 "/usr/include/boost/function/function1.hpp" 1 3 4
+# 10 "/usr/include/boost/function/function1.hpp" 3 4
+#define BOOST_FUNCTION_NUM_ARGS 1
+# 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
+# 18 "/usr/include/boost/function/detail/maybe_include.hpp" 3 4
+#undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#define BOOST_FUNCTION_MAX_ARGS_DEFINED 1
+
+#define BOOST_FUNCTION_1 
+# 1 "/usr/include/boost/function/function_template.hpp" 1 3 4
+# 21 "/usr/include/boost/function/function_template.hpp" 3 4
+#define BOOST_FUNCTION_TEMPLATE_PARMS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, typename T)
+
+#define BOOST_FUNCTION_TEMPLATE_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, T)
+
+#define BOOST_FUNCTION_PARM(J,I,D) BOOST_PP_CAT(T,I) BOOST_PP_CAT(a,I)
+
+#define BOOST_FUNCTION_PARMS BOOST_PP_ENUM(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_PARM,BOOST_PP_EMPTY)
+
+
+
+
+#define BOOST_FUNCTION_ARG(J,I,D) static_cast<BOOST_PP_CAT(T,I)&&>(BOOST_PP_CAT(a,I))
+#define BOOST_FUNCTION_ARGS BOOST_PP_ENUM(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_ARG,BOOST_PP_EMPTY)
+
+
+#define BOOST_FUNCTION_ARG_TYPE(J,I,D) typedef BOOST_PP_CAT(T,I) BOOST_PP_CAT(BOOST_PP_CAT(arg, BOOST_PP_INC(I)),_type);
+
+
+#define BOOST_FUNCTION_ARG_TYPES BOOST_PP_REPEAT(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_ARG_TYPE,BOOST_PP_EMPTY)
+
+
+
+
+
+#define BOOST_FUNCTION_COMMA ,
+
+
+
+#define BOOST_FUNCTION_FUNCTION BOOST_JOIN(function,BOOST_FUNCTION_NUM_ARGS)
+#define BOOST_FUNCTION_FUNCTION_INVOKER BOOST_JOIN(function_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_VOID_FUNCTION_INVOKER BOOST_JOIN(void_function_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_FUNCTION_OBJ_INVOKER BOOST_JOIN(function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER BOOST_JOIN(void_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_FUNCTION_REF_INVOKER BOOST_JOIN(function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER BOOST_JOIN(void_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_MEMBER_INVOKER BOOST_JOIN(function_mem_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_VOID_MEMBER_INVOKER BOOST_JOIN(function_void_mem_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_GET_FUNCTION_INVOKER BOOST_JOIN(get_function_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER BOOST_JOIN(get_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER BOOST_JOIN(get_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_GET_MEMBER_INVOKER BOOST_JOIN(get_member_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_GET_INVOKER BOOST_JOIN(get_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_VTABLE BOOST_JOIN(basic_vtable,BOOST_FUNCTION_NUM_ARGS)
+
+
+#define BOOST_FUNCTION_VOID_RETURN_TYPE void
+#define BOOST_FUNCTION_RETURN(X) X
+
+
+
+
+
+namespace boost {
+  namespace detail {
+    namespace function {
+      template<
+        typename FunctionPtr,
+        typename R ,
+        typename T0
+        >
+      struct function_invoker1
+      {
+        static R invoke(function_buffer& function_ptr ,
+                        T0 a0)
+        {
+          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.members.func_ptr);
+          return f( static_cast<T0&&>(a0));
+        }
+      };
+
+      template<
+        typename FunctionPtr,
+        typename R ,
+        typename T0
+        >
+      struct void_function_invoker1
+      {
+        static void
+        invoke(function_buffer& function_ptr ,
+               T0 a0)
+
+        {
+          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.members.func_ptr);
+          f( static_cast<T0&&>(a0));
+        }
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0
+      >
+      struct function_obj_invoker1
+      {
+        static R invoke(function_buffer& function_obj_ptr ,
+                        T0 a0)
+
+        {
+          FunctionObj* f;
+          if (function_allows_small_object_optimization<FunctionObj>::value)
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.data);
+          else
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
+          return (*f)( static_cast<T0&&>(a0));
+        }
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0
+      >
+      struct void_function_obj_invoker1
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr ,
+               T0 a0)
+
+        {
+          FunctionObj* f;
+          if (function_allows_small_object_optimization<FunctionObj>::value)
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.data);
+          else
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
+          (*f)( static_cast<T0&&>(a0));
+        }
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0
+      >
+      struct function_ref_invoker1
+      {
+        static R invoke(function_buffer& function_obj_ptr ,
+                        T0 a0)
+
+        {
+          FunctionObj* f =
+            reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
+          return (*f)( static_cast<T0&&>(a0));
+        }
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0
+      >
+      struct void_function_ref_invoker1
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr ,
+               T0 a0)
+
+        {
+          FunctionObj* f =
+            reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
+          (*f)( static_cast<T0&&>(a0));
+        }
+      };
+
+
+
+      template<
+        typename MemberPtr,
+        typename R ,
+        typename T0
+      >
+      struct function_mem_invoker1
+      {
+        static R invoke(function_buffer& function_obj_ptr ,
+                        T0 a0)
+
+        {
+          MemberPtr* f =
+            reinterpret_cast<MemberPtr*>(function_obj_ptr.data);
+          return boost::mem_fn(*f)( static_cast<T0&&>(a0));
+        }
+      };
+
+      template<
+        typename MemberPtr,
+        typename R ,
+        typename T0
+      >
+      struct function_void_mem_invoker1
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr ,
+               T0 a0)
+
+        {
+          MemberPtr* f =
+            reinterpret_cast<MemberPtr*>(function_obj_ptr.data);
+          boost::mem_fn(*f)( static_cast<T0&&>(a0));
+        }
+      };
+
+
+      template<
+        typename FunctionPtr,
+        typename R ,
+        typename T0
+      >
+      struct get_function_invoker1
+      {
+        typedef typename conditional<(is_void<R>::value),
+                            void_function_invoker1<
+                            FunctionPtr,
+                            R ,
+                            T0
+                          >,
+                          function_invoker1<
+                            FunctionPtr,
+                            R ,
+                            T0
+                          >
+                       >::type type;
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0
+       >
+      struct get_function_obj_invoker1
+      {
+        typedef typename conditional<(is_void<R>::value),
+                            void_function_obj_invoker1<
+                            FunctionObj,
+                            R ,
+                            T0
+                          >,
+                          function_obj_invoker1<
+                            FunctionObj,
+                            R ,
+                            T0
+                          >
+                       >::type type;
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0
+       >
+      struct get_function_ref_invoker1
+      {
+        typedef typename conditional<(is_void<R>::value),
+                            void_function_ref_invoker1<
+                            FunctionObj,
+                            R ,
+                            T0
+                          >,
+                          function_ref_invoker1<
+                            FunctionObj,
+                            R ,
+                            T0
+                          >
+                       >::type type;
+      };
+
+
+
+      template<
+        typename MemberPtr,
+        typename R ,
+        typename T0
+       >
+      struct get_member_invoker1
+      {
+        typedef typename conditional<(is_void<R>::value),
+                            function_void_mem_invoker1<
+                            MemberPtr,
+                            R ,
+                            T0
+                          >,
+                          function_mem_invoker1<
+                            MemberPtr,
+                            R ,
+                            T0
+                          >
+                       >::type type;
+      };
+# 331 "/usr/include/boost/function/function_template.hpp" 3 4
+      template<typename Tag>
+      struct get_invoker1 { };
+
+
+      template<>
+      struct get_invoker1<function_ptr_tag>
+      {
+        template<typename FunctionPtr,
+                 typename R , typename T0>
+        struct apply
+        {
+          typedef typename get_function_invoker1<
+                             FunctionPtr,
+                             R ,
+                             T0
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<FunctionPtr> manager_type;
+        };
+
+        template<typename FunctionPtr, typename Allocator,
+                 typename R , typename T0>
+        struct apply_a
+        {
+          typedef typename get_function_invoker1<
+                             FunctionPtr,
+                             R ,
+                             T0
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<FunctionPtr> manager_type;
+        };
+      };
+
+
+
+      template<>
+      struct get_invoker1<member_ptr_tag>
+      {
+        template<typename MemberPtr,
+                 typename R , typename T0>
+        struct apply
+        {
+          typedef typename get_member_invoker1<
+                             MemberPtr,
+                             R ,
+                             T0
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<MemberPtr> manager_type;
+        };
+
+        template<typename MemberPtr, typename Allocator,
+                 typename R , typename T0>
+        struct apply_a
+        {
+          typedef typename get_member_invoker1<
+                             MemberPtr,
+                             R ,
+                             T0
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<MemberPtr> manager_type;
+        };
+      };
+
+
+
+      template<>
+      struct get_invoker1<function_obj_tag>
+      {
+        template<typename FunctionObj,
+                 typename R , typename T0>
+        struct apply
+        {
+          typedef typename get_function_obj_invoker1<
+                             FunctionObj,
+                             R ,
+                             T0
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<FunctionObj> manager_type;
+        };
+
+        template<typename FunctionObj, typename Allocator,
+                 typename R , typename T0>
+        struct apply_a
+        {
+          typedef typename get_function_obj_invoker1<
+                             FunctionObj,
+                             R ,
+                             T0
+                           >::type
+            invoker_type;
+
+          typedef functor_manager_a<FunctionObj, Allocator> manager_type;
+        };
+      };
+
+
+      template<>
+      struct get_invoker1<function_obj_ref_tag>
+      {
+        template<typename RefWrapper,
+                 typename R , typename T0>
+        struct apply
+        {
+          typedef typename get_function_ref_invoker1<
+                             typename RefWrapper::type,
+                             R ,
+                             T0
+                           >::type
+            invoker_type;
+
+          typedef reference_manager<typename RefWrapper::type> manager_type;
+        };
+
+        template<typename RefWrapper, typename Allocator,
+                 typename R , typename T0>
+        struct apply_a
+        {
+          typedef typename get_function_ref_invoker1<
+                             typename RefWrapper::type,
+                             R ,
+                             T0
+                           >::type
+            invoker_type;
+
+          typedef reference_manager<typename RefWrapper::type> manager_type;
+        };
+      };
+# 476 "/usr/include/boost/function/function_template.hpp" 3 4
+      template<typename R , typename T0>
+      struct basic_vtable1
+      {
+
+        typedef R result_type;
+
+
+
+
+        typedef result_type (*invoker_type)(function_buffer&
+                                            ,
+                                            T0);
+
+        template<typename F>
+        bool assign_to(F f, function_buffer& functor) const
+        {
+          typedef typename get_function_tag<F>::type tag;
+          return assign_to(f, functor, tag());
+        }
+        template<typename F,typename Allocator>
+        bool assign_to_a(F f, function_buffer& functor, Allocator a) const
+        {
+          typedef typename get_function_tag<F>::type tag;
+          return assign_to_a(f, functor, a, tag());
+        }
+
+        void clear(function_buffer& functor) const
+        {
+          if (base.manager)
+            base.manager(functor, functor, destroy_functor_tag);
+        }
+
+      private:
+
+        template<typename FunctionPtr>
+        bool
+        assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag) const
+        {
+          this->clear(functor);
+          if (f) {
+
+
+            functor.members.func_ptr = reinterpret_cast<void (*)()>(f);
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionPtr,typename Allocator>
+        bool
+        assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const
+        {
+          return assign_to(f,functor,function_ptr_tag());
+        }
+
+
+
+        template<typename MemberPtr>
+        bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag) const
+        {
+
+
+
+          if (f) {
+            this->assign_to(boost::mem_fn(f), functor);
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename MemberPtr,typename Allocator>
+        bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag) const
+        {
+
+
+
+          if (f) {
+            this->assign_to_a(boost::mem_fn(f), functor, a);
+            return true;
+          } else {
+            return false;
+          }
+        }
+
+
+
+
+        template<typename FunctionObj>
+        void
+        assign_functor(FunctionObj f, function_buffer& functor, true_type) const
+        {
+          new (reinterpret_cast<void*>(functor.data)) FunctionObj(f);
+        }
+        template<typename FunctionObj,typename Allocator>
+        void
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, true_type) const
+        {
+          assign_functor(f,functor,true_type());
+        }
+
+
+        template<typename FunctionObj>
+        void
+        assign_functor(FunctionObj f, function_buffer& functor, false_type) const
+        {
+          functor.members.obj_ptr = new FunctionObj(f);
+        }
+        template<typename FunctionObj,typename Allocator>
+        void
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, false_type) const
+        {
+          typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;
+
+
+
+
+
+          using wrapper_allocator_type = typename std::allocator_traits<Allocator>::template rebind_alloc<functor_wrapper_type>;
+          using wrapper_allocator_pointer_type = typename std::allocator_traits<wrapper_allocator_type>::pointer;
+
+          wrapper_allocator_type wrapper_allocator(a);
+          wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
+
+
+
+          std::allocator_traits<wrapper_allocator_type>::construct(wrapper_allocator, copy, functor_wrapper_type(f,a));
+
+          functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
+          functor.members.obj_ptr = new_f;
+        }
+
+        template<typename FunctionObj>
+        bool
+        assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) const
+        {
+          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
+            assign_functor(f, functor,
+                           integral_constant<bool, (function_allows_small_object_optimization<FunctionObj>::value)>());
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionObj,typename Allocator>
+        bool
+        assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag) const
+        {
+          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
+            assign_functor_a(f, functor, a,
+                           integral_constant<bool, (function_allows_small_object_optimization<FunctionObj>::value)>());
+            return true;
+          } else {
+            return false;
+          }
+        }
+
+
+        template<typename FunctionObj>
+        bool
+        assign_to(const reference_wrapper<FunctionObj>& f,
+                  function_buffer& functor, function_obj_ref_tag) const
+        {
+          functor.members.obj_ref.obj_ptr = (void *)(f.get_pointer());
+          functor.members.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
+          functor.members.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
+          return true;
+        }
+        template<typename FunctionObj,typename Allocator>
+        bool
+        assign_to_a(const reference_wrapper<FunctionObj>& f,
+                  function_buffer& functor, Allocator, function_obj_ref_tag) const
+        {
+          return assign_to(f,functor,function_obj_ref_tag());
+        }
+
+      public:
+        vtable_base base;
+        invoker_type invoker;
+      };
+    }
+  }
+
+  template<
+    typename R ,
+    typename T0
+  >
+  class function1 : public function_base
+  {
+  public:
+
+    typedef R result_type;
+
+
+
+
+
+  private:
+    typedef boost::detail::function::basic_vtable1<
+              R , T0>
+      vtable_type;
+
+    vtable_type* get_vtable() const {
+      return reinterpret_cast<vtable_type*>(
+               reinterpret_cast<std::size_t>(vtable) & ~static_cast<std::size_t>(0x01));
+    }
+
+    struct clear_type {};
+
+  public:
+    static const int args = 1;
+
+
+    template<typename Args>
+    struct sig
+    {
+      typedef result_type type;
+    };
+
+
+    typedef T0 argument_type;
+
+
+
+
+
+    static const int arity = 1;
+    typedef T0 arg1_type;
+
+    typedef function1 self_type;
+
+    function1() = default;
+
+
+
+    template<typename Functor>
+    function1(Functor f
+
+                            ,typename boost::enable_if_<
+                             !(is_integral<Functor>::value),
+                                        int>::type = 0
+
+                            ) :
+      function_base()
+    {
+      this->assign_to(f);
+    }
+    template<typename Functor,typename Allocator>
+    function1(Functor f, Allocator a
+
+                            ,typename boost::enable_if_<
+                              !(is_integral<Functor>::value),
+                                        int>::type = 0
+
+                            ) :
+      function_base()
+    {
+      this->assign_to_a(f,a);
+    }
+
+
+    function1(clear_type*) : function_base() { }
+
+
+
+
+
+
+
+    function1(const function1& f) : function_base()
+    {
+      this->assign_to_own(f);
+    }
+
+
+    function1(function1&& f) : function_base()
+    {
+      this->move_assign(f);
+    }
+
+
+    ~function1() { clear(); }
+
+    result_type operator()( T0 a0) const
+    {
+      if (this->empty())
+        boost::throw_exception(bad_function_call());
+
+      return get_vtable()->invoker
+               (this->functor , static_cast<T0&&>(a0));
+    }
+
+
+
+
+
+
+    template<typename Functor>
+
+    typename boost::enable_if_<
+                  !(is_integral<Functor>::value),
+               function1&>::type
+
+
+
+    operator=(Functor f)
+    {
+      this->clear();
+      { try {
+        this->assign_to(f);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+      return *this;
+    }
+    template<typename Functor,typename Allocator>
+    void assign(Functor f, Allocator a)
+    {
+      this->clear();
+      { try{
+        this->assign_to_a(f,a);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+    }
+
+
+    function1& operator=(clear_type*)
+    {
+      this->clear();
+      return *this;
+    }
+# 821 "/usr/include/boost/function/function_template.hpp" 3 4
+    function1& operator=(const function1& f)
+    {
+      if (&f == this)
+        return *this;
+
+      this->clear();
+      { try {
+        this->assign_to_own(f);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+      return *this;
+    }
+
+
+
+    function1& operator=(function1&& f)
+    {
+      if (&f == this)
+        return *this;
+
+      this->clear();
+      { try {
+        this->move_assign(f);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+      return *this;
+    }
+
+
+    void swap(function1& other)
+    {
+      if (&other == this)
+        return;
+
+      function1 tmp;
+      tmp.move_assign(*this);
+      this->move_assign(other);
+      other.move_assign(tmp);
+    }
+
+
+    void clear()
+    {
+      if (vtable) {
+        if (!this->has_trivial_copy_and_destroy())
+          get_vtable()->clear(this->functor);
+        vtable = 0;
+      }
+    }
+
+
+
+
+
+  private:
+    struct dummy {
+      void nonnull() {}
+    };
+
+    typedef void (dummy::*safe_bool)();
+
+  public:
+    operator safe_bool () const
+      { return (this->empty())? 0 : &dummy::nonnull; }
+
+    bool operator!() const
+      { return this->empty(); }
+
+
+  private:
+    void assign_to_own(const function1& f)
+    {
+      if (!f.empty()) {
+        this->vtable = f.vtable;
+        if (this->has_trivial_copy_and_destroy())
+
+
+          std::memcpy(this->functor.data, f.functor.data, sizeof(boost::detail::function::function_buffer));
+        else
+          get_vtable()->base.manager(f.functor, this->functor,
+                                     boost::detail::function::clone_functor_tag);
+      }
+    }
+
+    template<typename Functor>
+    void assign_to(Functor f)
+    {
+      using boost::detail::function::vtable_base;
+
+      typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
+      typedef boost::detail::function::get_invoker1<tag> get_invoker;
+      typedef typename get_invoker::
+                         template apply<Functor, R ,
+                        T0>
+        handler_type;
+
+      typedef typename handler_type::invoker_type invoker_type;
+      typedef typename handler_type::manager_type manager_type;
+
+
+
+
+
+      static const vtable_type stored_vtable =
+        { { &manager_type::manage }, &invoker_type::invoke };
+
+      if (stored_vtable.assign_to(f, functor)) {
+        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
+
+        if (boost::has_trivial_copy_constructor<Functor>::value &&
+            boost::has_trivial_destructor<Functor>::value &&
+            boost::detail::function::function_allows_small_object_optimization<Functor>::value)
+          value |= static_cast<std::size_t>(0x01);
+        vtable = reinterpret_cast<boost::detail::function::vtable_base *>(value);
+      } else
+        vtable = 0;
+    }
+
+    template<typename Functor,typename Allocator>
+    void assign_to_a(Functor f,Allocator a)
+    {
+      using boost::detail::function::vtable_base;
+
+      typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
+      typedef boost::detail::function::get_invoker1<tag> get_invoker;
+      typedef typename get_invoker::
+                         template apply_a<Functor, Allocator, R ,
+                         T0>
+        handler_type;
+
+      typedef typename handler_type::invoker_type invoker_type;
+      typedef typename handler_type::manager_type manager_type;
+
+
+
+
+
+      static const vtable_type stored_vtable =
+        { { &manager_type::manage }, &invoker_type::invoke };
+
+      if (stored_vtable.assign_to_a(f, functor, a)) {
+        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
+
+        if (boost::has_trivial_copy_constructor<Functor>::value &&
+            boost::has_trivial_destructor<Functor>::value &&
+            boost::detail::function::function_allows_small_object_optimization<Functor>::value)
+          value |= static_cast<std::size_t>(0x01);
+        vtable = reinterpret_cast<boost::detail::function::vtable_base *>(value);
+      } else
+        vtable = 0;
+    }
+
+
+
+
+    void move_assign(function1& f)
+    {
+      if (&f == this)
+        return;
+
+      { try {
+        if (!f.empty()) {
+          this->vtable = f.vtable;
+          if (this->has_trivial_copy_and_destroy())
+
+
+            std::memcpy(this->functor.data, f.functor.data, sizeof(this->functor.data));
+          else
+            get_vtable()->base.manager(f.functor, this->functor,
+                                     boost::detail::function::move_functor_tag);
+          f.vtable = 0;
+        } else {
+          clear();
+        }
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+    }
+  };
+
+  template<typename R , typename T0>
+  inline void swap(function1<
+                     R ,
+                     T0
+                   >& f1,
+                   function1<
+                     R ,
+                     T0
+                   >& f2)
+  {
+    f1.swap(f2);
+  }
+
+
+template<typename R , typename T0>
+  void operator==(const function1<
+                          R ,
+                          T0>&,
+                  const function1<
+                          R ,
+                          T0>&);
+template<typename R , typename T0>
+  void operator!=(const function1<
+                          R ,
+                          T0>&,
+                  const function1<
+                          R ,
+                          T0>& );
+
+
+
+
+
+
+#define BOOST_FUNCTION_PARTIAL_SPEC R (BOOST_FUNCTION_TEMPLATE_ARGS)
+
+
+template<typename R ,
+         typename T0>
+class function<R ( T0)>
+  : public function1<R , T0>
+{
+  typedef function1<R , T0> base_type;
+  typedef function self_type;
+
+  struct clear_type {};
+
+public:
+
+  function() = default;
+
+  template<typename Functor>
+  function(Functor f
+
+           ,typename boost::enable_if_<
+                          !(is_integral<Functor>::value),
+                       int>::type = 0
+
+           ) :
+    base_type(f)
+  {
+  }
+  template<typename Functor,typename Allocator>
+  function(Functor f, Allocator a
+
+           ,typename boost::enable_if_<
+                           !(is_integral<Functor>::value),
+                       int>::type = 0
+
+           ) :
+    base_type(f,a)
+  {
+  }
+
+
+  function(clear_type*) : base_type() {}
+
+
+  function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}
+
+  function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}
+
+
+
+  function(self_type&& f): base_type(static_cast<base_type&&>(f)){}
+  function(base_type&& f): base_type(static_cast<base_type&&>(f)){}
+
+
+  self_type& operator=(const self_type& f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+
+
+  self_type& operator=(self_type&& f)
+  {
+    self_type(static_cast<self_type&&>(f)).swap(*this);
+    return *this;
+  }
+
+
+  template<typename Functor>
+
+  typename boost::enable_if_<
+                         !(is_integral<Functor>::value),
+                      self_type&>::type
+
+
+
+  operator=(Functor f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+
+
+  self_type& operator=(clear_type*)
+  {
+    this->clear();
+    return *this;
+  }
+
+
+  self_type& operator=(const base_type& f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+
+
+  self_type& operator=(base_type&& f)
+  {
+    self_type(static_cast<base_type&&>(f)).swap(*this);
+    return *this;
+  }
+
+};
+
+#undef BOOST_FUNCTION_PARTIAL_SPEC
+
+
+}
+
+
+#undef BOOST_FUNCTION_VTABLE
+#undef BOOST_FUNCTION_COMMA
+#undef BOOST_FUNCTION_FUNCTION
+#undef BOOST_FUNCTION_FUNCTION_INVOKER
+#undef BOOST_FUNCTION_VOID_FUNCTION_INVOKER
+#undef BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
+#undef BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
+#undef BOOST_FUNCTION_FUNCTION_REF_INVOKER
+#undef BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER
+#undef BOOST_FUNCTION_MEMBER_INVOKER
+#undef BOOST_FUNCTION_VOID_MEMBER_INVOKER
+#undef BOOST_FUNCTION_GET_FUNCTION_INVOKER
+#undef BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
+#undef BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER
+#undef BOOST_FUNCTION_GET_MEM_FUNCTION_INVOKER
+#undef BOOST_FUNCTION_GET_INVOKER
+#undef BOOST_FUNCTION_TEMPLATE_PARMS
+#undef BOOST_FUNCTION_TEMPLATE_ARGS
+#undef BOOST_FUNCTION_PARMS
+#undef BOOST_FUNCTION_PARM
+
+#undef BOOST_FUNCTION_ARG
+
+#undef BOOST_FUNCTION_ARGS
+#undef BOOST_FUNCTION_ARG_TYPE
+#undef BOOST_FUNCTION_ARG_TYPES
+#undef BOOST_FUNCTION_VOID_RETURN_TYPE
+#undef BOOST_FUNCTION_RETURN
+# 23 "/usr/include/boost/function/detail/maybe_include.hpp" 2 3 4
+# 12 "/usr/include/boost/function/function1.hpp" 2 3 4
+#undef BOOST_FUNCTION_NUM_ARGS
+# 31 "/usr/include/boost/test/tree/decorator.hpp" 2 3 4
+
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 33 "/usr/include/boost/test/tree/decorator.hpp" 2 3 4
+
+
+
+
+
+
+namespace boost {
+namespace unit_test {
+
+class test_unit;
+
+namespace decorator {
+
+
+
+
+
+class base;
+typedef boost::shared_ptr<base> base_ptr;
+
+class __attribute__((__visibility__("default"))) collector_t {
+
+public:
+    collector_t& operator*( base const& d );
+
+    void store_in( test_unit& tu );
+
+    void reset();
+
+    void stack();
+
+    std::vector<base_ptr> get_lazy_decorators() const;
+
+
+    public: static collector_t& instance(); private: collector_t(collector_t const&) = delete; collector_t& operator=(collector_t const&) = delete; ~collector_t() = default;
+
+private:
+
+    collector_t() : m_tu_decorators_stack(1) {}
+
+
+    std::vector< std::vector<base_ptr> > m_tu_decorators_stack;
+};
+
+
+
+
+
+
+class __attribute__((__visibility__("default"))) base {
+public:
+
+    virtual collector_t& operator*() const;
+
+
+    virtual void apply( test_unit& tu ) = 0;
+
+
+    virtual base_ptr clone() const = 0;
+
+protected:
+    virtual ~base() {}
+};
+# 109 "/usr/include/boost/test/tree/decorator.hpp" 3 4
+class __attribute__((__visibility__("default"))) stack_decorator : public decorator::base {
+public:
+    explicit stack_decorator() {}
+
+    virtual collector_t& operator*() const;
+
+private:
+
+    virtual void apply( test_unit& tu );
+    virtual base_ptr clone() const { return base_ptr(new stack_decorator()); }
+};
+
+
+
+
+
+class __attribute__((__visibility__("default"))) label : public decorator::base {
+public:
+    explicit label( const_string l ) : m_label( l ) {}
+
+private:
+
+    virtual void apply( test_unit& tu );
+    virtual base_ptr clone() const { return base_ptr(new label( m_label )); }
+
+
+    const_string m_label;
+};
+
+
+
+
+
+class __attribute__((__visibility__("default"))) expected_failures : public decorator::base {
+public:
+    explicit expected_failures( counter_t ef ) : m_exp_fail( ef ) {}
+
+private:
+
+    virtual void apply( test_unit& tu );
+    virtual base_ptr clone() const { return base_ptr(new expected_failures( m_exp_fail )); }
+
+
+    counter_t m_exp_fail;
+};
+
+
+
+
+
+class __attribute__((__visibility__("default"))) timeout : public decorator::base {
+public:
+    explicit timeout( unsigned t ) : m_timeout( t ) {}
+
+private:
+
+    virtual void apply( test_unit& tu );
+    virtual base_ptr clone() const { return base_ptr(new timeout( m_timeout )); }
+
+
+    unsigned m_timeout;
+};
+
+
+
+
+
+class __attribute__((__visibility__("default"))) description : public decorator::base {
+public:
+    explicit description( const_string descr ) : m_description( descr ) {}
+
+private:
+
+    virtual void apply( test_unit& tu );
+    virtual base_ptr clone() const { return base_ptr(new description( m_description )); }
+
+
+    const_string m_description;
+};
+
+
+
+
+
+class __attribute__((__visibility__("default"))) depends_on : public decorator::base {
+public:
+    explicit depends_on( const_string dependency ) : m_dependency( dependency ) {}
+
+private:
+
+    virtual void apply( test_unit& tu );
+    virtual base_ptr clone() const { return base_ptr(new depends_on( m_dependency )); }
+
+
+    const_string m_dependency;
+};
+
+
+
+
+
+class __attribute__((__visibility__("default"))) enable_if_impl : public decorator::base {
+protected:
+    void apply_impl( test_unit& tu, bool condition );
+};
+
+template<bool condition>
+class enable_if : public enable_if_impl {
+private:
+
+    virtual void apply( test_unit& tu ) { this->apply_impl( tu, condition ); }
+    virtual base_ptr clone() const { return base_ptr(new enable_if<condition>()); }
+};
+
+typedef enable_if<true> enabled;
+typedef enable_if<false> disabled;
+
+
+
+
+
+class __attribute__((__visibility__("default"))) fixture_t : public decorator::base {
+public:
+
+    explicit fixture_t( test_unit_fixture_ptr impl ) : m_impl( impl ) {}
+
+private:
+
+    virtual void apply( test_unit& tu );
+    virtual base_ptr clone() const { return base_ptr(new fixture_t( m_impl )); }
+
+
+    test_unit_fixture_ptr m_impl;
+};
+
+
+
+template<typename F>
+inline fixture_t
+fixture()
+{
+    return fixture_t( test_unit_fixture_ptr( new unit_test::class_based_fixture<F>() ) );
+}
+
+
+
+template<typename F, typename Arg>
+inline fixture_t
+fixture( Arg const& arg )
+{
+    return fixture_t( test_unit_fixture_ptr( new unit_test::class_based_fixture<F,Arg>( arg ) ) );
+}
+
+
+
+inline fixture_t
+fixture( boost::function<void()> const& setup, boost::function<void()> const& teardown = boost::function<void()>() )
+{
+    return fixture_t( test_unit_fixture_ptr( new unit_test::function_based_fixture( setup, teardown ) ) );
+}
+
+
+
+
+
+
+
+class __attribute__((__visibility__("default"))) precondition : public decorator::base {
+public:
+    typedef boost::function<test_tools::assertion_result (test_unit_id)> predicate_t;
+
+    explicit precondition( predicate_t p ) : m_precondition( p ) {}
+
+private:
+
+    virtual void apply( test_unit& tu );
+    virtual base_ptr clone() const { return base_ptr(new precondition( m_precondition )); }
+
+
+    predicate_t m_precondition;
+};
+
+}
+
+using decorator::label;
+using decorator::expected_failures;
+using decorator::timeout;
+using decorator::description;
+using decorator::depends_on;
+using decorator::enable_if;
+using decorator::enabled;
+using decorator::disabled;
+using decorator::fixture;
+using decorator::precondition;
+
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 308 "/usr/include/boost/test/tree/decorator.hpp" 2 3 4
+# 22 "/usr/include/boost/test/tree/test_unit.hpp" 2 3 4
+# 30 "/usr/include/boost/test/tree/test_unit.hpp" 3 4
+# 1 "/usr/include/boost/function/function0.hpp" 1 3 4
+# 10 "/usr/include/boost/function/function0.hpp" 3 4
+#define BOOST_FUNCTION_NUM_ARGS 0
+# 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
+# 11 "/usr/include/boost/function/detail/maybe_include.hpp" 3 4
+#undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#define BOOST_FUNCTION_MAX_ARGS_DEFINED 0
+# 12 "/usr/include/boost/function/function0.hpp" 2 3 4
+#undef BOOST_FUNCTION_NUM_ARGS
+# 31 "/usr/include/boost/test/tree/test_unit.hpp" 2 3 4
+# 1 "/usr/include/boost/function/function1.hpp" 1 3 4
+# 10 "/usr/include/boost/function/function1.hpp" 3 4
+#define BOOST_FUNCTION_NUM_ARGS 1
+# 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
+# 18 "/usr/include/boost/function/detail/maybe_include.hpp" 3 4
+#undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#define BOOST_FUNCTION_MAX_ARGS_DEFINED 1
+# 12 "/usr/include/boost/function/function1.hpp" 2 3 4
+#undef BOOST_FUNCTION_NUM_ARGS
+# 32 "/usr/include/boost/test/tree/test_unit.hpp" 2 3 4
+
+
+
+
+
+
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 39 "/usr/include/boost/test/tree/test_unit.hpp" 2 3 4
+
+
+
+namespace boost {
+namespace unit_test {
+
+namespace framework {
+  class state;
+}
+
+
+
+
+
+typedef std::vector<test_unit_id> test_unit_id_list;
+
+class __attribute__((__visibility__("default"))) test_unit {
+public:
+    enum { type = TUT_ANY };
+    enum run_status { RS_DISABLED, RS_ENABLED, RS_INHERIT, RS_INVALID };
+
+    typedef std::vector<test_unit_id> id_list;
+    typedef std::vector<test_unit_fixture_ptr> fixture_list_t;
+    typedef class readonly_property62 : public boost::unit_test::readonly_property<test_unit_id > { typedef boost::unit_test::readonly_property<test_unit_id > base_prop; friend class framework::state; typedef base_prop::write_param_t write_param_t; public: readonly_property62() {} explicit readonly_property62( write_param_t init_v ) : base_prop( init_v ) {} } id_t;
+    typedef class readonly_property63 : public boost::unit_test::readonly_property<test_unit_id > { typedef boost::unit_test::readonly_property<test_unit_id > base_prop; friend class test_suite; typedef base_prop::write_param_t write_param_t; public: readonly_property63() {} explicit readonly_property63( write_param_t init_v ) : base_prop( init_v ) {} } parent_id_t;
+    typedef class readonly_property64 : public boost::unit_test::readonly_property<id_list > { typedef boost::unit_test::readonly_property<id_list > base_prop; friend class test_unit; typedef base_prop::write_param_t write_param_t; public: readonly_property64() {} explicit readonly_property64( write_param_t init_v ) : base_prop( init_v ) {} } id_list_t;
+    typedef std::vector<decorator::base_ptr> decor_list_t;
+    typedef class readonly_property66 : public boost::unit_test::readonly_property<std::vector<std::string> > { typedef boost::unit_test::readonly_property<std::vector<std::string> > base_prop; friend class test_unit; typedef base_prop::write_param_t write_param_t; public: readonly_property66() {} explicit readonly_property66( write_param_t init_v ) : base_prop( init_v ) {} } label_list_t;
+
+    typedef boost::function<test_tools::assertion_result (test_unit_id)> precondition_t;
+    typedef class readonly_property69 : public boost::unit_test::readonly_property<std::vector<precondition_t> > { typedef boost::unit_test::readonly_property<std::vector<precondition_t> > base_prop; friend class test_unit; typedef base_prop::write_param_t write_param_t; public: readonly_property69() {} explicit readonly_property69( write_param_t init_v ) : base_prop( init_v ) {} } precond_list_t;
+
+
+    void depends_on( test_unit* tu );
+    void add_precondition( precondition_t const& );
+    test_tools::assertion_result check_preconditions() const;
+
+
+    void add_label( const_string l );
+    bool has_label( const_string l ) const;
+
+
+    void increase_exp_fail( counter_t num );
+    bool is_enabled() const { return p_run_status == RS_ENABLED; }
+    std::string full_name() const;
+
+
+    test_unit_type const p_type;
+    const_string const p_type_name;
+    const_string const p_file_name;
+    std::size_t const p_line_num;
+    id_t p_id;
+    parent_id_t p_parent_id;
+    label_list_t p_labels;
+
+    id_list_t p_dependencies;
+    precond_list_t p_preconditions;
+
+
+    readwrite_property<std::string> p_name;
+    readwrite_property<std::string> p_description;
+    readwrite_property<unsigned> p_timeout;
+    readwrite_property<counter_t> p_expected_failures;
+
+    readwrite_property<run_status> p_default_status;
+    readwrite_property<run_status> p_run_status;
+
+    readwrite_property<counter_t> p_sibling_rank;
+
+    readwrite_property<decor_list_t> p_decorators;
+    readwrite_property<fixture_list_t> p_fixtures;
+
+protected:
+    ~test_unit();
+
+    test_unit( const_string tu_name, const_string tc_file, std::size_t tc_line, test_unit_type t );
+
+    explicit test_unit( const_string module_name );
+};
+
+
+
+
+
+class __attribute__((__visibility__("default"))) test_unit_generator {
+public:
+    virtual test_unit* next() const = 0;
+
+protected:
+    virtual ~test_unit_generator() {}
+};
+
+
+
+
+
+class __attribute__((__visibility__("default"))) test_case : public test_unit {
+public:
+    enum { type = TUT_CASE };
+
+
+    test_case( const_string tc_name, boost::function<void ()> const& test_func );
+    test_case( const_string tc_name, const_string tc_file, std::size_t tc_line, boost::function<void ()> const& test_func );
+
+
+    typedef class readonly_property144 : public boost::unit_test::readonly_property<boost::function<void ()> > { typedef boost::unit_test::readonly_property<boost::function<void ()> > base_prop; friend class test_case; typedef base_prop::write_param_t write_param_t; public: readonly_property144() {} explicit readonly_property144( write_param_t init_v ) : base_prop( init_v ) {} } test_func;
+
+    test_func p_test_func;
+
+private:
+    friend class framework::state;
+    ~test_case() {}
+};
+
+
+
+
+
+
+class __attribute__((__visibility__("default"))) test_suite : public test_unit {
+public:
+    enum { type = TUT_SUITE };
+
+
+    explicit test_suite( const_string ts_name, const_string ts_file, std::size_t ts_line );
+
+
+
+
+
+
+
+    void add( test_unit* tu, counter_t expected_failures = 0, unsigned timeout = 0 );
+
+
+    void add( test_unit_generator const& gen, unsigned timeout = 0 );
+
+
+    void add( test_unit_generator const& gen, decorator::collector_t& decorators );
+
+
+    void add( boost::shared_ptr<test_unit_generator> gen_ptr, decorator::collector_t& decorators );
+
+
+    void remove( test_unit_id id );
+
+
+    void generate( );
+
+
+
+
+    void check_for_duplicate_test_cases();
+
+
+    test_unit_id get( const_string tu_name ) const;
+    std::size_t size() const { return m_children.size(); }
+
+protected:
+
+    explicit test_suite( const_string module_name );
+
+    friend __attribute__((__visibility__("default")))
+    void traverse_test_tree( test_suite const&, test_tree_visitor&, bool );
+    friend class framework::state;
+    virtual ~test_suite() {}
+
+    typedef std::multimap<counter_t,test_unit_id> children_per_rank;
+
+
+    test_unit_id_list m_children;
+    children_per_rank m_ranked_children;
+
+    std::vector< std::pair<boost::shared_ptr<test_unit_generator>, std::vector<decorator::base_ptr> > > m_generators;
+};
+
+
+
+
+
+class __attribute__((__visibility__("default"))) master_test_suite_t : public test_suite {
+private:
+    master_test_suite_t();
+    master_test_suite_t(const master_test_suite_t&);
+    master_test_suite_t& operator=(master_test_suite_t const &);
+
+public:
+
+    int argc;
+    char** argv;
+
+    friend __attribute__((__visibility__("default"))) master_test_suite_t& boost::unit_test::framework::master_test_suite();
+};
+
+
+
+
+
+namespace ut_detail {
+
+__attribute__((__visibility__("default"))) std::string normalize_test_case_name( const_string tu_name );
+
+
+
+template<typename InstanceType,typename UserTestCase>
+struct user_tc_method_invoker {
+    typedef void (UserTestCase::*TestMethod )();
+
+    user_tc_method_invoker( shared_ptr<InstanceType> inst, TestMethod test_method )
+    : m_inst( inst ), m_test_method( test_method ) {}
+
+    void operator()() { ((*m_inst).*m_test_method)(); }
+
+    shared_ptr<InstanceType> m_inst;
+    TestMethod m_test_method;
+};
+
+}
+
+
+
+
+
+inline test_case*
+make_test_case( boost::function<void ()> const& test_func, const_string tc_name, const_string tc_file, std::size_t tc_line )
+{
+    return new test_case( ut_detail::normalize_test_case_name( tc_name ), tc_file, tc_line, test_func );
+}
+
+
+
+template<typename UserTestCase, typename InstanceType>
+inline test_case*
+make_test_case( void (UserTestCase::* test_method )(),
+                const_string tc_name,
+                const_string tc_file,
+                std::size_t tc_line,
+                boost::shared_ptr<InstanceType> user_test_case )
+{
+    return new test_case( ut_detail::normalize_test_case_name( tc_name ),
+                          tc_file,
+                          tc_line,
+                          ut_detail::user_tc_method_invoker<InstanceType,UserTestCase>( user_test_case, test_method ) );
+}
+
+
+
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 290 "/usr/include/boost/test/tree/test_unit.hpp" 2 3 4
+# 26 "/usr/include/boost/test/impl/compiler_log_formatter.ipp" 2 3 4
+
+
+# 1 "/usr/include/boost/test/utils/lazy_ostream.hpp" 1 3 4
+# 12 "/usr/include/boost/test/utils/lazy_ostream.hpp" 3 4
+#define BOOST_TEST_UTILS_LAZY_OSTREAM_HPP 
+
+
+
+
+
+
+
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 21 "/usr/include/boost/test/utils/lazy_ostream.hpp" 2 3 4
+
+
+
+
+
+
+
+namespace boost {
+namespace unit_test {
+
+class __attribute__((__visibility__("default"))) lazy_ostream {
+public:
+    virtual ~lazy_ostream() {}
+
+    static lazy_ostream& instance() { return inst; }
+
+    friend std::ostream& operator<<( std::ostream& ostr, lazy_ostream const& o ) { return o( ostr ); }
+
+
+    bool empty() const { return m_empty; }
+
+
+    virtual std::ostream& operator()( std::ostream& ostr ) const { return ostr; }
+protected:
+    explicit lazy_ostream( bool p_empty = true ) : m_empty( p_empty ) {}
+
+private:
+
+    bool m_empty;
+    static lazy_ostream inst;
+};
+
+
+
+template<typename PrevType, typename T, typename StorageT=T const&>
+class lazy_ostream_impl : public lazy_ostream {
+public:
+    lazy_ostream_impl( PrevType const& prev, T const& value )
+    : lazy_ostream( false )
+    , m_prev( prev )
+    , m_value( value )
+    {
+    }
+
+    virtual std::ostream& operator()( std::ostream& ostr ) const
+    {
+        return m_prev(ostr) << m_value;
+    }
+private:
+
+    PrevType const& m_prev;
+    StorageT m_value;
+};
+
+
+
+template<typename T>
+inline lazy_ostream_impl<lazy_ostream,T>
+operator<<( lazy_ostream const& prev, T const& v )
+{
+    return lazy_ostream_impl<lazy_ostream,T>( prev, v );
+}
+
+
+
+template<typename PrevPrevType, typename TPrev, typename T>
+inline lazy_ostream_impl<lazy_ostream_impl<PrevPrevType,TPrev>,T>
+operator<<( lazy_ostream_impl<PrevPrevType,TPrev> const& prev, T const& v )
+{
+    typedef lazy_ostream_impl<PrevPrevType,TPrev> PrevType;
+    return lazy_ostream_impl<PrevType,T>( prev, v );
+}
+
+
+
+
+
+template<typename R,typename S>
+inline lazy_ostream_impl<lazy_ostream,R& ( *)(S&),R& ( *)(S&)>
+operator<<( lazy_ostream const& prev, R& ( *man)(S&) )
+{
+    typedef R& ( * ManipType)(S&);
+
+    return lazy_ostream_impl<lazy_ostream,ManipType,ManipType>( prev, man );
+}
+
+
+
+template<typename PrevPrevType, typename TPrev,typename R,typename S>
+inline lazy_ostream_impl<lazy_ostream_impl<PrevPrevType,TPrev>,R& ( *)(S&),R& ( *)(S&)>
+operator<<( lazy_ostream_impl<PrevPrevType,TPrev> const& prev, R& ( *man)(S&) )
+{
+    typedef R& ( * ManipType)(S&);
+
+    return lazy_ostream_impl<lazy_ostream_impl<PrevPrevType,TPrev>,ManipType,ManipType>( prev, man );
+}
+
+
+
+
+
+#define BOOST_TEST_LAZY_MSG(M) (::boost::unit_test::lazy_ostream::instance() << M)
+
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 128 "/usr/include/boost/test/utils/lazy_ostream.hpp" 2 3 4
+# 29 "/usr/include/boost/test/impl/compiler_log_formatter.ipp" 2 3 4
+# 1 "/usr/include/boost/test/utils/setcolor.hpp" 1 3 4
+# 16 "/usr/include/boost/test/utils/setcolor.hpp" 3 4
+#define BOOST_TEST_UTILS_SETCOLOR_HPP 
+
+
+
+
+# 1 "/usr/include/boost/core/ignore_unused.hpp" 1 3 4
+
+
+
+
+
+
+
+#define BOOST_CORE_IGNORE_UNUSED_HPP 
+
+
+
+namespace boost {
+
+
+
+template <typename... Ts>
+inline __attribute__ ((__always_inline__)) constexpr void ignore_unused(Ts const& ...)
+{}
+
+template <typename... Ts>
+inline __attribute__ ((__always_inline__)) constexpr void ignore_unused()
+{}
+# 68 "/usr/include/boost/core/ignore_unused.hpp" 3 4
+}
+# 22 "/usr/include/boost/test/utils/setcolor.hpp" 2 3 4
+
+
+
+# 1 "/usr/include/c++/10.2.0/cstdio" 1 3 4
+# 39 "/usr/include/c++/10.2.0/cstdio" 3 4
+       
+# 40 "/usr/include/c++/10.2.0/cstdio" 3
+# 26 "/usr/include/boost/test/utils/setcolor.hpp" 2 3 4
+
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 28 "/usr/include/boost/test/utils/setcolor.hpp" 2 3 4
+# 40 "/usr/include/boost/test/utils/setcolor.hpp" 3 4
+namespace boost {
+namespace unit_test {
+namespace utils {
+
+
+
+
+
+struct term_attr { enum _ {
+    NORMAL = 0,
+    BRIGHT = 1,
+    DIM = 2,
+    UNDERLINE = 4,
+    BLINK = 5,
+    REVERSE = 7,
+    CROSSOUT = 9
+}; };
+
+
+
+
+
+struct term_color { enum _ {
+    BLACK = 0,
+    RED = 1,
+    GREEN = 2,
+    YELLOW = 3,
+    BLUE = 4,
+    MAGENTA = 5,
+    CYAN = 6,
+    WHITE = 7,
+    ORIGINAL = 9
+}; };
+
+
+
+
+
+
+class setcolor {
+public:
+
+    explicit setcolor( bool is_color_output = false,
+                          term_attr::_ attr = term_attr::NORMAL,
+                          term_color::_ fg = term_color::ORIGINAL,
+                          term_color::_ bg = term_color::ORIGINAL )
+    : m_is_color_output(is_color_output)
+    {
+        m_command_size = std::sprintf( m_control_command, "%c[%c;3%c;4%cm",
+          0x1B,
+          static_cast<char>(attr + '0'),
+          static_cast<char>(fg + '0'),
+          static_cast<char>(bg + '0'));
+    }
+
+    friend std::ostream&
+    operator<<( std::ostream& os, setcolor const& sc )
+    {
+       if (sc.m_is_color_output && (&os == &std::cout || &os == &std::cerr)) {
+          return os.write( sc.m_control_command, sc.m_command_size );
+       }
+       return os;
+    }
+
+private:
+
+    bool m_is_color_output;
+    char m_control_command[13];
+    int m_command_size;
+};
+# 256 "/usr/include/boost/test/utils/setcolor.hpp" 3 4
+struct scope_setcolor {
+    scope_setcolor() : m_os( 0 ) {}
+    explicit scope_setcolor( bool is_color_output,
+                                std::ostream& os,
+                                term_attr::_ attr = term_attr::NORMAL,
+                                term_color::_ fg = term_color::ORIGINAL,
+                                term_color::_ bg = term_color::ORIGINAL )
+    : m_os( &os )
+    , m_is_color_output( is_color_output )
+    {
+        os << setcolor( is_color_output, attr, fg, bg );
+    }
+    ~scope_setcolor()
+    {
+        if( m_os )
+            *m_os << setcolor( m_is_color_output );
+    }
+private:
+    scope_setcolor(const scope_setcolor& r);
+    scope_setcolor& operator=(const scope_setcolor& r);
+
+    std::ostream* m_os;
+    bool m_is_color_output;
+};
+# 313 "/usr/include/boost/test/utils/setcolor.hpp" 3 4
+#define BOOST_TEST_SCOPE_SETCOLOR(is_color_output,os,attr,color) utils::scope_setcolor const sc(is_color_output, os, utils::attr, utils::color); boost::ignore_unused( sc )
+
+
+
+
+}
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 323 "/usr/include/boost/test/utils/setcolor.hpp" 2 3 4
+# 30 "/usr/include/boost/test/impl/compiler_log_formatter.ipp" 2 3 4
+# 38 "/usr/include/boost/test/impl/compiler_log_formatter.ipp" 3 4
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 39 "/usr/include/boost/test/impl/compiler_log_formatter.ipp" 2 3 4
+
+
+
+namespace boost {
+namespace unit_test {
+namespace output {
+
+
+
+
+
+namespace {
+
+std::string
+test_phase_identifier()
+{
+    return framework::test_in_progress() ? framework::current_test_unit().full_name() : std::string( "Test setup" );
+}
+
+}
+
+
+
+void
+compiler_log_formatter::log_start( std::ostream& output, counter_t test_cases_amount )
+{
+    m_color_output = runtime_config::get<bool>( runtime_config::btrt_color_output );
+
+    if( test_cases_amount > 0 )
+        output << "Running " << test_cases_amount << " test "
+                << (test_cases_amount > 1 ? "cases" : "case") << "...\n";
+}
+
+
+
+void
+compiler_log_formatter::log_finish( std::ostream& ostr )
+{
+    ostr.flush();
+}
+
+
+
+void
+compiler_log_formatter::log_build_info( std::ostream& output, bool log_build_info )
+{
+    if(log_build_info) {
+        output << "Platform: " << "linux" << '\n'
+                << "Compiler: " << "GNU C++ version " "10.2.0" << '\n'
+                << "STL     : " << "GNU libstdc++ version " "20200723" << '\n'
+                << "Boost   : " << 107200/100000 << "."
+                                << 107200/100 % 1000 << "."
+                                << 107200 % 100 << std::endl;
+    }
+}
+
+
+
+void
+compiler_log_formatter::test_unit_start( std::ostream& output, test_unit const& tu )
+{
+    utils::scope_setcolor const sc(m_color_output, output, utils::term_attr::BRIGHT, utils::term_color::BLUE); boost::ignore_unused( sc );
+
+    print_prefix( output, tu.p_file_name, tu.p_line_num );
+
+    output << "Entering test " << tu.p_type_name << " \"" << tu.p_name << "\"" << std::endl;
+}
+
+
+
+void
+compiler_log_formatter::test_unit_finish( std::ostream& output, test_unit const& tu, unsigned long elapsed )
+{
+    utils::scope_setcolor const sc(m_color_output, output, utils::term_attr::BRIGHT, utils::term_color::BLUE); boost::ignore_unused( sc );
+
+    print_prefix( output, tu.p_file_name, tu.p_line_num );
+
+    output << "Leaving test " << tu.p_type_name << " \"" << tu.p_name << "\"";
+
+    if( elapsed > 0 ) {
+        output << "; testing time: ";
+        if( elapsed % 1000 == 0 )
+            output << elapsed/1000 << "ms";
+        else
+            output << elapsed << "us";
+    }
+
+    output << std::endl;
+}
+
+
+
+void
+compiler_log_formatter::test_unit_skipped( std::ostream& output, test_unit const& tu, const_string reason )
+{
+    utils::scope_setcolor const sc(m_color_output, output, utils::term_attr::BRIGHT, utils::term_color::YELLOW); boost::ignore_unused( sc );
+
+    print_prefix( output, tu.p_file_name, tu.p_line_num );
+
+    output << "Test " << tu.p_type_name << " \"" << tu.full_name() << "\"" << " is skipped because " << reason << std::endl;
+}
+
+
+
+void
+compiler_log_formatter::log_exception_start( std::ostream& output, log_checkpoint_data const& checkpoint_data, execution_exception const& ex )
+{
+    execution_exception::location const& loc = ex.where();
+
+    print_prefix( output, loc.m_file_name, loc.m_line_num );
+
+    {
+        utils::scope_setcolor const sc(m_color_output, output, utils::term_attr::UNDERLINE, utils::term_color::RED); boost::ignore_unused( sc );
+
+        output << "fatal error: in \"" << (loc.m_function.is_empty() ? test_phase_identifier() : loc.m_function ) << "\": "
+               << ex.what();
+    }
+
+    if( !checkpoint_data.m_file_name.is_empty() ) {
+        output << '\n';
+        print_prefix( output, checkpoint_data.m_file_name, checkpoint_data.m_line_num );
+
+        utils::scope_setcolor const sc(m_color_output, output, utils::term_attr::BRIGHT, utils::term_color::CYAN); boost::ignore_unused( sc );
+
+        output << "last checkpoint";
+        if( !checkpoint_data.m_message.empty() )
+            output << ": " << checkpoint_data.m_message;
+    }
+}
+
+
+
+void
+compiler_log_formatter::log_exception_finish( std::ostream& output )
+{
+    output << std::endl;
+}
+
+
+
+void
+compiler_log_formatter::log_entry_start( std::ostream& output, log_entry_data const& entry_data, log_entry_types let )
+{
+    using namespace utils;
+
+    switch( let ) {
+        case BOOST_UTL_ET_INFO:
+            print_prefix( output, entry_data.m_file_name, entry_data.m_line_num );
+            output << setcolor( m_color_output, term_attr::BRIGHT, term_color::GREEN );
+            output << "info: ";
+            break;
+        case BOOST_UTL_ET_MESSAGE:
+            output << setcolor( m_color_output, term_attr::BRIGHT, term_color::CYAN );
+            break;
+        case BOOST_UTL_ET_WARNING:
+            print_prefix( output, entry_data.m_file_name, entry_data.m_line_num );
+            output << setcolor( m_color_output, term_attr::BRIGHT, term_color::YELLOW );
+            output << "warning: in \"" << test_phase_identifier() << "\": ";
+            break;
+        case BOOST_UTL_ET_ERROR:
+            print_prefix( output, entry_data.m_file_name, entry_data.m_line_num );
+            output << setcolor( m_color_output, term_attr::BRIGHT, term_color::RED );
+            output << "error: in \"" << test_phase_identifier() << "\": ";
+            break;
+        case BOOST_UTL_ET_FATAL_ERROR:
+            print_prefix( output, entry_data.m_file_name, entry_data.m_line_num );
+            output << setcolor( m_color_output, term_attr::UNDERLINE, term_color::RED );
+            output << "fatal error: in \"" << test_phase_identifier() << "\": ";
+            break;
+    }
+}
+
+
+
+void
+compiler_log_formatter::log_entry_value( std::ostream& output, const_string value )
+{
+    output << value;
+}
+
+
+
+void
+compiler_log_formatter::log_entry_value( std::ostream& output, lazy_ostream const& value )
+{
+    output << value;
+}
+
+
+
+void
+compiler_log_formatter::log_entry_finish( std::ostream& output )
+{
+    if( m_color_output )
+        output << utils::setcolor(m_color_output);
+
+    output << std::endl;
+}
+
+
+
+
+void
+compiler_log_formatter::print_prefix( std::ostream& output, const_string file_name, std::size_t line_num )
+{
+    if( !file_name.empty() ) {
+
+
+
+
+
+        output << file_name << '(' << line_num << "): ";
+
+    }
+}
+
+
+
+void
+compiler_log_formatter::entry_context_start( std::ostream& output, log_level l )
+{
+    if( l == log_messages ) {
+        output << "\n[context:";
+    }
+    else {
+        output << (l == log_successful_tests ? "\nAssertion" : "\nFailure" ) << " occurred in a following context:";
+    }
+}
+
+
+
+void
+compiler_log_formatter::entry_context_finish( std::ostream& output, log_level l )
+{
+    if( l == log_messages ) {
+        output << "]";
+    }
+    output.flush();
+}
+
+
+
+void
+compiler_log_formatter::log_entry_context( std::ostream& output, log_level , const_string context_descr )
+{
+    output << "\n    " << context_descr;
+}
+
+
+
+}
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 294 "/usr/include/boost/test/impl/compiler_log_formatter.ipp" 2 3 4
+# 19 "/usr/include/boost/test/included/unit_test.hpp" 2 3 4
+# 1 "/usr/include/boost/test/impl/junit_log_formatter.ipp" 1 3 4
+# 13 "/usr/include/boost/test/impl/junit_log_formatter.ipp" 3 4
+#define BOOST_TEST_JUNIT_LOG_FORMATTER_IPP__ 
+
+
+# 1 "/usr/include/boost/test/output/junit_log_formatter.hpp" 1 3 4
+# 13 "/usr/include/boost/test/output/junit_log_formatter.hpp" 3 4
+#define BOOST_TEST_JUNIT_LOG_FORMATTER__ 
+# 25 "/usr/include/boost/test/output/junit_log_formatter.hpp" 3 4
+# 1 "/usr/include/c++/10.2.0/list" 1 3 4
+# 56 "/usr/include/c++/10.2.0/list" 3 4
+#define _GLIBCXX_LIST 1
+
+       
+# 59 "/usr/include/c++/10.2.0/list" 3
+
+
+
+
+# 1 "/usr/include/c++/10.2.0/bits/stl_list.h" 1 3
+# 57 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+#define _STL_LIST_H 1
+# 67 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  namespace __detail
+  {
+
+
+
+
+
+
+
+    struct _List_node_base
+    {
+      _List_node_base* _M_next;
+      _List_node_base* _M_prev;
+
+      static void
+      swap(_List_node_base& __x, _List_node_base& __y) noexcept;
+
+      void
+      _M_transfer(_List_node_base* const __first,
+    _List_node_base* const __last) noexcept;
+
+      void
+      _M_reverse() noexcept;
+
+      void
+      _M_hook(_List_node_base* const __position) noexcept;
+
+      void
+      _M_unhook() noexcept;
+    };
+
+
+    struct _List_node_header : public _List_node_base
+    {
+
+      std::size_t _M_size;
+
+
+      _List_node_header() noexcept
+      { _M_init(); }
+
+
+      _List_node_header(_List_node_header&& __x) noexcept
+      : _List_node_base{ __x._M_next, __x._M_prev }
+
+      , _M_size(__x._M_size)
+
+      {
+ if (__x._M_base()->_M_next == __x._M_base())
+   this->_M_next = this->_M_prev = this;
+ else
+   {
+     this->_M_next->_M_prev = this->_M_prev->_M_next = this->_M_base();
+     __x._M_init();
+   }
+      }
+
+      void
+      _M_move_nodes(_List_node_header&& __x)
+      {
+ _List_node_base* const __xnode = __x._M_base();
+ if (__xnode->_M_next == __xnode)
+   _M_init();
+ else
+   {
+     _List_node_base* const __node = this->_M_base();
+     __node->_M_next = __xnode->_M_next;
+     __node->_M_prev = __xnode->_M_prev;
+     __node->_M_next->_M_prev = __node->_M_prev->_M_next = __node;
+
+     _M_size = __x._M_size;
+
+     __x._M_init();
+   }
+      }
+
+
+      void
+      _M_init() noexcept
+      {
+ this->_M_next = this->_M_prev = this;
+
+ this->_M_size = 0;
+
+      }
+
+    private:
+      _List_node_base* _M_base() { return this; }
+    };
+  }
+
+
+
+
+  template<typename _Tp>
+    struct _List_node : public __detail::_List_node_base
+    {
+
+      __gnu_cxx::__aligned_membuf<_Tp> _M_storage;
+      _Tp* _M_valptr() { return _M_storage._M_ptr(); }
+      _Tp const* _M_valptr() const { return _M_storage._M_ptr(); }
+
+
+
+
+
+    };
+
+
+
+
+
+
+  template<typename _Tp>
+    struct _List_iterator
+    {
+      typedef _List_iterator<_Tp> _Self;
+      typedef _List_node<_Tp> _Node;
+
+      typedef ptrdiff_t difference_type;
+      typedef std::bidirectional_iterator_tag iterator_category;
+      typedef _Tp value_type;
+      typedef _Tp* pointer;
+      typedef _Tp& reference;
+
+      _List_iterator() noexcept
+      : _M_node() { }
+
+      explicit
+      _List_iterator(__detail::_List_node_base* __x) noexcept
+      : _M_node(__x) { }
+
+      _Self
+      _M_const_cast() const noexcept
+      { return *this; }
+
+
+      reference
+      operator*() const noexcept
+      { return *static_cast<_Node*>(_M_node)->_M_valptr(); }
+
+      pointer
+      operator->() const noexcept
+      { return static_cast<_Node*>(_M_node)->_M_valptr(); }
+
+      _Self&
+      operator++() noexcept
+      {
+ _M_node = _M_node->_M_next;
+ return *this;
+      }
+
+      _Self
+      operator++(int) noexcept
+      {
+ _Self __tmp = *this;
+ _M_node = _M_node->_M_next;
+ return __tmp;
+      }
+
+      _Self&
+      operator--() noexcept
+      {
+ _M_node = _M_node->_M_prev;
+ return *this;
+      }
+
+      _Self
+      operator--(int) noexcept
+      {
+ _Self __tmp = *this;
+ _M_node = _M_node->_M_prev;
+ return __tmp;
+      }
+
+      friend bool
+      operator==(const _Self& __x, const _Self& __y) noexcept
+      { return __x._M_node == __y._M_node; }
+
+
+      friend bool
+      operator!=(const _Self& __x, const _Self& __y) noexcept
+      { return __x._M_node != __y._M_node; }
+
+
+
+      __detail::_List_node_base* _M_node;
+    };
+
+
+
+
+
+
+  template<typename _Tp>
+    struct _List_const_iterator
+    {
+      typedef _List_const_iterator<_Tp> _Self;
+      typedef const _List_node<_Tp> _Node;
+      typedef _List_iterator<_Tp> iterator;
+
+      typedef ptrdiff_t difference_type;
+      typedef std::bidirectional_iterator_tag iterator_category;
+      typedef _Tp value_type;
+      typedef const _Tp* pointer;
+      typedef const _Tp& reference;
+
+      _List_const_iterator() noexcept
+      : _M_node() { }
+
+      explicit
+      _List_const_iterator(const __detail::_List_node_base* __x)
+      noexcept
+      : _M_node(__x) { }
+
+      _List_const_iterator(const iterator& __x) noexcept
+      : _M_node(__x._M_node) { }
+
+      iterator
+      _M_const_cast() const noexcept
+      { return iterator(const_cast<__detail::_List_node_base*>(_M_node)); }
+
+
+      reference
+      operator*() const noexcept
+      { return *static_cast<_Node*>(_M_node)->_M_valptr(); }
+
+      pointer
+      operator->() const noexcept
+      { return static_cast<_Node*>(_M_node)->_M_valptr(); }
+
+      _Self&
+      operator++() noexcept
+      {
+ _M_node = _M_node->_M_next;
+ return *this;
+      }
+
+      _Self
+      operator++(int) noexcept
+      {
+ _Self __tmp = *this;
+ _M_node = _M_node->_M_next;
+ return __tmp;
+      }
+
+      _Self&
+      operator--() noexcept
+      {
+ _M_node = _M_node->_M_prev;
+ return *this;
+      }
+
+      _Self
+      operator--(int) noexcept
+      {
+ _Self __tmp = *this;
+ _M_node = _M_node->_M_prev;
+ return __tmp;
+      }
+
+      friend bool
+      operator==(const _Self& __x, const _Self& __y) noexcept
+      { return __x._M_node == __y._M_node; }
+
+
+      friend bool
+      operator!=(const _Self& __x, const _Self& __y) noexcept
+      { return __x._M_node != __y._M_node; }
+
+
+
+      const __detail::_List_node_base* _M_node;
+    };
+
+namespace __cxx11 {
+
+  template<typename _Tp, typename _Alloc>
+    class _List_base
+    {
+    protected:
+      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
+ rebind<_Tp>::other _Tp_alloc_type;
+      typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tp_alloc_traits;
+      typedef typename _Tp_alloc_traits::template
+ rebind<_List_node<_Tp> >::other _Node_alloc_type;
+      typedef __gnu_cxx::__alloc_traits<_Node_alloc_type> _Node_alloc_traits;
+
+
+      static size_t
+      _S_distance(const __detail::_List_node_base* __first,
+    const __detail::_List_node_base* __last)
+      {
+ size_t __n = 0;
+ while (__first != __last)
+   {
+     __first = __first->_M_next;
+     ++__n;
+   }
+ return __n;
+      }
+
+
+      struct _List_impl
+      : public _Node_alloc_type
+      {
+ __detail::_List_node_header _M_node;
+
+ _List_impl() noexcept(is_nothrow_default_constructible<_Node_alloc_type>::value)
+
+ : _Node_alloc_type()
+ { }
+
+ _List_impl(const _Node_alloc_type& __a) noexcept
+ : _Node_alloc_type(__a)
+ { }
+
+
+ _List_impl(_List_impl&&) = default;
+
+ _List_impl(_Node_alloc_type&& __a, _List_impl&& __x)
+ : _Node_alloc_type(std::move(__a)), _M_node(std::move(__x._M_node))
+ { }
+
+ _List_impl(_Node_alloc_type&& __a) noexcept
+ : _Node_alloc_type(std::move(__a))
+ { }
+
+      };
+
+      _List_impl _M_impl;
+
+
+      size_t _M_get_size() const { return _M_impl._M_node._M_size; }
+
+      void _M_set_size(size_t __n) { _M_impl._M_node._M_size = __n; }
+
+      void _M_inc_size(size_t __n) { _M_impl._M_node._M_size += __n; }
+
+      void _M_dec_size(size_t __n) { _M_impl._M_node._M_size -= __n; }
+
+
+      size_t
+      _M_distance(const __detail::_List_node_base* __first,
+    const __detail::_List_node_base* __last) const
+      { return _S_distance(__first, __last); }
+
+
+      size_t _M_node_count() const { return _M_get_size(); }
+# 440 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      typename _Node_alloc_traits::pointer
+      _M_get_node()
+      { return _Node_alloc_traits::allocate(_M_impl, 1); }
+
+      void
+      _M_put_node(typename _Node_alloc_traits::pointer __p) noexcept
+      { _Node_alloc_traits::deallocate(_M_impl, __p, 1); }
+
+  public:
+      typedef _Alloc allocator_type;
+
+      _Node_alloc_type&
+      _M_get_Node_allocator() noexcept
+      { return _M_impl; }
+
+      const _Node_alloc_type&
+      _M_get_Node_allocator() const noexcept
+      { return _M_impl; }
+
+
+      _List_base() = default;
+
+
+
+
+      _List_base(const _Node_alloc_type& __a) noexcept
+      : _M_impl(__a)
+      { }
+
+
+      _List_base(_List_base&&) = default;
+
+
+      _List_base(_List_base&& __x, _Node_alloc_type&& __a)
+      : _M_impl(std::move(__a))
+      {
+ if (__x._M_get_Node_allocator() == _M_get_Node_allocator())
+   _M_move_nodes(std::move(__x));
+
+      }
+
+
+
+      _List_base(_Node_alloc_type&& __a, _List_base&& __x)
+      : _M_impl(std::move(__a), std::move(__x._M_impl))
+      { }
+
+
+      _List_base(_Node_alloc_type&& __a)
+      : _M_impl(std::move(__a))
+      { }
+
+      void
+      _M_move_nodes(_List_base&& __x)
+      { _M_impl._M_node._M_move_nodes(std::move(__x._M_impl._M_node)); }
+
+
+
+      ~_List_base() noexcept
+      { _M_clear(); }
+
+      void
+      _M_clear() noexcept;
+
+      void
+      _M_init() noexcept
+      { this->_M_impl._M_node._M_init(); }
+    };
+# 555 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+  template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
+    class list : protected _List_base<_Tp, _Alloc>
+    {
+# 568 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      static_assert(is_same<typename remove_cv<_Tp>::type, _Tp>::value,
+   "std::list must have a non-const, non-volatile value_type");
+
+      static_assert(is_same<typename _Alloc::value_type, _Tp>::value,
+   "std::list must have the same value_type as its allocator");
+
+
+
+      typedef _List_base<_Tp, _Alloc> _Base;
+      typedef typename _Base::_Tp_alloc_type _Tp_alloc_type;
+      typedef typename _Base::_Tp_alloc_traits _Tp_alloc_traits;
+      typedef typename _Base::_Node_alloc_type _Node_alloc_type;
+      typedef typename _Base::_Node_alloc_traits _Node_alloc_traits;
+
+    public:
+      typedef _Tp value_type;
+      typedef typename _Tp_alloc_traits::pointer pointer;
+      typedef typename _Tp_alloc_traits::const_pointer const_pointer;
+      typedef typename _Tp_alloc_traits::reference reference;
+      typedef typename _Tp_alloc_traits::const_reference const_reference;
+      typedef _List_iterator<_Tp> iterator;
+      typedef _List_const_iterator<_Tp> const_iterator;
+      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+      typedef std::reverse_iterator<iterator> reverse_iterator;
+      typedef size_t size_type;
+      typedef ptrdiff_t difference_type;
+      typedef _Alloc allocator_type;
+
+    protected:
+
+
+      typedef _List_node<_Tp> _Node;
+
+      using _Base::_M_impl;
+      using _Base::_M_put_node;
+      using _Base::_M_get_node;
+      using _Base::_M_get_Node_allocator;
+# 630 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      template<typename... _Args>
+ _Node*
+ _M_create_node(_Args&&... __args)
+ {
+   auto __p = this->_M_get_node();
+   auto& __alloc = _M_get_Node_allocator();
+   __allocated_ptr<_Node_alloc_type> __guard{__alloc, __p};
+   _Node_alloc_traits::construct(__alloc, __p->_M_valptr(),
+     std::forward<_Args>(__args)...);
+   __guard = nullptr;
+   return __p;
+ }
+
+
+
+      static size_t
+      _S_distance(const_iterator __first, const_iterator __last)
+      { return std::distance(__first, __last); }
+
+
+      size_t
+      _M_node_count() const
+      { return this->_M_get_size(); }
+# 665 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+    public:
+
+
+
+
+
+
+
+      list() = default;
+# 682 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      explicit
+      list(const allocator_type& __a) noexcept
+      : _Base(_Node_alloc_type(__a)) { }
+# 695 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      explicit
+      list(size_type __n, const allocator_type& __a = allocator_type())
+      : _Base(_Node_alloc_type(__a))
+      { _M_default_initialize(__n); }
+# 708 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      list(size_type __n, const value_type& __value,
+    const allocator_type& __a = allocator_type())
+      : _Base(_Node_alloc_type(__a))
+      { _M_fill_initialize(__n, __value); }
+# 735 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      list(const list& __x)
+      : _Base(_Node_alloc_traits::
+       _S_select_on_copy(__x._M_get_Node_allocator()))
+      { _M_initialize_dispatch(__x.begin(), __x.end(), __false_type()); }
+# 748 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      list(list&&) = default;
+# 758 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      list(initializer_list<value_type> __l,
+    const allocator_type& __a = allocator_type())
+      : _Base(_Node_alloc_type(__a))
+      { _M_initialize_dispatch(__l.begin(), __l.end(), __false_type()); }
+
+      list(const list& __x, const allocator_type& __a)
+      : _Base(_Node_alloc_type(__a))
+      { _M_initialize_dispatch(__x.begin(), __x.end(), __false_type()); }
+
+    private:
+      list(list&& __x, const allocator_type& __a, true_type) noexcept
+      : _Base(_Node_alloc_type(__a), std::move(__x))
+      { }
+
+      list(list&& __x, const allocator_type& __a, false_type)
+      : _Base(_Node_alloc_type(__a))
+      {
+ if (__x._M_get_Node_allocator() == this->_M_get_Node_allocator())
+   this->_M_move_nodes(std::move(__x));
+ else
+   insert(begin(), std::__make_move_if_noexcept_iterator(__x.begin()),
+     std::__make_move_if_noexcept_iterator(__x.end()));
+      }
+
+    public:
+      list(list&& __x, const allocator_type& __a)
+      noexcept(_Node_alloc_traits::_S_always_equal())
+      : list(std::move(__x), __a,
+      typename _Node_alloc_traits::is_always_equal{})
+      { }
+# 801 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      template<typename _InputIterator,
+        typename = std::_RequireInputIter<_InputIterator>>
+ list(_InputIterator __first, _InputIterator __last,
+      const allocator_type& __a = allocator_type())
+ : _Base(_Node_alloc_type(__a))
+ { _M_initialize_dispatch(__first, __last, __false_type()); }
+# 827 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      ~list() = default;
+# 838 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      list&
+      operator=(const list& __x);
+# 852 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      list&
+      operator=(list&& __x)
+      noexcept(_Node_alloc_traits::_S_nothrow_move())
+      {
+ constexpr bool __move_storage =
+   _Node_alloc_traits::_S_propagate_on_move_assign()
+   || _Node_alloc_traits::_S_always_equal();
+ _M_move_assign(std::move(__x), __bool_constant<__move_storage>());
+ return *this;
+      }
+# 870 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      list&
+      operator=(initializer_list<value_type> __l)
+      {
+ this->assign(__l.begin(), __l.end());
+ return *this;
+      }
+# 888 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      void
+      assign(size_type __n, const value_type& __val)
+      { _M_fill_assign(__n, __val); }
+# 905 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      template<typename _InputIterator,
+        typename = std::_RequireInputIter<_InputIterator>>
+ void
+ assign(_InputIterator __first, _InputIterator __last)
+ { _M_assign_dispatch(__first, __last, __false_type()); }
+# 929 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      void
+      assign(initializer_list<value_type> __l)
+      { this->_M_assign_dispatch(__l.begin(), __l.end(), __false_type()); }
+
+
+
+      allocator_type
+      get_allocator() const noexcept
+      { return allocator_type(_Base::_M_get_Node_allocator()); }
+
+
+
+
+
+
+      iterator
+      begin() noexcept
+      { return iterator(this->_M_impl._M_node._M_next); }
+
+
+
+
+
+
+      const_iterator
+      begin() const noexcept
+      { return const_iterator(this->_M_impl._M_node._M_next); }
+
+
+
+
+
+
+      iterator
+      end() noexcept
+      { return iterator(&this->_M_impl._M_node); }
+
+
+
+
+
+
+      const_iterator
+      end() const noexcept
+      { return const_iterator(&this->_M_impl._M_node); }
+
+
+
+
+
+
+      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()); }
+
+
+
+
+
+
+
+      const_iterator
+      cbegin() const noexcept
+      { return const_iterator(this->_M_impl._M_node._M_next); }
+
+
+
+
+
+
+      const_iterator
+      cend() const noexcept
+      { return const_iterator(&this->_M_impl._M_node); }
+
+
+
+
+
+
+      const_reverse_iterator
+      crbegin() const noexcept
+      { return const_reverse_iterator(end()); }
+
+
+
+
+
+
+      const_reverse_iterator
+      crend() const noexcept
+      { return const_reverse_iterator(begin()); }
+
+
+
+
+
+
+
+      [[__nodiscard__]] bool
+      empty() const noexcept
+      { return this->_M_impl._M_node._M_next == &this->_M_impl._M_node; }
+
+
+      size_type
+      size() const noexcept
+      { return _M_node_count(); }
+
+
+      size_type
+      max_size() const noexcept
+      { return _Node_alloc_traits::max_size(_M_get_Node_allocator()); }
+# 1078 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      void
+      resize(size_type __new_size);
+# 1091 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      void
+      resize(size_type __new_size, const value_type& __x);
+# 1113 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      reference
+      front() noexcept
+      { return *begin(); }
+
+
+
+
+
+      const_reference
+      front() const noexcept
+      { return *begin(); }
+
+
+
+
+
+      reference
+      back() noexcept
+      {
+ iterator __tmp = end();
+ --__tmp;
+ return *__tmp;
+      }
+
+
+
+
+
+      const_reference
+      back() const noexcept
+      {
+ const_iterator __tmp = end();
+ --__tmp;
+ return *__tmp;
+      }
+# 1160 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      void
+      push_front(const value_type& __x)
+      { this->_M_insert(begin(), __x); }
+
+
+      void
+      push_front(value_type&& __x)
+      { this->_M_insert(begin(), std::move(__x)); }
+
+      template<typename... _Args>
+
+ reference
+
+
+
+ emplace_front(_Args&&... __args)
+ {
+   this->_M_insert(begin(), std::forward<_Args>(__args)...);
+
+   return front();
+
+ }
+# 1196 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      void
+      pop_front() noexcept
+      { this->_M_erase(begin()); }
+# 1210 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      void
+      push_back(const value_type& __x)
+      { this->_M_insert(end(), __x); }
+
+
+      void
+      push_back(value_type&& __x)
+      { this->_M_insert(end(), std::move(__x)); }
+
+      template<typename... _Args>
+
+ reference
+
+
+
+ emplace_back(_Args&&... __args)
+ {
+   this->_M_insert(end(), std::forward<_Args>(__args)...);
+
+ return back();
+
+ }
+# 1245 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      void
+      pop_back() noexcept
+      { this->_M_erase(iterator(this->_M_impl._M_node._M_prev)); }
+# 1262 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      template<typename... _Args>
+ iterator
+ emplace(const_iterator __position, _Args&&... __args);
+# 1277 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      iterator
+      insert(const_iterator __position, const value_type& __x);
+# 1307 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      iterator
+      insert(const_iterator __position, value_type&& __x)
+      { return emplace(__position, std::move(__x)); }
+# 1326 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      iterator
+      insert(const_iterator __p, initializer_list<value_type> __l)
+      { return this->insert(__p, __l.begin(), __l.end()); }
+# 1346 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      iterator
+      insert(const_iterator __position, size_type __n, const value_type& __x);
+# 1385 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      template<typename _InputIterator,
+        typename = std::_RequireInputIter<_InputIterator>>
+ iterator
+ insert(const_iterator __position, _InputIterator __first,
+        _InputIterator __last);
+# 1429 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      iterator
+
+      erase(const_iterator __position) noexcept;
+# 1454 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      iterator
+
+      erase(const_iterator __first, const_iterator __last) noexcept
+
+
+
+      {
+ while (__first != __last)
+   __first = erase(__first);
+ return __last._M_const_cast();
+      }
+# 1477 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      void
+      swap(list& __x) noexcept
+      {
+ __detail::_List_node_base::swap(this->_M_impl._M_node,
+     __x._M_impl._M_node);
+
+ size_t __xsize = __x._M_get_size();
+ __x._M_set_size(this->_M_get_size());
+ this->_M_set_size(__xsize);
+
+ _Node_alloc_traits::_S_on_swap(this->_M_get_Node_allocator(),
+           __x._M_get_Node_allocator());
+      }
+
+
+
+
+
+
+
+      void
+      clear() noexcept
+      {
+ _Base::_M_clear();
+ _Base::_M_init();
+      }
+# 1516 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      void
+
+      splice(const_iterator __position, list&& __x) noexcept
+
+
+
+      {
+ if (!__x.empty())
+   {
+     _M_check_equal_allocators(__x);
+
+     this->_M_transfer(__position._M_const_cast(),
+         __x.begin(), __x.end());
+
+     this->_M_inc_size(__x._M_get_size());
+     __x._M_set_size(0);
+   }
+      }
+
+
+      void
+      splice(const_iterator __position, list& __x) noexcept
+      { splice(__position, std::move(__x)); }
+# 1552 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      void
+      splice(const_iterator __position, list&& __x, const_iterator __i) noexcept
+# 1567 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      {
+ iterator __j = __i._M_const_cast();
+ ++__j;
+ if (__position == __i || __position == __j)
+   return;
+
+ if (this != std::__addressof(__x))
+   _M_check_equal_allocators(__x);
+
+ this->_M_transfer(__position._M_const_cast(),
+     __i._M_const_cast(), __j);
+
+ this->_M_inc_size(1);
+ __x._M_dec_size(1);
+      }
+# 1594 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      void
+      splice(const_iterator __position, list& __x, const_iterator __i) noexcept
+      { splice(__position, std::move(__x), __i); }
+# 1613 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      void
+      splice(const_iterator __position, list&& __x, const_iterator __first,
+      const_iterator __last) noexcept
+# 1633 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      {
+ if (__first != __last)
+   {
+     if (this != std::__addressof(__x))
+       _M_check_equal_allocators(__x);
+
+     size_t __n = _S_distance(__first, __last);
+     this->_M_inc_size(__n);
+     __x._M_dec_size(__n);
+
+     this->_M_transfer(__position._M_const_cast(),
+         __first._M_const_cast(),
+         __last._M_const_cast());
+   }
+      }
+# 1663 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      void
+      splice(const_iterator __position, list& __x, const_iterator __first,
+      const_iterator __last) noexcept
+      { splice(__position, std::move(__x), __first, __last); }
+
+
+    private:
+
+
+
+
+
+
+      typedef void __remove_return_type;
+#define _GLIBCXX_LIST_REMOVE_RETURN_TYPE_TAG 
+
+    public:
+# 1692 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+     
+      __remove_return_type
+      remove(const _Tp& __value);
+# 1707 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      template<typename _Predicate>
+ __remove_return_type
+ remove_if(_Predicate);
+# 1721 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+     
+      __remove_return_type
+      unique();
+# 1737 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      template<typename _BinaryPredicate>
+ __remove_return_type
+ unique(_BinaryPredicate);
+
+#undef _GLIBCXX_LIST_REMOVE_RETURN_TYPE_TAG
+# 1753 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      void
+      merge(list&& __x);
+
+      void
+      merge(list& __x)
+      { merge(std::move(__x)); }
+# 1778 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      template<typename _StrictWeakOrdering>
+ void
+ merge(list&& __x, _StrictWeakOrdering __comp);
+
+      template<typename _StrictWeakOrdering>
+ void
+ merge(list& __x, _StrictWeakOrdering __comp)
+ { merge(std::move(__x), __comp); }
+# 1797 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      void
+      reverse() noexcept
+      { this->_M_impl._M_node._M_reverse(); }
+
+
+
+
+
+
+
+      void
+      sort();
+
+
+
+
+
+
+
+      template<typename _StrictWeakOrdering>
+ void
+ sort(_StrictWeakOrdering);
+
+    protected:
+
+
+
+
+
+
+      template<typename _Integer>
+ void
+ _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type)
+ { _M_fill_initialize(static_cast<size_type>(__n), __x); }
+
+
+      template<typename _InputIterator>
+ void
+ _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
+          __false_type)
+ {
+   for (; __first != __last; ++__first)
+
+     emplace_back(*__first);
+
+
+
+ }
+
+
+
+      void
+      _M_fill_initialize(size_type __n, const value_type& __x)
+      {
+ for (; __n; --__n)
+   push_back(__x);
+      }
+
+
+
+      void
+      _M_default_initialize(size_type __n)
+      {
+ for (; __n; --__n)
+   emplace_back();
+      }
+
+
+      void
+      _M_default_append(size_type __n);
+# 1875 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      template<typename _Integer>
+ void
+ _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
+ { _M_fill_assign(__n, __val); }
+
+
+      template<typename _InputIterator>
+ void
+ _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
+      __false_type);
+
+
+
+      void
+      _M_fill_assign(size_type __n, const value_type& __val);
+
+
+
+      void
+      _M_transfer(iterator __position, iterator __first, iterator __last)
+      { __position._M_node->_M_transfer(__first._M_node, __last._M_node); }
+# 1907 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+     template<typename... _Args>
+       void
+       _M_insert(iterator __position, _Args&&... __args)
+       {
+  _Node* __tmp = _M_create_node(std::forward<_Args>(__args)...);
+  __tmp->_M_hook(__position._M_node);
+  this->_M_inc_size(1);
+       }
+
+
+
+      void
+      _M_erase(iterator __position) noexcept
+      {
+ this->_M_dec_size(1);
+ __position._M_node->_M_unhook();
+ _Node* __n = static_cast<_Node*>(__position._M_node);
+
+ _Node_alloc_traits::destroy(_M_get_Node_allocator(), __n->_M_valptr());
+
+
+
+
+ _M_put_node(__n);
+      }
+
+
+      void
+      _M_check_equal_allocators(list& __x) noexcept
+      {
+ if (std::__alloc_neq<typename _Base::_Node_alloc_type>::
+     _S_do_it(_M_get_Node_allocator(), __x._M_get_Node_allocator()))
+   __builtin_abort();
+      }
+
+
+      const_iterator
+      _M_resize_pos(size_type& __new_size) const;
+
+
+      void
+      _M_move_assign(list&& __x, true_type) noexcept
+      {
+ this->_M_clear();
+ this->_M_move_nodes(std::move(__x));
+ std::__alloc_on_move(this->_M_get_Node_allocator(),
+        __x._M_get_Node_allocator());
+      }
+
+      void
+      _M_move_assign(list&& __x, false_type)
+      {
+ if (__x._M_get_Node_allocator() == this->_M_get_Node_allocator())
+   _M_move_assign(std::move(__x), true_type{});
+ else
+
+
+   _M_assign_dispatch(std::make_move_iterator(__x.begin()),
+        std::make_move_iterator(__x.end()),
+        __false_type{});
+      }
+
+    };
+
+
+  template<typename _InputIterator, typename _ValT
+      = typename iterator_traits<_InputIterator>::value_type,
+    typename _Allocator = allocator<_ValT>,
+    typename = _RequireInputIter<_InputIterator>,
+    typename = _RequireAllocator<_Allocator>>
+    list(_InputIterator, _InputIterator, _Allocator = _Allocator())
+      -> list<_ValT, _Allocator>;
+
+
+}
+# 1993 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator==(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
+    {
+
+      if (__x.size() != __y.size())
+ return false;
+
+
+      typedef typename list<_Tp, _Alloc>::const_iterator const_iterator;
+      const_iterator __end1 = __x.end();
+      const_iterator __end2 = __y.end();
+
+      const_iterator __i1 = __x.begin();
+      const_iterator __i2 = __y.begin();
+      while (__i1 != __end1 && __i2 != __end2 && *__i1 == *__i2)
+ {
+   ++__i1;
+   ++__i2;
+ }
+      return __i1 == __end1 && __i2 == __end2;
+    }
+# 2048 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator<(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
+    { return std::lexicographical_compare(__x.begin(), __x.end(),
+       __y.begin(), __y.end()); }
+
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator!=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
+    { return !(__x == __y); }
+
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator>(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
+    { return __y < __x; }
+
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator<=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
+    { return !(__y < __x); }
+
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator>=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
+    { return !(__x < __y); }
+
+
+
+  template<typename _Tp, typename _Alloc>
+    inline void
+    swap(list<_Tp, _Alloc>& __x, list<_Tp, _Alloc>& __y)
+    noexcept(noexcept(__x.swap(__y)))
+    { __x.swap(__y); }
+
+
+
+
+
+
+  template<typename _Tp>
+    inline ptrdiff_t
+    __distance(std::_List_iterator<_Tp> __first,
+        std::_List_iterator<_Tp> __last,
+        input_iterator_tag __tag)
+    {
+      typedef std::_List_const_iterator<_Tp> _CIter;
+      return std::__distance(_CIter(__first), _CIter(__last), __tag);
+    }
+
+  template<typename _Tp>
+    inline ptrdiff_t
+    __distance(std::_List_const_iterator<_Tp> __first,
+        std::_List_const_iterator<_Tp> __last,
+        input_iterator_tag)
+    {
+      typedef __detail::_List_node_header _Sentinel;
+      std::_List_const_iterator<_Tp> __beyond = __last;
+      ++__beyond;
+      const bool __whole = __first == __beyond;
+      if (__builtin_constant_p (__whole) && __whole)
+ return static_cast<const _Sentinel*>(__last._M_node)->_M_size;
+
+      ptrdiff_t __n = 0;
+      while (__first != __last)
+ {
+   ++__first;
+   ++__n;
+ }
+      return __n;
+    }
+
+
+
+}
+# 64 "/usr/include/c++/10.2.0/list" 2 3
+# 1 "/usr/include/c++/10.2.0/bits/list.tcc" 1 3
+# 57 "/usr/include/c++/10.2.0/bits/list.tcc" 3
+#define _LIST_TCC 1
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+  template<typename _Tp, typename _Alloc>
+    void
+    _List_base<_Tp, _Alloc>::
+    _M_clear() noexcept
+    {
+      typedef _List_node<_Tp> _Node;
+      __detail::_List_node_base* __cur = _M_impl._M_node._M_next;
+      while (__cur != &_M_impl._M_node)
+ {
+   _Node* __tmp = static_cast<_Node*>(__cur);
+   __cur = __tmp->_M_next;
+   _Tp* __val = __tmp->_M_valptr();
+
+   _Node_alloc_traits::destroy(_M_get_Node_allocator(), __val);
+
+
+
+   _M_put_node(__tmp);
+ }
+    }
+
+
+  template<typename _Tp, typename _Alloc>
+    template<typename... _Args>
+      typename list<_Tp, _Alloc>::iterator
+      list<_Tp, _Alloc>::
+      emplace(const_iterator __position, _Args&&... __args)
+      {
+ _Node* __tmp = _M_create_node(std::forward<_Args>(__args)...);
+ __tmp->_M_hook(__position._M_const_cast()._M_node);
+ this->_M_inc_size(1);
+ return iterator(__tmp);
+      }
+
+
+  template<typename _Tp, typename _Alloc>
+    typename list<_Tp, _Alloc>::iterator
+    list<_Tp, _Alloc>::
+
+    insert(const_iterator __position, const value_type& __x)
+
+
+
+    {
+      _Node* __tmp = _M_create_node(__x);
+      __tmp->_M_hook(__position._M_const_cast()._M_node);
+      this->_M_inc_size(1);
+      return iterator(__tmp);
+    }
+
+
+  template<typename _Tp, typename _Alloc>
+    typename list<_Tp, _Alloc>::iterator
+    list<_Tp, _Alloc>::
+    insert(const_iterator __position, size_type __n, const value_type& __x)
+    {
+      if (__n)
+ {
+   list __tmp(__n, __x, get_allocator());
+   iterator __it = __tmp.begin();
+   splice(__position, __tmp);
+   return __it;
+ }
+      return __position._M_const_cast();
+    }
+
+  template<typename _Tp, typename _Alloc>
+    template<typename _InputIterator, typename>
+      typename list<_Tp, _Alloc>::iterator
+      list<_Tp, _Alloc>::
+      insert(const_iterator __position, _InputIterator __first,
+      _InputIterator __last)
+      {
+ list __tmp(__first, __last, get_allocator());
+ if (!__tmp.empty())
+   {
+     iterator __it = __tmp.begin();
+     splice(__position, __tmp);
+     return __it;
+   }
+ return __position._M_const_cast();
+      }
+
+
+  template<typename _Tp, typename _Alloc>
+    typename list<_Tp, _Alloc>::iterator
+    list<_Tp, _Alloc>::
+
+    erase(const_iterator __position) noexcept
+
+
+
+    {
+      iterator __ret = iterator(__position._M_node->_M_next);
+      _M_erase(__position._M_const_cast());
+      return __ret;
+    }
+# 173 "/usr/include/c++/10.2.0/bits/list.tcc" 3
+  template<typename _Tp, typename _Alloc>
+    typename list<_Tp, _Alloc>::const_iterator
+    list<_Tp, _Alloc>::
+    _M_resize_pos(size_type& __new_size) const
+    {
+      const_iterator __i;
+
+      const size_type __len = size();
+      if (__new_size < __len)
+ {
+   if (__new_size <= __len / 2)
+     {
+       __i = begin();
+       std::advance(__i, __new_size);
+     }
+   else
+     {
+       __i = end();
+       ptrdiff_t __num_erase = __len - __new_size;
+       std::advance(__i, -__num_erase);
+     }
+   __new_size = 0;
+   return __i;
+ }
+      else
+ __i = end();
+
+
+
+
+
+      __new_size -= __len;
+      return __i;
+    }
+
+
+  template<typename _Tp, typename _Alloc>
+    void
+    list<_Tp, _Alloc>::
+    _M_default_append(size_type __n)
+    {
+      size_type __i = 0;
+      try
+ {
+   for (; __i < __n; ++__i)
+     emplace_back();
+ }
+      catch(...)
+ {
+   for (; __i; --__i)
+     pop_back();
+   throw;
+ }
+    }
+
+  template<typename _Tp, typename _Alloc>
+    void
+    list<_Tp, _Alloc>::
+    resize(size_type __new_size)
+    {
+      const_iterator __i = _M_resize_pos(__new_size);
+      if (__new_size)
+ _M_default_append(__new_size);
+      else
+        erase(__i, end());
+    }
+
+  template<typename _Tp, typename _Alloc>
+    void
+    list<_Tp, _Alloc>::
+    resize(size_type __new_size, const value_type& __x)
+    {
+      const_iterator __i = _M_resize_pos(__new_size);
+      if (__new_size)
+        insert(end(), __new_size, __x);
+      else
+        erase(__i, end());
+    }
+# 265 "/usr/include/c++/10.2.0/bits/list.tcc" 3
+  template<typename _Tp, typename _Alloc>
+    list<_Tp, _Alloc>&
+    list<_Tp, _Alloc>::
+    operator=(const list& __x)
+    {
+      if (this != std::__addressof(__x))
+ {
+
+   if (_Node_alloc_traits::_S_propagate_on_copy_assign())
+     {
+              auto& __this_alloc = this->_M_get_Node_allocator();
+              auto& __that_alloc = __x._M_get_Node_allocator();
+              if (!_Node_alloc_traits::_S_always_equal()
+           && __this_alloc != __that_alloc)
+         {
+
+    clear();
+  }
+       std::__alloc_on_copy(__this_alloc, __that_alloc);
+            }
+
+   _M_assign_dispatch(__x.begin(), __x.end(), __false_type());
+ }
+      return *this;
+    }
+
+  template<typename _Tp, typename _Alloc>
+    void
+    list<_Tp, _Alloc>::
+    _M_fill_assign(size_type __n, const value_type& __val)
+    {
+      iterator __i = begin();
+      for (; __i != end() && __n > 0; ++__i, --__n)
+        *__i = __val;
+      if (__n > 0)
+        insert(end(), __n, __val);
+      else
+        erase(__i, end());
+    }
+
+  template<typename _Tp, typename _Alloc>
+    template <typename _InputIterator>
+      void
+      list<_Tp, _Alloc>::
+      _M_assign_dispatch(_InputIterator __first2, _InputIterator __last2,
+    __false_type)
+      {
+        iterator __first1 = begin();
+        iterator __last1 = end();
+        for (; __first1 != __last1 && __first2 != __last2;
+      ++__first1, (void)++__first2)
+          *__first1 = *__first2;
+        if (__first2 == __last2)
+          erase(__first1, __last1);
+        else
+          insert(__last1, __first2, __last2);
+      }
+
+
+
+
+#define _GLIBCXX20_ONLY(__expr) 
+
+
+  template<typename _Tp, typename _Alloc>
+    typename list<_Tp, _Alloc>::__remove_return_type
+    list<_Tp, _Alloc>::
+    remove(const value_type& __value)
+    {
+      size_type __removed __attribute__((__unused__)) = 0;
+      iterator __first = begin();
+      iterator __last = end();
+      iterator __extra = __last;
+      while (__first != __last)
+ {
+   iterator __next = __first;
+   ++__next;
+   if (*__first == __value)
+     {
+
+
+
+       if (std::__addressof(*__first) != std::__addressof(__value))
+  {
+    _M_erase(__first);
+    ;
+  }
+       else
+  __extra = __first;
+     }
+   __first = __next;
+ }
+      if (__extra != __last)
+ {
+   _M_erase(__extra);
+   ;
+ }
+      return ;
+    }
+
+  template<typename _Tp, typename _Alloc>
+    typename list<_Tp, _Alloc>::__remove_return_type
+    list<_Tp, _Alloc>::
+    unique()
+    {
+      iterator __first = begin();
+      iterator __last = end();
+      if (__first == __last)
+ return ;
+      size_type __removed __attribute__((__unused__)) = 0;
+      iterator __next = __first;
+      while (++__next != __last)
+ {
+   if (*__first == *__next)
+     {
+       _M_erase(__next);
+       ;
+     }
+   else
+     __first = __next;
+   __next = __first;
+ }
+      return ;
+    }
+
+  template<typename _Tp, typename _Alloc>
+    void
+    list<_Tp, _Alloc>::
+
+    merge(list&& __x)
+
+
+
+    {
+
+
+      if (this != std::__addressof(__x))
+ {
+   _M_check_equal_allocators(__x);
+
+   iterator __first1 = begin();
+   iterator __last1 = end();
+   iterator __first2 = __x.begin();
+   iterator __last2 = __x.end();
+   const size_t __orig_size = __x.size();
+   try {
+     while (__first1 != __last1 && __first2 != __last2)
+       if (*__first2 < *__first1)
+  {
+    iterator __next = __first2;
+    _M_transfer(__first1, __first2, ++__next);
+    __first2 = __next;
+  }
+       else
+  ++__first1;
+     if (__first2 != __last2)
+       _M_transfer(__last1, __first2, __last2);
+
+     this->_M_inc_size(__x._M_get_size());
+     __x._M_set_size(0);
+   }
+   catch(...)
+     {
+       const size_t __dist = std::distance(__first2, __last2);
+       this->_M_inc_size(__orig_size - __dist);
+       __x._M_set_size(__dist);
+       throw;
+     }
+ }
+    }
+
+  template<typename _Tp, typename _Alloc>
+    template <typename _StrictWeakOrdering>
+      void
+      list<_Tp, _Alloc>::
+
+      merge(list&& __x, _StrictWeakOrdering __comp)
+
+
+
+      {
+
+
+ if (this != std::__addressof(__x))
+   {
+     _M_check_equal_allocators(__x);
+
+     iterator __first1 = begin();
+     iterator __last1 = end();
+     iterator __first2 = __x.begin();
+     iterator __last2 = __x.end();
+     const size_t __orig_size = __x.size();
+     try
+       {
+  while (__first1 != __last1 && __first2 != __last2)
+    if (__comp(*__first2, *__first1))
+      {
+        iterator __next = __first2;
+        _M_transfer(__first1, __first2, ++__next);
+        __first2 = __next;
+      }
+    else
+      ++__first1;
+  if (__first2 != __last2)
+    _M_transfer(__last1, __first2, __last2);
+
+  this->_M_inc_size(__x._M_get_size());
+  __x._M_set_size(0);
+       }
+     catch(...)
+       {
+  const size_t __dist = std::distance(__first2, __last2);
+  this->_M_inc_size(__orig_size - __dist);
+  __x._M_set_size(__dist);
+  throw;
+       }
+   }
+      }
+
+  template<typename _Tp, typename _Alloc>
+    void
+    list<_Tp, _Alloc>::
+    sort()
+    {
+
+      if (this->_M_impl._M_node._M_next != &this->_M_impl._M_node
+   && this->_M_impl._M_node._M_next->_M_next != &this->_M_impl._M_node)
+      {
+        list __carry;
+        list __tmp[64];
+        list * __fill = __tmp;
+        list * __counter;
+ try
+   {
+     do
+       {
+  __carry.splice(__carry.begin(), *this, begin());
+
+  for(__counter = __tmp;
+      __counter != __fill && !__counter->empty();
+      ++__counter)
+    {
+      __counter->merge(__carry);
+      __carry.swap(*__counter);
+    }
+  __carry.swap(*__counter);
+  if (__counter == __fill)
+    ++__fill;
+       }
+     while ( !empty() );
+
+     for (__counter = __tmp + 1; __counter != __fill; ++__counter)
+       __counter->merge(*(__counter - 1));
+     swap( *(__fill - 1) );
+   }
+ catch(...)
+   {
+     this->splice(this->end(), __carry);
+     for (int __i = 0; __i < sizeof(__tmp)/sizeof(__tmp[0]); ++__i)
+       this->splice(this->end(), __tmp[__i]);
+     throw;
+   }
+      }
+    }
+
+  template<typename _Tp, typename _Alloc>
+    template <typename _Predicate>
+      typename list<_Tp, _Alloc>::__remove_return_type
+      list<_Tp, _Alloc>::
+      remove_if(_Predicate __pred)
+      {
+ size_type __removed __attribute__((__unused__)) = 0;
+        iterator __first = begin();
+        iterator __last = end();
+        while (__first != __last)
+   {
+     iterator __next = __first;
+     ++__next;
+     if (__pred(*__first))
+       {
+  _M_erase(__first);
+  ;
+       }
+     __first = __next;
+   }
+ return ;
+      }
+
+  template<typename _Tp, typename _Alloc>
+    template <typename _BinaryPredicate>
+      typename list<_Tp, _Alloc>::__remove_return_type
+      list<_Tp, _Alloc>::
+      unique(_BinaryPredicate __binary_pred)
+      {
+        iterator __first = begin();
+        iterator __last = end();
+        if (__first == __last)
+   return ;
+        size_type __removed __attribute__((__unused__)) = 0;
+        iterator __next = __first;
+        while (++__next != __last)
+   {
+     if (__binary_pred(*__first, *__next))
+       {
+  _M_erase(__next);
+  ;
+       }
+     else
+       __first = __next;
+     __next = __first;
+   }
+ return ;
+      }
+
+#undef _GLIBCXX20_ONLY
+
+  template<typename _Tp, typename _Alloc>
+    template <typename _StrictWeakOrdering>
+      void
+      list<_Tp, _Alloc>::
+      sort(_StrictWeakOrdering __comp)
+      {
+
+ if (this->_M_impl._M_node._M_next != &this->_M_impl._M_node
+     && this->_M_impl._M_node._M_next->_M_next != &this->_M_impl._M_node)
+   {
+     list __carry;
+     list __tmp[64];
+     list * __fill = __tmp;
+     list * __counter;
+     try
+       {
+  do
+    {
+      __carry.splice(__carry.begin(), *this, begin());
+
+      for(__counter = __tmp;
+   __counter != __fill && !__counter->empty();
+   ++__counter)
+        {
+   __counter->merge(__carry, __comp);
+   __carry.swap(*__counter);
+        }
+      __carry.swap(*__counter);
+      if (__counter == __fill)
+        ++__fill;
+    }
+  while ( !empty() );
+
+  for (__counter = __tmp + 1; __counter != __fill; ++__counter)
+    __counter->merge(*(__counter - 1), __comp);
+  swap(*(__fill - 1));
+       }
+     catch(...)
+       {
+  this->splice(this->end(), __carry);
+  for (int __i = 0; __i < sizeof(__tmp)/sizeof(__tmp[0]); ++__i)
+    this->splice(this->end(), __tmp[__i]);
+  throw;
+       }
+   }
+      }
+
+
+
+}
+# 65 "/usr/include/c++/10.2.0/list" 2 3
+
+
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  namespace pmr
+  {
+    template<typename _Tp> class polymorphic_allocator;
+    template<typename _Tp>
+      using list = std::list<_Tp, polymorphic_allocator<_Tp>>;
+  }
+
+}
+# 26 "/usr/include/boost/test/output/junit_log_formatter.hpp" 2 3 4
+
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 28 "/usr/include/boost/test/output/junit_log_formatter.hpp" 2 3 4
+
+
+
+namespace boost {
+namespace unit_test {
+namespace output {
+
+
+  namespace junit_impl {
+
+
+    struct junit_log_helper
+    {
+      struct assertion_entry {
+
+        enum log_entry_t {
+          log_entry_info,
+          log_entry_error,
+          log_entry_failure
+        };
+
+        assertion_entry() : sealed(false)
+        {}
+
+        std::string logentry_message;
+        std::string logentry_type;
+        std::string output;
+
+        log_entry_t log_entry;
+
+        bool sealed;
+      };
+
+      std::list<std::string> system_out;
+      std::list<std::string> system_err;
+      std::string skipping_reason;
+
+
+      std::vector< assertion_entry > assertion_entries;
+
+      bool skipping;
+
+      junit_log_helper(): skipping(false)
+      {}
+
+      void clear() {
+          assertion_entries.clear();
+          system_out.clear();
+          system_err.clear();
+          skipping_reason.clear();
+          skipping = false;
+      }
+
+    };
+  }
+
+
+
+
+
+
+class junit_log_formatter : public unit_test_log_formatter {
+public:
+
+    junit_log_formatter() : m_display_build_info(false)
+    {
+
+
+
+        this->m_log_level = log_successful_tests;
+        m_log_level_internal = log_messages;
+    }
+
+
+    void log_start( std::ostream&, counter_t test_cases_amount );
+    void log_finish( std::ostream& );
+    void log_build_info( std::ostream&, bool );
+
+    void test_unit_start( std::ostream&, test_unit const& tu );
+    void test_unit_finish( std::ostream&, test_unit const& tu, unsigned long elapsed );
+    void test_unit_skipped( std::ostream&, test_unit const& tu, const_string reason );
+    void test_unit_aborted( std::ostream& os, test_unit const& tu );
+    void test_unit_timed_out( std::ostream& os, test_unit const& tu);
+
+    void log_exception_start( std::ostream&, log_checkpoint_data const&, execution_exception const& ex );
+    void log_exception_finish( std::ostream& );
+
+    void log_entry_start( std::ostream&, log_entry_data const&, log_entry_types let );
+
+    using unit_test_log_formatter::log_entry_value;
+    void log_entry_value( std::ostream&, const_string value );
+    void log_entry_finish( std::ostream& );
+
+    void entry_context_start( std::ostream&, log_level );
+    void log_entry_context( std::ostream&, log_level, const_string );
+    void entry_context_finish( std::ostream&, log_level );
+
+
+    virtual void set_log_level(log_level ll)
+    {
+        if(ll > log_successful_tests && ll < log_messages)
+            ll = log_successful_tests;
+        else if (ll > log_all_errors)
+            ll = log_all_errors;
+
+        this->m_log_level_internal = ll;
+    }
+
+
+
+
+    virtual std::string get_default_stream_description() const;
+
+
+private:
+    typedef std::map<test_unit_id, junit_impl::junit_log_helper> map_trace_t;
+    map_trace_t map_tests;
+    junit_impl::junit_log_helper runner_log_entry;
+
+    junit_impl::junit_log_helper& get_current_log_entry() {
+        if(list_path_to_root.empty())
+            return runner_log_entry;
+        map_trace_t::iterator it = map_tests.find(list_path_to_root.back());
+        return (it == map_tests.end() ? runner_log_entry : it->second);
+    }
+
+    std::list<test_unit_id> list_path_to_root;
+    bool m_display_build_info;
+    bool m_is_last_assertion_or_error;
+
+    log_level m_log_level_internal;
+    friend class junit_result_helper;
+};
+
+}
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 167 "/usr/include/boost/test/output/junit_log_formatter.hpp" 2 3 4
+# 17 "/usr/include/boost/test/impl/junit_log_formatter.ipp" 2 3 4
+
+
+
+
+# 1 "/usr/include/boost/test/utils/xml_printer.hpp" 1 3 4
+# 16 "/usr/include/boost/test/utils/xml_printer.hpp" 3 4
+#define BOOST_TEST_UTILS_XML_PRINTER_HPP 
+
+
+
+
+# 1 "/usr/include/boost/test/utils/custom_manip.hpp" 1 3 4
+# 16 "/usr/include/boost/test/utils/custom_manip.hpp" 3 4
+#define BOOST_TEST_UTILS_CUSTOM_MANIP_HPP 
+
+
+
+
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 22 "/usr/include/boost/test/utils/custom_manip.hpp" 2 3 4
+
+
+
+namespace boost {
+namespace unit_test {
+namespace utils {
+
+
+
+
+
+template<typename Manip>
+struct custom_printer {
+    explicit custom_printer( std::ostream& ostr ) : m_ostr( &ostr ) {}
+
+    std::ostream& operator*() const { return *m_ostr; }
+
+private:
+    std::ostream* const m_ostr;
+};
+
+
+
+template<typename Uniq> struct custom_manip {};
+
+
+
+template<typename Uniq>
+inline custom_printer<custom_manip<Uniq> >
+operator<<( std::ostream& ostr, custom_manip<Uniq> const& ) { return custom_printer<custom_manip<Uniq> >( ostr ); }
+
+
+
+}
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 60 "/usr/include/boost/test/utils/custom_manip.hpp" 2 3 4
+# 22 "/usr/include/boost/test/utils/xml_printer.hpp" 2 3 4
+# 1 "/usr/include/boost/test/utils/foreach.hpp" 1 3 4
+# 21 "/usr/include/boost/test/utils/foreach.hpp" 3 4
+#define BOOST_TEST_UTILS_FOREACH_HPP 
+
+
+
+
+
+
+# 1 "/usr/include/boost/mpl/bool.hpp" 1 3 4
+
+
+#define BOOST_MPL_BOOL_HPP_INCLUDED 
+# 17 "/usr/include/boost/mpl/bool.hpp" 3 4
+# 1 "/usr/include/boost/mpl/bool_fwd.hpp" 1 3 4
+
+
+#define BOOST_MPL_BOOL_FWD_HPP_INCLUDED 
+# 17 "/usr/include/boost/mpl/bool_fwd.hpp" 3 4
+# 1 "/usr/include/boost/mpl/aux_/adl_barrier.hpp" 1 3 4
+
+
+#define BOOST_MPL_AUX_ADL_BARRIER_HPP_INCLUDED 
+# 17 "/usr/include/boost/mpl/aux_/adl_barrier.hpp" 3 4
+# 1 "/usr/include/boost/mpl/aux_/config/adl.hpp" 1 3 4
+
+
+#define BOOST_MPL_AUX_CONFIG_ADL_HPP_INCLUDED 
+# 17 "/usr/include/boost/mpl/aux_/config/adl.hpp" 3 4
+# 1 "/usr/include/boost/mpl/aux_/config/msvc.hpp" 1 3 4
+
+
+#define BOOST_MPL_AUX_CONFIG_MSVC_HPP_INCLUDED 
+# 18 "/usr/include/boost/mpl/aux_/config/adl.hpp" 2 3 4
+# 1 "/usr/include/boost/mpl/aux_/config/intel.hpp" 1 3 4
+
+
+#define BOOST_MPL_AUX_CONFIG_INTEL_HPP_INCLUDED 
+# 19 "/usr/include/boost/mpl/aux_/config/adl.hpp" 2 3 4
+# 1 "/usr/include/boost/mpl/aux_/config/gcc.hpp" 1 3 4
+
+
+#define BOOST_MPL_AUX_CONFIG_GCC_HPP_INCLUDED 
+# 18 "/usr/include/boost/mpl/aux_/config/gcc.hpp" 3 4
+#define BOOST_MPL_CFG_GCC ((__GNUC__ << 8) | __GNUC_MINOR__)
+# 20 "/usr/include/boost/mpl/aux_/config/adl.hpp" 2 3 4
+# 1 "/usr/include/boost/mpl/aux_/config/workaround.hpp" 1 3 4
+
+
+#define BOOST_MPL_AUX_CONFIG_WORKAROUND_HPP_INCLUDED 
+# 21 "/usr/include/boost/mpl/aux_/config/adl.hpp" 2 3 4
+# 18 "/usr/include/boost/mpl/aux_/adl_barrier.hpp" 2 3 4
+
+
+
+
+
+#define BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE mpl_
+#define BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN namespace mpl_ {
+#define BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE }
+#define BOOST_MPL_AUX_ADL_BARRIER_DECL(type) namespace boost { namespace mpl { using ::BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::type; } }
+
+
+
+
+
+
+namespace mpl_ { namespace aux {} }
+namespace boost { namespace mpl { using namespace mpl_;
+namespace aux { using namespace mpl_::aux; }
+}}
+# 18 "/usr/include/boost/mpl/bool_fwd.hpp" 2 3 4
+
+namespace mpl_ {
+
+template< bool C_ > struct bool_;
+
+
+typedef bool_<true> true_;
+typedef bool_<false> false_;
+
+}
+
+namespace boost { namespace mpl { using ::mpl_::bool_; } }
+namespace boost { namespace mpl { using ::mpl_::true_; } }
+namespace boost { namespace mpl { using ::mpl_::false_; } }
+# 18 "/usr/include/boost/mpl/bool.hpp" 2 3 4
+# 1 "/usr/include/boost/mpl/integral_c_tag.hpp" 1 3 4
+
+
+#define BOOST_MPL_INTEGRAL_C_TAG_HPP_INCLUDED 
+# 19 "/usr/include/boost/mpl/integral_c_tag.hpp" 3 4
+# 1 "/usr/include/boost/mpl/aux_/config/static_constant.hpp" 1 3 4
+
+
+#define BOOST_MPL_AUX_CONFIG_STATIC_CONSTANT_HPP_INCLUDED 
+# 20 "/usr/include/boost/mpl/integral_c_tag.hpp" 2 3 4
+
+namespace mpl_ {
+struct integral_c_tag { static const int value = 0; };
+}
+namespace boost { namespace mpl { using ::mpl_::integral_c_tag; } }
+# 19 "/usr/include/boost/mpl/bool.hpp" 2 3 4
+
+
+namespace mpl_ {
+
+template< bool C_ > struct bool_
+{
+    static const bool value = C_;
+    typedef integral_c_tag tag;
+    typedef bool_ type;
+    typedef bool value_type;
+    constexpr operator bool() const { return this->value; }
+};
+
+
+template< bool C_ >
+bool const bool_<C_>::value;
+
+
+}
+# 29 "/usr/include/boost/test/utils/foreach.hpp" 2 3 4
+
+
+
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 33 "/usr/include/boost/test/utils/foreach.hpp" 2 3 4
+
+
+
+namespace boost {
+namespace unit_test {
+namespace for_each {
+
+
+
+
+
+struct static_any_base
+{
+    operator bool() const { return false; }
+};
+
+
+
+template<typename Iter>
+struct static_any : static_any_base
+{
+    static_any( Iter const& t ) : m_it( t ) {}
+
+    mutable Iter m_it;
+};
+
+
+
+typedef static_any_base const& static_any_t;
+
+
+
+template<typename Iter>
+inline Iter&
+static_any_cast( static_any_t a, Iter* = 0 )
+{
+    return static_cast<Iter&>( static_cast<static_any<Iter> const&>( a ).m_it );
+}
+
+
+
+
+
+
+
+template<typename C>
+inline is_const<C>
+is_const_coll( C& )
+{
+    return is_const<C>();
+}
+
+
+
+
+
+
+
+template<typename C>
+inline static_any<typename C::iterator>
+begin( C& t, mpl::false_ )
+{
+    return static_any<typename C::iterator>( t.begin() );
+}
+
+
+
+template<typename C>
+inline static_any<typename C::const_iterator>
+begin( C const& t, mpl::true_ )
+{
+    return static_any<typename C::const_iterator>( t.begin() );
+}
+
+
+
+
+
+
+
+template<typename C>
+inline static_any<typename C::iterator>
+end( C& t, mpl::false_ )
+{
+    return static_any<typename C::iterator>( t.end() );
+}
+
+
+
+template<typename C>
+inline static_any<typename C::const_iterator>
+end( C const& t, mpl::true_ )
+{
+    return static_any<typename C::const_iterator>( t.end() );
+}
+
+
+
+
+
+
+
+template<typename C>
+inline bool
+done( static_any_t cur, static_any_t end, C&, mpl::false_ )
+{
+    return static_any_cast<typename C::iterator>( cur ) ==
+            static_any_cast<typename C::iterator>( end );
+}
+
+
+
+template<typename C>
+inline bool
+done( static_any_t cur, static_any_t end, C const&, mpl::true_ )
+{
+    return static_any_cast<typename C::const_iterator>( cur ) ==
+            static_any_cast<typename C::const_iterator>( end );
+}
+
+
+
+
+
+
+
+template<typename C>
+inline void
+next( static_any_t cur, C&, mpl::false_ )
+{
+    ++static_any_cast<typename C::iterator>( cur );
+}
+
+
+
+template<typename C>
+inline void
+next( static_any_t cur, C const&, mpl::true_ )
+{
+    ++static_any_cast<typename C::const_iterator>( cur );
+}
+
+
+
+
+
+
+
+template<typename C>
+inline void
+prev( static_any_t cur, C&, mpl::false_ )
+{
+    --static_any_cast<typename C::iterator>( cur );
+}
+
+
+
+template<typename C>
+inline void
+prev( static_any_t cur, C const&, mpl::true_ )
+{
+    --static_any_cast<typename C::const_iterator>( cur );
+}
+
+
+
+
+
+
+
+template<class RefType,typename C>
+inline RefType
+deref( static_any_t cur, C&, ::boost::type<RefType>, mpl::false_ )
+{
+    return *static_any_cast<typename C::iterator>( cur );
+}
+
+
+
+template<class RefType,typename C>
+inline RefType
+deref( static_any_t cur, C const&, ::boost::type<RefType>, mpl::true_ )
+{
+    return *static_any_cast<typename C::const_iterator>( cur );
+}
+
+
+
+
+
+
+
+#define BOOST_TEST_FE_ANY ::boost::unit_test::for_each::static_any_t
+#define BOOST_TEST_FE_IS_CONST(COL) ::boost::unit_test::for_each::is_const_coll( COL )
+
+#define BOOST_TEST_FE_BEG(COL) ::boost::unit_test::for_each::begin( COL, BOOST_TEST_FE_IS_CONST( COL ) )
+
+
+
+
+
+#define BOOST_TEST_FE_END(COL) ::boost::unit_test::for_each::end( COL, BOOST_TEST_FE_IS_CONST( COL ) )
+
+
+
+
+
+#define BOOST_TEST_FE_DONE(COL) ::boost::unit_test::for_each::done( BOOST_TEST_FE_CUR_VAR, BOOST_TEST_FE_END_VAR, COL, BOOST_TEST_FE_IS_CONST( COL ) )
+
+
+
+
+
+
+
+#define BOOST_TEST_FE_NEXT(COL) ::boost::unit_test::for_each::next( BOOST_TEST_FE_CUR_VAR, COL, BOOST_TEST_FE_IS_CONST( COL ) )
+
+
+
+
+
+
+#define BOOST_TEST_FE_PREV(COL) ::boost::unit_test::for_each::prev( BOOST_TEST_FE_CUR_VAR, COL, BOOST_TEST_FE_IS_CONST( COL ) )
+
+
+
+
+
+
+#define BOOST_FOREACH_NOOP(COL) ((void)&(COL))
+
+
+#define BOOST_TEST_FE_DEREF(COL,RefType) ::boost::unit_test::for_each::deref( BOOST_TEST_FE_CUR_VAR, COL, ::boost::type<RefType >(), BOOST_TEST_FE_IS_CONST( COL ) )
+# 276 "/usr/include/boost/test/utils/foreach.hpp" 3 4
+#define BOOST_TEST_LINE_NUM __LINE__
+
+
+#define BOOST_TEST_FE_CUR_VAR BOOST_JOIN( _fe_cur_, BOOST_TEST_LINE_NUM )
+#define BOOST_TEST_FE_END_VAR BOOST_JOIN( _fe_end_, BOOST_TEST_LINE_NUM )
+#define BOOST_TEST_FE_CON_VAR BOOST_JOIN( _fe_con_, BOOST_TEST_LINE_NUM )
+
+#define BOOST_TEST_FOREACH(RefType,var,COL) if( BOOST_TEST_FE_ANY BOOST_TEST_FE_CUR_VAR = BOOST_TEST_FE_BEG( COL ) ) {} else if( BOOST_TEST_FE_ANY BOOST_TEST_FE_END_VAR = BOOST_TEST_FE_END( COL ) ) {} else for( bool BOOST_TEST_FE_CON_VAR = true; BOOST_TEST_FE_CON_VAR && !BOOST_TEST_FE_DONE( COL ); BOOST_TEST_FE_CON_VAR ? BOOST_TEST_FE_NEXT( COL ) : BOOST_FOREACH_NOOP( COL )) if( (BOOST_TEST_FE_CON_VAR = false, false) ) {} else for( RefType var = BOOST_TEST_FE_DEREF( COL, RefType ); !BOOST_TEST_FE_CON_VAR; BOOST_TEST_FE_CON_VAR = true )
+# 295 "/usr/include/boost/test/utils/foreach.hpp" 3 4
+#define BOOST_TEST_REVERSE_FOREACH(RefType,var,COL) if( BOOST_TEST_FE_ANY BOOST_TEST_FE_CUR_VAR = BOOST_TEST_FE_END( COL ) ) {} else if( BOOST_TEST_FE_ANY BOOST_TEST_FE_END_VAR = BOOST_TEST_FE_BEG( COL ) ) {} else for( bool BOOST_TEST_FE_CON_VAR = true; BOOST_TEST_FE_CON_VAR && !BOOST_TEST_FE_DONE( COL ); ) if( (BOOST_TEST_FE_CON_VAR = false, false) ) {} else if( (BOOST_TEST_FE_PREV( COL ), false) ) {} else for( RefType var = BOOST_TEST_FE_DEREF( COL, RefType ); !BOOST_TEST_FE_CON_VAR; BOOST_TEST_FE_CON_VAR = true )
+# 309 "/usr/include/boost/test/utils/foreach.hpp" 3 4
+}
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 314 "/usr/include/boost/test/utils/foreach.hpp" 2 3 4
+# 23 "/usr/include/boost/test/utils/xml_printer.hpp" 2 3 4
+# 32 "/usr/include/boost/test/utils/xml_printer.hpp" 3 4
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 33 "/usr/include/boost/test/utils/xml_printer.hpp" 2 3 4
+
+
+
+namespace boost {
+namespace unit_test {
+namespace utils {
+
+
+
+
+
+inline void
+print_escaped( std::ostream& where_to, const_string value )
+{
+
+    static std::map<char,char const*> const char_type{{
+        {'<' , "lt"},
+        {'>' , "gt"},
+        {'&' , "amp"},
+        {'\'', "apos"},
+        {'"' , "quot"}
+    }};
+# 67 "/usr/include/boost/test/utils/xml_printer.hpp" 3 4
+    if( ::boost::unit_test::for_each::static_any_t _fe_cur_67 = ::boost::unit_test::for_each::begin( value, ::boost::unit_test::for_each::is_const_coll( value ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_67 = ::boost::unit_test::for_each::end( value, ::boost::unit_test::for_each::is_const_coll( value ) ) ) {} else for( bool _fe_con_67 = true; _fe_con_67 && !::boost::unit_test::for_each::done( _fe_cur_67, _fe_end_67, value, ::boost::unit_test::for_each::is_const_coll( value ) ); _fe_con_67 ? ::boost::unit_test::for_each::next( _fe_cur_67, value, ::boost::unit_test::for_each::is_const_coll( value ) ) : ((void)&(value))) if( (_fe_con_67 = false, false) ) {} else for( char c = ::boost::unit_test::for_each::deref( _fe_cur_67, value, ::boost::type<char >(), ::boost::unit_test::for_each::is_const_coll( value ) ); !_fe_con_67; _fe_con_67 = true ) {
+        std::map<char,char const*>::const_iterator found_ref = char_type.find( c );
+
+        if( found_ref != char_type.end() )
+            where_to << '&' << found_ref->second << ';';
+        else
+            where_to << c;
+    }
+}
+
+
+
+inline void
+print_escaped( std::ostream& where_to, std::string const& value )
+{
+    print_escaped( where_to, const_string( value ) );
+}
+
+
+
+template<typename T>
+inline void
+print_escaped( std::ostream& where_to, T const& value )
+{
+    where_to << value;
+}
+
+
+
+inline void
+print_escaped_cdata( std::ostream& where_to, const_string value )
+{
+    static const_string cdata_end( "]]>" );
+
+    const_string::size_type pos = value.find( cdata_end );
+    if( pos == const_string::npos )
+        where_to << value;
+    else {
+        where_to << value.substr( 0, pos+2 ) << cdata_end
+                 << ::boost::unit_test::const_string( "<![CDATA[", sizeof( "<![CDATA[" ) - 1 ) << value.substr( pos+2 );
+    }
+}
+
+
+
+typedef custom_manip<struct attr_value_t> attr_value;
+
+template<typename T>
+inline std::ostream&
+operator<<( custom_printer<attr_value> const& p, T const& value )
+{
+    *p << "=\"";
+    print_escaped( *p, value );
+    *p << '"';
+
+    return *p;
+}
+
+
+
+typedef custom_manip<struct cdata_t> cdata;
+
+inline std::ostream&
+operator<<( custom_printer<cdata> const& p, const_string value )
+{
+    *p << ::boost::unit_test::const_string( "<![CDATA[", sizeof( "<![CDATA[" ) - 1 );
+    print_escaped_cdata( *p, value );
+    return *p << ::boost::unit_test::const_string( "]]>", sizeof( "]]>" ) - 1 );
+}
+
+
+
+}
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 144 "/usr/include/boost/test/utils/xml_printer.hpp" 2 3 4
+# 22 "/usr/include/boost/test/impl/junit_log_formatter.ipp" 2 3 4
+
+
+
+# 1 "/usr/include/boost/test/tree/visitor.hpp" 1 3 4
+# 16 "/usr/include/boost/test/tree/visitor.hpp" 3 4
+#define BOOST_TEST_TREE_VISITOR_HPP_100211GER 
+
+
+
+
+
+
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 24 "/usr/include/boost/test/tree/visitor.hpp" 2 3 4
+
+
+
+namespace boost {
+namespace unit_test {
+
+
+
+
+
+class __attribute__((__visibility__("default"))) test_tree_visitor {
+public:
+
+    virtual bool visit( test_unit const& ) { return true; }
+    virtual void visit( test_case const& tc ) { visit( (test_unit const&)tc ); }
+    virtual bool test_suite_start( test_suite const& ts ){ return visit( (test_unit const&)ts ); }
+    virtual void test_suite_finish( test_suite const& ) {}
+
+protected:
+    virtual ~test_tree_visitor() {}
+};
+
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 50 "/usr/include/boost/test/tree/visitor.hpp" 2 3 4
+# 26 "/usr/include/boost/test/impl/junit_log_formatter.ipp" 2 3 4
+# 1 "/usr/include/boost/test/tree/traverse.hpp" 1 3 4
+# 16 "/usr/include/boost/test/tree/traverse.hpp" 3 4
+#define BOOST_TEST_TREE_TRAVERSE_HPP_100211GER 
+
+
+
+
+
+
+
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 25 "/usr/include/boost/test/tree/traverse.hpp" 2 3 4
+
+
+
+
+namespace boost {
+namespace unit_test {
+
+
+
+
+
+__attribute__((__visibility__("default"))) void traverse_test_tree( test_case const&, test_tree_visitor&, bool ignore_status = false );
+__attribute__((__visibility__("default"))) void traverse_test_tree( test_suite const&, test_tree_visitor&, bool ignore_status = false );
+__attribute__((__visibility__("default"))) void traverse_test_tree( test_unit_id , test_tree_visitor&, bool ignore_status = false );
+
+
+
+inline void
+traverse_test_tree( test_unit const& tu, test_tree_visitor& V, bool ignore_status = false )
+{
+    if( tu.p_type == TUT_CASE )
+        traverse_test_tree( static_cast<test_case const&>( tu ), V, ignore_status );
+    else
+        traverse_test_tree( static_cast<test_suite const&>( tu ), V, ignore_status );
+}
+
+
+
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 57 "/usr/include/boost/test/tree/traverse.hpp" 2 3 4
+# 27 "/usr/include/boost/test/impl/junit_log_formatter.ipp" 2 3 4
+# 1 "/usr/include/boost/test/results_collector.hpp" 1 3 4
+# 16 "/usr/include/boost/test/results_collector.hpp" 3 4
+#define BOOST_TEST_RESULTS_COLLECTOR_HPP_071894GER 
+
+
+# 1 "/usr/include/boost/test/tree/observer.hpp" 1 3 4
+# 13 "/usr/include/boost/test/tree/observer.hpp" 3 4
+#define BOOST_TEST_TEST_OBSERVER_HPP_021005GER 
+
+
+
+
+
+
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 21 "/usr/include/boost/test/tree/observer.hpp" 2 3 4
+
+
+
+namespace boost {
+namespace unit_test {
+# 40 "/usr/include/boost/test/tree/observer.hpp" 3 4
+class __attribute__((__visibility__("default"))) test_observer {
+public:
+
+
+
+
+
+    virtual void test_start( counter_t ) {}
+
+
+
+
+    virtual void test_finish() {}
+# 61 "/usr/include/boost/test/tree/observer.hpp" 3 4
+    virtual void test_aborted() {}
+
+
+
+
+    virtual void test_unit_start( test_unit const& ) {}
+
+
+
+
+    virtual void test_unit_finish( test_unit const& , unsigned long ) {}
+    virtual void test_unit_skipped( test_unit const& tu, const_string ) { test_unit_skipped( tu ); }
+    virtual void test_unit_skipped( test_unit const& ) {}
+
+
+
+
+
+    virtual void test_unit_timed_out( test_unit const& ) {}
+
+
+
+
+
+
+    virtual void test_unit_aborted( test_unit const& ) {}
+
+    virtual void assertion_result( unit_test::assertion_result )
+    {
+    }
+
+
+
+
+
+
+    virtual void exception_caught( execution_exception const& ) {}
+
+
+
+    virtual int priority() { return 0; }
+
+protected:
+
+    virtual ~test_observer() {}
+};
+
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 112 "/usr/include/boost/test/tree/observer.hpp" 2 3 4
+# 20 "/usr/include/boost/test/results_collector.hpp" 2 3 4
+
+
+
+
+
+
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 27 "/usr/include/boost/test/results_collector.hpp" 2 3 4
+
+
+
+namespace boost {
+namespace unit_test {
+
+namespace {
+
+
+
+
+
+
+
+inline void first_failed_assertion() {}
+}
+# 52 "/usr/include/boost/test/results_collector.hpp" 3 4
+class __attribute__((__visibility__("default"))) test_results {
+public:
+    test_results();
+
+
+    typedef class readonly_property57 : public boost::unit_test::readonly_property<counter_t > { typedef boost::unit_test::readonly_property<counter_t > base_prop; friend class results_collector_t; friend class test_results; friend class results_collect_helper; typedef base_prop::write_param_t write_param_t; public: readonly_property57() {} explicit readonly_property57( write_param_t init_v ) : base_prop( init_v ) {} }
+
+                                                                           counter_prop;
+
+    typedef class readonly_property61 : public boost::unit_test::readonly_property<bool > { typedef boost::unit_test::readonly_property<bool > base_prop; friend class results_collector_t; friend class test_results; friend class results_collect_helper; typedef base_prop::write_param_t write_param_t; public: readonly_property61() {} explicit readonly_property61( write_param_t init_v ) : base_prop( init_v ) {} }
+
+                                                                           bool_prop;
+
+    counter_prop p_test_suites;
+    counter_prop p_assertions_passed;
+    counter_prop p_assertions_failed;
+    counter_prop p_warnings_failed;
+    counter_prop p_expected_failures;
+    counter_prop p_test_cases_passed;
+    counter_prop p_test_cases_warned;
+    counter_prop p_test_cases_failed;
+    counter_prop p_test_cases_skipped;
+    counter_prop p_test_cases_aborted;
+    counter_prop p_test_cases_timed_out;
+    counter_prop p_test_suites_timed_out;
+    counter_prop p_duration_microseconds;
+    bool_prop p_aborted;
+    bool_prop p_skipped;
+    bool_prop p_timed_out;
+
+
+    bool passed() const;
+
+
+
+
+
+    bool skipped() const;
+
+
+    bool aborted() const;
+# 102 "/usr/include/boost/test/results_collector.hpp" 3 4
+    int result_code() const;
+
+
+
+
+    void operator+=( test_results const& );
+
+
+    void clear();
+};
+# 121 "/usr/include/boost/test/results_collector.hpp" 3 4
+class __attribute__((__visibility__("default"))) results_collector_t : public test_observer {
+public:
+
+    virtual void test_start( counter_t );
+
+    virtual void test_unit_start( test_unit const& );
+    virtual void test_unit_finish( test_unit const&, unsigned long );
+    virtual void test_unit_skipped( test_unit const&, const_string );
+    virtual void test_unit_aborted( test_unit const& );
+    virtual void test_unit_timed_out( test_unit const& );
+
+    virtual void assertion_result( unit_test::assertion_result );
+    virtual void exception_caught( execution_exception const& );
+
+    virtual int priority() { return 3; }
+
+
+
+
+    test_results const& results( test_unit_id tu_id ) const;
+
+
+    public: static results_collector_t& instance(); private: results_collector_t(results_collector_t const&) = delete; results_collector_t& operator=(results_collector_t const&) = delete; ~results_collector_t() = default; private: results_collector_t() = default;
+};
+
+namespace { results_collector_t& results_collector __attribute__((__unused__)) = results_collector_t::instance(); }
+
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 152 "/usr/include/boost/test/results_collector.hpp" 2 3 4
+# 28 "/usr/include/boost/test/impl/junit_log_formatter.ipp" 2 3 4
+
+# 1 "/usr/include/boost/test/utils/algorithm.hpp" 1 3 4
+# 13 "/usr/include/boost/test/utils/algorithm.hpp" 3 4
+#define BOOST_TEST_UTILS_ALGORITHM_HPP 
+
+
+
+
+
+
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 21 "/usr/include/boost/test/utils/algorithm.hpp" 2 3 4
+
+
+
+
+#define BOOST_TEST_BIND1ST(F,A) std::bind1st( (F), (A) )
+
+
+
+
+namespace boost {
+namespace unit_test {
+namespace utils {
+# 41 "/usr/include/boost/test/utils/algorithm.hpp" 3 4
+template <class InputIter1, class InputIter2>
+inline std::pair<InputIter1, InputIter2>
+mismatch( InputIter1 first1, InputIter1 last1,
+          InputIter2 first2, InputIter2 last2 )
+{
+    while( first1 != last1 && first2 != last2 && *first1 == *first2 ) {
+        ++first1;
+        ++first2;
+    }
+
+    return std::pair<InputIter1, InputIter2>(first1, first2);
+}
+# 65 "/usr/include/boost/test/utils/algorithm.hpp" 3 4
+template <class InputIter1, class InputIter2, class Predicate>
+inline std::pair<InputIter1, InputIter2>
+mismatch( InputIter1 first1, InputIter1 last1,
+          InputIter2 first2, InputIter2 last2,
+          Predicate pred )
+{
+    while( first1 != last1 && first2 != last2 && pred( *first1, *first2 ) ) {
+        ++first1;
+        ++first2;
+    }
+
+    return std::pair<InputIter1, InputIter2>(first1, first2);
+}
+# 87 "/usr/include/boost/test/utils/algorithm.hpp" 3 4
+template<class ForwardIterator1, class ForwardIterator2>
+inline ForwardIterator1
+find_first_not_of( ForwardIterator1 first1, ForwardIterator1 last1,
+                   ForwardIterator2 first2, ForwardIterator2 last2 )
+{
+    while( first1 != last1 ) {
+        if( std::find( first2, last2, *first1 ) == last2 )
+            break;
+        ++first1;
+    }
+
+    return first1;
+}
+# 111 "/usr/include/boost/test/utils/algorithm.hpp" 3 4
+template<class ForwardIterator1, class ForwardIterator2, class Predicate>
+inline ForwardIterator1
+find_first_not_of( ForwardIterator1 first1, ForwardIterator1 last1,
+                   ForwardIterator2 first2, ForwardIterator2 last2,
+                   Predicate pred )
+{
+    while( first1 != last1 ) {
+        if( std::find_if( first2, last2, std::bind1st( (pred), (*first1) ) ) == last2 )
+            break;
+        ++first1;
+    }
+
+    return first1;
+}
+# 134 "/usr/include/boost/test/utils/algorithm.hpp" 3 4
+template<class BidirectionalIterator1, class ForwardIterator2>
+inline BidirectionalIterator1
+find_last_of( BidirectionalIterator1 first1, BidirectionalIterator1 last1,
+              ForwardIterator2 first2, ForwardIterator2 last2 )
+{
+    if( first1 == last1 || first2 == last2 )
+        return last1;
+
+    BidirectionalIterator1 it1 = last1;
+    while( --it1 != first1 && std::find( first2, last2, *it1 ) == last2 ) {}
+
+    return it1 == first1 && std::find( first2, last2, *it1 ) == last2 ? last1 : it1;
+}
+# 158 "/usr/include/boost/test/utils/algorithm.hpp" 3 4
+template<class BidirectionalIterator1, class ForwardIterator2, class Predicate>
+inline BidirectionalIterator1
+find_last_of( BidirectionalIterator1 first1, BidirectionalIterator1 last1,
+              ForwardIterator2 first2, ForwardIterator2 last2,
+              Predicate pred )
+{
+    if( first1 == last1 || first2 == last2 )
+        return last1;
+
+    BidirectionalIterator1 it1 = last1;
+    while( --it1 != first1 && std::find_if( first2, last2, std::bind1st( (pred), (*it1) ) ) == last2 ) {}
+
+    return it1 == first1 && std::find_if( first2, last2, std::bind1st( (pred), (*it1) ) ) == last2 ? last1 : it1;
+}
+# 181 "/usr/include/boost/test/utils/algorithm.hpp" 3 4
+template<class BidirectionalIterator1, class ForwardIterator2>
+inline BidirectionalIterator1
+find_last_not_of( BidirectionalIterator1 first1, BidirectionalIterator1 last1,
+                  ForwardIterator2 first2, ForwardIterator2 last2 )
+{
+    if( first1 == last1 || first2 == last2 )
+        return last1;
+
+    BidirectionalIterator1 it1 = last1;
+    while( --it1 != first1 && std::find( first2, last2, *it1 ) != last2 ) {}
+
+    return it1 == first1 && std::find( first2, last2, *it1 ) != last2 ? last1 : it1;
+}
+# 205 "/usr/include/boost/test/utils/algorithm.hpp" 3 4
+template<class BidirectionalIterator1, class ForwardIterator2, class Predicate>
+inline BidirectionalIterator1
+find_last_not_of( BidirectionalIterator1 first1, BidirectionalIterator1 last1,
+                  ForwardIterator2 first2, ForwardIterator2 last2,
+                  Predicate pred )
+{
+    if( first1 == last1 || first2 == last2 )
+        return last1;
+
+    BidirectionalIterator1 it1 = last1;
+    while( --it1 != first1 && std::find_if( first2, last2, std::bind1st( (pred), (*it1) ) ) != last2 ) {}
+
+    return it1 == first1 && std::find_if( first2, last2, std::bind1st( (pred), (*it1) ) ) == last2 ? last1 : it1;
+}
+# 230 "/usr/include/boost/test/utils/algorithm.hpp" 3 4
+template<class StringClass, class ForwardIterator>
+inline StringClass
+replace_all_occurrences_of( StringClass str,
+                            ForwardIterator first1, ForwardIterator last1,
+                            ForwardIterator first2, ForwardIterator last2)
+{
+    for(; first1 != last1 && first2 != last2; ++first1, ++first2) {
+        std::size_t found = str.find( *first1 );
+        while( found != StringClass::npos ) {
+            str.replace(found, first1->size(), *first2 );
+            found = str.find( *first1, found + first2->size() );
+        }
+    }
+
+    return str;
+}
+# 264 "/usr/include/boost/test/utils/algorithm.hpp" 3 4
+template<class StringClass, class ForwardIterator>
+inline StringClass
+replace_all_occurrences_with_wildcards(
+    StringClass str,
+    ForwardIterator it_string_to_find, ForwardIterator it_string_to_find_end,
+    ForwardIterator it_string_to_replace, ForwardIterator it_string_to_replace_end)
+{
+    for(; it_string_to_find != it_string_to_find_end && it_string_to_replace != it_string_to_replace_end;
+        ++it_string_to_find, ++ it_string_to_replace) {
+
+        std::size_t wildcard_pos = it_string_to_find->find("*");
+        if(wildcard_pos == StringClass::npos) {
+            ForwardIterator it_to_find_current_end(it_string_to_find);
+            ForwardIterator it_to_replace_current_end(it_string_to_replace);
+            str = replace_all_occurrences_of(
+                str,
+                it_string_to_find, ++it_to_find_current_end,
+                it_string_to_replace, ++it_to_replace_current_end);
+            continue;
+        }
+
+        std::size_t wildcard_pos_replace = it_string_to_replace->find("*");
+
+        std::size_t found_begin = str.find( it_string_to_find->substr(0, wildcard_pos) );
+        while( found_begin != StringClass::npos ) {
+            std::size_t found_end = str.find(it_string_to_find->substr(wildcard_pos+1), found_begin + wildcard_pos + 1);
+            if( found_end != StringClass::npos ) {
+
+                if( wildcard_pos_replace == StringClass::npos ) {
+                    StringClass replace_content = *it_string_to_replace;
+                    str.replace(
+                        found_begin,
+                        found_end + (it_string_to_find->size() - wildcard_pos - 1 ) - found_begin,
+                        replace_content);
+                } else {
+                    StringClass replace_content =
+                        it_string_to_replace->substr(0, wildcard_pos_replace)
+                        + str.substr(found_begin + wildcard_pos,
+                                     found_end - found_begin - wildcard_pos)
+                        + it_string_to_replace->substr(wildcard_pos_replace+1) ;
+                    str.replace(
+                        found_begin,
+                        found_end + (it_string_to_find->size() - wildcard_pos - 1 ) - found_begin,
+                        replace_content);
+
+                }
+            }
+
+
+            found_begin = str.find( it_string_to_find->substr(0, wildcard_pos), found_begin + 1 );
+       }
+    }
+
+    return str;
+}
+
+}
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 325 "/usr/include/boost/test/utils/algorithm.hpp" 2 3 4
+# 30 "/usr/include/boost/test/impl/junit_log_formatter.ipp" 2 3 4
+# 42 "/usr/include/boost/test/impl/junit_log_formatter.ipp" 3 4
+# 1 "/usr/include/c++/10.2.0/set" 1 3 4
+# 56 "/usr/include/c++/10.2.0/set" 3 4
+#define _GLIBCXX_SET 1
+
+       
+# 59 "/usr/include/c++/10.2.0/set" 3
+
+
+# 1 "/usr/include/c++/10.2.0/bits/stl_set.h" 1 3
+# 57 "/usr/include/c++/10.2.0/bits/stl_set.h" 3
+#define _STL_SET_H 1
+
+
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+  template<typename _Key, typename _Compare, typename _Alloc>
+    class multiset;
+# 92 "/usr/include/c++/10.2.0/bits/stl_set.h" 3
+  template<typename _Key, typename _Compare = std::less<_Key>,
+    typename _Alloc = std::allocator<_Key> >
+    class set
+    {
+# 108 "/usr/include/c++/10.2.0/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");
+
+      static_assert(is_same<typename _Alloc::value_type, _Key>::value,
+   "std::set must have the same value_type as its allocator");
+
+
+
+    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;
+
+
+
+      using node_type = typename _Rep_type::node_type;
+      using insert_return_type = typename _Rep_type::insert_return_type;
+# 167 "/usr/include/c++/10.2.0/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 "/usr/include/c++/10.2.0/bits/stl_set.h" 3
+      template<typename _InputIterator>
+ set(_InputIterator __first, _InputIterator __last)
+ : _M_t()
+ { _M_t._M_insert_range_unique(__first, __last); }
+# 207 "/usr/include/c++/10.2.0/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_range_unique(__first, __last); }
+# 223 "/usr/include/c++/10.2.0/bits/stl_set.h" 3
+      set(const set&) = default;
+
+
+
+
+
+
+
+      set(set&&) = default;
+# 243 "/usr/include/c++/10.2.0/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_range_unique(__l.begin(), __l.end()); }
+
+
+      explicit
+      set(const allocator_type& __a)
+      : _M_t(_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(_Key_alloc_type(__a))
+      { _M_t._M_insert_range_unique(__l.begin(), __l.end()); }
+
+
+      template<typename _InputIterator>
+ set(_InputIterator __first, _InputIterator __last,
+     const allocator_type& __a)
+ : _M_t(_Key_alloc_type(__a))
+ { _M_t._M_insert_range_unique(__first, __last); }
+
+
+
+
+
+
+      ~set() = default;
+# 297 "/usr/include/c++/10.2.0/bits/stl_set.h" 3
+      set&
+      operator=(const set&) = default;
+
+
+      set&
+      operator=(set&&) = default;
+# 315 "/usr/include/c++/10.2.0/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(); }
+
+
+
+      [[__nodiscard__]] 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 "/usr/include/c++/10.2.0/bits/stl_set.h" 3
+      void
+      swap(set& __x)
+      noexcept(__is_nothrow_swappable<_Compare>::value)
+      { _M_t.swap(__x._M_t); }
+# 460 "/usr/include/c++/10.2.0/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 "/usr/include/c++/10.2.0/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 "/usr/include/c++/10.2.0/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 "/usr/include/c++/10.2.0/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 "/usr/include/c++/10.2.0/bits/stl_set.h" 3
+      template<typename _InputIterator>
+ void
+ insert(_InputIterator __first, _InputIterator __last)
+ { _M_t._M_insert_range_unique(__first, __last); }
+# 577 "/usr/include/c++/10.2.0/bits/stl_set.h" 3
+      void
+      insert(initializer_list<value_type> __l)
+      { this->insert(__l.begin(), __l.end()); }
+
+
+
+
+      node_type
+      extract(const_iterator __pos)
+      {
+ ;
+ return _M_t.extract(__pos);
+      }
+
+
+      node_type
+      extract(const key_type& __x)
+      { return _M_t.extract(__x); }
+
+
+      insert_return_type
+      insert(node_type&& __nh)
+      { return _M_t._M_reinsert_node_unique(std::move(__nh)); }
+
+
+      iterator
+      insert(const_iterator __hint, node_type&& __nh)
+      { return _M_t._M_reinsert_node_hint_unique(__hint, std::move(__nh)); }
+
+      template<typename, typename>
+ friend class std::_Rb_tree_merge_helper;
+
+      template<typename _Compare1>
+ void
+ merge(set<_Key, _Compare1, _Alloc>& __source)
+ {
+   using _Merge_helper = _Rb_tree_merge_helper<set, _Compare1>;
+   _M_t._M_merge_unique(_Merge_helper::_S_get_tree(__source));
+ }
+
+      template<typename _Compare1>
+ void
+ merge(set<_Key, _Compare1, _Alloc>&& __source)
+ { merge(__source); }
+
+      template<typename _Compare1>
+ void
+ merge(multiset<_Key, _Compare1, _Alloc>& __source)
+ {
+   using _Merge_helper = _Rb_tree_merge_helper<set, _Compare1>;
+   _M_t._M_merge_unique(_Merge_helper::_S_get_tree(__source));
+ }
+
+      template<typename _Compare1>
+ void
+ merge(multiset<_Key, _Compare1, _Alloc>&& __source)
+ { merge(__source); }
+# 652 "/usr/include/c++/10.2.0/bits/stl_set.h" 3
+      __attribute ((__abi_tag__ ("cxx11")))
+      iterator
+      erase(const_iterator __position)
+      { return _M_t.erase(__position); }
+# 683 "/usr/include/c++/10.2.0/bits/stl_set.h" 3
+      size_type
+      erase(const key_type& __x)
+      { return _M_t.erase(__x); }
+# 704 "/usr/include/c++/10.2.0/bits/stl_set.h" 3
+      __attribute ((__abi_tag__ ("cxx11")))
+      iterator
+      erase(const_iterator __first, const_iterator __last)
+      { return _M_t.erase(__first, __last); }
+# 732 "/usr/include/c++/10.2.0/bits/stl_set.h" 3
+      void
+      clear() noexcept
+      { _M_t.clear(); }
+# 747 "/usr/include/c++/10.2.0/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); }
+# 793 "/usr/include/c++/10.2.0/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)}; }
+# 828 "/usr/include/c++/10.2.0/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)); }
+# 858 "/usr/include/c++/10.2.0/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)); }
+# 897 "/usr/include/c++/10.2.0/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>&);
+
+    };
+
+
+
+  template<typename _InputIterator,
+    typename _Compare =
+      less<typename iterator_traits<_InputIterator>::value_type>,
+    typename _Allocator =
+      allocator<typename iterator_traits<_InputIterator>::value_type>,
+    typename = _RequireInputIter<_InputIterator>,
+    typename = _RequireNotAllocator<_Compare>,
+    typename = _RequireAllocator<_Allocator>>
+    set(_InputIterator, _InputIterator,
+ _Compare = _Compare(), _Allocator = _Allocator())
+    -> set<typename iterator_traits<_InputIterator>::value_type,
+   _Compare, _Allocator>;
+
+  template<typename _Key, typename _Compare = less<_Key>,
+    typename _Allocator = allocator<_Key>,
+    typename = _RequireNotAllocator<_Compare>,
+    typename = _RequireAllocator<_Allocator>>
+    set(initializer_list<_Key>,
+ _Compare = _Compare(), _Allocator = _Allocator())
+    -> set<_Key, _Compare, _Allocator>;
+
+  template<typename _InputIterator, typename _Allocator,
+    typename = _RequireInputIter<_InputIterator>,
+    typename = _RequireAllocator<_Allocator>>
+    set(_InputIterator, _InputIterator, _Allocator)
+    -> set<typename iterator_traits<_InputIterator>::value_type,
+    less<typename iterator_traits<_InputIterator>::value_type>,
+    _Allocator>;
+
+  template<typename _Key, typename _Allocator,
+    typename = _RequireAllocator<_Allocator>>
+    set(initializer_list<_Key>, _Allocator)
+    -> set<_Key, less<_Key>, _Allocator>;
+# 983 "/usr/include/c++/10.2.0/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; }
+# 1021 "/usr/include/c++/10.2.0/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); }
+
+
+
+
+
+  template<typename _Val, typename _Cmp1, typename _Alloc, typename _Cmp2>
+    struct
+    _Rb_tree_merge_helper<std::set<_Val, _Cmp1, _Alloc>, _Cmp2>
+    {
+    private:
+      friend class std::set<_Val, _Cmp1, _Alloc>;
+
+      static auto&
+      _S_get_tree(std::set<_Val, _Cmp2, _Alloc>& __set)
+      { return __set._M_t; }
+
+      static auto&
+      _S_get_tree(std::multiset<_Val, _Cmp2, _Alloc>& __set)
+      { return __set._M_t; }
+    };
+
+
+
+}
+# 62 "/usr/include/c++/10.2.0/set" 2 3
+# 1 "/usr/include/c++/10.2.0/bits/stl_multiset.h" 1 3
+# 57 "/usr/include/c++/10.2.0/bits/stl_multiset.h" 3
+#define _STL_MULTISET_H 1
+
+
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+  template<typename _Key, typename _Compare, typename _Alloc>
+    class set;
+# 94 "/usr/include/c++/10.2.0/bits/stl_multiset.h" 3
+  template <typename _Key, typename _Compare = std::less<_Key>,
+     typename _Alloc = std::allocator<_Key> >
+    class multiset
+    {
+# 110 "/usr/include/c++/10.2.0/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");
+
+      static_assert(is_same<typename _Alloc::value_type, _Key>::value,
+   "std::multiset must have the same value_type as its allocator");
+
+
+
+    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;
+
+
+      using node_type = typename _Rep_type::node_type;
+# 164 "/usr/include/c++/10.2.0/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 "/usr/include/c++/10.2.0/bits/stl_multiset.h" 3
+      template<typename _InputIterator>
+ multiset(_InputIterator __first, _InputIterator __last)
+ : _M_t()
+ { _M_t._M_insert_range_equal(__first, __last); }
+# 202 "/usr/include/c++/10.2.0/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_range_equal(__first, __last); }
+# 218 "/usr/include/c++/10.2.0/bits/stl_multiset.h" 3
+      multiset(const multiset&) = default;
+# 227 "/usr/include/c++/10.2.0/bits/stl_multiset.h" 3
+      multiset(multiset&&) = default;
+# 239 "/usr/include/c++/10.2.0/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_range_equal(__l.begin(), __l.end()); }
+
+
+      explicit
+      multiset(const allocator_type& __a)
+      : _M_t(_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(_Key_alloc_type(__a))
+      { _M_t._M_insert_range_equal(__l.begin(), __l.end()); }
+
+
+      template<typename _InputIterator>
+ multiset(_InputIterator __first, _InputIterator __last,
+   const allocator_type& __a)
+ : _M_t(_Key_alloc_type(__a))
+ { _M_t._M_insert_range_equal(__first, __last); }
+
+
+
+
+
+
+      ~multiset() = default;
+# 293 "/usr/include/c++/10.2.0/bits/stl_multiset.h" 3
+      multiset&
+      operator=(const multiset&) = default;
+
+
+      multiset&
+      operator=(multiset&&) = default;
+# 311 "/usr/include/c++/10.2.0/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(); }
+
+
+
+      [[__nodiscard__]] 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 "/usr/include/c++/10.2.0/bits/stl_multiset.h" 3
+      void
+      swap(multiset& __x)
+      noexcept(__is_nothrow_swappable<_Compare>::value)
+      { _M_t.swap(__x._M_t); }
+# 455 "/usr/include/c++/10.2.0/bits/stl_multiset.h" 3
+      template<typename... _Args>
+ iterator
+ emplace(_Args&&... __args)
+ { return _M_t._M_emplace_equal(std::forward<_Args>(__args)...); }
+# 481 "/usr/include/c++/10.2.0/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 "/usr/include/c++/10.2.0/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 "/usr/include/c++/10.2.0/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 "/usr/include/c++/10.2.0/bits/stl_multiset.h" 3
+      template<typename _InputIterator>
+ void
+ insert(_InputIterator __first, _InputIterator __last)
+ { _M_t._M_insert_range_equal(__first, __last); }
+# 562 "/usr/include/c++/10.2.0/bits/stl_multiset.h" 3
+      void
+      insert(initializer_list<value_type> __l)
+      { this->insert(__l.begin(), __l.end()); }
+
+
+
+
+      node_type
+      extract(const_iterator __pos)
+      {
+ ;
+ return _M_t.extract(__pos);
+      }
+
+
+      node_type
+      extract(const key_type& __x)
+      { return _M_t.extract(__x); }
+
+
+      iterator
+      insert(node_type&& __nh)
+      { return _M_t._M_reinsert_node_equal(std::move(__nh)); }
+
+
+      iterator
+      insert(const_iterator __hint, node_type&& __nh)
+      { return _M_t._M_reinsert_node_hint_equal(__hint, std::move(__nh)); }
+
+      template<typename, typename>
+ friend class std::_Rb_tree_merge_helper;
+
+      template<typename _Compare1>
+ void
+ merge(multiset<_Key, _Compare1, _Alloc>& __source)
+ {
+   using _Merge_helper = _Rb_tree_merge_helper<multiset, _Compare1>;
+   _M_t._M_merge_equal(_Merge_helper::_S_get_tree(__source));
+ }
+
+      template<typename _Compare1>
+ void
+ merge(multiset<_Key, _Compare1, _Alloc>&& __source)
+ { merge(__source); }
+
+      template<typename _Compare1>
+ void
+ merge(set<_Key, _Compare1, _Alloc>& __source)
+ {
+   using _Merge_helper = _Rb_tree_merge_helper<multiset, _Compare1>;
+   _M_t._M_merge_equal(_Merge_helper::_S_get_tree(__source));
+ }
+
+      template<typename _Compare1>
+ void
+ merge(set<_Key, _Compare1, _Alloc>&& __source)
+ { merge(__source); }
+# 637 "/usr/include/c++/10.2.0/bits/stl_multiset.h" 3
+      __attribute ((__abi_tag__ ("cxx11")))
+      iterator
+      erase(const_iterator __position)
+      { return _M_t.erase(__position); }
+# 668 "/usr/include/c++/10.2.0/bits/stl_multiset.h" 3
+      size_type
+      erase(const key_type& __x)
+      { return _M_t.erase(__x); }
+# 689 "/usr/include/c++/10.2.0/bits/stl_multiset.h" 3
+      __attribute ((__abi_tag__ ("cxx11")))
+      iterator
+      erase(const_iterator __first, const_iterator __last)
+      { return _M_t.erase(__first, __last); }
+# 717 "/usr/include/c++/10.2.0/bits/stl_multiset.h" 3
+      void
+      clear() noexcept
+      { _M_t.clear(); }
+# 729 "/usr/include/c++/10.2.0/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); }
+# 774 "/usr/include/c++/10.2.0/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)}; }
+# 809 "/usr/include/c++/10.2.0/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)); }
+# 839 "/usr/include/c++/10.2.0/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)); }
+# 878 "/usr/include/c++/10.2.0/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>&);
+
+    };
+
+
+
+  template<typename _InputIterator,
+    typename _Compare =
+      less<typename iterator_traits<_InputIterator>::value_type>,
+    typename _Allocator =
+      allocator<typename iterator_traits<_InputIterator>::value_type>,
+    typename = _RequireInputIter<_InputIterator>,
+    typename = _RequireNotAllocator<_Compare>,
+    typename = _RequireAllocator<_Allocator>>
+    multiset(_InputIterator, _InputIterator,
+      _Compare = _Compare(), _Allocator = _Allocator())
+    -> multiset<typename iterator_traits<_InputIterator>::value_type,
+  _Compare, _Allocator>;
+
+  template<typename _Key,
+    typename _Compare = less<_Key>,
+    typename _Allocator = allocator<_Key>,
+    typename = _RequireNotAllocator<_Compare>,
+    typename = _RequireAllocator<_Allocator>>
+    multiset(initializer_list<_Key>,
+      _Compare = _Compare(), _Allocator = _Allocator())
+    -> multiset<_Key, _Compare, _Allocator>;
+
+  template<typename _InputIterator, typename _Allocator,
+    typename = _RequireInputIter<_InputIterator>,
+    typename = _RequireAllocator<_Allocator>>
+    multiset(_InputIterator, _InputIterator, _Allocator)
+    -> multiset<typename iterator_traits<_InputIterator>::value_type,
+         less<typename iterator_traits<_InputIterator>::value_type>,
+         _Allocator>;
+
+  template<typename _Key, typename _Allocator,
+    typename = _RequireAllocator<_Allocator>>
+    multiset(initializer_list<_Key>, _Allocator)
+    -> multiset<_Key, less<_Key>, _Allocator>;
+# 969 "/usr/include/c++/10.2.0/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; }
+# 1007 "/usr/include/c++/10.2.0/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); }
+
+
+
+
+
+  template<typename _Val, typename _Cmp1, typename _Alloc, typename _Cmp2>
+    struct
+    _Rb_tree_merge_helper<std::multiset<_Val, _Cmp1, _Alloc>,
+     _Cmp2>
+    {
+    private:
+      friend class std::multiset<_Val, _Cmp1, _Alloc>;
+
+      static auto&
+      _S_get_tree(std::set<_Val, _Cmp2, _Alloc>& __set)
+      { return __set._M_t; }
+
+      static auto&
+      _S_get_tree(std::multiset<_Val, _Cmp2, _Alloc>& __set)
+      { return __set._M_t; }
+    };
+
+
+
+}
+# 63 "/usr/include/c++/10.2.0/set" 2 3
+# 71 "/usr/include/c++/10.2.0/set" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  namespace pmr
+  {
+    template<typename _Tp> class polymorphic_allocator;
+    template<typename _Key, typename _Cmp = std::less<_Key>>
+      using set = std::set<_Key, _Cmp, polymorphic_allocator<_Key>>;
+    template<typename _Key, typename _Cmp = std::less<_Key>>
+      using multiset = std::multiset<_Key, _Cmp, polymorphic_allocator<_Key>>;
+  }
+
+}
+# 43 "/usr/include/boost/test/impl/junit_log_formatter.ipp" 2 3 4
+
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 45 "/usr/include/boost/test/impl/junit_log_formatter.ipp" 2 3 4
+
+
+
+
+namespace boost {
+namespace unit_test {
+namespace output {
+
+
+struct s_replace_chars {
+  template <class T>
+  void operator()(T& to_replace)
+  {
+    if(to_replace == '/')
+      to_replace = '.';
+    else if(to_replace == ' ')
+      to_replace = '_';
+  }
+};
+
+inline std::string tu_name_normalize(std::string full_name)
+{
+
+  std::for_each(full_name.begin(), full_name.end(), s_replace_chars());
+  return full_name;
+}
+
+inline std::string tu_name_remove_newlines(std::string full_name)
+{
+  full_name.erase(std::remove(full_name.begin(), full_name.end(), '\n'), full_name.end());
+  return full_name;
+}
+
+const_string file_basename(const_string filename) {
+
+    const_string path_sep( "\\/" );
+    const_string::iterator it = unit_test::utils::find_last_of( filename.begin(), filename.end(),
+                                                                path_sep.begin(), path_sep.end() );
+    if( it != filename.end() )
+        filename.trim_left( it + 1 );
+
+    return filename;
+
+}
+
+
+
+
+
+void
+junit_log_formatter::log_start( std::ostream& , counter_t )
+{
+    map_tests.clear();
+    list_path_to_root.clear();
+    runner_log_entry.clear();
+}
+
+
+
+class junit_result_helper : public test_tree_visitor {
+private:
+    typedef junit_impl::junit_log_helper::assertion_entry assertion_entry;
+    typedef std::vector< assertion_entry >::const_iterator vect_assertion_entry_citerator;
+    typedef std::list<std::string>::const_iterator list_str_citerator;
+
+public:
+    explicit junit_result_helper(
+        std::ostream& stream,
+        test_unit const& ts,
+        junit_log_formatter::map_trace_t const& mt,
+        junit_impl::junit_log_helper const& runner_log_,
+        bool display_build_info )
+    : m_stream(stream)
+    , m_ts( ts )
+    , m_map_test( mt )
+    , runner_log( runner_log_ )
+    , m_id( 0 )
+    , m_display_build_info(display_build_info)
+    { }
+
+    void add_log_entry(assertion_entry const& log) const
+    {
+        std::string entry_type;
+        if( log.log_entry == assertion_entry::log_entry_failure ) {
+            entry_type = "failure";
+        }
+        else if( log.log_entry == assertion_entry::log_entry_error ) {
+            entry_type = "error";
+        }
+        else {
+            return;
+        }
+
+        m_stream
+            << "<" << entry_type
+            << " message" << utils::attr_value() << log.logentry_message
+            << " type" << utils::attr_value() << log.logentry_type
+            << ">";
+
+        if(!log.output.empty()) {
+            m_stream << utils::cdata() << "\n" + log.output;
+        }
+
+        m_stream << "</" << entry_type << ">";
+    }
+
+    struct conditional_cdata_helper {
+        std::ostream &ostr;
+        std::string const field;
+        bool empty;
+
+        conditional_cdata_helper(std::ostream &ostr_, std::string field_)
+        : ostr(ostr_)
+        , field(field_)
+        , empty(true)
+        {}
+
+        ~conditional_cdata_helper() {
+            if(!empty) {
+                ostr << ::boost::unit_test::const_string( "]]>", sizeof( "]]>" ) - 1 ) << "</" << field << '>' << std::endl;
+            }
+        }
+
+        void operator()(const std::string& s) {
+            bool current_empty = s.empty();
+            if(empty) {
+                if(!current_empty) {
+                    empty = false;
+                    ostr << '<' << field << '>' << ::boost::unit_test::const_string( "<![CDATA[", sizeof( "<![CDATA[" ) - 1 );
+                }
+            }
+            if(!current_empty) {
+                ostr << s;
+            }
+        }
+    };
+
+    std::list<std::string> build_skipping_chain(test_unit const & tu) const
+    {
+
+
+        (static_cast <bool> (m_map_test.count(tu.p_id) == 0 || results_collector.results( tu.p_id ).p_skipped) ? void (0) : __assert_fail ("m_map_test.count(tu.p_id) == 0 || results_collector.results( tu.p_id ).p_skipped", "/usr/include/boost/test/impl/junit_log_formatter.ipp", 186, __extension__ __PRETTY_FUNCTION__));
+
+        std::list<std::string> out;
+
+        test_unit_id id(tu.p_id);
+        while( id != m_ts.p_id && id != INV_TEST_UNIT_ID) {
+            test_unit const& tu_hierarchy = boost::unit_test::framework::get( id, TUT_ANY );
+            out.push_back("- disabled test unit: '" + tu_name_remove_newlines(tu_hierarchy.full_name()) + "'\n");
+            if(m_map_test.count(id) > 0)
+            {
+
+                break;
+            }
+            id = tu_hierarchy.p_parent_id;
+        }
+        junit_log_formatter::map_trace_t::const_iterator it_element_stack(m_map_test.find(id));
+        if( it_element_stack != m_map_test.end() )
+        {
+            out.push_back("- reason: '" + it_element_stack->second.skipping_reason + "'");
+            out.push_front("Test case disabled because of the following chain of decision:\n");
+        }
+
+        return out;
+    }
+
+    std::string get_class_name(test_unit const & tu_class) const {
+        std::string classname;
+        test_unit_id id(tu_class.p_parent_id);
+        while( id != m_ts.p_id && id != INV_TEST_UNIT_ID ) {
+            test_unit const& tu = boost::unit_test::framework::get( id, TUT_ANY );
+            classname = tu_name_normalize(tu.p_name) + "." + classname;
+            id = tu.p_parent_id;
+        }
+
+
+        if(!classname.empty() && *classname.rbegin() == '.') {
+            classname.erase(classname.size()-1);
+        }
+
+        return classname;
+    }
+
+    void write_testcase_header(test_unit const & tu,
+                                  test_results const *tr,
+                                  int nb_assertions) const
+    {
+        std::string name;
+        std::string classname;
+
+        if(tu.p_id == m_ts.p_id ) {
+            name = "boost_test";
+        }
+        else {
+            classname = get_class_name(tu);
+            name = tu_name_normalize(tu.p_name);
+        }
+
+        if( tu.p_type == TUT_SUITE ) {
+            if(tr->p_timed_out)
+              name += "-timed-execution";
+            else
+              name += "-setup-teardown";
+        }
+
+        m_stream << "<testcase assertions" << utils::attr_value() << nb_assertions;
+        if(!classname.empty())
+            m_stream << " classname" << utils::attr_value() << classname;
+
+
+        m_stream
+            << " name" << utils::attr_value() << name
+            << " time" << utils::attr_value() << double(tr->p_duration_microseconds) * 1E-6
+            << ">" << std::endl;
+    }
+
+    void write_testcase_system_out(junit_impl::junit_log_helper const &detailed_log,
+                                      test_unit const * tu,
+                                      bool skipped) const
+    {
+
+        conditional_cdata_helper system_out_helper(m_stream, "system-out");
+
+
+        if( skipped ) {
+            std::list<std::string> skipping_decision_chain = build_skipping_chain(*tu);
+            for(list_str_citerator it(skipping_decision_chain.begin()), ite(skipping_decision_chain.end());
+                it != ite;
+                ++it)
+            {
+              system_out_helper(*it);
+            }
+        }
+
+
+        for(list_str_citerator it(detailed_log.system_out.begin()), ite(detailed_log.system_out.end());
+            it != ite;
+            ++it)
+        {
+          system_out_helper(*it);
+        }
+
+
+        for(vect_assertion_entry_citerator it(detailed_log.assertion_entries.begin());
+            it != detailed_log.assertion_entries.end();
+            ++it)
+        {
+            if(it->log_entry != assertion_entry::log_entry_info)
+                continue;
+            system_out_helper(it->output);
+        }
+    }
+
+    void write_testcase_system_err(junit_impl::junit_log_helper const &detailed_log,
+                                      test_unit const * tu,
+                                      test_results const *tr) const
+    {
+
+        bool has_failed = (tr != 0) ? !tr->p_skipped && !tr->passed() : false;
+        if(!detailed_log.system_err.empty() || has_failed)
+        {
+            std::ostringstream o;
+            if(has_failed) {
+                o << "Failures detected in:" << std::endl;
+            }
+            else {
+                o << "ERROR STREAM:" << std::endl;
+            }
+
+            if(tu->p_type == TUT_SUITE) {
+                if( tu->p_id == m_ts.p_id ) {
+                    o << " boost.test global setup/teardown" << std::endl;
+                } else {
+                    o << "- test suite: " << tu_name_remove_newlines(tu->full_name()) << std::endl;
+                }
+            }
+            else {
+              o << "- test case: " << tu_name_remove_newlines(tu->full_name());
+              if(!tu->p_description.value.empty())
+                  o << " '" << tu->p_description << "'";
+
+              o << std::endl
+                  << "- file: " << file_basename(tu->p_file_name) << std::endl
+                  << "- line: " << tu->p_line_num << std::endl
+                  ;
+            }
+
+            if(!detailed_log.system_err.empty())
+                o << std::endl << "STDERR BEGIN: ------------" << std::endl;
+
+            for(list_str_citerator it(detailed_log.system_err.begin()), ite(detailed_log.system_err.end());
+                it != ite;
+                ++it)
+            {
+              o << *it;
+            }
+
+            if(!detailed_log.system_err.empty())
+                o << std::endl << "STDERR END    ------------" << std::endl;
+
+            conditional_cdata_helper system_err_helper(m_stream, "system-err");
+            system_err_helper(o.str());
+        }
+    }
+
+    int get_nb_assertions(junit_impl::junit_log_helper const &detailed_log,
+                              test_unit const & tu,
+                              test_results const *tr) const {
+        int nb_assertions(-1);
+        if( tu.p_type == TUT_SUITE ) {
+            nb_assertions = 0;
+            for(vect_assertion_entry_citerator it(detailed_log.assertion_entries.begin());
+                it != detailed_log.assertion_entries.end();
+                ++it)
+            {
+                if(it->log_entry != assertion_entry::log_entry_info)
+                    nb_assertions++;
+            }
+        }
+        else {
+            nb_assertions = static_cast<int>(tr->p_assertions_passed + tr->p_assertions_failed);
+        }
+
+        return nb_assertions;
+    }
+
+    void output_detailed_logs(junit_impl::junit_log_helper const &detailed_log,
+                                 test_unit const & tu,
+                                 bool skipped,
+                                 test_results const *tr) const
+    {
+        int nb_assertions = get_nb_assertions(detailed_log, tu, tr);
+        if(!nb_assertions && tu.p_type == TUT_SUITE)
+            return;
+
+        write_testcase_header(tu, tr, nb_assertions);
+
+        if( skipped ) {
+            m_stream << "<skipped/>" << std::endl;
+        }
+        else {
+
+          for(vect_assertion_entry_citerator it(detailed_log.assertion_entries.begin());
+              it != detailed_log.assertion_entries.end();
+              ++it)
+          {
+              add_log_entry(*it);
+          }
+        }
+
+        write_testcase_system_out(detailed_log, &tu, skipped);
+        write_testcase_system_err(detailed_log, &tu, tr);
+        m_stream << "</testcase>" << std::endl;
+    }
+
+    void visit( test_case const& tc )
+    {
+
+        test_results const& tr = results_collector.results( tc.p_id );
+        junit_log_formatter::map_trace_t::const_iterator it_find = m_map_test.find(tc.p_id);
+        if(it_find == m_map_test.end())
+        {
+
+            output_detailed_logs(junit_impl::junit_log_helper(), tc, true, &tr);
+        }
+        else {
+            output_detailed_logs(it_find->second, tc, tr.p_skipped, &tr);
+        }
+    }
+
+    bool test_suite_start( test_suite const& ts )
+    {
+        test_results const& tr = results_collector.results( ts.p_id );
+
+
+        if( m_ts.p_id == ts.p_id ) {
+            m_stream << "<testsuite";
+
+
+
+
+
+
+
+            m_stream
+
+              << " tests" << utils::attr_value()
+                  << tr.p_test_cases_passed
+                     + tr.p_test_cases_failed
+
+              << " skipped" << utils::attr_value() << tr.p_test_cases_skipped
+              << " errors" << utils::attr_value() << tr.p_test_cases_aborted
+              << " failures" << utils::attr_value()
+                  << tr.p_test_cases_failed
+                     + tr.p_test_suites_timed_out
+                     + tr.p_test_cases_timed_out
+                     - tr.p_test_cases_aborted
+              << " id" << utils::attr_value() << m_id++
+              << " name" << utils::attr_value() << tu_name_normalize(ts.p_name)
+              << " time" << utils::attr_value() << (tr.p_duration_microseconds * 1E-6)
+              << ">" << std::endl;
+
+            if(m_display_build_info)
+            {
+                m_stream << "<properties>" << std::endl;
+                m_stream << "<property name=\"platform\" value" << utils::attr_value() << "linux" << " />" << std::endl;
+                m_stream << "<property name=\"compiler\" value" << utils::attr_value() << "GNU C++ version " "10.2.0" << " />" << std::endl;
+                m_stream << "<property name=\"stl\" value" << utils::attr_value() << "GNU libstdc++ version " "20200723" << " />" << std::endl;
+
+                std::ostringstream o;
+                o << 107200/100000 << "." << 107200/100 % 1000 << "." << 107200 % 100;
+                m_stream << "<property name=\"boost\" value" << utils::attr_value() << o.str() << " />" << std::endl;
+                m_stream << "</properties>" << std::endl;
+            }
+        }
+
+        if( !tr.p_skipped ) {
+
+
+
+            junit_log_formatter::map_trace_t::const_iterator it_find = m_map_test.find(ts.p_id);
+            if(it_find != m_map_test.end()) {
+                output_detailed_logs(it_find->second, ts, false, &tr);
+            }
+        }
+
+        return true;
+    }
+
+    virtual void test_suite_finish( test_suite const& ts )
+    {
+        if( m_ts.p_id == ts.p_id ) {
+            write_testcase_system_out(runner_log, 0, false);
+            write_testcase_system_err(runner_log, 0, 0);
+
+            m_stream << "</testsuite>";
+            return;
+        }
+    }
+
+private:
+
+    std::ostream& m_stream;
+    test_unit const& m_ts;
+    junit_log_formatter::map_trace_t const& m_map_test;
+    junit_impl::junit_log_helper const& runner_log;
+    size_t m_id;
+    bool m_display_build_info;
+};
+
+
+
+void
+junit_log_formatter::log_finish( std::ostream& ostr )
+{
+    ostr << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" << std::endl;
+
+
+    if(!map_tests.empty()) {
+        test_unit* root = &boost::unit_test::framework::get( map_tests.begin()->first, TUT_ANY );
+
+
+        while(root->p_parent_id != INV_TEST_UNIT_ID && map_tests.count(root->p_parent_id) > 0) {
+            root = &boost::unit_test::framework::get( root->p_parent_id, TUT_ANY );
+        }
+        junit_result_helper ch( ostr, *root, map_tests, this->runner_log_entry, m_display_build_info );
+        traverse_test_tree( root->p_id, ch, true );
+    }
+    else {
+        ostr << "<testsuites errors=\"1\">";
+        ostr << "<testsuite errors=\"1\" name=\"boost-test-framework\">";
+        ostr << "<testcase assertions=\"1\" name=\"test-setup\">";
+        ostr << "<system-out>Incorrect setup: no test case executed</system-out>";
+        ostr << "</testcase></testsuite></testsuites>";
+    }
+    return;
+}
+
+
+
+void
+junit_log_formatter::log_build_info( std::ostream& , bool log_build_info )
+{
+    m_display_build_info = log_build_info;
+}
+
+
+
+void
+junit_log_formatter::test_unit_start( std::ostream& , test_unit const& tu )
+{
+    list_path_to_root.push_back( tu.p_id );
+    map_tests.insert(std::make_pair(tu.p_id, junit_impl::junit_log_helper()));
+}
+
+
+
+
+
+
+void
+junit_log_formatter::test_unit_finish( std::ostream& , test_unit const& tu, unsigned long )
+{
+
+    boost::ignore_unused( tu );
+    (static_cast <bool> (tu.p_id == list_path_to_root.back()) ? void (0) : __assert_fail ("tu.p_id == list_path_to_root.back()", "/usr/include/boost/test/impl/junit_log_formatter.ipp", 550, __extension__ __PRETTY_FUNCTION__));
+    list_path_to_root.pop_back();
+}
+
+void
+junit_log_formatter::test_unit_aborted( std::ostream& , test_unit const& tu )
+{
+    boost::ignore_unused( tu );
+    (static_cast <bool> (tu.p_id == list_path_to_root.back()) ? void (0) : __assert_fail ("tu.p_id == list_path_to_root.back()", "/usr/include/boost/test/impl/junit_log_formatter.ipp", 558, __extension__ __PRETTY_FUNCTION__));
+
+}
+
+
+
+void
+junit_log_formatter::test_unit_timed_out( std::ostream& , test_unit const& tu)
+{
+    if(tu.p_type == TUT_SUITE)
+    {
+
+
+        junit_impl::junit_log_helper& last_entry = get_current_log_entry();
+        junit_impl::junit_log_helper::assertion_entry entry;
+        entry.logentry_message = "test-suite time out";
+        entry.logentry_type = "execution timeout";
+        entry.log_entry = junit_impl::junit_log_helper::assertion_entry::log_entry_error;
+        entry.output = "the current suite exceeded the allocated execution time";
+        last_entry.assertion_entries.push_back(entry);
+    }
+}
+
+
+
+void
+junit_log_formatter::test_unit_skipped( std::ostream& , test_unit const& tu, const_string reason )
+{
+
+
+
+    junit_impl::junit_log_helper& v = map_tests[tu.p_id];
+    v.skipping_reason.assign(reason.begin(), reason.end());
+}
+
+
+
+void
+junit_log_formatter::log_exception_start( std::ostream& , log_checkpoint_data const& checkpoint_data, execution_exception const& ex )
+{
+    std::ostringstream o;
+    execution_exception::location const& loc = ex.where();
+
+    m_is_last_assertion_or_error = false;
+
+    junit_impl::junit_log_helper& last_entry = get_current_log_entry();
+
+    junit_impl::junit_log_helper::assertion_entry entry;
+
+    entry.logentry_message = "unexpected exception";
+    entry.log_entry = junit_impl::junit_log_helper::assertion_entry::log_entry_error;
+
+    switch(ex.code())
+    {
+    case execution_exception::cpp_exception_error:
+        entry.logentry_type = "uncaught exception";
+        break;
+    case execution_exception::timeout_error:
+        entry.logentry_type = "execution timeout";
+        break;
+    case execution_exception::user_error:
+        entry.logentry_type = "user, assert() or CRT error";
+        break;
+    case execution_exception::user_fatal_error:
+
+        entry.logentry_type = "user fatal error";
+        break;
+    case execution_exception::system_error:
+        entry.logentry_type = "system error";
+        break;
+    case execution_exception::system_fatal_error:
+        entry.logentry_type = "system fatal error";
+        break;
+    default:
+        entry.logentry_type = "no error";
+        break;
+    }
+
+    o << "UNCAUGHT EXCEPTION:" << std::endl;
+    if( !loc.m_function.is_empty() )
+        o << "- function: \"" << loc.m_function << "\"" << std::endl;
+
+    o << "- file: " << file_basename(loc.m_file_name) << std::endl
+      << "- line: " << loc.m_line_num << std::endl
+      << std::endl;
+
+    o << "\nEXCEPTION STACK TRACE: --------------\n" << ex.what()
+      << "\n-------------------------------------";
+
+    if( !checkpoint_data.m_file_name.is_empty() ) {
+        o << std::endl << std::endl
+          << "Last checkpoint:" << std::endl
+          << "- message: \"" << checkpoint_data.m_message << "\"" << std::endl
+          << "- file: " << file_basename(checkpoint_data.m_file_name) << std::endl
+          << "- line: " << checkpoint_data.m_line_num << std::endl
+        ;
+    }
+
+    entry.output = o.str();
+
+    last_entry.assertion_entries.push_back(entry);
+}
+
+
+
+void
+junit_log_formatter::log_exception_finish( std::ostream& )
+{
+
+    (static_cast <bool> (!get_current_log_entry().assertion_entries.back().sealed) ? void (0) : __assert_fail ("!get_current_log_entry().assertion_entries.back().sealed", "/usr/include/boost/test/impl/junit_log_formatter.ipp", 667, __extension__ __PRETTY_FUNCTION__));
+    get_current_log_entry().assertion_entries.back().sealed = true;
+}
+
+
+
+void
+junit_log_formatter::log_entry_start( std::ostream& , log_entry_data const& entry_data, log_entry_types let )
+{
+    junit_impl::junit_log_helper& last_entry = get_current_log_entry();
+    last_entry.skipping = false;
+    m_is_last_assertion_or_error = true;
+    switch(let)
+    {
+      case unit_test_log_formatter::BOOST_UTL_ET_INFO:
+      {
+        if(m_log_level_internal > log_successful_tests) {
+          last_entry.skipping = true;
+          break;
+        }
+        __attribute__((fallthrough));
+      }
+      case unit_test_log_formatter::BOOST_UTL_ET_MESSAGE:
+      {
+        if(m_log_level_internal > log_messages) {
+          last_entry.skipping = true;
+          break;
+        }
+        __attribute__((fallthrough));
+      }
+      case unit_test_log_formatter::BOOST_UTL_ET_WARNING:
+      {
+        if(m_log_level_internal > log_warnings) {
+          last_entry.skipping = true;
+          break;
+        }
+        std::ostringstream o;
+        junit_impl::junit_log_helper::assertion_entry entry;
+
+        entry.log_entry = junit_impl::junit_log_helper::assertion_entry::log_entry_info;
+        entry.logentry_message = "info";
+        entry.logentry_type = "message";
+
+        o << (let == unit_test_log_formatter::BOOST_UTL_ET_WARNING ?
+              "WARNING:" : (let == unit_test_log_formatter::BOOST_UTL_ET_MESSAGE ?
+                            "MESSAGE:" : "INFO:"))
+             << std::endl
+          << "- file   : " << file_basename(entry_data.m_file_name) << std::endl
+          << "- line   : " << entry_data.m_line_num << std::endl
+          << "- message: ";
+
+        entry.output += o.str();
+        last_entry.assertion_entries.push_back(entry);
+        break;
+      }
+      default:
+      case unit_test_log_formatter::BOOST_UTL_ET_ERROR:
+      case unit_test_log_formatter::BOOST_UTL_ET_FATAL_ERROR:
+      {
+        std::ostringstream o;
+        junit_impl::junit_log_helper::assertion_entry entry;
+        entry.log_entry = junit_impl::junit_log_helper::assertion_entry::log_entry_failure;
+        entry.logentry_message = "failure";
+        entry.logentry_type = (let == unit_test_log_formatter::BOOST_UTL_ET_ERROR ? "assertion error" : "fatal error");
+
+        o << "ASSERTION FAILURE:" << std::endl
+          << "- file   : " << file_basename(entry_data.m_file_name) << std::endl
+          << "- line   : " << entry_data.m_line_num << std::endl
+          << "- message: " ;
+
+        entry.output += o.str();
+        last_entry.assertion_entries.push_back(entry);
+        break;
+      }
+    }
+}
+
+
+
+void
+junit_log_formatter::log_entry_value( std::ostream& , const_string value )
+{
+    junit_impl::junit_log_helper& last_entry = get_current_log_entry();
+    if(last_entry.skipping)
+        return;
+
+    (static_cast <bool> (last_entry.assertion_entries.empty() || !last_entry.assertion_entries.back().sealed) ? void (0) : __assert_fail ("last_entry.assertion_entries.empty() || !last_entry.assertion_entries.back().sealed", "/usr/include/boost/test/impl/junit_log_formatter.ipp", 753, __extension__ __PRETTY_FUNCTION__));
+
+    if(!last_entry.assertion_entries.empty())
+    {
+        junit_impl::junit_log_helper::assertion_entry& log_entry = last_entry.assertion_entries.back();
+        log_entry.output += value;
+    }
+    else
+    {
+
+
+        last_entry.system_out.push_back(std::string(value.begin(), value.end()));
+    }
+}
+
+
+
+void
+junit_log_formatter::log_entry_finish( std::ostream& )
+{
+    junit_impl::junit_log_helper& last_entry = get_current_log_entry();
+    if(!last_entry.skipping)
+    {
+        (static_cast <bool> (last_entry.assertion_entries.empty() || !last_entry.assertion_entries.back().sealed) ? void (0) : __assert_fail ("last_entry.assertion_entries.empty() || !last_entry.assertion_entries.back().sealed", "/usr/include/boost/test/impl/junit_log_formatter.ipp", 776, __extension__ __PRETTY_FUNCTION__));
+
+        if(!last_entry.assertion_entries.empty()) {
+            junit_impl::junit_log_helper::assertion_entry& log_entry = last_entry.assertion_entries.back();
+            log_entry.output += "\n\n";
+            log_entry.sealed = true;
+        }
+        else {
+            last_entry.system_out.push_back("\n\n");
+        }
+    }
+
+    last_entry.skipping = false;
+}
+
+
+
+void
+junit_log_formatter::entry_context_start( std::ostream& , log_level )
+{
+    junit_impl::junit_log_helper& last_entry = get_current_log_entry();
+    if(last_entry.skipping)
+        return;
+
+    std::vector< junit_impl::junit_log_helper::assertion_entry > &v_failure_or_error = last_entry.assertion_entries;
+    (static_cast <bool> (!v_failure_or_error.back().sealed) ? void (0) : __assert_fail ("!v_failure_or_error.back().sealed", "/usr/include/boost/test/impl/junit_log_formatter.ipp", 801, __extension__ __PRETTY_FUNCTION__));
+
+    junit_impl::junit_log_helper::assertion_entry& last_log_entry = v_failure_or_error.back();
+    if(m_is_last_assertion_or_error)
+    {
+        last_log_entry.output += "\n- context:\n";
+    }
+    else
+    {
+        last_log_entry.output += "\n\nCONTEXT:\n";
+    }
+}
+
+
+
+void
+junit_log_formatter::entry_context_finish( std::ostream& , log_level )
+{
+
+    junit_impl::junit_log_helper& last_entry = get_current_log_entry();
+    if(last_entry.skipping)
+        return;
+    (static_cast <bool> (!get_current_log_entry().assertion_entries.back().sealed) ? void (0) : __assert_fail ("!get_current_log_entry().assertion_entries.back().sealed", "/usr/include/boost/test/impl/junit_log_formatter.ipp", 823, __extension__ __PRETTY_FUNCTION__));
+}
+
+
+
+void
+junit_log_formatter::log_entry_context( std::ostream& , log_level , const_string context_descr )
+{
+    junit_impl::junit_log_helper& last_entry = get_current_log_entry();
+    if(last_entry.skipping)
+        return;
+
+    (static_cast <bool> (!last_entry.assertion_entries.back().sealed) ? void (0) : __assert_fail ("!last_entry.assertion_entries.back().sealed", "/usr/include/boost/test/impl/junit_log_formatter.ipp", 835, __extension__ __PRETTY_FUNCTION__));
+    junit_impl::junit_log_helper::assertion_entry& last_log_entry = get_current_log_entry().assertion_entries.back();
+
+    last_log_entry.output +=
+        (m_is_last_assertion_or_error ? "  - '": "- '") + std::string(context_descr.begin(), context_descr.end()) + "'\n";
+}
+
+
+
+
+std::string
+junit_log_formatter::get_default_stream_description() const {
+    std::string name = framework::master_test_suite().p_name.value;
+
+    static const std::string to_replace[] = { " ", "\"", "/", "\\", ":"};
+    static const std::string replacement[] = { "_", "_" , "_", "_" , "_"};
+
+    name = unit_test::utils::replace_all_occurrences_of(
+        name,
+        to_replace, to_replace + sizeof(to_replace)/sizeof(to_replace[0]),
+        replacement, replacement + sizeof(replacement)/sizeof(replacement[0]));
+
+    std::ifstream check_init((name + ".xml").c_str());
+    if(!check_init)
+        return name + ".xml";
+
+    int index = 0;
+    for(; index < 100; index++) {
+      std::string candidate = name + "_" + utils::string_cast(index) + ".xml";
+      std::ifstream file(candidate.c_str());
+      if(!file)
+          return candidate;
+    }
+
+    return name + ".xml";
+}
+
+}
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 877 "/usr/include/boost/test/impl/junit_log_formatter.ipp" 2 3 4
+# 20 "/usr/include/boost/test/included/unit_test.hpp" 2 3 4
+# 1 "/usr/include/boost/test/impl/debug.ipp" 1 3 4
+# 16 "/usr/include/boost/test/impl/debug.ipp" 3 4
+#define BOOST_TEST_DEBUG_API_IPP_112006GER 
+
+
+
+
+
+# 1 "/usr/include/boost/test/debug.hpp" 1 3 4
+# 15 "/usr/include/boost/test/debug.hpp" 3 4
+#define BOOST_TEST_DEBUG_API_HPP_112006GER 
+
+
+
+
+
+
+# 1 "/usr/include/boost/function/function1.hpp" 1 3 4
+# 10 "/usr/include/boost/function/function1.hpp" 3 4
+#define BOOST_FUNCTION_NUM_ARGS 1
+# 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
+# 18 "/usr/include/boost/function/detail/maybe_include.hpp" 3 4
+#undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#define BOOST_FUNCTION_MAX_ARGS_DEFINED 1
+# 12 "/usr/include/boost/function/function1.hpp" 2 3 4
+#undef BOOST_FUNCTION_NUM_ARGS
+# 23 "/usr/include/boost/test/debug.hpp" 2 3 4
+
+
+
+
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 28 "/usr/include/boost/test/debug.hpp" 2 3 4
+
+
+
+namespace boost {
+
+namespace debug {
+# 54 "/usr/include/boost/test/debug.hpp" 3 4
+bool __attribute__((__visibility__("default"))) under_debugger();
+
+
+
+
+
+void __attribute__((__visibility__("default"))) debugger_break();
+
+
+
+
+
+struct dbg_startup_info {
+    long pid;
+    bool break_or_continue;
+    unit_test::const_string binary_path;
+    unit_test::const_string display;
+    unit_test::const_string init_done_lock;
+};
+
+
+typedef boost::function<void (dbg_startup_info const&)> dbg_starter;
+# 94 "/usr/include/boost/test/debug.hpp" 3 4
+std::string __attribute__((__visibility__("default"))) set_debugger( unit_test::const_string dbg_id, dbg_starter s = dbg_starter() );
+# 106 "/usr/include/boost/test/debug.hpp" 3 4
+bool __attribute__((__visibility__("default"))) attach_debugger( bool break_or_continue = true );
+# 118 "/usr/include/boost/test/debug.hpp" 3 4
+void __attribute__((__visibility__("default"))) detect_memory_leaks( bool on_off, unit_test::const_string report_file = unit_test::const_string() );
+# 129 "/usr/include/boost/test/debug.hpp" 3 4
+void __attribute__((__visibility__("default"))) break_memory_alloc( long mem_alloc_order_num );
+
+}
+
+
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 137 "/usr/include/boost/test/debug.hpp" 2 3 4
+# 23 "/usr/include/boost/test/impl/debug.ipp" 2 3 4
+# 1 "/usr/include/boost/test/debug_config.hpp" 1 3 4
+# 16 "/usr/include/boost/test/debug_config.hpp" 3 4
+#define BOOST_TEST_DEBUG_CONFIG_HPP_112006GER 
+# 24 "/usr/include/boost/test/impl/debug.ipp" 2 3 4
+# 50 "/usr/include/boost/test/impl/debug.ipp" 3 4
+#define BOOST_UNIX_BASED_DEBUG 
+
+
+
+
+
+
+# 1 "/usr/include/c++/10.2.0/cstring" 1 3 4
+# 39 "/usr/include/c++/10.2.0/cstring" 3 4
+       
+# 40 "/usr/include/c++/10.2.0/cstring" 3
+# 58 "/usr/include/boost/test/impl/debug.ipp" 2 3 4
+
+# 1 "/usr/include/c++/10.2.0/cstdio" 1 3 4
+# 39 "/usr/include/c++/10.2.0/cstdio" 3 4
+       
+# 40 "/usr/include/c++/10.2.0/cstdio" 3
+# 60 "/usr/include/boost/test/impl/debug.ipp" 2 3 4
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stdarg.h" 1 3 4
+# 31 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stdarg.h" 3 4
+#define _STDARG_H 
+#define _ANSI_STDARG_H_ 
+
+#undef __need___va_list
+# 47 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stdarg.h" 3 4
+#define va_start(v,l) __builtin_va_start(v,l)
+#define va_end(v) __builtin_va_end(v)
+#define va_arg(v,l) __builtin_va_arg(v,l)
+
+
+#define va_copy(d,s) __builtin_va_copy(d,s)
+
+#define __va_copy(d,s) __builtin_va_copy(d,s)
+# 105 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stdarg.h" 3 4
+#define _VA_LIST_ 
+
+
+#define _VA_LIST 
+
+
+
+
+
+#define _VA_LIST_T_H 
+
+
+#define __va_list__ 
+# 61 "/usr/include/boost/test/impl/debug.ipp" 2 3 4
+
+
+
+# 1 "/usr/include/signal.h" 1 3 4
+# 23 "/usr/include/signal.h" 3 4
+#define _SIGNAL_H 
+
+
+
+extern "C" {
+
+
+# 1 "/usr/include/bits/signum-generic.h" 1 3 4
+# 20 "/usr/include/bits/signum-generic.h" 3 4
+#define _BITS_SIGNUM_GENERIC_H 1
+
+
+
+
+
+
+
+#define SIG_ERR ((__sighandler_t) -1)
+#define SIG_DFL ((__sighandler_t) 0)
+#define SIG_IGN ((__sighandler_t) 1)
+
+
+#define SIG_HOLD ((__sighandler_t) 2)
+# 48 "/usr/include/bits/signum-generic.h" 3 4
+#define SIGINT 2
+#define SIGILL 4
+#define SIGABRT 6
+#define SIGFPE 8
+#define SIGSEGV 11
+#define SIGTERM 15
+
+
+#define SIGHUP 1
+#define SIGQUIT 3
+#define SIGTRAP 5
+#define SIGKILL 9
+#define SIGPIPE 13
+#define SIGALRM 14
+
+
+#define SIGIO SIGPOLL
+#define SIGIOT SIGABRT
+#define SIGCLD SIGCHLD
+# 76 "/usr/include/bits/signum-generic.h" 3 4
+# 1 "/usr/include/bits/signum-arch.h" 1 3 4
+# 20 "/usr/include/bits/signum-arch.h" 3 4
+#define _BITS_SIGNUM_ARCH_H 1
+# 29 "/usr/include/bits/signum-arch.h" 3 4
+#define SIGSTKFLT 16
+#define SIGPWR 30
+
+
+#define SIGBUS 7
+#define SIGSYS 31
+
+
+#define SIGURG 23
+#define SIGSTOP 19
+#define SIGTSTP 20
+#define SIGCONT 18
+#define SIGCHLD 17
+#define SIGTTIN 21
+#define SIGTTOU 22
+#define SIGPOLL 29
+#define SIGXFSZ 25
+#define SIGXCPU 24
+#define SIGVTALRM 26
+#define SIGPROF 27
+#define SIGUSR1 10
+#define SIGUSR2 12
+
+
+
+#define SIGWINCH 28
+
+
+#define SIGIO SIGPOLL
+#define SIGIOT SIGABRT
+#define SIGCLD SIGCHLD
+
+#define __SIGRTMIN 32
+#define __SIGRTMAX 64
+# 77 "/usr/include/bits/signum-generic.h" 2 3 4
+
+
+#define _NSIG (__SIGRTMAX + 1)
+# 31 "/usr/include/signal.h" 2 3 4
+
+# 1 "/usr/include/bits/types/sig_atomic_t.h" 1 3 4
+
+#define __sig_atomic_t_defined 1
+
+
+
+
+
+typedef __sig_atomic_t sig_atomic_t;
+# 33 "/usr/include/signal.h" 2 3 4
+# 57 "/usr/include/signal.h" 3 4
+# 1 "/usr/include/bits/types/siginfo_t.h" 1 3 4
+
+#define __siginfo_t_defined 1
+
+# 1 "/usr/include/bits/wordsize.h" 1 3 4
+
+
+
+#define __WORDSIZE 64
+
+
+
+
+
+
+
+#define __WORDSIZE_TIME64_COMPAT32 1
+
+#define __SYSCALL_WORDSIZE 64
+# 5 "/usr/include/bits/types/siginfo_t.h" 2 3 4
+
+# 1 "/usr/include/bits/types/__sigval_t.h" 1 3 4
+# 20 "/usr/include/bits/types/__sigval_t.h" 3 4
+#define ____sigval_t_defined 
+
+
+
+union sigval
+{
+  int sival_int;
+  void *sival_ptr;
+};
+
+typedef union sigval __sigval_t;
+# 7 "/usr/include/bits/types/siginfo_t.h" 2 3 4
+
+#define __SI_MAX_SIZE 128
+
+#define __SI_PAD_SIZE ((__SI_MAX_SIZE / sizeof (int)) - 4)
+
+
+
+
+
+# 1 "/usr/include/bits/siginfo-arch.h" 1 3 4
+
+
+#define _BITS_SIGINFO_ARCH_H 1
+# 17 "/usr/include/bits/types/siginfo_t.h" 2 3 4
+
+#define __SI_ALIGNMENT 
+
+
+#define __SI_BAND_TYPE long int
+
+
+#define __SI_CLOCK_T __clock_t
+
+
+#define __SI_ERRNO_THEN_CODE 1
+
+
+#define __SI_HAVE_SIGSYS 1
+
+
+#define __SI_SIGFAULT_ADDL 
+
+
+typedef struct
+  {
+    int si_signo;
+
+    int si_errno;
+
+    int si_code;
+
+
+
+
+
+    int __pad0;
+
+
+    union
+      {
+ int _pad[((128 / sizeof (int)) - 4)];
+
+
+ struct
+   {
+     __pid_t si_pid;
+     __uid_t si_uid;
+   } _kill;
+
+
+ struct
+   {
+     int si_tid;
+     int si_overrun;
+     __sigval_t si_sigval;
+   } _timer;
+
+
+ struct
+   {
+     __pid_t si_pid;
+     __uid_t si_uid;
+     __sigval_t si_sigval;
+   } _rt;
+
+
+ struct
+   {
+     __pid_t si_pid;
+     __uid_t si_uid;
+     int si_status;
+     __clock_t si_utime;
+     __clock_t si_stime;
+   } _sigchld;
+
+
+ struct
+   {
+     void *si_addr;
+    
+     short int si_addr_lsb;
+     union
+       {
+
+  struct
+    {
+      void *_lower;
+      void *_upper;
+    } _addr_bnd;
+
+  __uint32_t _pkey;
+       } _bounds;
+   } _sigfault;
+
+
+ struct
+   {
+     long int si_band;
+     int si_fd;
+   } _sigpoll;
+
+
+
+ struct
+   {
+     void *_call_addr;
+     int _syscall;
+     unsigned int _arch;
+   } _sigsys;
+
+      } _sifields;
+  } siginfo_t ;
+
+
+
+#define si_pid _sifields._kill.si_pid
+#define si_uid _sifields._kill.si_uid
+#define si_timerid _sifields._timer.si_tid
+#define si_overrun _sifields._timer.si_overrun
+#define si_status _sifields._sigchld.si_status
+#define si_utime _sifields._sigchld.si_utime
+#define si_stime _sifields._sigchld.si_stime
+#define si_value _sifields._rt.si_sigval
+#define si_int _sifields._rt.si_sigval.sival_int
+#define si_ptr _sifields._rt.si_sigval.sival_ptr
+#define si_addr _sifields._sigfault.si_addr
+#define si_addr_lsb _sifields._sigfault.si_addr_lsb
+#define si_lower _sifields._sigfault._bounds._addr_bnd._lower
+#define si_upper _sifields._sigfault._bounds._addr_bnd._upper
+#define si_pkey _sifields._sigfault._bounds._pkey
+#define si_band _sifields._sigpoll.si_band
+#define si_fd _sifields._sigpoll.si_fd
+
+#define si_call_addr _sifields._sigsys._call_addr
+#define si_syscall _sifields._sigsys._syscall
+#define si_arch _sifields._sigsys._arch
+# 58 "/usr/include/signal.h" 2 3 4
+# 1 "/usr/include/bits/siginfo-consts.h" 1 3 4
+# 20 "/usr/include/bits/siginfo-consts.h" 3 4
+#define _BITS_SIGINFO_CONSTS_H 1
+# 30 "/usr/include/bits/siginfo-consts.h" 3 4
+#define __SI_ASYNCIO_AFTER_SIGIO 1
+
+
+
+
+enum
+{
+  SI_ASYNCNL = -60,
+  SI_DETHREAD = -7,
+
+  SI_TKILL,
+  SI_SIGIO,
+
+  SI_ASYNCIO,
+  SI_MESGQ,
+  SI_TIMER,
+
+
+
+
+
+  SI_QUEUE,
+  SI_USER,
+  SI_KERNEL = 0x80
+
+#define SI_ASYNCNL SI_ASYNCNL
+#define SI_DETHREAD SI_DETHREAD
+#define SI_TKILL SI_TKILL
+#define SI_SIGIO SI_SIGIO
+#define SI_ASYNCIO SI_ASYNCIO
+#define SI_MESGQ SI_MESGQ
+#define SI_TIMER SI_TIMER
+#define SI_ASYNCIO SI_ASYNCIO
+#define SI_QUEUE SI_QUEUE
+#define SI_USER SI_USER
+#define SI_KERNEL SI_KERNEL
+};
+
+
+
+
+enum
+{
+  ILL_ILLOPC = 1,
+#define ILL_ILLOPC ILL_ILLOPC
+  ILL_ILLOPN,
+#define ILL_ILLOPN ILL_ILLOPN
+  ILL_ILLADR,
+#define ILL_ILLADR ILL_ILLADR
+  ILL_ILLTRP,
+#define ILL_ILLTRP ILL_ILLTRP
+  ILL_PRVOPC,
+#define ILL_PRVOPC ILL_PRVOPC
+  ILL_PRVREG,
+#define ILL_PRVREG ILL_PRVREG
+  ILL_COPROC,
+#define ILL_COPROC ILL_COPROC
+  ILL_BADSTK,
+#define ILL_BADSTK ILL_BADSTK
+  ILL_BADIADDR
+#define ILL_BADIADDR ILL_BADIADDR
+};
+
+
+enum
+{
+  FPE_INTDIV = 1,
+#define FPE_INTDIV FPE_INTDIV
+  FPE_INTOVF,
+#define FPE_INTOVF FPE_INTOVF
+  FPE_FLTDIV,
+#define FPE_FLTDIV FPE_FLTDIV
+  FPE_FLTOVF,
+#define FPE_FLTOVF FPE_FLTOVF
+  FPE_FLTUND,
+#define FPE_FLTUND FPE_FLTUND
+  FPE_FLTRES,
+#define FPE_FLTRES FPE_FLTRES
+  FPE_FLTINV,
+#define FPE_FLTINV FPE_FLTINV
+  FPE_FLTSUB,
+#define FPE_FLTSUB FPE_FLTSUB
+  FPE_FLTUNK = 14,
+#define FPE_FLTUNK FPE_FLTUNK
+  FPE_CONDTRAP
+#define FPE_CONDTRAP FPE_CONDTRAP
+};
+
+
+enum
+{
+  SEGV_MAPERR = 1,
+#define SEGV_MAPERR SEGV_MAPERR
+  SEGV_ACCERR,
+#define SEGV_ACCERR SEGV_ACCERR
+  SEGV_BNDERR,
+#define SEGV_BNDERR SEGV_BNDERR
+  SEGV_PKUERR,
+#define SEGV_PKUERR SEGV_PKUERR
+  SEGV_ACCADI,
+#define SEGV_ACCADI SEGV_ACCADI
+  SEGV_ADIDERR,
+#define SEGV_ADIDERR SEGV_ADIDERR
+  SEGV_ADIPERR
+#define SEGV_ADIPERR SEGV_ADIPERR
+};
+
+
+enum
+{
+  BUS_ADRALN = 1,
+#define BUS_ADRALN BUS_ADRALN
+  BUS_ADRERR,
+#define BUS_ADRERR BUS_ADRERR
+  BUS_OBJERR,
+#define BUS_OBJERR BUS_OBJERR
+  BUS_MCEERR_AR,
+#define BUS_MCEERR_AR BUS_MCEERR_AR
+  BUS_MCEERR_AO
+#define BUS_MCEERR_AO BUS_MCEERR_AO
+};
+
+
+
+
+enum
+{
+  TRAP_BRKPT = 1,
+#define TRAP_BRKPT TRAP_BRKPT
+  TRAP_TRACE,
+#define TRAP_TRACE TRAP_TRACE
+  TRAP_BRANCH,
+#define TRAP_BRANCH TRAP_BRANCH
+  TRAP_HWBKPT,
+#define TRAP_HWBKPT TRAP_HWBKPT
+  TRAP_UNK
+#define TRAP_UNK TRAP_UNK
+};
+
+
+
+
+enum
+{
+  CLD_EXITED = 1,
+#define CLD_EXITED CLD_EXITED
+  CLD_KILLED,
+#define CLD_KILLED CLD_KILLED
+  CLD_DUMPED,
+#define CLD_DUMPED CLD_DUMPED
+  CLD_TRAPPED,
+#define CLD_TRAPPED CLD_TRAPPED
+  CLD_STOPPED,
+#define CLD_STOPPED CLD_STOPPED
+  CLD_CONTINUED
+#define CLD_CONTINUED CLD_CONTINUED
+};
+
+
+enum
+{
+  POLL_IN = 1,
+#define POLL_IN POLL_IN
+  POLL_OUT,
+#define POLL_OUT POLL_OUT
+  POLL_MSG,
+#define POLL_MSG POLL_MSG
+  POLL_ERR,
+#define POLL_ERR POLL_ERR
+  POLL_PRI,
+#define POLL_PRI POLL_PRI
+  POLL_HUP
+#define POLL_HUP POLL_HUP
+};
+
+
+
+
+
+# 1 "/usr/include/bits/siginfo-consts-arch.h" 1 3 4
+
+
+#define _BITS_SIGINFO_CONSTS_ARCH_H 1
+# 210 "/usr/include/bits/siginfo-consts.h" 2 3 4
+# 59 "/usr/include/signal.h" 2 3 4
+
+
+
+# 1 "/usr/include/bits/types/sigval_t.h" 1 3 4
+
+#define __sigval_t_defined 
+# 16 "/usr/include/bits/types/sigval_t.h" 3 4
+typedef __sigval_t sigval_t;
+# 63 "/usr/include/signal.h" 2 3 4
+
+
+
+# 1 "/usr/include/bits/types/sigevent_t.h" 1 3 4
+
+#define __sigevent_t_defined 1
+
+# 1 "/usr/include/bits/wordsize.h" 1 3 4
+
+
+
+#define __WORDSIZE 64
+
+
+
+
+
+
+
+#define __WORDSIZE_TIME64_COMPAT32 1
+
+#define __SYSCALL_WORDSIZE 64
+# 5 "/usr/include/bits/types/sigevent_t.h" 2 3 4
+
+
+
+#define __SIGEV_MAX_SIZE 64
+
+#define __SIGEV_PAD_SIZE ((__SIGEV_MAX_SIZE / sizeof (int)) - 4)
+# 22 "/usr/include/bits/types/sigevent_t.h" 3 4
+typedef struct sigevent
+  {
+    __sigval_t sigev_value;
+    int sigev_signo;
+    int sigev_notify;
+
+    union
+      {
+ int _pad[((64 / sizeof (int)) - 4)];
+
+
+
+ __pid_t _tid;
+
+ struct
+   {
+     void (*_function) (__sigval_t);
+     pthread_attr_t *_attribute;
+   } _sigev_thread;
+      } _sigev_un;
+  } sigevent_t;
+
+
+#define sigev_notify_function _sigev_un._sigev_thread._function
+#define sigev_notify_attributes _sigev_un._sigev_thread._attribute
+# 67 "/usr/include/signal.h" 2 3 4
+# 1 "/usr/include/bits/sigevent-consts.h" 1 3 4
+# 20 "/usr/include/bits/sigevent-consts.h" 3 4
+#define _BITS_SIGEVENT_CONSTS_H 1
+
+
+
+
+
+
+enum
+{
+  SIGEV_SIGNAL = 0,
+#define SIGEV_SIGNAL SIGEV_SIGNAL
+  SIGEV_NONE,
+#define SIGEV_NONE SIGEV_NONE
+  SIGEV_THREAD,
+#define SIGEV_THREAD SIGEV_THREAD
+
+  SIGEV_THREAD_ID = 4
+
+#define SIGEV_THREAD_ID SIGEV_THREAD_ID
+};
+# 68 "/usr/include/signal.h" 2 3 4
+
+
+
+
+typedef void (*__sighandler_t) (int);
+
+
+
+
+extern __sighandler_t __sysv_signal (int __sig, __sighandler_t __handler)
+     throw ();
+
+extern __sighandler_t sysv_signal (int __sig, __sighandler_t __handler)
+     throw ();
+
+
+
+
+
+
+extern __sighandler_t signal (int __sig, __sighandler_t __handler)
+     throw ();
+# 112 "/usr/include/signal.h" 3 4
+extern int kill (__pid_t __pid, int __sig) throw ();
+
+
+
+
+
+
+extern int killpg (__pid_t __pgrp, int __sig) throw ();
+
+
+
+extern int raise (int __sig) throw ();
+
+
+
+extern __sighandler_t ssignal (int __sig, __sighandler_t __handler)
+     throw ();
+extern int gsignal (int __sig) throw ();
+
+
+
+
+extern void psignal (int __sig, const char *__s);
+
+
+extern void psiginfo (const siginfo_t *__pinfo, const char *__s);
+# 151 "/usr/include/signal.h" 3 4
+extern int sigpause (int __sig) __asm__ ("__xpg_sigpause")
+  __attribute__ ((__deprecated__ ("Use the sigsuspend function instead")));
+# 168 "/usr/include/signal.h" 3 4
+#define sigmask(sig) __glibc_macro_warning ("sigmask is deprecated") ((int)(1u << ((sig) - 1)))
+
+
+
+
+extern int sigblock (int __mask) throw () __attribute__ ((__deprecated__));
+
+
+extern int sigsetmask (int __mask) throw () __attribute__ ((__deprecated__));
+
+
+extern int siggetmask (void) throw () __attribute__ ((__deprecated__));
+
+
+
+
+#define NSIG _NSIG
+
+
+
+typedef __sighandler_t sighandler_t;
+
+
+
+
+typedef __sighandler_t sig_t;
+
+
+
+
+
+extern int sigemptyset (sigset_t *__set) throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int sigfillset (sigset_t *__set) throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int sigaddset (sigset_t *__set, int __signo) throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int sigdelset (sigset_t *__set, int __signo) throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int sigismember (const sigset_t *__set, int __signo)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int sigisemptyset (const sigset_t *__set) throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int sigandset (sigset_t *__set, const sigset_t *__left,
+        const sigset_t *__right) throw () __attribute__ ((__nonnull__ (1, 2, 3)));
+
+
+extern int sigorset (sigset_t *__set, const sigset_t *__left,
+       const sigset_t *__right) throw () __attribute__ ((__nonnull__ (1, 2, 3)));
+
+
+
+
+# 1 "/usr/include/bits/sigaction.h" 1 3 4
+# 20 "/usr/include/bits/sigaction.h" 3 4
+#define _BITS_SIGACTION_H 1
+
+
+
+
+
+
+struct sigaction
+  {
+
+
+    union
+      {
+
+ __sighandler_t sa_handler;
+
+ void (*sa_sigaction) (int, siginfo_t *, void *);
+      }
+    __sigaction_handler;
+#define sa_handler __sigaction_handler.sa_handler
+#define sa_sigaction __sigaction_handler.sa_sigaction
+
+
+
+
+
+    __sigset_t sa_mask;
+
+
+    int sa_flags;
+
+
+    void (*sa_restorer) (void);
+  };
+
+
+#define SA_NOCLDSTOP 1
+#define SA_NOCLDWAIT 2
+#define SA_SIGINFO 4
+
+
+#define SA_ONSTACK 0x08000000
+
+
+#define SA_RESTART 0x10000000
+#define SA_NODEFER 0x40000000
+
+#define SA_RESETHAND 0x80000000
+
+
+#define SA_INTERRUPT 0x20000000
+
+
+#define SA_NOMASK SA_NODEFER
+#define SA_ONESHOT SA_RESETHAND
+#define SA_STACK SA_ONSTACK
+
+
+
+#define SIG_BLOCK 0
+#define SIG_UNBLOCK 1
+#define SIG_SETMASK 2
+# 230 "/usr/include/signal.h" 2 3 4
+
+
+extern int sigprocmask (int __how, const sigset_t *__restrict __set,
+   sigset_t *__restrict __oset) throw ();
+
+
+
+
+
+
+extern int sigsuspend (const sigset_t *__set) __attribute__ ((__nonnull__ (1)));
+
+
+extern int sigaction (int __sig, const struct sigaction *__restrict __act,
+        struct sigaction *__restrict __oact) throw ();
+
+
+extern int sigpending (sigset_t *__set) throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+
+extern int sigwait (const sigset_t *__restrict __set, int *__restrict __sig)
+     __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+
+
+
+extern int sigwaitinfo (const sigset_t *__restrict __set,
+   siginfo_t *__restrict __info) __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+extern int sigtimedwait (const sigset_t *__restrict __set,
+    siginfo_t *__restrict __info,
+    const struct timespec *__restrict __timeout)
+     __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int sigqueue (__pid_t __pid, int __sig, const union sigval __val)
+     throw ();
+
+
+
+
+
+
+
+# 1 "/usr/include/bits/sigcontext.h" 1 3 4
+# 19 "/usr/include/bits/sigcontext.h" 3 4
+#define _BITS_SIGCONTEXT_H 1
+
+
+
+
+
+
+
+#define FP_XSTATE_MAGIC1 0x46505853U
+#define FP_XSTATE_MAGIC2 0x46505845U
+#define FP_XSTATE_MAGIC2_SIZE sizeof (FP_XSTATE_MAGIC2)
+
+struct _fpx_sw_bytes
+{
+  __uint32_t magic1;
+  __uint32_t extended_size;
+  __uint64_t xstate_bv;
+  __uint32_t xstate_size;
+  __uint32_t __glibc_reserved1[7];
+};
+
+struct _fpreg
+{
+  unsigned short significand[4];
+  unsigned short exponent;
+};
+
+struct _fpxreg
+{
+  unsigned short significand[4];
+  unsigned short exponent;
+  unsigned short __glibc_reserved1[3];
+};
+
+struct _xmmreg
+{
+  __uint32_t element[4];
+};
+# 123 "/usr/include/bits/sigcontext.h" 3 4
+struct _fpstate
+{
+
+  __uint16_t cwd;
+  __uint16_t swd;
+  __uint16_t ftw;
+  __uint16_t fop;
+  __uint64_t rip;
+  __uint64_t rdp;
+  __uint32_t mxcsr;
+  __uint32_t mxcr_mask;
+  struct _fpxreg _st[8];
+  struct _xmmreg _xmm[16];
+  __uint32_t __glibc_reserved1[24];
+};
+
+struct sigcontext
+{
+  __uint64_t r8;
+  __uint64_t r9;
+  __uint64_t r10;
+  __uint64_t r11;
+  __uint64_t r12;
+  __uint64_t r13;
+  __uint64_t r14;
+  __uint64_t r15;
+  __uint64_t rdi;
+  __uint64_t rsi;
+  __uint64_t rbp;
+  __uint64_t rbx;
+  __uint64_t rdx;
+  __uint64_t rax;
+  __uint64_t rcx;
+  __uint64_t rsp;
+  __uint64_t rip;
+  __uint64_t eflags;
+  unsigned short cs;
+  unsigned short gs;
+  unsigned short fs;
+  unsigned short __pad0;
+  __uint64_t err;
+  __uint64_t trapno;
+  __uint64_t oldmask;
+  __uint64_t cr2;
+  __extension__ union
+    {
+      struct _fpstate * fpstate;
+      __uint64_t __fpstate_word;
+    };
+  __uint64_t __reserved1 [8];
+};
+
+
+
+struct _xsave_hdr
+{
+  __uint64_t xstate_bv;
+  __uint64_t __glibc_reserved1[2];
+  __uint64_t __glibc_reserved2[5];
+};
+
+struct _ymmh_state
+{
+  __uint32_t ymmh_space[64];
+};
+
+struct _xstate
+{
+  struct _fpstate fpstate;
+  struct _xsave_hdr xstate_hdr;
+  struct _ymmh_state ymmh;
+};
+# 289 "/usr/include/signal.h" 2 3 4
+
+
+extern int sigreturn (struct sigcontext *__scp) throw ();
+
+
+
+
+
+#define __need_size_t 
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 1 3 4
+# 155 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef __need_ptrdiff_t
+# 231 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef __need_size_t
+# 340 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef __need_wchar_t
+# 390 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef NULL
+
+#define NULL __null
+# 401 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef __need_NULL
+
+
+
+
+#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
+# 299 "/usr/include/signal.h" 2 3 4
+
+# 1 "/usr/include/bits/types/stack_t.h" 1 3 4
+# 20 "/usr/include/bits/types/stack_t.h" 3 4
+#define __stack_t_defined 1
+
+#define __need_size_t 
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 1 3 4
+# 155 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef __need_ptrdiff_t
+# 231 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef __need_size_t
+# 340 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef __need_wchar_t
+# 390 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef NULL
+
+#define NULL __null
+# 401 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef __need_NULL
+
+
+
+
+#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
+# 24 "/usr/include/bits/types/stack_t.h" 2 3 4
+
+
+typedef struct
+  {
+    void *ss_sp;
+    int ss_flags;
+    size_t ss_size;
+  } stack_t;
+# 301 "/usr/include/signal.h" 2 3 4
+
+
+# 1 "/usr/include/sys/ucontext.h" 1 3 4
+# 19 "/usr/include/sys/ucontext.h" 3 4
+#define _SYS_UCONTEXT_H 1
+# 29 "/usr/include/sys/ucontext.h" 3 4
+#define __ctx(fld) fld
+
+
+
+
+
+
+
+__extension__ typedef long long int greg_t;
+
+
+#define __NGREG 23
+
+#define NGREG __NGREG
+
+
+
+typedef greg_t gregset_t[23];
+
+
+
+enum
+{
+  REG_R8 = 0,
+#define REG_R8 REG_R8
+  REG_R9,
+#define REG_R9 REG_R9
+  REG_R10,
+#define REG_R10 REG_R10
+  REG_R11,
+#define REG_R11 REG_R11
+  REG_R12,
+#define REG_R12 REG_R12
+  REG_R13,
+#define REG_R13 REG_R13
+  REG_R14,
+#define REG_R14 REG_R14
+  REG_R15,
+#define REG_R15 REG_R15
+  REG_RDI,
+#define REG_RDI REG_RDI
+  REG_RSI,
+#define REG_RSI REG_RSI
+  REG_RBP,
+#define REG_RBP REG_RBP
+  REG_RBX,
+#define REG_RBX REG_RBX
+  REG_RDX,
+#define REG_RDX REG_RDX
+  REG_RAX,
+#define REG_RAX REG_RAX
+  REG_RCX,
+#define REG_RCX REG_RCX
+  REG_RSP,
+#define REG_RSP REG_RSP
+  REG_RIP,
+#define REG_RIP REG_RIP
+  REG_EFL,
+#define REG_EFL REG_EFL
+  REG_CSGSFS,
+#define REG_CSGSFS REG_CSGSFS
+  REG_ERR,
+#define REG_ERR REG_ERR
+  REG_TRAPNO,
+#define REG_TRAPNO REG_TRAPNO
+  REG_OLDMASK,
+#define REG_OLDMASK REG_OLDMASK
+  REG_CR2
+#define REG_CR2 REG_CR2
+};
+
+
+struct _libc_fpxreg
+{
+  unsigned short int significand[4];
+  unsigned short int exponent;
+  unsigned short int __glibc_reserved1[3];
+};
+
+struct _libc_xmmreg
+{
+  __uint32_t element[4];
+};
+
+struct _libc_fpstate
+{
+
+  __uint16_t cwd;
+  __uint16_t swd;
+  __uint16_t ftw;
+  __uint16_t fop;
+  __uint64_t rip;
+  __uint64_t rdp;
+  __uint32_t mxcsr;
+  __uint32_t mxcr_mask;
+  struct _libc_fpxreg _st[8];
+  struct _libc_xmmreg _xmm[16];
+  __uint32_t __glibc_reserved1[24];
+};
+
+
+typedef struct _libc_fpstate *fpregset_t;
+
+
+typedef struct
+  {
+    gregset_t gregs;
+
+    fpregset_t fpregs;
+    __extension__ unsigned long long __reserved1 [8];
+} mcontext_t;
+
+
+typedef struct ucontext_t
+  {
+    unsigned long int uc_flags;
+    struct ucontext_t *uc_link;
+    stack_t uc_stack;
+    mcontext_t uc_mcontext;
+    sigset_t uc_sigmask;
+    struct _libc_fpstate __fpregs_mem;
+    __extension__ unsigned long long int __ssp[4];
+  } ucontext_t;
+# 260 "/usr/include/sys/ucontext.h" 3 4
+#undef __ctx
+# 304 "/usr/include/signal.h" 2 3 4
+
+
+
+
+
+
+
+extern int siginterrupt (int __sig, int __interrupt) throw ()
+  __attribute__ ((__deprecated__ ("Use sigaction with SA_RESTART instead")));
+
+# 1 "/usr/include/bits/sigstack.h" 1 3 4
+# 20 "/usr/include/bits/sigstack.h" 3 4
+#define _BITS_SIGSTACK_H 1
+
+
+
+
+
+
+#define MINSIGSTKSZ 2048
+
+
+#define SIGSTKSZ 8192
+# 315 "/usr/include/signal.h" 2 3 4
+# 1 "/usr/include/bits/ss_flags.h" 1 3 4
+# 20 "/usr/include/bits/ss_flags.h" 3 4
+#define _BITS_SS_FLAGS_H 1
+
+
+
+
+
+
+enum
+{
+  SS_ONSTACK = 1,
+#define SS_ONSTACK SS_ONSTACK
+  SS_DISABLE
+#define SS_DISABLE SS_DISABLE
+};
+# 316 "/usr/include/signal.h" 2 3 4
+
+
+
+extern int sigaltstack (const stack_t *__restrict __ss,
+   stack_t *__restrict __oss) throw ();
+
+
+
+
+# 1 "/usr/include/bits/types/struct_sigstack.h" 1 3 4
+# 20 "/usr/include/bits/types/struct_sigstack.h" 3 4
+#define __sigstack_defined 1
+
+
+struct sigstack
+  {
+    void *ss_sp;
+    int ss_onstack;
+  };
+# 326 "/usr/include/signal.h" 2 3 4
+
+
+
+
+
+
+
+extern int sigstack (struct sigstack *__ss, struct sigstack *__oss)
+     throw () __attribute__ ((__deprecated__));
+
+
+
+
+
+
+extern int sighold (int __sig) throw ()
+  __attribute__ ((__deprecated__ ("Use the sigprocmask function instead")));
+
+
+extern int sigrelse (int __sig) throw ()
+  __attribute__ ((__deprecated__ ("Use the sigprocmask function instead")));
+
+
+extern int sigignore (int __sig) throw ()
+  __attribute__ ((__deprecated__ ("Use the signal function instead")));
+
+
+extern __sighandler_t sigset (int __sig, __sighandler_t __disp) throw ()
+  __attribute__ ((__deprecated__ ("Use the signal and sigprocmask functions instead")))
+                                                        ;
+
+
+
+
+
+
+# 1 "/usr/include/bits/sigthread.h" 1 3 4
+# 20 "/usr/include/bits/sigthread.h" 3 4
+#define _BITS_SIGTHREAD_H 1
+# 31 "/usr/include/bits/sigthread.h" 3 4
+extern int pthread_sigmask (int __how,
+       const __sigset_t *__restrict __newmask,
+       __sigset_t *__restrict __oldmask)throw ();
+
+
+extern int pthread_kill (pthread_t __threadid, int __signo) throw ();
+
+
+
+extern int pthread_sigqueue (pthread_t __threadid, int __signo,
+        const union sigval __value) throw ();
+# 363 "/usr/include/signal.h" 2 3 4
+
+
+
+
+
+
+extern int __libc_current_sigrtmin (void) throw ();
+
+extern int __libc_current_sigrtmax (void) throw ();
+
+#define SIGRTMIN (__libc_current_sigrtmin ())
+#define SIGRTMAX (__libc_current_sigrtmax ())
+
+
+# 1 "/usr/include/bits/signal_ext.h" 1 3 4
+# 29 "/usr/include/bits/signal_ext.h" 3 4
+extern int tgkill (__pid_t __tgid, __pid_t __tid, int __signal);
+# 378 "/usr/include/signal.h" 2 3 4
+
+}
+# 65 "/usr/include/boost/test/impl/debug.ipp" 2 3 4
+# 1 "/usr/include/fcntl.h" 1 3 4
+# 23 "/usr/include/fcntl.h" 3 4
+#define _FCNTL_H 1
+
+
+
+
+extern "C" {
+
+
+
+
+
+
+# 1 "/usr/include/bits/fcntl.h" 1 3 4
+# 24 "/usr/include/bits/fcntl.h" 3 4
+#define __O_LARGEFILE 0
+
+
+
+
+#define F_GETLK64 5
+#define F_SETLK64 6
+#define F_SETLKW64 7
+
+
+
+struct flock
+  {
+    short int l_type;
+    short int l_whence;
+
+    __off_t l_start;
+    __off_t l_len;
+
+
+
+
+    __pid_t l_pid;
+  };
+
+
+struct flock64
+  {
+    short int l_type;
+    short int l_whence;
+    __off64_t l_start;
+    __off64_t l_len;
+    __pid_t l_pid;
+  };
+
+
+
+# 1 "/usr/include/bits/fcntl-linux.h" 1 3 4
+# 38 "/usr/include/bits/fcntl-linux.h" 3 4
+# 1 "/usr/include/bits/types/struct_iovec.h" 1 3 4
+# 20 "/usr/include/bits/types/struct_iovec.h" 3 4
+#define __iovec_defined 1
+
+#define __need_size_t 
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 1 3 4
+# 155 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef __need_ptrdiff_t
+# 231 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef __need_size_t
+# 340 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef __need_wchar_t
+# 390 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef NULL
+
+#define NULL __null
+# 401 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+#undef __need_NULL
+
+
+
+
+#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
+# 24 "/usr/include/bits/types/struct_iovec.h" 2 3 4
+
+
+struct iovec
+  {
+    void *iov_base;
+    size_t iov_len;
+  };
+# 39 "/usr/include/bits/fcntl-linux.h" 2 3 4
+
+
+
+#define O_ACCMODE 0003
+#define O_RDONLY 00
+#define O_WRONLY 01
+#define O_RDWR 02
+
+#define O_CREAT 0100
+
+
+#define O_EXCL 0200
+
+
+#define O_NOCTTY 0400
+
+
+#define O_TRUNC 01000
+
+
+#define O_APPEND 02000
+
+
+#define O_NONBLOCK 04000
+
+
+#define O_NDELAY O_NONBLOCK
+
+
+#define O_SYNC 04010000
+
+#define O_FSYNC O_SYNC
+
+#define O_ASYNC 020000
+
+
+
+
+
+
+#define __O_DIRECTORY 0200000
+
+
+#define __O_NOFOLLOW 0400000
+
+
+#define __O_CLOEXEC 02000000
+
+
+#define __O_DIRECT 040000
+
+
+#define __O_NOATIME 01000000
+
+
+#define __O_PATH 010000000
+
+
+#define __O_DSYNC 010000
+
+
+#define __O_TMPFILE (020000000 | __O_DIRECTORY)
+
+
+
+
+#define F_GETLK 5
+#define F_SETLK 6
+#define F_SETLKW 7
+# 132 "/usr/include/bits/fcntl-linux.h" 3 4
+#define F_OFD_GETLK 36
+#define F_OFD_SETLK 37
+#define F_OFD_SETLKW 38
+
+
+
+#define O_LARGEFILE __O_LARGEFILE
+
+
+
+#define O_DIRECTORY __O_DIRECTORY
+#define O_NOFOLLOW __O_NOFOLLOW
+#define O_CLOEXEC __O_CLOEXEC
+
+
+
+#define O_DIRECT __O_DIRECT
+#define O_NOATIME __O_NOATIME
+#define O_PATH __O_PATH
+#define O_TMPFILE __O_TMPFILE
+
+
+
+
+
+
+#define O_DSYNC __O_DSYNC
+
+
+
+#define O_RSYNC O_SYNC
+
+
+
+
+#define F_DUPFD 0
+#define F_GETFD 1
+#define F_SETFD 2
+#define F_GETFL 3
+#define F_SETFL 4
+
+
+#define __F_SETOWN 8
+#define __F_GETOWN 9
+
+
+
+#define F_SETOWN __F_SETOWN
+#define F_GETOWN __F_GETOWN
+
+
+
+#define __F_SETSIG 10
+#define __F_GETSIG 11
+
+
+#define __F_SETOWN_EX 15
+#define __F_GETOWN_EX 16
+
+
+
+#define F_SETSIG __F_SETSIG
+#define F_GETSIG __F_GETSIG
+#define F_SETOWN_EX __F_SETOWN_EX
+#define F_GETOWN_EX __F_GETOWN_EX
+
+
+
+#define F_SETLEASE 1024
+#define F_GETLEASE 1025
+#define F_NOTIFY 1026
+#define F_SETPIPE_SZ 1031
+#define F_GETPIPE_SZ 1032
+#define F_ADD_SEALS 1033
+#define F_GET_SEALS 1034
+
+#define F_GET_RW_HINT 1035
+#define F_SET_RW_HINT 1036
+#define F_GET_FILE_RW_HINT 1037
+#define F_SET_FILE_RW_HINT 1038
+
+
+#define F_DUPFD_CLOEXEC 1030
+
+
+
+
+#define FD_CLOEXEC 1
+
+
+
+#define F_RDLCK 0
+#define F_WRLCK 1
+#define F_UNLCK 2
+
+
+
+
+
+#define F_EXLCK 4
+#define F_SHLCK 8
+
+
+
+
+#define LOCK_SH 1
+#define LOCK_EX 2
+#define LOCK_NB 4
+
+#define LOCK_UN 8
+
+
+
+#define LOCK_MAND 32
+#define LOCK_READ 64
+#define LOCK_WRITE 128
+#define LOCK_RW 192
+
+
+
+
+#define DN_ACCESS 0x00000001
+#define DN_MODIFY 0x00000002
+#define DN_CREATE 0x00000004
+#define DN_DELETE 0x00000008
+#define DN_RENAME 0x00000010
+#define DN_ATTRIB 0x00000020
+#define DN_MULTISHOT 0x80000000
+
+
+
+
+
+enum __pid_type
+  {
+    F_OWNER_TID = 0,
+    F_OWNER_PID,
+    F_OWNER_PGRP,
+    F_OWNER_GID = F_OWNER_PGRP
+  };
+
+
+struct f_owner_ex
+  {
+    enum __pid_type type;
+    __pid_t pid;
+  };
+
+
+
+
+#define F_SEAL_SEAL 0x0001
+#define F_SEAL_SHRINK 0x0002
+#define F_SEAL_GROW 0x0004
+#define F_SEAL_WRITE 0x0008
+#define F_SEAL_FUTURE_WRITE 0x0010
+
+
+
+
+
+#define RWH_WRITE_LIFE_NOT_SET 0
+#define RWF_WRITE_LIFE_NOT_SET RWH_WRITE_LIFE_NOT_SET
+#define RWH_WRITE_LIFE_NONE 1
+#define RWH_WRITE_LIFE_SHORT 2
+#define RWH_WRITE_LIFE_MEDIUM 3
+#define RWH_WRITE_LIFE_LONG 4
+#define RWH_WRITE_LIFE_EXTREME 5
+
+
+
+
+
+#define FAPPEND O_APPEND
+#define FFSYNC O_FSYNC
+#define FASYNC O_ASYNC
+#define FNONBLOCK O_NONBLOCK
+#define FNDELAY O_NDELAY
+
+
+
+#define __POSIX_FADV_DONTNEED 4
+#define __POSIX_FADV_NOREUSE 5
+
+
+
+#define POSIX_FADV_NORMAL 0
+#define POSIX_FADV_RANDOM 1
+#define POSIX_FADV_SEQUENTIAL 2
+#define POSIX_FADV_WILLNEED 3
+#define POSIX_FADV_DONTNEED __POSIX_FADV_DONTNEED
+#define POSIX_FADV_NOREUSE __POSIX_FADV_NOREUSE
+
+
+
+
+
+#define SYNC_FILE_RANGE_WAIT_BEFORE 1
+
+
+#define SYNC_FILE_RANGE_WRITE 2
+
+
+#define SYNC_FILE_RANGE_WAIT_AFTER 4
+
+
+
+
+#define SYNC_FILE_RANGE_WRITE_AND_WAIT (SYNC_FILE_RANGE_WRITE | SYNC_FILE_RANGE_WAIT_BEFORE | SYNC_FILE_RANGE_WAIT_AFTER)
+
+
+
+
+#define SPLICE_F_MOVE 1
+#define SPLICE_F_NONBLOCK 2
+
+
+#define SPLICE_F_MORE 4
+#define SPLICE_F_GIFT 8
+
+
+
+# 1 "/usr/include/linux/falloc.h" 1 3 4
+
+
+#define _FALLOC_H_ 
+
+#define FALLOC_FL_KEEP_SIZE 0x01
+#define FALLOC_FL_PUNCH_HOLE 0x02
+#define FALLOC_FL_NO_HIDE_STALE 0x04
+# 29 "/usr/include/linux/falloc.h" 3 4
+#define FALLOC_FL_COLLAPSE_RANGE 0x08
+# 43 "/usr/include/linux/falloc.h" 3 4
+#define FALLOC_FL_ZERO_RANGE 0x10
+# 60 "/usr/include/linux/falloc.h" 3 4
+#define FALLOC_FL_INSERT_RANGE 0x20
+# 78 "/usr/include/linux/falloc.h" 3 4
+#define FALLOC_FL_UNSHARE_RANGE 0x40
+# 355 "/usr/include/bits/fcntl-linux.h" 2 3 4
+
+
+
+struct file_handle
+{
+  unsigned int handle_bytes;
+  int handle_type;
+
+  unsigned char f_handle[0];
+};
+
+
+#define MAX_HANDLE_SZ 128
+
+
+extern "C" {
+
+
+
+
+extern __ssize_t readahead (int __fd, __off64_t __offset, size_t __count)
+    throw ();
+
+
+
+
+
+
+extern int sync_file_range (int __fd, __off64_t __offset, __off64_t __count,
+       unsigned int __flags);
+
+
+
+
+
+
+extern __ssize_t vmsplice (int __fdout, const struct iovec *__iov,
+      size_t __count, unsigned int __flags);
+
+
+
+
+
+extern __ssize_t splice (int __fdin, __off64_t *__offin, int __fdout,
+    __off64_t *__offout, size_t __len,
+    unsigned int __flags);
+
+
+
+
+
+extern __ssize_t tee (int __fdin, int __fdout, size_t __len,
+        unsigned int __flags);
+
+
+
+
+
+
+extern int fallocate (int __fd, int __mode, __off_t __offset, __off_t __len);
+# 425 "/usr/include/bits/fcntl-linux.h" 3 4
+extern int fallocate64 (int __fd, int __mode, __off64_t __offset,
+   __off64_t __len);
+
+
+
+
+extern int name_to_handle_at (int __dfd, const char *__name,
+         struct file_handle *__handle, int *__mnt_id,
+         int __flags) throw ();
+
+
+
+
+
+extern int open_by_handle_at (int __mountdirfd, struct file_handle *__handle,
+         int __flags);
+
+
+
+}
+# 62 "/usr/include/bits/fcntl.h" 2 3 4
+# 36 "/usr/include/fcntl.h" 2 3 4
+
+
+
+
+#define __OPEN_NEEDS_MODE(oflag) (((oflag) & O_CREAT) != 0 || ((oflag) & __O_TMPFILE) == __O_TMPFILE)
+# 78 "/usr/include/fcntl.h" 3 4
+# 1 "/usr/include/bits/stat.h" 1 3 4
+# 23 "/usr/include/bits/stat.h" 3 4
+#define _BITS_STAT_H 1
+# 37 "/usr/include/bits/stat.h" 3 4
+#define _STAT_VER_KERNEL 0
+#define _STAT_VER_LINUX 1
+
+
+#define _MKNOD_VER_LINUX 0
+
+
+#define _STAT_VER _STAT_VER_LINUX
+
+struct stat
+  {
+    __dev_t st_dev;
+
+
+
+
+    __ino_t st_ino;
+
+
+
+
+
+
+
+    __nlink_t st_nlink;
+    __mode_t st_mode;
+
+    __uid_t st_uid;
+    __gid_t st_gid;
+
+    int __pad0;
+
+    __dev_t st_rdev;
+
+
+
+
+    __off_t st_size;
+
+
+
+    __blksize_t st_blksize;
+
+    __blkcnt_t st_blocks;
+# 91 "/usr/include/bits/stat.h" 3 4
+    struct timespec st_atim;
+    struct timespec st_mtim;
+    struct timespec st_ctim;
+#define st_atime st_atim.tv_sec
+#define st_mtime st_mtim.tv_sec
+#define st_ctime st_ctim.tv_sec
+# 106 "/usr/include/bits/stat.h" 3 4
+    __syscall_slong_t __glibc_reserved[3];
+# 115 "/usr/include/bits/stat.h" 3 4
+  };
+
+
+
+struct stat64
+  {
+    __dev_t st_dev;
+
+    __ino64_t st_ino;
+    __nlink_t st_nlink;
+    __mode_t st_mode;
+
+
+
+
+
+
+    __uid_t st_uid;
+    __gid_t st_gid;
+
+    int __pad0;
+    __dev_t st_rdev;
+    __off_t st_size;
+
+
+
+
+
+    __blksize_t st_blksize;
+    __blkcnt64_t st_blocks;
+
+
+
+
+
+
+
+    struct timespec st_atim;
+    struct timespec st_mtim;
+    struct timespec st_ctim;
+# 164 "/usr/include/bits/stat.h" 3 4
+    __syscall_slong_t __glibc_reserved[3];
+
+
+
+  };
+
+
+
+#define _STATBUF_ST_BLKSIZE 
+#define _STATBUF_ST_RDEV 
+
+#define _STATBUF_ST_NSEC 
+
+
+
+#define __S_IFMT 0170000
+
+
+#define __S_IFDIR 0040000
+#define __S_IFCHR 0020000
+#define __S_IFBLK 0060000
+#define __S_IFREG 0100000
+#define __S_IFIFO 0010000
+#define __S_IFLNK 0120000
+#define __S_IFSOCK 0140000
+
+
+
+#define __S_TYPEISMQ(buf) ((buf)->st_mode - (buf)->st_mode)
+#define __S_TYPEISSEM(buf) ((buf)->st_mode - (buf)->st_mode)
+#define __S_TYPEISSHM(buf) ((buf)->st_mode - (buf)->st_mode)
+
+
+
+#define __S_ISUID 04000
+#define __S_ISGID 02000
+#define __S_ISVTX 01000
+#define __S_IREAD 0400
+#define __S_IWRITE 0200
+#define __S_IEXEC 0100
+
+
+#define UTIME_NOW ((1l << 30) - 1l)
+#define UTIME_OMIT ((1l << 30) - 2l)
+# 79 "/usr/include/fcntl.h" 2 3 4
+
+#define S_IFMT __S_IFMT
+#define S_IFDIR __S_IFDIR
+#define S_IFCHR __S_IFCHR
+#define S_IFBLK __S_IFBLK
+#define S_IFREG __S_IFREG
+
+#define S_IFIFO __S_IFIFO
+
+
+#define S_IFLNK __S_IFLNK
+
+
+#define S_IFSOCK __S_IFSOCK
+
+
+
+
+#define S_ISUID __S_ISUID
+#define S_ISGID __S_ISGID
+
+
+
+#define S_ISVTX __S_ISVTX
+
+
+#define S_IRUSR __S_IREAD
+#define S_IWUSR __S_IWRITE
+#define S_IXUSR __S_IEXEC
+
+#define S_IRWXU (__S_IREAD|__S_IWRITE|__S_IEXEC)
+
+#define S_IRGRP (S_IRUSR >> 3)
+#define S_IWGRP (S_IWUSR >> 3)
+#define S_IXGRP (S_IXUSR >> 3)
+
+#define S_IRWXG (S_IRWXU >> 3)
+
+#define S_IROTH (S_IRGRP >> 3)
+#define S_IWOTH (S_IWGRP >> 3)
+#define S_IXOTH (S_IXGRP >> 3)
+
+#define S_IRWXO (S_IRWXG >> 3)
+# 137 "/usr/include/fcntl.h" 3 4
+#define SEEK_SET 0
+#define SEEK_CUR 1
+#define SEEK_END 2
+# 149 "/usr/include/fcntl.h" 3 4
+#define AT_FDCWD -100
+
+
+#define AT_SYMLINK_NOFOLLOW 0x100
+#define AT_REMOVEDIR 0x200
+
+#define AT_SYMLINK_FOLLOW 0x400
+
+#define AT_NO_AUTOMOUNT 0x800
+
+#define AT_EMPTY_PATH 0x1000
+#define AT_STATX_SYNC_TYPE 0x6000
+#define AT_STATX_SYNC_AS_STAT 0x0000
+#define AT_STATX_FORCE_SYNC 0x2000
+#define AT_STATX_DONT_SYNC 0x4000
+#define AT_RECURSIVE 0x8000
+
+#define AT_EACCESS 0x200
+# 176 "/usr/include/fcntl.h" 3 4
+extern int fcntl (int __fd, int __cmd, ...);
+# 185 "/usr/include/fcntl.h" 3 4
+extern int fcntl64 (int __fd, int __cmd, ...);
+# 196 "/usr/include/fcntl.h" 3 4
+extern int open (const char *__file, int __oflag, ...) __attribute__ ((__nonnull__ (1)));
+# 206 "/usr/include/fcntl.h" 3 4
+extern int open64 (const char *__file, int __oflag, ...) __attribute__ ((__nonnull__ (1)));
+# 220 "/usr/include/fcntl.h" 3 4
+extern int openat (int __fd, const char *__file, int __oflag, ...)
+     __attribute__ ((__nonnull__ (2)));
+# 231 "/usr/include/fcntl.h" 3 4
+extern int openat64 (int __fd, const char *__file, int __oflag, ...)
+     __attribute__ ((__nonnull__ (2)));
+# 242 "/usr/include/fcntl.h" 3 4
+extern int creat (const char *__file, mode_t __mode) __attribute__ ((__nonnull__ (1)));
+# 252 "/usr/include/fcntl.h" 3 4
+extern int creat64 (const char *__file, mode_t __mode) __attribute__ ((__nonnull__ (1)));
+# 288 "/usr/include/fcntl.h" 3 4
+extern int posix_fadvise (int __fd, off_t __offset, off_t __len,
+     int __advise) throw ();
+# 300 "/usr/include/fcntl.h" 3 4
+extern int posix_fadvise64 (int __fd, off64_t __offset, off64_t __len,
+       int __advise) throw ();
+# 310 "/usr/include/fcntl.h" 3 4
+extern int posix_fallocate (int __fd, off_t __offset, off_t __len);
+# 321 "/usr/include/fcntl.h" 3 4
+extern int posix_fallocate64 (int __fd, off64_t __offset, off64_t __len);
+# 332 "/usr/include/fcntl.h" 3 4
+}
+# 66 "/usr/include/boost/test/impl/debug.ipp" 2 3 4
+
+
+# 1 "/usr/include/sys/stat.h" 1 3 4
+# 23 "/usr/include/sys/stat.h" 3 4
+#define _SYS_STAT_H 1
+# 99 "/usr/include/sys/stat.h" 3 4
+extern "C" {
+
+# 1 "/usr/include/bits/stat.h" 1 3 4
+# 102 "/usr/include/sys/stat.h" 2 3 4
+
+
+#define S_IFMT __S_IFMT
+#define S_IFDIR __S_IFDIR
+#define S_IFCHR __S_IFCHR
+#define S_IFBLK __S_IFBLK
+#define S_IFREG __S_IFREG
+
+#define S_IFIFO __S_IFIFO
+
+
+#define S_IFLNK __S_IFLNK
+
+
+
+#define S_IFSOCK __S_IFSOCK
+
+
+
+
+
+#define __S_ISTYPE(mode,mask) (((mode) & __S_IFMT) == (mask))
+
+#define S_ISDIR(mode) __S_ISTYPE((mode), __S_IFDIR)
+#define S_ISCHR(mode) __S_ISTYPE((mode), __S_IFCHR)
+#define S_ISBLK(mode) __S_ISTYPE((mode), __S_IFBLK)
+#define S_ISREG(mode) __S_ISTYPE((mode), __S_IFREG)
+
+#define S_ISFIFO(mode) __S_ISTYPE((mode), __S_IFIFO)
+
+
+#define S_ISLNK(mode) __S_ISTYPE((mode), __S_IFLNK)
+# 142 "/usr/include/sys/stat.h" 3 4
+#define S_ISSOCK(mode) __S_ISTYPE((mode), __S_IFSOCK)
+# 152 "/usr/include/sys/stat.h" 3 4
+#define S_TYPEISMQ(buf) __S_TYPEISMQ(buf)
+#define S_TYPEISSEM(buf) __S_TYPEISSEM(buf)
+#define S_TYPEISSHM(buf) __S_TYPEISSHM(buf)
+
+
+
+
+
+#define S_ISUID __S_ISUID
+#define S_ISGID __S_ISGID
+
+
+
+#define S_ISVTX __S_ISVTX
+
+
+#define S_IRUSR __S_IREAD
+#define S_IWUSR __S_IWRITE
+#define S_IXUSR __S_IEXEC
+
+#define S_IRWXU (__S_IREAD|__S_IWRITE|__S_IEXEC)
+
+
+#define S_IREAD S_IRUSR
+#define S_IWRITE S_IWUSR
+#define S_IEXEC S_IXUSR
+
+
+#define S_IRGRP (S_IRUSR >> 3)
+#define S_IWGRP (S_IWUSR >> 3)
+#define S_IXGRP (S_IXUSR >> 3)
+
+#define S_IRWXG (S_IRWXU >> 3)
+
+#define S_IROTH (S_IRGRP >> 3)
+#define S_IWOTH (S_IWGRP >> 3)
+#define S_IXOTH (S_IXGRP >> 3)
+
+#define S_IRWXO (S_IRWXG >> 3)
+
+
+
+
+#define ACCESSPERMS (S_IRWXU|S_IRWXG|S_IRWXO)
+#define ALLPERMS (S_ISUID|S_ISGID|S_ISVTX|S_IRWXU|S_IRWXG|S_IRWXO)
+#define DEFFILEMODE (S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH)
+
+#define S_BLKSIZE 512
+
+
+
+
+
+extern int stat (const char *__restrict __file,
+   struct stat *__restrict __buf) throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+extern int fstat (int __fd, struct stat *__buf) throw () __attribute__ ((__nonnull__ (2)));
+# 224 "/usr/include/sys/stat.h" 3 4
+extern int stat64 (const char *__restrict __file,
+     struct stat64 *__restrict __buf) throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int fstat64 (int __fd, struct stat64 *__buf) throw () __attribute__ ((__nonnull__ (2)));
+
+
+
+
+
+
+
+extern int fstatat (int __fd, const char *__restrict __file,
+      struct stat *__restrict __buf, int __flag)
+     throw () __attribute__ ((__nonnull__ (2, 3)));
+# 249 "/usr/include/sys/stat.h" 3 4
+extern int fstatat64 (int __fd, const char *__restrict __file,
+        struct stat64 *__restrict __buf, int __flag)
+     throw () __attribute__ ((__nonnull__ (2, 3)));
+
+
+
+
+
+
+
+extern int lstat (const char *__restrict __file,
+    struct stat *__restrict __buf) throw () __attribute__ ((__nonnull__ (1, 2)));
+# 272 "/usr/include/sys/stat.h" 3 4
+extern int lstat64 (const char *__restrict __file,
+      struct stat64 *__restrict __buf)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+
+extern int chmod (const char *__file, __mode_t __mode)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+extern int lchmod (const char *__file, __mode_t __mode)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+extern int fchmod (int __fd, __mode_t __mode) throw ();
+
+
+
+
+
+extern int fchmodat (int __fd, const char *__file, __mode_t __mode,
+       int __flag)
+     throw () __attribute__ ((__nonnull__ (2))) ;
+
+
+
+
+
+
+extern __mode_t umask (__mode_t __mask) throw ();
+
+
+
+
+extern __mode_t getumask (void) throw ();
+
+
+
+extern int mkdir (const char *__path, __mode_t __mode)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+extern int mkdirat (int __fd, const char *__path, __mode_t __mode)
+     throw () __attribute__ ((__nonnull__ (2)));
+
+
+
+
+
+
+extern int mknod (const char *__path, __mode_t __mode, __dev_t __dev)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+extern int mknodat (int __fd, const char *__path, __mode_t __mode,
+      __dev_t __dev) throw () __attribute__ ((__nonnull__ (2)));
+
+
+
+
+
+extern int mkfifo (const char *__path, __mode_t __mode)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+extern int mkfifoat (int __fd, const char *__path, __mode_t __mode)
+     throw () __attribute__ ((__nonnull__ (2)));
+
+
+
+
+
+extern int utimensat (int __fd, const char *__path,
+        const struct timespec __times[2],
+        int __flags)
+     throw () __attribute__ ((__nonnull__ (2)));
+
+
+
+
+extern int futimens (int __fd, const struct timespec __times[2]) throw ();
+# 390 "/usr/include/sys/stat.h" 3 4
+#define _MKNOD_VER 0
+
+
+
+
+extern int __fxstat (int __ver, int __fildes, struct stat *__stat_buf)
+     throw () __attribute__ ((__nonnull__ (3)));
+extern int __xstat (int __ver, const char *__filename,
+      struct stat *__stat_buf) throw () __attribute__ ((__nonnull__ (2, 3)));
+extern int __lxstat (int __ver, const char *__filename,
+       struct stat *__stat_buf) throw () __attribute__ ((__nonnull__ (2, 3)));
+extern int __fxstatat (int __ver, int __fildes, const char *__filename,
+         struct stat *__stat_buf, int __flag)
+     throw () __attribute__ ((__nonnull__ (3, 4)));
+# 428 "/usr/include/sys/stat.h" 3 4
+extern int __fxstat64 (int __ver, int __fildes, struct stat64 *__stat_buf)
+     throw () __attribute__ ((__nonnull__ (3)));
+extern int __xstat64 (int __ver, const char *__filename,
+        struct stat64 *__stat_buf) throw () __attribute__ ((__nonnull__ (2, 3)));
+extern int __lxstat64 (int __ver, const char *__filename,
+         struct stat64 *__stat_buf) throw () __attribute__ ((__nonnull__ (2, 3)));
+extern int __fxstatat64 (int __ver, int __fildes, const char *__filename,
+    struct stat64 *__stat_buf, int __flag)
+     throw () __attribute__ ((__nonnull__ (3, 4)));
+
+extern int __xmknod (int __ver, const char *__path, __mode_t __mode,
+       __dev_t *__dev) throw () __attribute__ ((__nonnull__ (2, 4)));
+
+extern int __xmknodat (int __ver, int __fd, const char *__path,
+         __mode_t __mode, __dev_t *__dev)
+     throw () __attribute__ ((__nonnull__ (3, 5)));
+
+
+# 1 "/usr/include/bits/statx.h" 1 3 4
+# 31 "/usr/include/bits/statx.h" 3 4
+# 1 "/usr/include/linux/stat.h" 1 3 4
+
+
+#define _LINUX_STAT_H 
+
+# 1 "/usr/include/linux/types.h" 1 3 4
+
+
+#define _LINUX_TYPES_H 
+
+# 1 "/usr/include/asm/types.h" 1 3 4
+# 1 "/usr/include/asm-generic/types.h" 1 3 4
+
+
+#define _ASM_GENERIC_TYPES_H 
+
+
+
+# 1 "/usr/include/asm-generic/int-ll64.h" 1 3 4
+# 10 "/usr/include/asm-generic/int-ll64.h" 3 4
+#define _ASM_GENERIC_INT_LL64_H 
+
+# 1 "/usr/include/asm/bitsperlong.h" 1 3 4
+
+
+#define __ASM_X86_BITSPERLONG_H 
+
+
+#define __BITS_PER_LONG 64
+
+
+
+
+# 1 "/usr/include/asm-generic/bitsperlong.h" 1 3 4
+
+
+#define __ASM_GENERIC_BITS_PER_LONG 
+# 12 "/usr/include/asm/bitsperlong.h" 2 3 4
+# 13 "/usr/include/asm-generic/int-ll64.h" 2 3 4
+
+
+
+
+
+
+
+typedef __signed__ char __s8;
+typedef unsigned char __u8;
+
+typedef __signed__ short __s16;
+typedef unsigned short __u16;
+
+typedef __signed__ int __s32;
+typedef unsigned int __u32;
+
+
+__extension__ typedef __signed__ long long __s64;
+__extension__ typedef unsigned long long __u64;
+# 8 "/usr/include/asm-generic/types.h" 2 3 4
+# 2 "/usr/include/asm/types.h" 2 3 4
+# 6 "/usr/include/linux/types.h" 2 3 4
+
+
+
+# 1 "/usr/include/linux/posix_types.h" 1 3 4
+
+
+#define _LINUX_POSIX_TYPES_H 
+
+# 1 "/usr/include/linux/stddef.h" 1 3 4
+# 6 "/usr/include/linux/posix_types.h" 2 3 4
+# 22 "/usr/include/linux/posix_types.h" 3 4
+#undef __FD_SETSIZE
+#define __FD_SETSIZE 1024
+
+typedef struct {
+ unsigned long fds_bits[1024 / (8 * sizeof(long))];
+} __kernel_fd_set;
+
+
+typedef void (*__kernel_sighandler_t)(int);
+
+
+typedef int __kernel_key_t;
+typedef int __kernel_mqd_t;
+
+# 1 "/usr/include/asm/posix_types.h" 1 3 4
+
+
+
+
+
+
+# 1 "/usr/include/asm/posix_types_64.h" 1 3 4
+
+
+#define _ASM_X86_POSIX_TYPES_64_H 
+
+
+
+
+
+
+
+typedef unsigned short __kernel_old_uid_t;
+typedef unsigned short __kernel_old_gid_t;
+#define __kernel_old_uid_t __kernel_old_uid_t
+
+typedef unsigned long __kernel_old_dev_t;
+#define __kernel_old_dev_t __kernel_old_dev_t
+
+# 1 "/usr/include/asm-generic/posix_types.h" 1 3 4
+
+
+#define __ASM_GENERIC_POSIX_TYPES_H 
+# 15 "/usr/include/asm-generic/posix_types.h" 3 4
+typedef long __kernel_long_t;
+typedef unsigned long __kernel_ulong_t;
+
+
+
+typedef __kernel_ulong_t __kernel_ino_t;
+
+
+
+typedef unsigned int __kernel_mode_t;
+
+
+
+typedef int __kernel_pid_t;
+
+
+
+typedef int __kernel_ipc_pid_t;
+
+
+
+typedef unsigned int __kernel_uid_t;
+typedef unsigned int __kernel_gid_t;
+
+
+
+typedef __kernel_long_t __kernel_suseconds_t;
+
+
+
+typedef int __kernel_daddr_t;
+
+
+
+typedef unsigned int __kernel_uid32_t;
+typedef unsigned int __kernel_gid32_t;
+# 72 "/usr/include/asm-generic/posix_types.h" 3 4
+typedef __kernel_ulong_t __kernel_size_t;
+typedef __kernel_long_t __kernel_ssize_t;
+typedef __kernel_long_t __kernel_ptrdiff_t;
+
+
+
+
+typedef struct {
+ int val[2];
+} __kernel_fsid_t;
+
+
+
+
+
+typedef __kernel_long_t __kernel_off_t;
+typedef long long __kernel_loff_t;
+typedef __kernel_long_t __kernel_old_time_t;
+typedef __kernel_long_t __kernel_time_t;
+typedef long long __kernel_time64_t;
+typedef __kernel_long_t __kernel_clock_t;
+typedef int __kernel_timer_t;
+typedef int __kernel_clockid_t;
+typedef char * __kernel_caddr_t;
+typedef unsigned short __kernel_uid16_t;
+typedef unsigned short __kernel_gid16_t;
+# 19 "/usr/include/asm/posix_types_64.h" 2 3 4
+# 8 "/usr/include/asm/posix_types.h" 2 3 4
+# 37 "/usr/include/linux/posix_types.h" 2 3 4
+# 10 "/usr/include/linux/types.h" 2 3 4
+# 20 "/usr/include/linux/types.h" 3 4
+#define __bitwise__ 
+
+#define __bitwise __bitwise__
+
+typedef __u16 __le16;
+typedef __u16 __be16;
+typedef __u32 __le32;
+typedef __u32 __be32;
+typedef __u64 __le64;
+typedef __u64 __be64;
+
+typedef __u16 __sum16;
+typedef __u32 __wsum;
+# 43 "/usr/include/linux/types.h" 3 4
+#define __aligned_u64 __u64 __attribute__((aligned(8)))
+#define __aligned_be64 __be64 __attribute__((aligned(8)))
+#define __aligned_le64 __le64 __attribute__((aligned(8)))
+
+typedef unsigned __poll_t;
+# 6 "/usr/include/linux/stat.h" 2 3 4
+# 56 "/usr/include/linux/stat.h" 3 4
+struct statx_timestamp {
+ __s64 tv_sec;
+ __u32 tv_nsec;
+ __s32 __reserved;
+};
+# 99 "/usr/include/linux/stat.h" 3 4
+struct statx {
+
+ __u32 stx_mask;
+ __u32 stx_blksize;
+ __u64 stx_attributes;
+
+ __u32 stx_nlink;
+ __u32 stx_uid;
+ __u32 stx_gid;
+ __u16 stx_mode;
+ __u16 __spare0[1];
+
+ __u64 stx_ino;
+ __u64 stx_size;
+ __u64 stx_blocks;
+ __u64 stx_attributes_mask;
+
+ struct statx_timestamp stx_atime;
+ struct statx_timestamp stx_btime;
+ struct statx_timestamp stx_ctime;
+ struct statx_timestamp stx_mtime;
+
+ __u32 stx_rdev_major;
+ __u32 stx_rdev_minor;
+ __u32 stx_dev_major;
+ __u32 stx_dev_minor;
+
+ __u64 stx_mnt_id;
+ __u64 __spare2;
+
+ __u64 __spare3[12];
+
+};
+# 141 "/usr/include/linux/stat.h" 3 4
+#define STATX_TYPE 0x00000001U
+#define STATX_MODE 0x00000002U
+#define STATX_NLINK 0x00000004U
+#define STATX_UID 0x00000008U
+#define STATX_GID 0x00000010U
+#define STATX_ATIME 0x00000020U
+#define STATX_MTIME 0x00000040U
+#define STATX_CTIME 0x00000080U
+#define STATX_INO 0x00000100U
+#define STATX_SIZE 0x00000200U
+#define STATX_BLOCKS 0x00000400U
+#define STATX_BASIC_STATS 0x000007ffU
+#define STATX_BTIME 0x00000800U
+#define STATX_MNT_ID 0x00001000U
+
+#define STATX__RESERVED 0x80000000U
+
+
+
+
+
+
+#define STATX_ALL 0x00000fffU
+# 176 "/usr/include/linux/stat.h" 3 4
+#define STATX_ATTR_COMPRESSED 0x00000004
+#define STATX_ATTR_IMMUTABLE 0x00000010
+#define STATX_ATTR_APPEND 0x00000020
+#define STATX_ATTR_NODUMP 0x00000040
+#define STATX_ATTR_ENCRYPTED 0x00000800
+#define STATX_ATTR_AUTOMOUNT 0x00001000
+#define STATX_ATTR_MOUNT_ROOT 0x00002000
+#define STATX_ATTR_VERITY 0x00100000
+#define STATX_ATTR_DAX 0x00002000
+# 32 "/usr/include/bits/statx.h" 2 3 4
+
+#define __statx_timestamp_defined 1
+#define __statx_defined 1
+
+
+
+
+# 1 "/usr/include/bits/statx-generic.h" 1 3 4
+# 25 "/usr/include/bits/statx-generic.h" 3 4
+# 1 "/usr/include/bits/types/struct_statx_timestamp.h" 1 3 4
+# 26 "/usr/include/bits/statx-generic.h" 2 3 4
+# 1 "/usr/include/bits/types/struct_statx.h" 1 3 4
+# 27 "/usr/include/bits/statx-generic.h" 2 3 4
+# 54 "/usr/include/bits/statx-generic.h" 3 4
+extern "C" {
+
+
+int statx (int __dirfd, const char *__restrict __path, int __flags,
+           unsigned int __mask, struct statx *__restrict __buf)
+  throw () __attribute__ ((__nonnull__ (2, 5)));
+
+}
+# 40 "/usr/include/bits/statx.h" 2 3 4
+# 447 "/usr/include/sys/stat.h" 2 3 4
+# 534 "/usr/include/sys/stat.h" 3 4
+}
+# 69 "/usr/include/boost/test/impl/debug.ipp" 2 3 4
+# 1 "/usr/include/sys/wait.h" 1 3 4
+# 23 "/usr/include/sys/wait.h" 3 4
+#define _SYS_WAIT_H 1
+
+
+
+extern "C" {
+# 66 "/usr/include/sys/wait.h" 3 4
+#define WCOREFLAG __WCOREFLAG
+#define WCOREDUMP(status) __WCOREDUMP (status)
+#define W_EXITCODE(ret,sig) __W_EXITCODE (ret, sig)
+#define W_STOPCODE(sig) __W_STOPCODE (sig)
+
+
+
+
+typedef enum
+{
+  P_ALL,
+  P_PID,
+  P_PGID
+} idtype_t;
+# 88 "/usr/include/sys/wait.h" 3 4
+extern __pid_t wait (int *__stat_loc);
+
+
+
+#define WAIT_ANY (-1)
+#define WAIT_MYPGRP 0
+# 111 "/usr/include/sys/wait.h" 3 4
+extern __pid_t waitpid (__pid_t __pid, int *__stat_loc, int __options);
+# 132 "/usr/include/sys/wait.h" 3 4
+extern int waitid (idtype_t __idtype, __id_t __id, siginfo_t *__infop,
+     int __options);
+
+
+
+
+
+
+struct rusage;
+
+
+
+
+
+
+extern __pid_t wait3 (int *__stat_loc, int __options,
+        struct rusage * __usage) throw ();
+
+
+
+
+extern __pid_t wait4 (__pid_t __pid, int *__stat_loc, int __options,
+        struct rusage *__usage) throw ();
+
+
+
+}
+# 70 "/usr/include/boost/test/impl/debug.ipp" 2 3 4
+# 1 "/usr/include/sys/time.h" 1 3 4
+# 19 "/usr/include/sys/time.h" 3 4
+#define _SYS_TIME_H 1
+# 34 "/usr/include/sys/time.h" 3 4
+extern "C" {
+
+
+
+#define TIMEVAL_TO_TIMESPEC(tv,ts) { (ts)->tv_sec = (tv)->tv_sec; (ts)->tv_nsec = (tv)->tv_usec * 1000; }
+
+
+
+#define TIMESPEC_TO_TIMEVAL(tv,ts) { (tv)->tv_sec = (ts)->tv_sec; (tv)->tv_usec = (ts)->tv_nsec / 1000; }
+# 52 "/usr/include/sys/time.h" 3 4
+struct timezone
+  {
+    int tz_minuteswest;
+    int tz_dsttime;
+  };
+# 66 "/usr/include/sys/time.h" 3 4
+extern int gettimeofday (struct timeval *__restrict __tv,
+    void *__restrict __tz) throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+
+extern int settimeofday (const struct timeval *__tv,
+    const struct timezone *__tz)
+     throw ();
+
+
+
+
+
+extern int adjtime (const struct timeval *__delta,
+      struct timeval *__olddelta) throw ();
+
+
+
+
+enum __itimer_which
+  {
+
+    ITIMER_REAL = 0,
+#define ITIMER_REAL ITIMER_REAL
+
+    ITIMER_VIRTUAL = 1,
+#define ITIMER_VIRTUAL ITIMER_VIRTUAL
+
+
+    ITIMER_PROF = 2
+#define ITIMER_PROF ITIMER_PROF
+  };
+
+
+
+struct itimerval
+  {
+
+    struct timeval it_interval;
+
+    struct timeval it_value;
+  };
+
+
+
+
+
+
+typedef int __itimer_which_t;
+
+
+
+
+extern int getitimer (__itimer_which_t __which,
+        struct itimerval *__value) throw ();
+
+
+
+
+extern int setitimer (__itimer_which_t __which,
+        const struct itimerval *__restrict __new,
+        struct itimerval *__restrict __old) throw ();
+
+
+
+
+extern int utimes (const char *__file, const struct timeval __tvp[2])
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int lutimes (const char *__file, const struct timeval __tvp[2])
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int futimes (int __fd, const struct timeval __tvp[2]) throw ();
+
+
+
+
+
+
+extern int futimesat (int __fd, const char *__file,
+        const struct timeval __tvp[2]) throw ();
+
+
+
+
+
+
+#define timerisset(tvp) ((tvp)->tv_sec || (tvp)->tv_usec)
+#define timerclear(tvp) ((tvp)->tv_sec = (tvp)->tv_usec = 0)
+#define timercmp(a,b,CMP) (((a)->tv_sec == (b)->tv_sec) ? ((a)->tv_usec CMP (b)->tv_usec) : ((a)->tv_sec CMP (b)->tv_sec))
+
+
+
+#define timeradd(a,b,result) do { (result)->tv_sec = (a)->tv_sec + (b)->tv_sec; (result)->tv_usec = (a)->tv_usec + (b)->tv_usec; if ((result)->tv_usec >= 1000000) { ++(result)->tv_sec; (result)->tv_usec -= 1000000; } } while (0)
+# 176 "/usr/include/sys/time.h" 3 4
+#define timersub(a,b,result) do { (result)->tv_sec = (a)->tv_sec - (b)->tv_sec; (result)->tv_usec = (a)->tv_usec - (b)->tv_usec; if ((result)->tv_usec < 0) { --(result)->tv_sec; (result)->tv_usec += 1000000; } } while (0)
+# 187 "/usr/include/sys/time.h" 3 4
+}
+# 71 "/usr/include/boost/test/impl/debug.ipp" 2 3 4
+
+# 1 "/usr/include/c++/10.2.0/stdlib.h" 1 3 4
+# 34 "/usr/include/c++/10.2.0/stdlib.h" 3 4
+#define _GLIBCXX_STDLIB_H 1
+
+# 1 "/usr/include/c++/10.2.0/cstdlib" 1 3 4
+# 39 "/usr/include/c++/10.2.0/cstdlib" 3 4
+       
+# 40 "/usr/include/c++/10.2.0/cstdlib" 3
+# 37 "/usr/include/c++/10.2.0/stdlib.h" 2 3 4
+
+using std::abort;
+using std::atexit;
+using std::exit;
+
+
+  using std::at_quick_exit;
+
+
+  using std::quick_exit;
+
+
+
+
+using std::div_t;
+using std::ldiv_t;
+
+using std::abs;
+using std::atof;
+using std::atoi;
+using std::atol;
+using std::bsearch;
+using std::calloc;
+using std::div;
+using std::free;
+using std::getenv;
+using std::labs;
+using std::ldiv;
+using std::malloc;
+
+using std::mblen;
+using std::mbstowcs;
+using std::mbtowc;
+
+using std::qsort;
+using std::rand;
+using std::realloc;
+using std::srand;
+using std::strtod;
+using std::strtol;
+using std::strtoul;
+using std::system;
+
+using std::wcstombs;
+using std::wctomb;
+# 73 "/usr/include/boost/test/impl/debug.ipp" 2 3 4
+# 89 "/usr/include/boost/test/impl/debug.ipp" 3 4
+#define BOOST_LINUX_BASED_DEBUG 
+
+# 1 "/usr/include/sys/ptrace.h" 1 3 4
+# 21 "/usr/include/sys/ptrace.h" 3 4
+#define _SYS_PTRACE_H 1
+
+
+
+
+extern "C" {
+
+
+enum __ptrace_request
+{
+
+
+
+  PTRACE_TRACEME = 0,
+#define PT_TRACE_ME PTRACE_TRACEME
+
+
+  PTRACE_PEEKTEXT = 1,
+#define PT_READ_I PTRACE_PEEKTEXT
+
+
+  PTRACE_PEEKDATA = 2,
+#define PT_READ_D PTRACE_PEEKDATA
+
+
+  PTRACE_PEEKUSER = 3,
+#define PT_READ_U PTRACE_PEEKUSER
+
+
+  PTRACE_POKETEXT = 4,
+#define PT_WRITE_I PTRACE_POKETEXT
+
+
+  PTRACE_POKEDATA = 5,
+#define PT_WRITE_D PTRACE_POKEDATA
+
+
+  PTRACE_POKEUSER = 6,
+#define PT_WRITE_U PTRACE_POKEUSER
+
+
+  PTRACE_CONT = 7,
+#define PT_CONTINUE PTRACE_CONT
+
+
+  PTRACE_KILL = 8,
+#define PT_KILL PTRACE_KILL
+
+
+  PTRACE_SINGLESTEP = 9,
+#define PT_STEP PTRACE_SINGLESTEP
+
+
+  PTRACE_GETREGS = 12,
+#define PT_GETREGS PTRACE_GETREGS
+
+
+  PTRACE_SETREGS = 13,
+#define PT_SETREGS PTRACE_SETREGS
+
+
+  PTRACE_GETFPREGS = 14,
+#define PT_GETFPREGS PTRACE_GETFPREGS
+
+
+  PTRACE_SETFPREGS = 15,
+#define PT_SETFPREGS PTRACE_SETFPREGS
+
+
+  PTRACE_ATTACH = 16,
+#define PT_ATTACH PTRACE_ATTACH
+
+
+  PTRACE_DETACH = 17,
+#define PT_DETACH PTRACE_DETACH
+
+
+  PTRACE_GETFPXREGS = 18,
+#define PT_GETFPXREGS PTRACE_GETFPXREGS
+
+
+  PTRACE_SETFPXREGS = 19,
+#define PT_SETFPXREGS PTRACE_SETFPXREGS
+
+
+  PTRACE_SYSCALL = 24,
+#define PT_SYSCALL PTRACE_SYSCALL
+
+
+  PTRACE_GET_THREAD_AREA = 25,
+#define PT_GET_THREAD_AREA PTRACE_GET_THREAD_AREA
+
+
+  PTRACE_SET_THREAD_AREA = 26,
+#define PT_SET_THREAD_AREA PTRACE_SET_THREAD_AREA
+
+
+
+  PTRACE_ARCH_PRCTL = 30,
+#define PT_ARCH_PRCTL PTRACE_ARCH_PRCTL
+
+
+
+  PTRACE_SYSEMU = 31,
+#define PT_SYSEMU PTRACE_SYSEMU
+
+
+  PTRACE_SYSEMU_SINGLESTEP = 32,
+#define PT_SYSEMU_SINGLESTEP PTRACE_SYSEMU_SINGLESTEP
+
+
+  PTRACE_SINGLEBLOCK = 33,
+#define PT_STEPBLOCK PTRACE_SINGLEBLOCK
+
+
+  PTRACE_SETOPTIONS = 0x4200,
+#define PT_SETOPTIONS PTRACE_SETOPTIONS
+
+
+  PTRACE_GETEVENTMSG = 0x4201,
+#define PT_GETEVENTMSG PTRACE_GETEVENTMSG
+
+
+  PTRACE_GETSIGINFO = 0x4202,
+#define PT_GETSIGINFO PTRACE_GETSIGINFO
+
+
+  PTRACE_SETSIGINFO = 0x4203,
+#define PT_SETSIGINFO PTRACE_SETSIGINFO
+
+
+  PTRACE_GETREGSET = 0x4204,
+#define PTRACE_GETREGSET PTRACE_GETREGSET
+
+
+  PTRACE_SETREGSET = 0x4205,
+#define PTRACE_SETREGSET PTRACE_SETREGSET
+
+
+
+  PTRACE_SEIZE = 0x4206,
+#define PTRACE_SEIZE PTRACE_SEIZE
+
+
+  PTRACE_INTERRUPT = 0x4207,
+#define PTRACE_INTERRUPT PTRACE_INTERRUPT
+
+
+  PTRACE_LISTEN = 0x4208,
+#define PTRACE_LISTEN PTRACE_LISTEN
+
+
+  PTRACE_PEEKSIGINFO = 0x4209,
+#define PTRACE_PEEKSIGINFO PTRACE_PEEKSIGINFO
+
+
+  PTRACE_GETSIGMASK = 0x420a,
+#define PTRACE_GETSIGMASK PTRACE_GETSIGMASK
+
+
+  PTRACE_SETSIGMASK = 0x420b,
+#define PTRACE_SETSIGMASK PTRACE_SETSIGMASK
+
+
+  PTRACE_SECCOMP_GET_FILTER = 0x420c,
+#define PTRACE_SECCOMP_GET_FILTER PTRACE_SECCOMP_GET_FILTER
+
+
+  PTRACE_SECCOMP_GET_METADATA = 0x420d,
+#define PTRACE_SECCOMP_GET_METADATA PTRACE_SECCOMP_GET_METADATA
+
+
+  PTRACE_GET_SYSCALL_INFO = 0x420e
+#define PTRACE_GET_SYSCALL_INFO PTRACE_GET_SYSCALL_INFO
+};
+
+
+# 1 "/usr/include/bits/ptrace-shared.h" 1 3 4
+# 26 "/usr/include/bits/ptrace-shared.h" 3 4
+enum __ptrace_setoptions
+{
+  PTRACE_O_TRACESYSGOOD = 0x00000001,
+  PTRACE_O_TRACEFORK = 0x00000002,
+  PTRACE_O_TRACEVFORK = 0x00000004,
+  PTRACE_O_TRACECLONE = 0x00000008,
+  PTRACE_O_TRACEEXEC = 0x00000010,
+  PTRACE_O_TRACEVFORKDONE = 0x00000020,
+  PTRACE_O_TRACEEXIT = 0x00000040,
+  PTRACE_O_TRACESECCOMP = 0x00000080,
+  PTRACE_O_EXITKILL = 0x00100000,
+  PTRACE_O_SUSPEND_SECCOMP = 0x00200000,
+  PTRACE_O_MASK = 0x003000ff
+};
+
+enum __ptrace_eventcodes
+{
+
+  PTRACE_EVENT_FORK = 1,
+  PTRACE_EVENT_VFORK = 2,
+  PTRACE_EVENT_CLONE = 3,
+  PTRACE_EVENT_EXEC = 4,
+  PTRACE_EVENT_VFORK_DONE = 5,
+  PTRACE_EVENT_EXIT = 6,
+  PTRACE_EVENT_SECCOMP = 7,
+
+  PTRACE_EVENT_STOP = 128
+};
+
+
+enum __ptrace_get_syscall_info_op
+{
+  PTRACE_SYSCALL_INFO_NONE = 0,
+  PTRACE_SYSCALL_INFO_ENTRY = 1,
+  PTRACE_SYSCALL_INFO_EXIT = 2,
+  PTRACE_SYSCALL_INFO_SECCOMP = 3
+};
+
+
+struct __ptrace_peeksiginfo_args
+{
+  __uint64_t off;
+  __uint32_t flags;
+  __int32_t nr;
+};
+
+enum __ptrace_peeksiginfo_flags
+{
+
+  PTRACE_PEEKSIGINFO_SHARED = (1 << 0)
+};
+
+
+struct __ptrace_seccomp_metadata
+{
+  __uint64_t filter_off;
+  __uint64_t flags;
+};
+
+
+struct __ptrace_syscall_info
+{
+  __uint8_t op;
+
+
+  __uint32_t arch __attribute__ ((__aligned__ (4)));
+
+  __uint64_t instruction_pointer;
+  __uint64_t stack_pointer;
+  union
+  {
+
+
+    struct
+    {
+      __uint64_t nr;
+      __uint64_t args[6];
+    } entry;
+
+
+    struct
+    {
+      __int64_t rval;
+      __uint8_t is_error;
+    } exit;
+
+
+
+    struct
+    {
+      __uint64_t nr;
+      __uint64_t args[6];
+      __uint32_t ret_data;
+    } seccomp;
+  };
+};
+# 132 "/usr/include/bits/ptrace-shared.h" 3 4
+extern long int ptrace (enum __ptrace_request __request, ...) throw ();
+# 199 "/usr/include/sys/ptrace.h" 2 3 4
+
+}
+# 92 "/usr/include/boost/test/impl/debug.ipp" 2 3 4
+
+
+#define BOOST_TEST_STAT_LINE_MAX 500
+
+
+
+#define BOOST_TEST_DBG_LIST gdb
+
+
+#define BOOST_TEST_CNL_DBG gdb
+#define BOOST_TEST_GUI_DBG gdb-xterm
+
+
+
+
+
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 109 "/usr/include/boost/test/impl/debug.ipp" 2 3 4
+
+
+
+namespace boost {
+namespace debug {
+
+using unit_test::const_string;
+
+
+
+
+
+namespace {
+# 172 "/usr/include/boost/test/impl/debug.ipp" 3 4
+struct fd_holder {
+    explicit fd_holder( int fd ) : m_fd( fd ) {}
+    ~fd_holder()
+    {
+        if( m_fd != -1 )
+            ::close( m_fd );
+    }
+
+    operator int() { return m_fd; }
+
+private:
+
+    int m_fd;
+};
+
+
+
+
+
+
+struct process_info {
+
+    explicit process_info( int pid );
+
+
+    int parent_pid() const { return m_parent_pid; }
+    const_string binary_name() const { return m_binary_name; }
+    const_string binary_path() const { return m_binary_path; }
+
+private:
+
+    int m_parent_pid;
+    const_string m_binary_name;
+    const_string m_binary_path;
+
+
+
+
+
+    char m_stat_line[500 +1];
+    char m_binary_path_buff[500+1];
+
+};
+
+
+
+process_info::process_info( int pid )
+: m_parent_pid( 0 )
+{
+# 256 "/usr/include/boost/test/impl/debug.ipp" 3 4
+    char fname_buff[30];
+
+    ::snprintf( fname_buff, sizeof(fname_buff), "/proc/%d/stat", pid );
+
+    fd_holder psinfo_fd( ::open( fname_buff, 00 ) );
+
+    if( psinfo_fd == -1 )
+        return;
+
+    ssize_t num_read = ::read( psinfo_fd, m_stat_line, sizeof(m_stat_line)-1 );
+    if( num_read == -1 )
+        return;
+
+    m_stat_line[num_read] = 0;
+
+    char const* name_beg = m_stat_line;
+    while( *name_beg && *name_beg != '(' )
+        ++name_beg;
+
+    char const* name_end = name_beg+1;
+    while( *name_end && *name_end != ')' )
+        ++name_end;
+
+    std::sscanf( name_end+1, "%*s%d", &m_parent_pid );
+
+    m_binary_name.assign( name_beg+1, name_end );
+
+    ::snprintf( fname_buff, sizeof(fname_buff), "/proc/%d/exe", pid );
+    num_read = ::readlink( fname_buff, m_binary_path_buff, sizeof(m_binary_path_buff)-1 );
+
+    if( num_read == -1 )
+        return;
+
+    m_binary_path_buff[num_read] = 0;
+    m_binary_path.assign( m_binary_path_buff, num_read );
+
+}
+
+
+
+
+
+
+
+static char*
+prepare_window_title( dbg_startup_info const& dsi )
+{
+    typedef unit_test::const_string str_t;
+
+    static char title_str[50];
+
+    str_t path_sep( "\\/" );
+
+    str_t::iterator it = unit_test::utils::find_last_of( dsi.binary_path.begin(), dsi.binary_path.end(),
+                                                          path_sep.begin(), path_sep.end() );
+
+    if( it == dsi.binary_path.end() )
+        it = dsi.binary_path.begin();
+    else
+        ++it;
+
+    ::snprintf( title_str, sizeof(title_str), "%*s %ld", (int)(dsi.binary_path.end()-it), it, dsi.pid );
+
+    return title_str;
+}
+
+
+
+
+
+
+
+typedef unit_test::basic_cstring<char> mbuffer;
+
+inline char*
+copy_arg( mbuffer& dest, const_string arg )
+{
+    if( dest.size() < arg.size()+1 )
+        return 0;
+
+    char* res = dest.begin();
+
+    std::memcpy( res, arg.begin(), arg.size()+1 );
+
+    dest.trim_left( arg.size()+1 );
+
+    return res;
+}
+
+
+
+bool
+safe_execlp( char const* file, ... )
+{
+    static char* argv_buff[200];
+
+    va_list args;
+    char const* arg;
+
+
+    int num_args = 2;
+
+    __builtin_va_start(args,file);
+    while( !!(arg = __builtin_va_arg(args,char const*)) )
+        num_args++;
+    __builtin_va_end(args);
+
+
+    char** argv_it = argv_buff;
+    mbuffer work_buff( reinterpret_cast<char*>(argv_buff), sizeof(argv_buff) );
+    work_buff.trim_left( num_args * sizeof(char*) );
+
+
+    if( !(*argv_it++ = copy_arg( work_buff, file )) )
+        return false;
+
+    printf( "!! %s\n", file );
+
+    __builtin_va_start(args,file);
+    while( !!(arg = __builtin_va_arg(args,char const*)) ) {
+        printf( "!! %s\n", arg );
+        if( !(*argv_it++ = copy_arg( work_buff, arg )) ) {
+            __builtin_va_end(args);
+            return false;
+        }
+    }
+    __builtin_va_end(args);
+
+    *argv_it = 0;
+
+    return ::execvp( file, argv_buff ) != -1;
+}
+
+
+
+
+
+
+
+static void
+start_debugger_in_emacs( dbg_startup_info const& dsi, char const* emacs_name, char const* dbg_command )
+{
+    char const* title = prepare_window_title( dsi );
+
+    if( !title )
+        return;
+
+    dsi.display.is_empty()
+        ? safe_execlp( emacs_name, "-title", title, "--eval", dbg_command, 0 )
+        : safe_execlp( emacs_name, "-title", title, "-display", dsi.display.begin(), "--eval", dbg_command, 0 );
+}
+
+
+
+
+
+
+
+static char const*
+prepare_gdb_cmnd_file( dbg_startup_info const& dsi )
+{
+
+    char pid_buff[16];
+    ::snprintf( pid_buff, sizeof(pid_buff), "%ld", dsi.pid );
+    unit_test::const_string pid_str( pid_buff );
+
+    static char cmd_file_name[] = "/tmp/btl_gdb_cmd_XXXXXX";
+
+
+    fd_holder cmd_fd( ::mkstemp( cmd_file_name ) );
+
+    if( cmd_fd == -1 )
+        return 0;
+
+#define WRITE_STR(str) if( ::write( cmd_fd, str.begin(), str.size() ) == -1 ) return 0;
+#define WRITE_CSTR(str) if( ::write( cmd_fd, str, sizeof( str )-1 ) == -1 ) return 0;
+
+    if( ::write( cmd_fd, "file ", sizeof( "file " )-1 ) == -1 ) return 0;;
+    if( ::write( cmd_fd, dsi.binary_path.begin(), dsi.binary_path.size() ) == -1 ) return 0;;
+    if( ::write( cmd_fd, "\nattach ", sizeof( "\nattach " )-1 ) == -1 ) return 0;;
+    if( ::write( cmd_fd, pid_str.begin(), pid_str.size() ) == -1 ) return 0;;
+    if( ::write( cmd_fd, "\nshell unlink ", sizeof( "\nshell unlink " )-1 ) == -1 ) return 0;;
+    if( ::write( cmd_fd, dsi.init_done_lock.begin(), dsi.init_done_lock.size() ) == -1 ) return 0;;
+    if( ::write( cmd_fd, "\ncont", sizeof( "\ncont" )-1 ) == -1 ) return 0;;
+    if( dsi.break_or_continue )
+        if( ::write( cmd_fd, "\nup 4", sizeof( "\nup 4" )-1 ) == -1 ) return 0;;
+
+    if( ::write( cmd_fd, "\necho \\n", sizeof( "\necho \\n" )-1 ) == -1 ) return 0;;
+    if( ::write( cmd_fd, "\nlist -", sizeof( "\nlist -" )-1 ) == -1 ) return 0;;
+    if( ::write( cmd_fd, "\nlist", sizeof( "\nlist" )-1 ) == -1 ) return 0;;
+    if( ::write( cmd_fd, "\nshell unlink ", sizeof( "\nshell unlink " )-1 ) == -1 ) return 0;;
+    if( ::write( cmd_fd, cmd_file_name, sizeof( cmd_file_name )-1 ) == -1 ) return 0;;
+
+    return cmd_file_name;
+}
+
+
+
+static void
+start_gdb_in_console( dbg_startup_info const& dsi )
+{
+    char const* cmnd_file_name = prepare_gdb_cmnd_file( dsi );
+
+    if( !cmnd_file_name )
+        return;
+
+    safe_execlp( "gdb", "-q", "-x", cmnd_file_name, 0 );
+}
+
+
+
+static void
+start_gdb_in_xterm( dbg_startup_info const& dsi )
+{
+    char const* title = prepare_window_title( dsi );
+    char const* cmnd_file_name = prepare_gdb_cmnd_file( dsi );
+
+    if( !title || !cmnd_file_name )
+        return;
+
+    safe_execlp( "xterm", "-T", title, "-display", dsi.display.begin(),
+                    "-bg", "black", "-fg", "white", "-geometry", "88x30+10+10", "-fn", "9x15", "-e",
+                 "gdb", "-q", "-x", cmnd_file_name, 0 );
+}
+
+
+
+static void
+start_gdb_in_emacs( dbg_startup_info const& dsi )
+{
+    char const* cmnd_file_name = prepare_gdb_cmnd_file( dsi );
+    if( !cmnd_file_name )
+        return;
+
+    char dbg_cmd_buff[500];
+    ::snprintf( dbg_cmd_buff, sizeof(dbg_cmd_buff), "(progn (gdb \"gdb -q -x %s\"))", cmnd_file_name );
+
+    start_debugger_in_emacs( dsi, "emacs", dbg_cmd_buff );
+}
+
+
+
+static void
+start_gdb_in_xemacs( dbg_startup_info const& )
+{
+
+}
+
+
+
+
+
+
+
+static char const*
+prepare_dbx_cmd_line( dbg_startup_info const& dsi, bool list_source = true )
+{
+    static char cmd_line_buff[500];
+
+    ::snprintf( cmd_line_buff, sizeof(cmd_line_buff), "unlink %s;cont;%s%s",
+                   dsi.init_done_lock.begin(),
+                   dsi.break_or_continue ? "up 2;": "",
+                   list_source ? "echo \" \";list -w3;" : "" );
+
+    return cmd_line_buff;
+}
+
+
+
+static void
+start_dbx_in_console( dbg_startup_info const& dsi )
+{
+    char pid_buff[16];
+    ::snprintf( pid_buff, sizeof(pid_buff), "%ld", dsi.pid );
+
+    safe_execlp( "dbx", "-q", "-c", prepare_dbx_cmd_line( dsi ), dsi.binary_path.begin(), pid_buff, 0 );
+}
+
+
+
+static void
+start_dbx_in_xterm( dbg_startup_info const& dsi )
+{
+    char const* title = prepare_window_title( dsi );
+    if( !title )
+        return;
+
+    char pid_buff[16];
+    ::snprintf( pid_buff, sizeof(pid_buff), "%ld", dsi.pid );
+
+    safe_execlp( "xterm", "-T", title, "-display", dsi.display.begin(),
+                    "-bg", "black", "-fg", "white", "-geometry", "88x30+10+10", "-fn", "9x15", "-e",
+                 "dbx", "-q", "-c", prepare_dbx_cmd_line( dsi ), dsi.binary_path.begin(), pid_buff, 0 );
+}
+
+
+
+static void
+start_dbx_in_emacs( dbg_startup_info const& )
+{
+
+
+
+
+
+}
+
+
+
+static void
+start_dbx_in_xemacs( dbg_startup_info const& )
+{
+
+}
+
+
+
+static void
+start_dbx_in_ddd( dbg_startup_info const& dsi )
+{
+    char const* title = prepare_window_title( dsi );
+    if( !title )
+        return;
+
+    char pid_buff[16];
+    ::snprintf( pid_buff, sizeof(pid_buff), "%ld", dsi.pid );
+
+    safe_execlp( "ddd", "-display", dsi.display.begin(),
+                 "--dbx", "-q", "-c", prepare_dbx_cmd_line( dsi, false ), dsi.binary_path.begin(), pid_buff, 0 );
+}
+
+
+
+
+
+
+
+static struct info_t {
+
+    info_t();
+
+
+    unit_test::readwrite_property<std::string> p_dbg;
+
+
+    std::map<std::string,dbg_starter> m_dbg_starter_reg;
+} s_info;
+
+
+
+info_t::info_t()
+{
+    p_dbg.value = ::getenv( "DISPLAY" )
+        ? std::string( "gdb-xterm" )
+        : std::string( "gdb" );
+
+    m_dbg_starter_reg[std::string("gdb")] = &start_gdb_in_console;
+    m_dbg_starter_reg[std::string("gdb-emacs")] = &start_gdb_in_emacs;
+    m_dbg_starter_reg[std::string("gdb-xterm")] = &start_gdb_in_xterm;
+    m_dbg_starter_reg[std::string("gdb-xemacs")] = &start_gdb_in_xemacs;
+
+    m_dbg_starter_reg[std::string("dbx")] = &start_dbx_in_console;
+    m_dbg_starter_reg[std::string("dbx-emacs")] = &start_dbx_in_emacs;
+    m_dbg_starter_reg[std::string("dbx-xterm")] = &start_dbx_in_xterm;
+    m_dbg_starter_reg[std::string("dbx-xemacs")] = &start_dbx_in_xemacs;
+    m_dbg_starter_reg[std::string("dbx-ddd")] = &start_dbx_in_ddd;
+}
+
+
+
+
+
+}
+
+
+
+
+
+bool
+under_debugger()
+{
+
+
+
+
+
+
+
+    const_string dbg_list = ::boost::unit_test::const_string( "gdb", sizeof( "gdb" ) - 1 );
+
+    pid_t pid = ::getpid();
+
+    while( pid != 0 ) {
+        process_info pi( pid );
+
+
+        if( dbg_list.find( pi.binary_name() ) != const_string::npos )
+            return true;
+
+        pid = (pi.parent_pid() == pid ? 0 : pi.parent_pid());
+    }
+
+    return false;
+
+
+
+
+
+
+}
+# 674 "/usr/include/boost/test/impl/debug.ipp" 3 4
+void
+debugger_break()
+{
+# 712 "/usr/include/boost/test/impl/debug.ipp" 3 4
+    ::kill( ::getpid(), 5 );
+
+
+
+
+}
+# 727 "/usr/include/boost/test/impl/debug.ipp" 3 4
+std::string
+set_debugger( unit_test::const_string dbg_id, dbg_starter s )
+{
+    std::string old = s_info.p_dbg;
+
+    assign_op( s_info.p_dbg.value, dbg_id, 0 );
+
+    if( !!s )
+        s_info.m_dbg_starter_reg[s_info.p_dbg.get()] = s;
+
+    return old;
+}
+# 779 "/usr/include/boost/test/impl/debug.ipp" 3 4
+bool
+attach_debugger( bool break_or_continue )
+{
+    if( under_debugger() )
+        return false;
+# 892 "/usr/include/boost/test/impl/debug.ipp" 3 4
+    char init_done_lock_fn[] = "/tmp/btl_dbg_init_done_XXXXXX";
+    fd_holder init_done_lock_fd( ::mkstemp( init_done_lock_fn ) );
+
+    if( init_done_lock_fd == -1 )
+        return false;
+
+    pid_t child_pid = fork();
+
+    if( child_pid == -1 )
+        return false;
+
+    if( child_pid != 0 ) {
+        dbg_startup_info dsi;
+
+        process_info pi( child_pid );
+        if( pi.binary_path().is_empty() )
+            ::exit( -1 );
+
+        dsi.pid = child_pid;
+        dsi.break_or_continue = break_or_continue;
+        dsi.binary_path = pi.binary_path();
+        dsi.display = ::getenv( "DISPLAY" );
+        dsi.init_done_lock = init_done_lock_fn;
+
+        dbg_starter starter = s_info.m_dbg_starter_reg[s_info.p_dbg];
+        if( !!starter )
+            starter( dsi );
+
+        ::perror( "Boost.Test execution monitor failed to start a debugger:" );
+
+        ::exit( -1 );
+    }
+
+
+
+    while( ::access( init_done_lock_fn, 0 ) == 0 ) {
+        struct timeval to = { 0, 100 };
+
+        ::select( 0, 0, 0, 0, &to );
+    }
+
+
+
+
+    if( break_or_continue )
+        debugger_break();
+
+    return true;
+
+
+
+
+
+
+}
+
+
+
+
+
+
+
+void
+detect_memory_leaks( bool on_off, unit_test::const_string report_file )
+{
+    boost::ignore_unused( on_off );
+# 979 "/usr/include/boost/test/impl/debug.ipp" 3 4
+    boost::ignore_unused( report_file );
+
+}
+# 990 "/usr/include/boost/test/impl/debug.ipp" 3 4
+void
+break_memory_alloc( long mem_alloc_order_num )
+{
+    boost::ignore_unused( mem_alloc_order_num );
+
+
+
+
+
+
+}
+
+
+
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 1008 "/usr/include/boost/test/impl/debug.ipp" 2 3 4
+# 21 "/usr/include/boost/test/included/unit_test.hpp" 2 3 4
+# 1 "/usr/include/boost/test/impl/decorator.ipp" 1 3 4
+# 12 "/usr/include/boost/test/impl/decorator.ipp" 3 4
+#define BOOST_TEST_TREE_DECORATOR_IPP_091911GER 
+
+
+
+
+
+
+
+# 1 "/usr/include/boost/test/utils/iterator/token_iterator.hpp" 1 3 4
+# 16 "/usr/include/boost/test/utils/iterator/token_iterator.hpp" 3 4
+#define BOOST_TEST_UTILS_TOKEN_ITERATOR_HPP 
+
+
+
+
+
+# 1 "/usr/include/boost/iterator/iterator_categories.hpp" 1 3 4
+
+
+
+
+
+
+#define BOOST_ITERATOR_CATEGORIES_HPP 
+
+
+# 1 "/usr/include/boost/iterator/detail/config_def.hpp" 1 3 4
+# 22 "/usr/include/boost/iterator/detail/config_def.hpp" 3 4
+#define BOOST_ITERATOR_CONFIG_DEF 
+# 45 "/usr/include/boost/iterator/detail/config_def.hpp" 3 4
+#define BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY 1
+# 11 "/usr/include/boost/iterator/iterator_categories.hpp" 2 3 4
+
+
+
+# 1 "/usr/include/boost/mpl/eval_if.hpp" 1 3 4
+
+
+#define BOOST_MPL_EVAL_IF_HPP_INCLUDED 
+# 17 "/usr/include/boost/mpl/eval_if.hpp" 3 4
+# 1 "/usr/include/boost/mpl/if.hpp" 1 3 4
+
+
+#define BOOST_MPL_IF_HPP_INCLUDED 
+# 17 "/usr/include/boost/mpl/if.hpp" 3 4
+# 1 "/usr/include/boost/mpl/aux_/value_wknd.hpp" 1 3 4
+
+
+#define BOOST_MPL_AUX_VALUE_WKND_HPP_INCLUDED 
+# 17 "/usr/include/boost/mpl/aux_/value_wknd.hpp" 3 4
+# 1 "/usr/include/boost/mpl/aux_/static_cast.hpp" 1 3 4
+
+
+#define BOOST_MPL_AUX_STATIC_CAST_HPP_INCLUDED 
+# 24 "/usr/include/boost/mpl/aux_/static_cast.hpp" 3 4
+#define BOOST_MPL_AUX_STATIC_CAST(T,expr) static_cast<T>(expr)
+# 18 "/usr/include/boost/mpl/aux_/value_wknd.hpp" 2 3 4
+# 1 "/usr/include/boost/mpl/aux_/config/integral.hpp" 1 3 4
+
+
+#define BOOST_MPL_AUX_CONFIG_INTEGRAL_HPP_INCLUDED 
+# 19 "/usr/include/boost/mpl/aux_/value_wknd.hpp" 2 3 4
+# 1 "/usr/include/boost/mpl/aux_/config/eti.hpp" 1 3 4
+
+
+#define BOOST_MPL_AUX_CONFIG_ETI_HPP_INCLUDED 
+# 20 "/usr/include/boost/mpl/aux_/value_wknd.hpp" 2 3 4
+# 57 "/usr/include/boost/mpl/aux_/value_wknd.hpp" 3 4
+#define BOOST_MPL_AUX_VALUE_WKND(C) C
+#define BOOST_MPL_AUX_MSVC_VALUE_WKND(C) C
+# 67 "/usr/include/boost/mpl/aux_/value_wknd.hpp" 3 4
+#define BOOST_MPL_AUX_NESTED_VALUE_WKND(T,C) BOOST_MPL_AUX_VALUE_WKND(C)::value
+
+
+
+
+
+namespace boost { namespace mpl { namespace aux {
+
+template< typename T > struct value_type_wknd
+{
+    typedef typename T::value_type type;
+};
+# 87 "/usr/include/boost/mpl/aux_/value_wknd.hpp" 3 4
+}}}
+# 18 "/usr/include/boost/mpl/if.hpp" 2 3 4
+
+# 1 "/usr/include/boost/mpl/aux_/na_spec.hpp" 1 3 4
+
+
+#define BOOST_MPL_AUX_NA_SPEC_HPP_INCLUDED 
+# 18 "/usr/include/boost/mpl/aux_/na_spec.hpp" 3 4
+# 1 "/usr/include/boost/mpl/lambda_fwd.hpp" 1 3 4
+
+
+#define BOOST_MPL_LAMBDA_FWD_HPP_INCLUDED 
+# 17 "/usr/include/boost/mpl/lambda_fwd.hpp" 3 4
+# 1 "/usr/include/boost/mpl/void_fwd.hpp" 1 3 4
+
+
+#define BOOST_MPL_VOID_FWD_HPP_INCLUDED 
+# 19 "/usr/include/boost/mpl/void_fwd.hpp" 3 4
+namespace mpl_ {
+
+struct void_;
+
+}
+namespace boost { namespace mpl { using ::mpl_::void_; } }
+# 18 "/usr/include/boost/mpl/lambda_fwd.hpp" 2 3 4
+# 1 "/usr/include/boost/mpl/aux_/na.hpp" 1 3 4
+
+
+#define BOOST_MPL_AUX_NA_HPP_INCLUDED 
+# 18 "/usr/include/boost/mpl/aux_/na.hpp" 3 4
+# 1 "/usr/include/boost/mpl/aux_/na_fwd.hpp" 1 3 4
+
+
+#define BOOST_MPL_AUX_NA_FWD_HPP_INCLUDED 
+# 19 "/usr/include/boost/mpl/aux_/na_fwd.hpp" 3 4
+namespace mpl_ {
+
+
+struct na
+{
+    typedef na type;
+    enum { value = 0 };
+};
+
+}
+namespace boost { namespace mpl { using ::mpl_::na; } }
+# 19 "/usr/include/boost/mpl/aux_/na.hpp" 2 3 4
+
+# 1 "/usr/include/boost/mpl/aux_/config/ctps.hpp" 1 3 4
+
+
+#define BOOST_MPL_AUX_CONFIG_CTPS_HPP_INCLUDED 
+# 21 "/usr/include/boost/mpl/aux_/na.hpp" 2 3 4
+
+namespace boost { namespace mpl {
+
+template< typename T >
+struct is_na
+    : false_
+{
+
+
+
+};
+
+template<>
+struct is_na<na>
+    : true_
+{
+
+
+
+};
+
+template< typename T >
+struct is_not_na
+    : true_
+{
+
+
+
+};
+
+template<>
+struct is_not_na<na>
+    : false_
+{
+
+
+
+};
+
+
+template< typename T, typename U > struct if_na
+{
+    typedef T type;
+};
+
+template< typename U > struct if_na<na,U>
+{
+    typedef U type;
+};
+# 93 "/usr/include/boost/mpl/aux_/na.hpp" 3 4
+}}
+# 19 "/usr/include/boost/mpl/lambda_fwd.hpp" 2 3 4
+# 1 "/usr/include/boost/mpl/aux_/config/lambda.hpp" 1 3 4
+
+
+#define BOOST_MPL_AUX_CONFIG_LAMBDA_HPP_INCLUDED 
+# 17 "/usr/include/boost/mpl/aux_/config/lambda.hpp" 3 4
+# 1 "/usr/include/boost/mpl/aux_/config/ttp.hpp" 1 3 4
+
+
+#define BOOST_MPL_AUX_CONFIG_TTP_HPP_INCLUDED 
+# 37 "/usr/include/boost/mpl/aux_/config/ttp.hpp" 3 4
+#define BOOST_MPL_CFG_EXTENDED_TEMPLATE_PARAMETERS_MATCHING 
+# 18 "/usr/include/boost/mpl/aux_/config/lambda.hpp" 2 3 4
+# 20 "/usr/include/boost/mpl/lambda_fwd.hpp" 2 3 4
+
+
+
+# 1 "/usr/include/boost/mpl/int.hpp" 1 3 4
+
+
+#define BOOST_MPL_INT_HPP_INCLUDED 
+# 17 "/usr/include/boost/mpl/int.hpp" 3 4
+# 1 "/usr/include/boost/mpl/int_fwd.hpp" 1 3 4
+
+
+#define BOOST_MPL_INT_FWD_HPP_INCLUDED 
+# 18 "/usr/include/boost/mpl/int_fwd.hpp" 3 4
+# 1 "/usr/include/boost/mpl/aux_/nttp_decl.hpp" 1 3 4
+
+
+#define BOOST_MPL_AUX_NTTP_DECL_HPP_INCLUDED 
+# 17 "/usr/include/boost/mpl/aux_/nttp_decl.hpp" 3 4
+# 1 "/usr/include/boost/mpl/aux_/config/nttp.hpp" 1 3 4
+
+
+#define BOOST_MPL_AUX_CONFIG_NTTP_HPP_INCLUDED 
+# 18 "/usr/include/boost/mpl/aux_/nttp_decl.hpp" 2 3 4
+# 31 "/usr/include/boost/mpl/aux_/nttp_decl.hpp" 3 4
+#define BOOST_MPL_AUX_NTTP_DECL(T,x) T x
+# 19 "/usr/include/boost/mpl/int_fwd.hpp" 2 3 4
+
+namespace mpl_ {
+
+template< int N > struct int_;
+
+}
+namespace boost { namespace mpl { using ::mpl_::int_; } }
+# 18 "/usr/include/boost/mpl/int.hpp" 2 3 4
+
+#define AUX_WRAPPER_VALUE_TYPE int
+# 1 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 1 3 4
+# 25 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 3 4
+#define AUX_WRAPPER_NAME BOOST_PP_CAT(AUX_WRAPPER_VALUE_TYPE,_)
+
+
+
+#define AUX_WRAPPER_PARAMS(N) BOOST_MPL_AUX_NTTP_DECL(AUX_WRAPPER_VALUE_TYPE, N)
+
+
+
+
+
+
+#define AUX_WRAPPER_INST(value) BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::AUX_WRAPPER_NAME< value >
+
+
+
+namespace mpl_ {
+
+template< int N >
+struct int_
+{
+    static const int value = N;
+
+
+
+
+
+    typedef int_ type;
+
+    typedef int value_type;
+    typedef integral_c_tag tag;
+# 72 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 3 4
+    typedef mpl_::int_< static_cast<int>((value + 1)) > next;
+    typedef mpl_::int_< static_cast<int>((value - 1)) > prior;
+
+
+
+
+
+
+    constexpr operator int() const { return static_cast<int>(this->value); }
+};
+
+
+template< int N >
+int const mpl_::int_< N >::value;
+
+
+}
+
+#undef AUX_WRAPPER_NAME
+#undef AUX_WRAPPER_PARAMS
+#undef AUX_WRAPPER_INST
+#undef AUX_WRAPPER_VALUE_TYPE
+# 21 "/usr/include/boost/mpl/int.hpp" 2 3 4
+# 24 "/usr/include/boost/mpl/lambda_fwd.hpp" 2 3 4
+# 1 "/usr/include/boost/mpl/aux_/lambda_arity_param.hpp" 1 3 4
+
+
+#define BOOST_MPL_AUX_LAMBDA_ARITY_PARAM_HPP_INCLUDED 
+# 22 "/usr/include/boost/mpl/aux_/lambda_arity_param.hpp" 3 4
+#define BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(param) , param
+# 25 "/usr/include/boost/mpl/lambda_fwd.hpp" 2 3 4
+# 1 "/usr/include/boost/mpl/aux_/template_arity_fwd.hpp" 1 3 4
+
+
+#define BOOST_MPL_AUX_TEMPLATE_ARITY_FWD_HPP_INCLUDED 
+# 17 "/usr/include/boost/mpl/aux_/template_arity_fwd.hpp" 3 4
+namespace boost { namespace mpl { namespace aux {
+
+template< typename F > struct template_arity;
+
+}}}
+# 26 "/usr/include/boost/mpl/lambda_fwd.hpp" 2 3 4
+
+namespace boost { namespace mpl {
+
+template<
+      typename T = na
+    , typename Tag = void_
+    , typename Arity = int_< aux::template_arity<T>::value >
+
+
+    >
+struct lambda;
+
+}}
+# 19 "/usr/include/boost/mpl/aux_/na_spec.hpp" 2 3 4
+
+
+
+# 1 "/usr/include/boost/mpl/aux_/arity.hpp" 1 3 4
+
+
+#define BOOST_MPL_AUX_ARITY_HPP_INCLUDED 
+# 17 "/usr/include/boost/mpl/aux_/arity.hpp" 3 4
+# 1 "/usr/include/boost/mpl/aux_/config/dtp.hpp" 1 3 4
+
+
+#define BOOST_MPL_AUX_CONFIG_DTP_HPP_INCLUDED 
+# 18 "/usr/include/boost/mpl/aux_/arity.hpp" 2 3 4
+# 23 "/usr/include/boost/mpl/aux_/na_spec.hpp" 2 3 4
+
+
+
+# 1 "/usr/include/boost/mpl/aux_/preprocessor/params.hpp" 1 3 4
+
+
+#define BOOST_MPL_AUX_PREPROCESSOR_PARAMS_HPP_INCLUDED 
+# 17 "/usr/include/boost/mpl/aux_/preprocessor/params.hpp" 3 4
+# 1 "/usr/include/boost/mpl/aux_/config/preprocessor.hpp" 1 3 4
+
+
+#define BOOST_MPL_AUX_CONFIG_PREPROCESSOR_HPP_INCLUDED 
+# 30 "/usr/include/boost/mpl/aux_/config/preprocessor.hpp" 3 4
+#define BOOST_MPL_CFG_NO_OWN_PP_PRIMITIVES 
+# 18 "/usr/include/boost/mpl/aux_/preprocessor/params.hpp" 2 3 4
+# 45 "/usr/include/boost/mpl/aux_/preprocessor/params.hpp" 3 4
+# 1 "/usr/include/boost/preprocessor/comma_if.hpp" 1 3 4
+# 13 "/usr/include/boost/preprocessor/comma_if.hpp" 3 4
+#define BOOST_PREPROCESSOR_COMMA_IF_HPP 
+# 46 "/usr/include/boost/mpl/aux_/preprocessor/params.hpp" 2 3 4
+
+
+
+
+#define BOOST_MPL_PP_AUX_PARAM_FUNC(unused,i,param) BOOST_PP_COMMA_IF(i) BOOST_PP_CAT(param, BOOST_PP_INC(i))
+
+
+
+
+#define BOOST_MPL_PP_PARAMS(n,param) BOOST_PP_REPEAT( n , BOOST_MPL_PP_AUX_PARAM_FUNC , param )
+# 27 "/usr/include/boost/mpl/aux_/na_spec.hpp" 2 3 4
+# 1 "/usr/include/boost/mpl/aux_/preprocessor/enum.hpp" 1 3 4
+
+
+#define BOOST_MPL_AUX_PREPROCESSOR_ENUM_HPP_INCLUDED 
+# 48 "/usr/include/boost/mpl/aux_/preprocessor/enum.hpp" 3 4
+#define BOOST_MPL_PP_AUX_ENUM_FUNC(unused,i,param) BOOST_PP_COMMA_IF(i) param
+
+
+
+#define BOOST_MPL_PP_ENUM(n,param) BOOST_PP_REPEAT( n , BOOST_MPL_PP_AUX_ENUM_FUNC , param )
+# 28 "/usr/include/boost/mpl/aux_/na_spec.hpp" 2 3 4
+# 1 "/usr/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 1 3 4
+
+
+#define BOOST_MPL_AUX_PREPROCESSOR_DEF_PARAMS_TAIL_HPP_INCLUDED 
+# 17 "/usr/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 3 4
+# 1 "/usr/include/boost/mpl/limits/arity.hpp" 1 3 4
+
+
+#define BOOST_MPL_LIMITS_ARITY_HPP_INCLUDED 
+# 18 "/usr/include/boost/mpl/limits/arity.hpp" 3 4
+#define BOOST_MPL_LIMIT_METAFUNCTION_ARITY 5
+# 18 "/usr/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 2 3 4
+
+
+
+
+# 1 "/usr/include/boost/preprocessor/logical/and.hpp" 1 3 4
+# 15 "/usr/include/boost/preprocessor/logical/and.hpp" 3 4
+#define BOOST_PREPROCESSOR_LOGICAL_AND_HPP 
+
+
+
+# 1 "/usr/include/boost/preprocessor/logical/bitand.hpp" 1 3 4
+# 13 "/usr/include/boost/preprocessor/logical/bitand.hpp" 3 4
+#define BOOST_PREPROCESSOR_LOGICAL_BITAND_HPP 
+
+
+
+
+
+
+#define BOOST_PP_BITAND(x,y) BOOST_PP_BITAND_I(x, y)
+
+
+
+
+
+
+#define BOOST_PP_BITAND_I(x,y) BOOST_PP_BITAND_ ## x ## y
+
+
+
+
+
+#define BOOST_PP_BITAND_00 0
+#define BOOST_PP_BITAND_01 0
+#define BOOST_PP_BITAND_10 0
+#define BOOST_PP_BITAND_11 1
+# 20 "/usr/include/boost/preprocessor/logical/and.hpp" 2 3 4
+
+
+
+
+#define BOOST_PP_AND(p,q) BOOST_PP_BITAND(BOOST_PP_BOOL(p), BOOST_PP_BOOL(q))
+# 23 "/usr/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 2 3 4
+# 1 "/usr/include/boost/preprocessor/identity.hpp" 1 3 4
+# 13 "/usr/include/boost/preprocessor/identity.hpp" 3 4
+#define BOOST_PREPROCESSOR_IDENTITY_HPP 
+
+# 1 "/usr/include/boost/preprocessor/facilities/identity.hpp" 1 3 4
+# 16 "/usr/include/boost/preprocessor/facilities/identity.hpp" 3 4
+#define BOOST_PREPROCESSOR_FACILITIES_IDENTITY_HPP 
+
+
+
+
+
+
+#define BOOST_PP_IDENTITY(item) item BOOST_PP_EMPTY
+
+#define BOOST_PP_IDENTITY_N(item,n) item BOOST_PP_TUPLE_EAT_N(n)
+# 16 "/usr/include/boost/preprocessor/identity.hpp" 2 3 4
+# 24 "/usr/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 2 3 4
+# 1 "/usr/include/boost/preprocessor/empty.hpp" 1 3 4
+# 13 "/usr/include/boost/preprocessor/empty.hpp" 3 4
+#define BOOST_PREPROCESSOR_EMPTY_HPP 
+# 25 "/usr/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 2 3 4
+# 66 "/usr/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 3 4
+# 1 "/usr/include/boost/preprocessor/arithmetic/add.hpp" 1 3 4
+# 15 "/usr/include/boost/preprocessor/arithmetic/add.hpp" 3 4
+#define BOOST_PREPROCESSOR_ARITHMETIC_ADD_HPP 
+
+
+
+
+# 1 "/usr/include/boost/preprocessor/control/while.hpp" 1 3 4
+# 15 "/usr/include/boost/preprocessor/control/while.hpp" 3 4
+#define BOOST_PREPROCESSOR_CONTROL_WHILE_HPP 
+
+
+
+
+# 1 "/usr/include/boost/preprocessor/detail/auto_rec.hpp" 1 3 4
+# 21 "/usr/include/boost/preprocessor/control/while.hpp" 2 3 4
+# 1 "/usr/include/boost/preprocessor/list/fold_left.hpp" 1 3 4
+# 15 "/usr/include/boost/preprocessor/list/fold_left.hpp" 3 4
+#define BOOST_PREPROCESSOR_LIST_FOLD_LEFT_HPP 
+
+
+# 1 "/usr/include/boost/preprocessor/control/while.hpp" 1 3 4
+# 19 "/usr/include/boost/preprocessor/list/fold_left.hpp" 2 3 4
+
+# 1 "/usr/include/boost/preprocessor/detail/auto_rec.hpp" 1 3 4
+# 21 "/usr/include/boost/preprocessor/list/fold_left.hpp" 2 3 4
+
+
+
+
+
+
+
+#define BOOST_PP_LIST_FOLD_LEFT BOOST_PP_CAT(BOOST_PP_LIST_FOLD_LEFT_, BOOST_PP_AUTO_REC(BOOST_PP_WHILE_P, 256))
+
+#define BOOST_PP_LIST_FOLD_LEFT_257(o,s,l) BOOST_PP_ERROR(0x0004)
+
+#define BOOST_PP_LIST_FOLD_LEFT_D(d,o,s,l) BOOST_PP_LIST_FOLD_LEFT_ ## d(o, s, l)
+#define BOOST_PP_LIST_FOLD_LEFT_2ND BOOST_PP_LIST_FOLD_LEFT
+#define BOOST_PP_LIST_FOLD_LEFT_2ND_D BOOST_PP_LIST_FOLD_LEFT_D
+
+
+
+
+
+
+# 1 "/usr/include/boost/preprocessor/list/detail/fold_left.hpp" 1 3 4
+# 15 "/usr/include/boost/preprocessor/list/detail/fold_left.hpp" 3 4
+#define BOOST_PREPROCESSOR_LIST_DETAIL_FOLD_LEFT_HPP 
+
+
+
+# 1 "/usr/include/boost/preprocessor/list/adt.hpp" 1 3 4
+# 15 "/usr/include/boost/preprocessor/list/adt.hpp" 3 4
+#define BOOST_PREPROCESSOR_LIST_ADT_HPP 
+
+
+# 1 "/usr/include/boost/preprocessor/detail/is_binary.hpp" 1 3 4
+# 13 "/usr/include/boost/preprocessor/detail/is_binary.hpp" 3 4
+#define BOOST_PREPROCESSOR_DETAIL_IS_BINARY_HPP 
+
+
+# 1 "/usr/include/boost/preprocessor/detail/check.hpp" 1 3 4
+# 13 "/usr/include/boost/preprocessor/detail/check.hpp" 3 4
+#define BOOST_PREPROCESSOR_DETAIL_CHECK_HPP 
+
+
+
+
+
+
+
+#define BOOST_PP_CHECK(x,type) BOOST_PP_CHECK_D(x, type)
+
+
+
+
+
+
+#define BOOST_PP_CHECK_D(x,type) BOOST_PP_CHECK_1(BOOST_PP_CAT(BOOST_PP_CHECK_RESULT_, type x))
+#define BOOST_PP_CHECK_1(chk) BOOST_PP_CHECK_2(chk)
+#define BOOST_PP_CHECK_2(res,_) res
+# 46 "/usr/include/boost/preprocessor/detail/check.hpp" 3 4
+#define BOOST_PP_CHECK_RESULT_1 1, BOOST_PP_NIL
+# 17 "/usr/include/boost/preprocessor/detail/is_binary.hpp" 2 3 4
+
+
+
+
+#define BOOST_PP_IS_BINARY(x) BOOST_PP_CHECK(x, BOOST_PP_IS_BINARY_CHECK)
+
+
+
+
+
+#define BOOST_PP_IS_BINARY_CHECK(a,b) 1
+#define BOOST_PP_CHECK_RESULT_BOOST_PP_IS_BINARY_CHECK 0, BOOST_PP_NIL
+# 19 "/usr/include/boost/preprocessor/list/adt.hpp" 2 3 4
+
+
+
+
+
+#define BOOST_PP_LIST_CONS(head,tail) (head, tail)
+
+
+
+#define BOOST_PP_LIST_NIL BOOST_PP_NIL
+
+
+
+#define BOOST_PP_LIST_FIRST(list) BOOST_PP_LIST_FIRST_D(list)
+
+
+#define BOOST_PP_LIST_FIRST_D(list) BOOST_PP_LIST_FIRST_I list
+
+
+
+
+#define BOOST_PP_LIST_FIRST_I(head,tail) head
+
+
+
+#define BOOST_PP_LIST_REST(list) BOOST_PP_LIST_REST_D(list)
+
+
+#define BOOST_PP_LIST_REST_D(list) BOOST_PP_LIST_REST_I list
+
+
+
+
+#define BOOST_PP_LIST_REST_I(head,tail) tail
+# 62 "/usr/include/boost/preprocessor/list/adt.hpp" 3 4
+#define BOOST_PP_LIST_IS_CONS(list) BOOST_PP_IS_BINARY(list)
+
+
+
+
+
+#define BOOST_PP_LIST_IS_NIL(list) BOOST_PP_COMPL(BOOST_PP_IS_BINARY(list))
+# 20 "/usr/include/boost/preprocessor/list/detail/fold_left.hpp" 2 3 4
+
+
+#define BOOST_PP_LIST_FOLD_LEFT_1(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_2, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(2, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_2(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_3, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(3, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_3(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_4, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(4, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_4(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_5, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(5, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_5(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_6, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(6, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_6(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_7, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(7, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_7(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_8, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(8, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_8(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_9, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(9, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_9(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_10, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(10, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_10(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_11, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(11, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_11(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_12, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(12, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_12(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_13, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(13, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_13(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_14, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(14, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_14(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_15, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(15, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_15(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_16, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(16, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_16(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_17, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(17, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_17(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_18, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(18, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_18(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_19, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(19, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_19(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_20, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(20, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_20(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_21, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(21, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_21(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_22, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(22, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_22(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_23, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(23, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_23(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_24, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(24, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_24(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_25, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(25, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_25(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_26, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(26, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_26(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_27, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(27, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_27(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_28, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(28, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_28(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_29, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(29, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_29(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_30, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(30, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_30(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_31, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(31, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_31(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_32, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(32, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_32(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_33, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(33, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_33(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_34, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(34, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_34(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_35, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(35, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_35(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_36, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(36, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_36(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_37, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(37, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_37(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_38, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(38, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_38(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_39, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(39, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_39(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_40, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(40, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_40(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_41, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(41, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_41(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_42, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(42, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_42(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_43, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(43, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_43(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_44, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(44, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_44(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_45, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(45, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_45(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_46, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(46, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_46(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_47, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(47, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_47(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_48, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(48, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_48(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_49, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(49, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_49(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_50, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(50, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_50(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_51, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(51, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_51(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_52, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(52, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_52(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_53, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(53, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_53(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_54, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(54, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_54(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_55, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(55, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_55(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_56, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(56, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_56(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_57, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(57, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_57(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_58, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(58, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_58(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_59, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(59, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_59(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_60, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(60, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_60(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_61, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(61, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_61(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_62, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(62, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_62(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_63, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(63, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_63(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_64, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(64, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_64(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_65, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(65, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_65(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_66, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(66, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_66(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_67, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(67, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_67(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_68, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(68, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_68(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_69, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(69, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_69(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_70, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(70, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_70(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_71, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(71, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_71(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_72, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(72, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_72(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_73, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(73, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_73(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_74, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(74, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_74(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_75, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(75, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_75(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_76, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(76, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_76(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_77, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(77, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_77(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_78, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(78, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_78(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_79, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(79, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_79(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_80, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(80, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_80(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_81, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(81, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_81(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_82, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(82, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_82(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_83, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(83, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_83(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_84, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(84, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_84(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_85, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(85, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_85(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_86, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(86, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_86(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_87, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(87, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_87(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_88, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(88, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_88(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_89, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(89, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_89(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_90, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(90, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_90(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_91, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(91, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_91(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_92, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(92, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_92(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_93, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(93, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_93(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_94, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(94, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_94(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_95, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(95, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_95(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_96, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(96, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_96(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_97, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(97, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_97(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_98, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(98, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_98(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_99, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(99, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_99(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_100, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(100, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_100(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_101, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(101, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_101(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_102, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(102, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_102(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_103, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(103, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_103(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_104, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(104, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_104(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_105, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(105, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_105(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_106, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(106, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_106(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_107, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(107, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_107(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_108, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(108, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_108(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_109, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(109, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_109(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_110, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(110, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_110(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_111, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(111, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_111(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_112, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(112, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_112(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_113, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(113, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_113(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_114, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(114, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_114(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_115, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(115, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_115(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_116, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(116, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_116(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_117, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(117, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_117(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_118, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(118, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_118(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_119, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(119, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_119(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_120, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(120, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_120(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_121, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(121, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_121(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_122, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(122, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_122(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_123, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(123, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_123(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_124, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(124, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_124(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_125, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(125, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_125(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_126, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(126, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_126(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_127, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(127, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_127(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_128, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(128, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_128(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_129, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(129, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_129(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_130, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(130, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_130(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_131, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(131, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_131(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_132, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(132, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_132(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_133, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(133, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_133(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_134, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(134, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_134(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_135, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(135, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_135(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_136, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(136, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_136(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_137, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(137, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_137(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_138, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(138, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_138(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_139, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(139, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_139(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_140, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(140, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_140(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_141, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(141, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_141(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_142, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(142, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_142(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_143, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(143, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_143(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_144, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(144, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_144(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_145, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(145, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_145(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_146, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(146, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_146(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_147, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(147, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_147(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_148, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(148, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_148(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_149, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(149, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_149(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_150, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(150, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_150(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_151, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(151, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_151(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_152, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(152, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_152(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_153, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(153, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_153(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_154, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(154, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_154(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_155, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(155, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_155(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_156, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(156, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_156(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_157, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(157, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_157(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_158, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(158, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_158(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_159, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(159, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_159(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_160, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(160, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_160(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_161, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(161, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_161(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_162, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(162, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_162(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_163, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(163, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_163(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_164, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(164, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_164(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_165, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(165, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_165(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_166, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(166, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_166(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_167, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(167, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_167(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_168, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(168, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_168(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_169, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(169, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_169(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_170, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(170, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_170(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_171, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(171, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_171(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_172, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(172, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_172(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_173, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(173, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_173(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_174, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(174, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_174(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_175, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(175, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_175(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_176, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(176, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_176(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_177, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(177, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_177(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_178, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(178, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_178(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_179, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(179, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_179(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_180, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(180, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_180(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_181, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(181, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_181(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_182, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(182, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_182(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_183, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(183, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_183(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_184, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(184, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_184(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_185, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(185, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_185(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_186, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(186, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_186(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_187, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(187, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_187(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_188, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(188, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_188(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_189, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(189, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_189(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_190, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(190, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_190(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_191, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(191, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_191(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_192, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(192, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_192(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_193, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(193, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_193(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_194, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(194, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_194(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_195, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(195, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_195(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_196, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(196, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_196(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_197, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(197, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_197(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_198, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(198, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_198(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_199, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(199, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_199(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_200, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(200, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_200(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_201, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(201, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_201(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_202, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(202, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_202(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_203, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(203, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_203(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_204, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(204, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_204(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_205, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(205, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_205(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_206, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(206, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_206(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_207, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(207, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_207(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_208, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(208, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_208(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_209, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(209, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_209(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_210, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(210, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_210(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_211, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(211, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_211(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_212, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(212, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_212(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_213, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(213, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_213(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_214, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(214, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_214(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_215, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(215, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_215(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_216, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(216, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_216(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_217, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(217, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_217(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_218, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(218, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_218(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_219, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(219, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_219(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_220, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(220, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_220(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_221, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(221, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_221(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_222, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(222, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_222(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_223, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(223, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_223(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_224, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(224, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_224(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_225, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(225, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_225(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_226, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(226, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_226(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_227, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(227, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_227(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_228, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(228, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_228(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_229, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(229, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_229(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_230, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(230, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_230(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_231, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(231, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_231(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_232, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(232, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_232(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_233, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(233, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_233(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_234, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(234, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_234(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_235, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(235, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_235(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_236, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(236, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_236(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_237, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(237, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_237(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_238, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(238, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_238(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_239, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(239, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_239(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_240, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(240, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_240(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_241, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(241, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_241(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_242, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(242, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_242(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_243, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(243, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_243(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_244, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(244, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_244(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_245, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(245, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_245(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_246, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(246, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_246(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_247, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(247, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_247(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_248, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(248, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_248(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_249, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(249, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_249(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_250, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(250, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_250(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_251, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(251, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_251(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_252, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(252, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_252(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_253, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(253, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_253(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_254, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(254, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_254(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_255, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(255, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_255(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_256, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(256, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+#define BOOST_PP_LIST_FOLD_LEFT_256(o,s,l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_257, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(257, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
+# 42 "/usr/include/boost/preprocessor/list/fold_left.hpp" 2 3 4
+
+
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_NIL 1
+
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_1(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_2(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_3(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_4(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_5(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_6(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_7(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_8(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_9(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_10(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_11(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_12(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_13(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_14(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_15(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_16(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_17(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_18(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_19(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_20(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_21(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_22(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_23(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_24(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_25(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_26(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_27(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_28(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_29(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_30(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_31(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_32(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_33(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_34(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_35(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_36(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_37(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_38(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_39(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_40(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_41(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_42(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_43(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_44(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_45(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_46(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_47(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_48(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_49(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_50(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_51(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_52(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_53(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_54(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_55(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_56(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_57(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_58(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_59(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_60(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_61(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_62(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_63(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_64(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_65(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_66(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_67(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_68(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_69(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_70(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_71(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_72(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_73(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_74(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_75(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_76(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_77(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_78(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_79(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_80(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_81(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_82(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_83(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_84(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_85(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_86(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_87(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_88(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_89(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_90(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_91(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_92(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_93(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_94(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_95(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_96(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_97(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_98(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_99(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_100(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_101(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_102(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_103(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_104(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_105(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_106(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_107(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_108(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_109(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_110(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_111(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_112(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_113(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_114(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_115(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_116(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_117(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_118(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_119(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_120(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_121(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_122(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_123(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_124(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_125(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_126(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_127(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_128(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_129(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_130(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_131(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_132(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_133(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_134(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_135(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_136(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_137(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_138(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_139(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_140(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_141(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_142(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_143(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_144(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_145(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_146(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_147(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_148(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_149(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_150(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_151(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_152(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_153(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_154(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_155(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_156(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_157(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_158(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_159(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_160(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_161(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_162(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_163(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_164(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_165(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_166(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_167(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_168(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_169(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_170(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_171(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_172(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_173(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_174(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_175(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_176(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_177(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_178(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_179(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_180(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_181(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_182(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_183(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_184(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_185(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_186(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_187(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_188(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_189(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_190(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_191(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_192(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_193(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_194(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_195(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_196(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_197(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_198(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_199(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_200(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_201(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_202(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_203(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_204(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_205(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_206(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_207(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_208(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_209(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_210(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_211(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_212(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_213(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_214(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_215(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_216(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_217(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_218(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_219(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_220(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_221(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_222(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_223(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_224(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_225(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_226(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_227(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_228(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_229(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_230(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_231(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_232(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_233(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_234(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_235(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_236(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_237(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_238(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_239(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_240(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_241(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_242(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_243(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_244(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_245(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_246(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_247(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_248(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_249(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_250(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_251(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_252(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_253(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_254(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_255(o,s,l) 0
+#define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_256(o,s,l) 0
+# 22 "/usr/include/boost/preprocessor/control/while.hpp" 2 3 4
+# 1 "/usr/include/boost/preprocessor/list/fold_right.hpp" 1 3 4
+# 15 "/usr/include/boost/preprocessor/list/fold_right.hpp" 3 4
+#define BOOST_PREPROCESSOR_LIST_FOLD_RIGHT_HPP 
+
+
+
+
+# 1 "/usr/include/boost/preprocessor/detail/auto_rec.hpp" 1 3 4
+# 21 "/usr/include/boost/preprocessor/list/fold_right.hpp" 2 3 4
+
+
+
+
+
+#define BOOST_PP_LIST_FOLD_RIGHT BOOST_PP_CAT(BOOST_PP_LIST_FOLD_RIGHT_, BOOST_PP_AUTO_REC(BOOST_PP_WHILE_P, 256))
+
+#define BOOST_PP_LIST_FOLD_RIGHT_257(o,s,l) BOOST_PP_ERROR(0x0004)
+
+#define BOOST_PP_LIST_FOLD_RIGHT_D(d,o,s,l) BOOST_PP_LIST_FOLD_RIGHT_ ## d(o, s, l)
+#define BOOST_PP_LIST_FOLD_RIGHT_2ND BOOST_PP_LIST_FOLD_RIGHT
+#define BOOST_PP_LIST_FOLD_RIGHT_2ND_D BOOST_PP_LIST_FOLD_RIGHT_D
+
+
+
+
+# 1 "/usr/include/boost/preprocessor/list/detail/fold_right.hpp" 1 3 4
+# 15 "/usr/include/boost/preprocessor/list/detail/fold_right.hpp" 3 4
+#define BOOST_PREPROCESSOR_LIST_DETAIL_FOLD_RIGHT_HPP 
+
+
+# 1 "/usr/include/boost/preprocessor/list/reverse.hpp" 1 3 4
+# 15 "/usr/include/boost/preprocessor/list/reverse.hpp" 3 4
+#define BOOST_PREPROCESSOR_LIST_REVERSE_HPP 
+
+
+
+
+
+
+
+#define BOOST_PP_LIST_REVERSE(list) BOOST_PP_LIST_FOLD_LEFT(BOOST_PP_LIST_REVERSE_O, BOOST_PP_NIL, list)
+
+
+
+
+
+#define BOOST_PP_LIST_REVERSE_O(d,s,x) (x, s)
+
+
+
+
+#define BOOST_PP_LIST_REVERSE_D(d,list) BOOST_PP_LIST_FOLD_LEFT_ ## d(BOOST_PP_LIST_REVERSE_O, BOOST_PP_NIL, list)
+# 19 "/usr/include/boost/preprocessor/list/detail/fold_right.hpp" 2 3 4
+
+#define BOOST_PP_LIST_FOLD_RIGHT_1(o,s,l) BOOST_PP_LIST_FOLD_LEFT_1(o, s, BOOST_PP_LIST_REVERSE_D(1, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_2(o,s,l) BOOST_PP_LIST_FOLD_LEFT_2(o, s, BOOST_PP_LIST_REVERSE_D(2, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_3(o,s,l) BOOST_PP_LIST_FOLD_LEFT_3(o, s, BOOST_PP_LIST_REVERSE_D(3, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_4(o,s,l) BOOST_PP_LIST_FOLD_LEFT_4(o, s, BOOST_PP_LIST_REVERSE_D(4, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_5(o,s,l) BOOST_PP_LIST_FOLD_LEFT_5(o, s, BOOST_PP_LIST_REVERSE_D(5, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_6(o,s,l) BOOST_PP_LIST_FOLD_LEFT_6(o, s, BOOST_PP_LIST_REVERSE_D(6, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_7(o,s,l) BOOST_PP_LIST_FOLD_LEFT_7(o, s, BOOST_PP_LIST_REVERSE_D(7, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_8(o,s,l) BOOST_PP_LIST_FOLD_LEFT_8(o, s, BOOST_PP_LIST_REVERSE_D(8, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_9(o,s,l) BOOST_PP_LIST_FOLD_LEFT_9(o, s, BOOST_PP_LIST_REVERSE_D(9, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_10(o,s,l) BOOST_PP_LIST_FOLD_LEFT_10(o, s, BOOST_PP_LIST_REVERSE_D(10, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_11(o,s,l) BOOST_PP_LIST_FOLD_LEFT_11(o, s, BOOST_PP_LIST_REVERSE_D(11, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_12(o,s,l) BOOST_PP_LIST_FOLD_LEFT_12(o, s, BOOST_PP_LIST_REVERSE_D(12, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_13(o,s,l) BOOST_PP_LIST_FOLD_LEFT_13(o, s, BOOST_PP_LIST_REVERSE_D(13, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_14(o,s,l) BOOST_PP_LIST_FOLD_LEFT_14(o, s, BOOST_PP_LIST_REVERSE_D(14, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_15(o,s,l) BOOST_PP_LIST_FOLD_LEFT_15(o, s, BOOST_PP_LIST_REVERSE_D(15, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_16(o,s,l) BOOST_PP_LIST_FOLD_LEFT_16(o, s, BOOST_PP_LIST_REVERSE_D(16, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_17(o,s,l) BOOST_PP_LIST_FOLD_LEFT_17(o, s, BOOST_PP_LIST_REVERSE_D(17, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_18(o,s,l) BOOST_PP_LIST_FOLD_LEFT_18(o, s, BOOST_PP_LIST_REVERSE_D(18, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_19(o,s,l) BOOST_PP_LIST_FOLD_LEFT_19(o, s, BOOST_PP_LIST_REVERSE_D(19, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_20(o,s,l) BOOST_PP_LIST_FOLD_LEFT_20(o, s, BOOST_PP_LIST_REVERSE_D(20, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_21(o,s,l) BOOST_PP_LIST_FOLD_LEFT_21(o, s, BOOST_PP_LIST_REVERSE_D(21, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_22(o,s,l) BOOST_PP_LIST_FOLD_LEFT_22(o, s, BOOST_PP_LIST_REVERSE_D(22, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_23(o,s,l) BOOST_PP_LIST_FOLD_LEFT_23(o, s, BOOST_PP_LIST_REVERSE_D(23, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_24(o,s,l) BOOST_PP_LIST_FOLD_LEFT_24(o, s, BOOST_PP_LIST_REVERSE_D(24, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_25(o,s,l) BOOST_PP_LIST_FOLD_LEFT_25(o, s, BOOST_PP_LIST_REVERSE_D(25, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_26(o,s,l) BOOST_PP_LIST_FOLD_LEFT_26(o, s, BOOST_PP_LIST_REVERSE_D(26, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_27(o,s,l) BOOST_PP_LIST_FOLD_LEFT_27(o, s, BOOST_PP_LIST_REVERSE_D(27, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_28(o,s,l) BOOST_PP_LIST_FOLD_LEFT_28(o, s, BOOST_PP_LIST_REVERSE_D(28, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_29(o,s,l) BOOST_PP_LIST_FOLD_LEFT_29(o, s, BOOST_PP_LIST_REVERSE_D(29, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_30(o,s,l) BOOST_PP_LIST_FOLD_LEFT_30(o, s, BOOST_PP_LIST_REVERSE_D(30, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_31(o,s,l) BOOST_PP_LIST_FOLD_LEFT_31(o, s, BOOST_PP_LIST_REVERSE_D(31, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_32(o,s,l) BOOST_PP_LIST_FOLD_LEFT_32(o, s, BOOST_PP_LIST_REVERSE_D(32, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_33(o,s,l) BOOST_PP_LIST_FOLD_LEFT_33(o, s, BOOST_PP_LIST_REVERSE_D(33, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_34(o,s,l) BOOST_PP_LIST_FOLD_LEFT_34(o, s, BOOST_PP_LIST_REVERSE_D(34, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_35(o,s,l) BOOST_PP_LIST_FOLD_LEFT_35(o, s, BOOST_PP_LIST_REVERSE_D(35, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_36(o,s,l) BOOST_PP_LIST_FOLD_LEFT_36(o, s, BOOST_PP_LIST_REVERSE_D(36, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_37(o,s,l) BOOST_PP_LIST_FOLD_LEFT_37(o, s, BOOST_PP_LIST_REVERSE_D(37, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_38(o,s,l) BOOST_PP_LIST_FOLD_LEFT_38(o, s, BOOST_PP_LIST_REVERSE_D(38, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_39(o,s,l) BOOST_PP_LIST_FOLD_LEFT_39(o, s, BOOST_PP_LIST_REVERSE_D(39, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_40(o,s,l) BOOST_PP_LIST_FOLD_LEFT_40(o, s, BOOST_PP_LIST_REVERSE_D(40, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_41(o,s,l) BOOST_PP_LIST_FOLD_LEFT_41(o, s, BOOST_PP_LIST_REVERSE_D(41, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_42(o,s,l) BOOST_PP_LIST_FOLD_LEFT_42(o, s, BOOST_PP_LIST_REVERSE_D(42, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_43(o,s,l) BOOST_PP_LIST_FOLD_LEFT_43(o, s, BOOST_PP_LIST_REVERSE_D(43, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_44(o,s,l) BOOST_PP_LIST_FOLD_LEFT_44(o, s, BOOST_PP_LIST_REVERSE_D(44, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_45(o,s,l) BOOST_PP_LIST_FOLD_LEFT_45(o, s, BOOST_PP_LIST_REVERSE_D(45, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_46(o,s,l) BOOST_PP_LIST_FOLD_LEFT_46(o, s, BOOST_PP_LIST_REVERSE_D(46, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_47(o,s,l) BOOST_PP_LIST_FOLD_LEFT_47(o, s, BOOST_PP_LIST_REVERSE_D(47, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_48(o,s,l) BOOST_PP_LIST_FOLD_LEFT_48(o, s, BOOST_PP_LIST_REVERSE_D(48, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_49(o,s,l) BOOST_PP_LIST_FOLD_LEFT_49(o, s, BOOST_PP_LIST_REVERSE_D(49, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_50(o,s,l) BOOST_PP_LIST_FOLD_LEFT_50(o, s, BOOST_PP_LIST_REVERSE_D(50, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_51(o,s,l) BOOST_PP_LIST_FOLD_LEFT_51(o, s, BOOST_PP_LIST_REVERSE_D(51, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_52(o,s,l) BOOST_PP_LIST_FOLD_LEFT_52(o, s, BOOST_PP_LIST_REVERSE_D(52, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_53(o,s,l) BOOST_PP_LIST_FOLD_LEFT_53(o, s, BOOST_PP_LIST_REVERSE_D(53, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_54(o,s,l) BOOST_PP_LIST_FOLD_LEFT_54(o, s, BOOST_PP_LIST_REVERSE_D(54, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_55(o,s,l) BOOST_PP_LIST_FOLD_LEFT_55(o, s, BOOST_PP_LIST_REVERSE_D(55, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_56(o,s,l) BOOST_PP_LIST_FOLD_LEFT_56(o, s, BOOST_PP_LIST_REVERSE_D(56, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_57(o,s,l) BOOST_PP_LIST_FOLD_LEFT_57(o, s, BOOST_PP_LIST_REVERSE_D(57, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_58(o,s,l) BOOST_PP_LIST_FOLD_LEFT_58(o, s, BOOST_PP_LIST_REVERSE_D(58, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_59(o,s,l) BOOST_PP_LIST_FOLD_LEFT_59(o, s, BOOST_PP_LIST_REVERSE_D(59, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_60(o,s,l) BOOST_PP_LIST_FOLD_LEFT_60(o, s, BOOST_PP_LIST_REVERSE_D(60, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_61(o,s,l) BOOST_PP_LIST_FOLD_LEFT_61(o, s, BOOST_PP_LIST_REVERSE_D(61, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_62(o,s,l) BOOST_PP_LIST_FOLD_LEFT_62(o, s, BOOST_PP_LIST_REVERSE_D(62, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_63(o,s,l) BOOST_PP_LIST_FOLD_LEFT_63(o, s, BOOST_PP_LIST_REVERSE_D(63, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_64(o,s,l) BOOST_PP_LIST_FOLD_LEFT_64(o, s, BOOST_PP_LIST_REVERSE_D(64, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_65(o,s,l) BOOST_PP_LIST_FOLD_LEFT_65(o, s, BOOST_PP_LIST_REVERSE_D(65, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_66(o,s,l) BOOST_PP_LIST_FOLD_LEFT_66(o, s, BOOST_PP_LIST_REVERSE_D(66, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_67(o,s,l) BOOST_PP_LIST_FOLD_LEFT_67(o, s, BOOST_PP_LIST_REVERSE_D(67, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_68(o,s,l) BOOST_PP_LIST_FOLD_LEFT_68(o, s, BOOST_PP_LIST_REVERSE_D(68, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_69(o,s,l) BOOST_PP_LIST_FOLD_LEFT_69(o, s, BOOST_PP_LIST_REVERSE_D(69, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_70(o,s,l) BOOST_PP_LIST_FOLD_LEFT_70(o, s, BOOST_PP_LIST_REVERSE_D(70, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_71(o,s,l) BOOST_PP_LIST_FOLD_LEFT_71(o, s, BOOST_PP_LIST_REVERSE_D(71, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_72(o,s,l) BOOST_PP_LIST_FOLD_LEFT_72(o, s, BOOST_PP_LIST_REVERSE_D(72, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_73(o,s,l) BOOST_PP_LIST_FOLD_LEFT_73(o, s, BOOST_PP_LIST_REVERSE_D(73, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_74(o,s,l) BOOST_PP_LIST_FOLD_LEFT_74(o, s, BOOST_PP_LIST_REVERSE_D(74, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_75(o,s,l) BOOST_PP_LIST_FOLD_LEFT_75(o, s, BOOST_PP_LIST_REVERSE_D(75, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_76(o,s,l) BOOST_PP_LIST_FOLD_LEFT_76(o, s, BOOST_PP_LIST_REVERSE_D(76, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_77(o,s,l) BOOST_PP_LIST_FOLD_LEFT_77(o, s, BOOST_PP_LIST_REVERSE_D(77, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_78(o,s,l) BOOST_PP_LIST_FOLD_LEFT_78(o, s, BOOST_PP_LIST_REVERSE_D(78, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_79(o,s,l) BOOST_PP_LIST_FOLD_LEFT_79(o, s, BOOST_PP_LIST_REVERSE_D(79, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_80(o,s,l) BOOST_PP_LIST_FOLD_LEFT_80(o, s, BOOST_PP_LIST_REVERSE_D(80, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_81(o,s,l) BOOST_PP_LIST_FOLD_LEFT_81(o, s, BOOST_PP_LIST_REVERSE_D(81, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_82(o,s,l) BOOST_PP_LIST_FOLD_LEFT_82(o, s, BOOST_PP_LIST_REVERSE_D(82, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_83(o,s,l) BOOST_PP_LIST_FOLD_LEFT_83(o, s, BOOST_PP_LIST_REVERSE_D(83, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_84(o,s,l) BOOST_PP_LIST_FOLD_LEFT_84(o, s, BOOST_PP_LIST_REVERSE_D(84, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_85(o,s,l) BOOST_PP_LIST_FOLD_LEFT_85(o, s, BOOST_PP_LIST_REVERSE_D(85, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_86(o,s,l) BOOST_PP_LIST_FOLD_LEFT_86(o, s, BOOST_PP_LIST_REVERSE_D(86, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_87(o,s,l) BOOST_PP_LIST_FOLD_LEFT_87(o, s, BOOST_PP_LIST_REVERSE_D(87, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_88(o,s,l) BOOST_PP_LIST_FOLD_LEFT_88(o, s, BOOST_PP_LIST_REVERSE_D(88, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_89(o,s,l) BOOST_PP_LIST_FOLD_LEFT_89(o, s, BOOST_PP_LIST_REVERSE_D(89, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_90(o,s,l) BOOST_PP_LIST_FOLD_LEFT_90(o, s, BOOST_PP_LIST_REVERSE_D(90, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_91(o,s,l) BOOST_PP_LIST_FOLD_LEFT_91(o, s, BOOST_PP_LIST_REVERSE_D(91, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_92(o,s,l) BOOST_PP_LIST_FOLD_LEFT_92(o, s, BOOST_PP_LIST_REVERSE_D(92, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_93(o,s,l) BOOST_PP_LIST_FOLD_LEFT_93(o, s, BOOST_PP_LIST_REVERSE_D(93, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_94(o,s,l) BOOST_PP_LIST_FOLD_LEFT_94(o, s, BOOST_PP_LIST_REVERSE_D(94, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_95(o,s,l) BOOST_PP_LIST_FOLD_LEFT_95(o, s, BOOST_PP_LIST_REVERSE_D(95, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_96(o,s,l) BOOST_PP_LIST_FOLD_LEFT_96(o, s, BOOST_PP_LIST_REVERSE_D(96, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_97(o,s,l) BOOST_PP_LIST_FOLD_LEFT_97(o, s, BOOST_PP_LIST_REVERSE_D(97, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_98(o,s,l) BOOST_PP_LIST_FOLD_LEFT_98(o, s, BOOST_PP_LIST_REVERSE_D(98, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_99(o,s,l) BOOST_PP_LIST_FOLD_LEFT_99(o, s, BOOST_PP_LIST_REVERSE_D(99, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_100(o,s,l) BOOST_PP_LIST_FOLD_LEFT_100(o, s, BOOST_PP_LIST_REVERSE_D(100, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_101(o,s,l) BOOST_PP_LIST_FOLD_LEFT_101(o, s, BOOST_PP_LIST_REVERSE_D(101, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_102(o,s,l) BOOST_PP_LIST_FOLD_LEFT_102(o, s, BOOST_PP_LIST_REVERSE_D(102, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_103(o,s,l) BOOST_PP_LIST_FOLD_LEFT_103(o, s, BOOST_PP_LIST_REVERSE_D(103, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_104(o,s,l) BOOST_PP_LIST_FOLD_LEFT_104(o, s, BOOST_PP_LIST_REVERSE_D(104, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_105(o,s,l) BOOST_PP_LIST_FOLD_LEFT_105(o, s, BOOST_PP_LIST_REVERSE_D(105, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_106(o,s,l) BOOST_PP_LIST_FOLD_LEFT_106(o, s, BOOST_PP_LIST_REVERSE_D(106, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_107(o,s,l) BOOST_PP_LIST_FOLD_LEFT_107(o, s, BOOST_PP_LIST_REVERSE_D(107, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_108(o,s,l) BOOST_PP_LIST_FOLD_LEFT_108(o, s, BOOST_PP_LIST_REVERSE_D(108, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_109(o,s,l) BOOST_PP_LIST_FOLD_LEFT_109(o, s, BOOST_PP_LIST_REVERSE_D(109, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_110(o,s,l) BOOST_PP_LIST_FOLD_LEFT_110(o, s, BOOST_PP_LIST_REVERSE_D(110, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_111(o,s,l) BOOST_PP_LIST_FOLD_LEFT_111(o, s, BOOST_PP_LIST_REVERSE_D(111, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_112(o,s,l) BOOST_PP_LIST_FOLD_LEFT_112(o, s, BOOST_PP_LIST_REVERSE_D(112, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_113(o,s,l) BOOST_PP_LIST_FOLD_LEFT_113(o, s, BOOST_PP_LIST_REVERSE_D(113, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_114(o,s,l) BOOST_PP_LIST_FOLD_LEFT_114(o, s, BOOST_PP_LIST_REVERSE_D(114, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_115(o,s,l) BOOST_PP_LIST_FOLD_LEFT_115(o, s, BOOST_PP_LIST_REVERSE_D(115, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_116(o,s,l) BOOST_PP_LIST_FOLD_LEFT_116(o, s, BOOST_PP_LIST_REVERSE_D(116, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_117(o,s,l) BOOST_PP_LIST_FOLD_LEFT_117(o, s, BOOST_PP_LIST_REVERSE_D(117, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_118(o,s,l) BOOST_PP_LIST_FOLD_LEFT_118(o, s, BOOST_PP_LIST_REVERSE_D(118, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_119(o,s,l) BOOST_PP_LIST_FOLD_LEFT_119(o, s, BOOST_PP_LIST_REVERSE_D(119, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_120(o,s,l) BOOST_PP_LIST_FOLD_LEFT_120(o, s, BOOST_PP_LIST_REVERSE_D(120, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_121(o,s,l) BOOST_PP_LIST_FOLD_LEFT_121(o, s, BOOST_PP_LIST_REVERSE_D(121, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_122(o,s,l) BOOST_PP_LIST_FOLD_LEFT_122(o, s, BOOST_PP_LIST_REVERSE_D(122, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_123(o,s,l) BOOST_PP_LIST_FOLD_LEFT_123(o, s, BOOST_PP_LIST_REVERSE_D(123, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_124(o,s,l) BOOST_PP_LIST_FOLD_LEFT_124(o, s, BOOST_PP_LIST_REVERSE_D(124, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_125(o,s,l) BOOST_PP_LIST_FOLD_LEFT_125(o, s, BOOST_PP_LIST_REVERSE_D(125, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_126(o,s,l) BOOST_PP_LIST_FOLD_LEFT_126(o, s, BOOST_PP_LIST_REVERSE_D(126, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_127(o,s,l) BOOST_PP_LIST_FOLD_LEFT_127(o, s, BOOST_PP_LIST_REVERSE_D(127, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_128(o,s,l) BOOST_PP_LIST_FOLD_LEFT_128(o, s, BOOST_PP_LIST_REVERSE_D(128, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_129(o,s,l) BOOST_PP_LIST_FOLD_LEFT_129(o, s, BOOST_PP_LIST_REVERSE_D(129, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_130(o,s,l) BOOST_PP_LIST_FOLD_LEFT_130(o, s, BOOST_PP_LIST_REVERSE_D(130, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_131(o,s,l) BOOST_PP_LIST_FOLD_LEFT_131(o, s, BOOST_PP_LIST_REVERSE_D(131, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_132(o,s,l) BOOST_PP_LIST_FOLD_LEFT_132(o, s, BOOST_PP_LIST_REVERSE_D(132, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_133(o,s,l) BOOST_PP_LIST_FOLD_LEFT_133(o, s, BOOST_PP_LIST_REVERSE_D(133, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_134(o,s,l) BOOST_PP_LIST_FOLD_LEFT_134(o, s, BOOST_PP_LIST_REVERSE_D(134, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_135(o,s,l) BOOST_PP_LIST_FOLD_LEFT_135(o, s, BOOST_PP_LIST_REVERSE_D(135, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_136(o,s,l) BOOST_PP_LIST_FOLD_LEFT_136(o, s, BOOST_PP_LIST_REVERSE_D(136, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_137(o,s,l) BOOST_PP_LIST_FOLD_LEFT_137(o, s, BOOST_PP_LIST_REVERSE_D(137, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_138(o,s,l) BOOST_PP_LIST_FOLD_LEFT_138(o, s, BOOST_PP_LIST_REVERSE_D(138, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_139(o,s,l) BOOST_PP_LIST_FOLD_LEFT_139(o, s, BOOST_PP_LIST_REVERSE_D(139, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_140(o,s,l) BOOST_PP_LIST_FOLD_LEFT_140(o, s, BOOST_PP_LIST_REVERSE_D(140, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_141(o,s,l) BOOST_PP_LIST_FOLD_LEFT_141(o, s, BOOST_PP_LIST_REVERSE_D(141, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_142(o,s,l) BOOST_PP_LIST_FOLD_LEFT_142(o, s, BOOST_PP_LIST_REVERSE_D(142, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_143(o,s,l) BOOST_PP_LIST_FOLD_LEFT_143(o, s, BOOST_PP_LIST_REVERSE_D(143, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_144(o,s,l) BOOST_PP_LIST_FOLD_LEFT_144(o, s, BOOST_PP_LIST_REVERSE_D(144, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_145(o,s,l) BOOST_PP_LIST_FOLD_LEFT_145(o, s, BOOST_PP_LIST_REVERSE_D(145, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_146(o,s,l) BOOST_PP_LIST_FOLD_LEFT_146(o, s, BOOST_PP_LIST_REVERSE_D(146, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_147(o,s,l) BOOST_PP_LIST_FOLD_LEFT_147(o, s, BOOST_PP_LIST_REVERSE_D(147, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_148(o,s,l) BOOST_PP_LIST_FOLD_LEFT_148(o, s, BOOST_PP_LIST_REVERSE_D(148, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_149(o,s,l) BOOST_PP_LIST_FOLD_LEFT_149(o, s, BOOST_PP_LIST_REVERSE_D(149, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_150(o,s,l) BOOST_PP_LIST_FOLD_LEFT_150(o, s, BOOST_PP_LIST_REVERSE_D(150, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_151(o,s,l) BOOST_PP_LIST_FOLD_LEFT_151(o, s, BOOST_PP_LIST_REVERSE_D(151, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_152(o,s,l) BOOST_PP_LIST_FOLD_LEFT_152(o, s, BOOST_PP_LIST_REVERSE_D(152, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_153(o,s,l) BOOST_PP_LIST_FOLD_LEFT_153(o, s, BOOST_PP_LIST_REVERSE_D(153, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_154(o,s,l) BOOST_PP_LIST_FOLD_LEFT_154(o, s, BOOST_PP_LIST_REVERSE_D(154, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_155(o,s,l) BOOST_PP_LIST_FOLD_LEFT_155(o, s, BOOST_PP_LIST_REVERSE_D(155, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_156(o,s,l) BOOST_PP_LIST_FOLD_LEFT_156(o, s, BOOST_PP_LIST_REVERSE_D(156, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_157(o,s,l) BOOST_PP_LIST_FOLD_LEFT_157(o, s, BOOST_PP_LIST_REVERSE_D(157, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_158(o,s,l) BOOST_PP_LIST_FOLD_LEFT_158(o, s, BOOST_PP_LIST_REVERSE_D(158, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_159(o,s,l) BOOST_PP_LIST_FOLD_LEFT_159(o, s, BOOST_PP_LIST_REVERSE_D(159, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_160(o,s,l) BOOST_PP_LIST_FOLD_LEFT_160(o, s, BOOST_PP_LIST_REVERSE_D(160, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_161(o,s,l) BOOST_PP_LIST_FOLD_LEFT_161(o, s, BOOST_PP_LIST_REVERSE_D(161, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_162(o,s,l) BOOST_PP_LIST_FOLD_LEFT_162(o, s, BOOST_PP_LIST_REVERSE_D(162, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_163(o,s,l) BOOST_PP_LIST_FOLD_LEFT_163(o, s, BOOST_PP_LIST_REVERSE_D(163, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_164(o,s,l) BOOST_PP_LIST_FOLD_LEFT_164(o, s, BOOST_PP_LIST_REVERSE_D(164, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_165(o,s,l) BOOST_PP_LIST_FOLD_LEFT_165(o, s, BOOST_PP_LIST_REVERSE_D(165, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_166(o,s,l) BOOST_PP_LIST_FOLD_LEFT_166(o, s, BOOST_PP_LIST_REVERSE_D(166, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_167(o,s,l) BOOST_PP_LIST_FOLD_LEFT_167(o, s, BOOST_PP_LIST_REVERSE_D(167, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_168(o,s,l) BOOST_PP_LIST_FOLD_LEFT_168(o, s, BOOST_PP_LIST_REVERSE_D(168, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_169(o,s,l) BOOST_PP_LIST_FOLD_LEFT_169(o, s, BOOST_PP_LIST_REVERSE_D(169, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_170(o,s,l) BOOST_PP_LIST_FOLD_LEFT_170(o, s, BOOST_PP_LIST_REVERSE_D(170, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_171(o,s,l) BOOST_PP_LIST_FOLD_LEFT_171(o, s, BOOST_PP_LIST_REVERSE_D(171, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_172(o,s,l) BOOST_PP_LIST_FOLD_LEFT_172(o, s, BOOST_PP_LIST_REVERSE_D(172, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_173(o,s,l) BOOST_PP_LIST_FOLD_LEFT_173(o, s, BOOST_PP_LIST_REVERSE_D(173, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_174(o,s,l) BOOST_PP_LIST_FOLD_LEFT_174(o, s, BOOST_PP_LIST_REVERSE_D(174, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_175(o,s,l) BOOST_PP_LIST_FOLD_LEFT_175(o, s, BOOST_PP_LIST_REVERSE_D(175, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_176(o,s,l) BOOST_PP_LIST_FOLD_LEFT_176(o, s, BOOST_PP_LIST_REVERSE_D(176, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_177(o,s,l) BOOST_PP_LIST_FOLD_LEFT_177(o, s, BOOST_PP_LIST_REVERSE_D(177, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_178(o,s,l) BOOST_PP_LIST_FOLD_LEFT_178(o, s, BOOST_PP_LIST_REVERSE_D(178, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_179(o,s,l) BOOST_PP_LIST_FOLD_LEFT_179(o, s, BOOST_PP_LIST_REVERSE_D(179, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_180(o,s,l) BOOST_PP_LIST_FOLD_LEFT_180(o, s, BOOST_PP_LIST_REVERSE_D(180, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_181(o,s,l) BOOST_PP_LIST_FOLD_LEFT_181(o, s, BOOST_PP_LIST_REVERSE_D(181, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_182(o,s,l) BOOST_PP_LIST_FOLD_LEFT_182(o, s, BOOST_PP_LIST_REVERSE_D(182, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_183(o,s,l) BOOST_PP_LIST_FOLD_LEFT_183(o, s, BOOST_PP_LIST_REVERSE_D(183, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_184(o,s,l) BOOST_PP_LIST_FOLD_LEFT_184(o, s, BOOST_PP_LIST_REVERSE_D(184, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_185(o,s,l) BOOST_PP_LIST_FOLD_LEFT_185(o, s, BOOST_PP_LIST_REVERSE_D(185, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_186(o,s,l) BOOST_PP_LIST_FOLD_LEFT_186(o, s, BOOST_PP_LIST_REVERSE_D(186, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_187(o,s,l) BOOST_PP_LIST_FOLD_LEFT_187(o, s, BOOST_PP_LIST_REVERSE_D(187, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_188(o,s,l) BOOST_PP_LIST_FOLD_LEFT_188(o, s, BOOST_PP_LIST_REVERSE_D(188, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_189(o,s,l) BOOST_PP_LIST_FOLD_LEFT_189(o, s, BOOST_PP_LIST_REVERSE_D(189, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_190(o,s,l) BOOST_PP_LIST_FOLD_LEFT_190(o, s, BOOST_PP_LIST_REVERSE_D(190, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_191(o,s,l) BOOST_PP_LIST_FOLD_LEFT_191(o, s, BOOST_PP_LIST_REVERSE_D(191, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_192(o,s,l) BOOST_PP_LIST_FOLD_LEFT_192(o, s, BOOST_PP_LIST_REVERSE_D(192, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_193(o,s,l) BOOST_PP_LIST_FOLD_LEFT_193(o, s, BOOST_PP_LIST_REVERSE_D(193, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_194(o,s,l) BOOST_PP_LIST_FOLD_LEFT_194(o, s, BOOST_PP_LIST_REVERSE_D(194, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_195(o,s,l) BOOST_PP_LIST_FOLD_LEFT_195(o, s, BOOST_PP_LIST_REVERSE_D(195, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_196(o,s,l) BOOST_PP_LIST_FOLD_LEFT_196(o, s, BOOST_PP_LIST_REVERSE_D(196, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_197(o,s,l) BOOST_PP_LIST_FOLD_LEFT_197(o, s, BOOST_PP_LIST_REVERSE_D(197, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_198(o,s,l) BOOST_PP_LIST_FOLD_LEFT_198(o, s, BOOST_PP_LIST_REVERSE_D(198, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_199(o,s,l) BOOST_PP_LIST_FOLD_LEFT_199(o, s, BOOST_PP_LIST_REVERSE_D(199, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_200(o,s,l) BOOST_PP_LIST_FOLD_LEFT_200(o, s, BOOST_PP_LIST_REVERSE_D(200, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_201(o,s,l) BOOST_PP_LIST_FOLD_LEFT_201(o, s, BOOST_PP_LIST_REVERSE_D(201, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_202(o,s,l) BOOST_PP_LIST_FOLD_LEFT_202(o, s, BOOST_PP_LIST_REVERSE_D(202, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_203(o,s,l) BOOST_PP_LIST_FOLD_LEFT_203(o, s, BOOST_PP_LIST_REVERSE_D(203, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_204(o,s,l) BOOST_PP_LIST_FOLD_LEFT_204(o, s, BOOST_PP_LIST_REVERSE_D(204, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_205(o,s,l) BOOST_PP_LIST_FOLD_LEFT_205(o, s, BOOST_PP_LIST_REVERSE_D(205, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_206(o,s,l) BOOST_PP_LIST_FOLD_LEFT_206(o, s, BOOST_PP_LIST_REVERSE_D(206, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_207(o,s,l) BOOST_PP_LIST_FOLD_LEFT_207(o, s, BOOST_PP_LIST_REVERSE_D(207, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_208(o,s,l) BOOST_PP_LIST_FOLD_LEFT_208(o, s, BOOST_PP_LIST_REVERSE_D(208, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_209(o,s,l) BOOST_PP_LIST_FOLD_LEFT_209(o, s, BOOST_PP_LIST_REVERSE_D(209, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_210(o,s,l) BOOST_PP_LIST_FOLD_LEFT_210(o, s, BOOST_PP_LIST_REVERSE_D(210, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_211(o,s,l) BOOST_PP_LIST_FOLD_LEFT_211(o, s, BOOST_PP_LIST_REVERSE_D(211, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_212(o,s,l) BOOST_PP_LIST_FOLD_LEFT_212(o, s, BOOST_PP_LIST_REVERSE_D(212, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_213(o,s,l) BOOST_PP_LIST_FOLD_LEFT_213(o, s, BOOST_PP_LIST_REVERSE_D(213, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_214(o,s,l) BOOST_PP_LIST_FOLD_LEFT_214(o, s, BOOST_PP_LIST_REVERSE_D(214, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_215(o,s,l) BOOST_PP_LIST_FOLD_LEFT_215(o, s, BOOST_PP_LIST_REVERSE_D(215, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_216(o,s,l) BOOST_PP_LIST_FOLD_LEFT_216(o, s, BOOST_PP_LIST_REVERSE_D(216, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_217(o,s,l) BOOST_PP_LIST_FOLD_LEFT_217(o, s, BOOST_PP_LIST_REVERSE_D(217, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_218(o,s,l) BOOST_PP_LIST_FOLD_LEFT_218(o, s, BOOST_PP_LIST_REVERSE_D(218, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_219(o,s,l) BOOST_PP_LIST_FOLD_LEFT_219(o, s, BOOST_PP_LIST_REVERSE_D(219, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_220(o,s,l) BOOST_PP_LIST_FOLD_LEFT_220(o, s, BOOST_PP_LIST_REVERSE_D(220, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_221(o,s,l) BOOST_PP_LIST_FOLD_LEFT_221(o, s, BOOST_PP_LIST_REVERSE_D(221, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_222(o,s,l) BOOST_PP_LIST_FOLD_LEFT_222(o, s, BOOST_PP_LIST_REVERSE_D(222, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_223(o,s,l) BOOST_PP_LIST_FOLD_LEFT_223(o, s, BOOST_PP_LIST_REVERSE_D(223, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_224(o,s,l) BOOST_PP_LIST_FOLD_LEFT_224(o, s, BOOST_PP_LIST_REVERSE_D(224, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_225(o,s,l) BOOST_PP_LIST_FOLD_LEFT_225(o, s, BOOST_PP_LIST_REVERSE_D(225, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_226(o,s,l) BOOST_PP_LIST_FOLD_LEFT_226(o, s, BOOST_PP_LIST_REVERSE_D(226, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_227(o,s,l) BOOST_PP_LIST_FOLD_LEFT_227(o, s, BOOST_PP_LIST_REVERSE_D(227, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_228(o,s,l) BOOST_PP_LIST_FOLD_LEFT_228(o, s, BOOST_PP_LIST_REVERSE_D(228, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_229(o,s,l) BOOST_PP_LIST_FOLD_LEFT_229(o, s, BOOST_PP_LIST_REVERSE_D(229, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_230(o,s,l) BOOST_PP_LIST_FOLD_LEFT_230(o, s, BOOST_PP_LIST_REVERSE_D(230, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_231(o,s,l) BOOST_PP_LIST_FOLD_LEFT_231(o, s, BOOST_PP_LIST_REVERSE_D(231, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_232(o,s,l) BOOST_PP_LIST_FOLD_LEFT_232(o, s, BOOST_PP_LIST_REVERSE_D(232, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_233(o,s,l) BOOST_PP_LIST_FOLD_LEFT_233(o, s, BOOST_PP_LIST_REVERSE_D(233, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_234(o,s,l) BOOST_PP_LIST_FOLD_LEFT_234(o, s, BOOST_PP_LIST_REVERSE_D(234, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_235(o,s,l) BOOST_PP_LIST_FOLD_LEFT_235(o, s, BOOST_PP_LIST_REVERSE_D(235, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_236(o,s,l) BOOST_PP_LIST_FOLD_LEFT_236(o, s, BOOST_PP_LIST_REVERSE_D(236, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_237(o,s,l) BOOST_PP_LIST_FOLD_LEFT_237(o, s, BOOST_PP_LIST_REVERSE_D(237, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_238(o,s,l) BOOST_PP_LIST_FOLD_LEFT_238(o, s, BOOST_PP_LIST_REVERSE_D(238, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_239(o,s,l) BOOST_PP_LIST_FOLD_LEFT_239(o, s, BOOST_PP_LIST_REVERSE_D(239, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_240(o,s,l) BOOST_PP_LIST_FOLD_LEFT_240(o, s, BOOST_PP_LIST_REVERSE_D(240, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_241(o,s,l) BOOST_PP_LIST_FOLD_LEFT_241(o, s, BOOST_PP_LIST_REVERSE_D(241, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_242(o,s,l) BOOST_PP_LIST_FOLD_LEFT_242(o, s, BOOST_PP_LIST_REVERSE_D(242, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_243(o,s,l) BOOST_PP_LIST_FOLD_LEFT_243(o, s, BOOST_PP_LIST_REVERSE_D(243, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_244(o,s,l) BOOST_PP_LIST_FOLD_LEFT_244(o, s, BOOST_PP_LIST_REVERSE_D(244, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_245(o,s,l) BOOST_PP_LIST_FOLD_LEFT_245(o, s, BOOST_PP_LIST_REVERSE_D(245, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_246(o,s,l) BOOST_PP_LIST_FOLD_LEFT_246(o, s, BOOST_PP_LIST_REVERSE_D(246, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_247(o,s,l) BOOST_PP_LIST_FOLD_LEFT_247(o, s, BOOST_PP_LIST_REVERSE_D(247, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_248(o,s,l) BOOST_PP_LIST_FOLD_LEFT_248(o, s, BOOST_PP_LIST_REVERSE_D(248, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_249(o,s,l) BOOST_PP_LIST_FOLD_LEFT_249(o, s, BOOST_PP_LIST_REVERSE_D(249, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_250(o,s,l) BOOST_PP_LIST_FOLD_LEFT_250(o, s, BOOST_PP_LIST_REVERSE_D(250, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_251(o,s,l) BOOST_PP_LIST_FOLD_LEFT_251(o, s, BOOST_PP_LIST_REVERSE_D(251, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_252(o,s,l) BOOST_PP_LIST_FOLD_LEFT_252(o, s, BOOST_PP_LIST_REVERSE_D(252, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_253(o,s,l) BOOST_PP_LIST_FOLD_LEFT_253(o, s, BOOST_PP_LIST_REVERSE_D(253, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_254(o,s,l) BOOST_PP_LIST_FOLD_LEFT_254(o, s, BOOST_PP_LIST_REVERSE_D(254, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_255(o,s,l) BOOST_PP_LIST_FOLD_LEFT_255(o, s, BOOST_PP_LIST_REVERSE_D(255, l))
+#define BOOST_PP_LIST_FOLD_RIGHT_256(o,s,l) BOOST_PP_LIST_FOLD_LEFT_256(o, s, BOOST_PP_LIST_REVERSE_D(256, l))
+# 38 "/usr/include/boost/preprocessor/list/fold_right.hpp" 2 3 4
+# 23 "/usr/include/boost/preprocessor/control/while.hpp" 2 3 4
+# 31 "/usr/include/boost/preprocessor/control/while.hpp" 3 4
+#define BOOST_PP_WHILE BOOST_PP_CAT(BOOST_PP_WHILE_, BOOST_PP_AUTO_REC(BOOST_PP_WHILE_P, 256))
+
+
+
+
+#define BOOST_PP_WHILE_P(n) BOOST_PP_BITAND(BOOST_PP_CAT(BOOST_PP_WHILE_CHECK_, BOOST_PP_WHILE_ ## n(BOOST_PP_WHILE_F, BOOST_PP_NIL, BOOST_PP_NIL)), BOOST_PP_CAT(BOOST_PP_LIST_FOLD_LEFT_CHECK_, BOOST_PP_LIST_FOLD_LEFT_ ## n(BOOST_PP_NIL, BOOST_PP_NIL, BOOST_PP_NIL)))
+
+
+#define BOOST_PP_WHILE_F(d,_) 0
+# 48 "/usr/include/boost/preprocessor/control/while.hpp" 3 4
+# 1 "/usr/include/boost/preprocessor/control/detail/while.hpp" 1 3 4
+# 15 "/usr/include/boost/preprocessor/control/detail/while.hpp" 3 4
+#define BOOST_PREPROCESSOR_CONTROL_DETAIL_WHILE_HPP 
+
+
+
+
+
+#define BOOST_PP_WHILE_1(p,o,s) BOOST_PP_WHILE_1_C(BOOST_PP_BOOL(p(2, s)), p, o, s)
+#define BOOST_PP_WHILE_2(p,o,s) BOOST_PP_WHILE_2_C(BOOST_PP_BOOL(p(3, s)), p, o, s)
+#define BOOST_PP_WHILE_3(p,o,s) BOOST_PP_WHILE_3_C(BOOST_PP_BOOL(p(4, s)), p, o, s)
+#define BOOST_PP_WHILE_4(p,o,s) BOOST_PP_WHILE_4_C(BOOST_PP_BOOL(p(5, s)), p, o, s)
+#define BOOST_PP_WHILE_5(p,o,s) BOOST_PP_WHILE_5_C(BOOST_PP_BOOL(p(6, s)), p, o, s)
+#define BOOST_PP_WHILE_6(p,o,s) BOOST_PP_WHILE_6_C(BOOST_PP_BOOL(p(7, s)), p, o, s)
+#define BOOST_PP_WHILE_7(p,o,s) BOOST_PP_WHILE_7_C(BOOST_PP_BOOL(p(8, s)), p, o, s)
+#define BOOST_PP_WHILE_8(p,o,s) BOOST_PP_WHILE_8_C(BOOST_PP_BOOL(p(9, s)), p, o, s)
+#define BOOST_PP_WHILE_9(p,o,s) BOOST_PP_WHILE_9_C(BOOST_PP_BOOL(p(10, s)), p, o, s)
+#define BOOST_PP_WHILE_10(p,o,s) BOOST_PP_WHILE_10_C(BOOST_PP_BOOL(p(11, s)), p, o, s)
+#define BOOST_PP_WHILE_11(p,o,s) BOOST_PP_WHILE_11_C(BOOST_PP_BOOL(p(12, s)), p, o, s)
+#define BOOST_PP_WHILE_12(p,o,s) BOOST_PP_WHILE_12_C(BOOST_PP_BOOL(p(13, s)), p, o, s)
+#define BOOST_PP_WHILE_13(p,o,s) BOOST_PP_WHILE_13_C(BOOST_PP_BOOL(p(14, s)), p, o, s)
+#define BOOST_PP_WHILE_14(p,o,s) BOOST_PP_WHILE_14_C(BOOST_PP_BOOL(p(15, s)), p, o, s)
+#define BOOST_PP_WHILE_15(p,o,s) BOOST_PP_WHILE_15_C(BOOST_PP_BOOL(p(16, s)), p, o, s)
+#define BOOST_PP_WHILE_16(p,o,s) BOOST_PP_WHILE_16_C(BOOST_PP_BOOL(p(17, s)), p, o, s)
+#define BOOST_PP_WHILE_17(p,o,s) BOOST_PP_WHILE_17_C(BOOST_PP_BOOL(p(18, s)), p, o, s)
+#define BOOST_PP_WHILE_18(p,o,s) BOOST_PP_WHILE_18_C(BOOST_PP_BOOL(p(19, s)), p, o, s)
+#define BOOST_PP_WHILE_19(p,o,s) BOOST_PP_WHILE_19_C(BOOST_PP_BOOL(p(20, s)), p, o, s)
+#define BOOST_PP_WHILE_20(p,o,s) BOOST_PP_WHILE_20_C(BOOST_PP_BOOL(p(21, s)), p, o, s)
+#define BOOST_PP_WHILE_21(p,o,s) BOOST_PP_WHILE_21_C(BOOST_PP_BOOL(p(22, s)), p, o, s)
+#define BOOST_PP_WHILE_22(p,o,s) BOOST_PP_WHILE_22_C(BOOST_PP_BOOL(p(23, s)), p, o, s)
+#define BOOST_PP_WHILE_23(p,o,s) BOOST_PP_WHILE_23_C(BOOST_PP_BOOL(p(24, s)), p, o, s)
+#define BOOST_PP_WHILE_24(p,o,s) BOOST_PP_WHILE_24_C(BOOST_PP_BOOL(p(25, s)), p, o, s)
+#define BOOST_PP_WHILE_25(p,o,s) BOOST_PP_WHILE_25_C(BOOST_PP_BOOL(p(26, s)), p, o, s)
+#define BOOST_PP_WHILE_26(p,o,s) BOOST_PP_WHILE_26_C(BOOST_PP_BOOL(p(27, s)), p, o, s)
+#define BOOST_PP_WHILE_27(p,o,s) BOOST_PP_WHILE_27_C(BOOST_PP_BOOL(p(28, s)), p, o, s)
+#define BOOST_PP_WHILE_28(p,o,s) BOOST_PP_WHILE_28_C(BOOST_PP_BOOL(p(29, s)), p, o, s)
+#define BOOST_PP_WHILE_29(p,o,s) BOOST_PP_WHILE_29_C(BOOST_PP_BOOL(p(30, s)), p, o, s)
+#define BOOST_PP_WHILE_30(p,o,s) BOOST_PP_WHILE_30_C(BOOST_PP_BOOL(p(31, s)), p, o, s)
+#define BOOST_PP_WHILE_31(p,o,s) BOOST_PP_WHILE_31_C(BOOST_PP_BOOL(p(32, s)), p, o, s)
+#define BOOST_PP_WHILE_32(p,o,s) BOOST_PP_WHILE_32_C(BOOST_PP_BOOL(p(33, s)), p, o, s)
+#define BOOST_PP_WHILE_33(p,o,s) BOOST_PP_WHILE_33_C(BOOST_PP_BOOL(p(34, s)), p, o, s)
+#define BOOST_PP_WHILE_34(p,o,s) BOOST_PP_WHILE_34_C(BOOST_PP_BOOL(p(35, s)), p, o, s)
+#define BOOST_PP_WHILE_35(p,o,s) BOOST_PP_WHILE_35_C(BOOST_PP_BOOL(p(36, s)), p, o, s)
+#define BOOST_PP_WHILE_36(p,o,s) BOOST_PP_WHILE_36_C(BOOST_PP_BOOL(p(37, s)), p, o, s)
+#define BOOST_PP_WHILE_37(p,o,s) BOOST_PP_WHILE_37_C(BOOST_PP_BOOL(p(38, s)), p, o, s)
+#define BOOST_PP_WHILE_38(p,o,s) BOOST_PP_WHILE_38_C(BOOST_PP_BOOL(p(39, s)), p, o, s)
+#define BOOST_PP_WHILE_39(p,o,s) BOOST_PP_WHILE_39_C(BOOST_PP_BOOL(p(40, s)), p, o, s)
+#define BOOST_PP_WHILE_40(p,o,s) BOOST_PP_WHILE_40_C(BOOST_PP_BOOL(p(41, s)), p, o, s)
+#define BOOST_PP_WHILE_41(p,o,s) BOOST_PP_WHILE_41_C(BOOST_PP_BOOL(p(42, s)), p, o, s)
+#define BOOST_PP_WHILE_42(p,o,s) BOOST_PP_WHILE_42_C(BOOST_PP_BOOL(p(43, s)), p, o, s)
+#define BOOST_PP_WHILE_43(p,o,s) BOOST_PP_WHILE_43_C(BOOST_PP_BOOL(p(44, s)), p, o, s)
+#define BOOST_PP_WHILE_44(p,o,s) BOOST_PP_WHILE_44_C(BOOST_PP_BOOL(p(45, s)), p, o, s)
+#define BOOST_PP_WHILE_45(p,o,s) BOOST_PP_WHILE_45_C(BOOST_PP_BOOL(p(46, s)), p, o, s)
+#define BOOST_PP_WHILE_46(p,o,s) BOOST_PP_WHILE_46_C(BOOST_PP_BOOL(p(47, s)), p, o, s)
+#define BOOST_PP_WHILE_47(p,o,s) BOOST_PP_WHILE_47_C(BOOST_PP_BOOL(p(48, s)), p, o, s)
+#define BOOST_PP_WHILE_48(p,o,s) BOOST_PP_WHILE_48_C(BOOST_PP_BOOL(p(49, s)), p, o, s)
+#define BOOST_PP_WHILE_49(p,o,s) BOOST_PP_WHILE_49_C(BOOST_PP_BOOL(p(50, s)), p, o, s)
+#define BOOST_PP_WHILE_50(p,o,s) BOOST_PP_WHILE_50_C(BOOST_PP_BOOL(p(51, s)), p, o, s)
+#define BOOST_PP_WHILE_51(p,o,s) BOOST_PP_WHILE_51_C(BOOST_PP_BOOL(p(52, s)), p, o, s)
+#define BOOST_PP_WHILE_52(p,o,s) BOOST_PP_WHILE_52_C(BOOST_PP_BOOL(p(53, s)), p, o, s)
+#define BOOST_PP_WHILE_53(p,o,s) BOOST_PP_WHILE_53_C(BOOST_PP_BOOL(p(54, s)), p, o, s)
+#define BOOST_PP_WHILE_54(p,o,s) BOOST_PP_WHILE_54_C(BOOST_PP_BOOL(p(55, s)), p, o, s)
+#define BOOST_PP_WHILE_55(p,o,s) BOOST_PP_WHILE_55_C(BOOST_PP_BOOL(p(56, s)), p, o, s)
+#define BOOST_PP_WHILE_56(p,o,s) BOOST_PP_WHILE_56_C(BOOST_PP_BOOL(p(57, s)), p, o, s)
+#define BOOST_PP_WHILE_57(p,o,s) BOOST_PP_WHILE_57_C(BOOST_PP_BOOL(p(58, s)), p, o, s)
+#define BOOST_PP_WHILE_58(p,o,s) BOOST_PP_WHILE_58_C(BOOST_PP_BOOL(p(59, s)), p, o, s)
+#define BOOST_PP_WHILE_59(p,o,s) BOOST_PP_WHILE_59_C(BOOST_PP_BOOL(p(60, s)), p, o, s)
+#define BOOST_PP_WHILE_60(p,o,s) BOOST_PP_WHILE_60_C(BOOST_PP_BOOL(p(61, s)), p, o, s)
+#define BOOST_PP_WHILE_61(p,o,s) BOOST_PP_WHILE_61_C(BOOST_PP_BOOL(p(62, s)), p, o, s)
+#define BOOST_PP_WHILE_62(p,o,s) BOOST_PP_WHILE_62_C(BOOST_PP_BOOL(p(63, s)), p, o, s)
+#define BOOST_PP_WHILE_63(p,o,s) BOOST_PP_WHILE_63_C(BOOST_PP_BOOL(p(64, s)), p, o, s)
+#define BOOST_PP_WHILE_64(p,o,s) BOOST_PP_WHILE_64_C(BOOST_PP_BOOL(p(65, s)), p, o, s)
+#define BOOST_PP_WHILE_65(p,o,s) BOOST_PP_WHILE_65_C(BOOST_PP_BOOL(p(66, s)), p, o, s)
+#define BOOST_PP_WHILE_66(p,o,s) BOOST_PP_WHILE_66_C(BOOST_PP_BOOL(p(67, s)), p, o, s)
+#define BOOST_PP_WHILE_67(p,o,s) BOOST_PP_WHILE_67_C(BOOST_PP_BOOL(p(68, s)), p, o, s)
+#define BOOST_PP_WHILE_68(p,o,s) BOOST_PP_WHILE_68_C(BOOST_PP_BOOL(p(69, s)), p, o, s)
+#define BOOST_PP_WHILE_69(p,o,s) BOOST_PP_WHILE_69_C(BOOST_PP_BOOL(p(70, s)), p, o, s)
+#define BOOST_PP_WHILE_70(p,o,s) BOOST_PP_WHILE_70_C(BOOST_PP_BOOL(p(71, s)), p, o, s)
+#define BOOST_PP_WHILE_71(p,o,s) BOOST_PP_WHILE_71_C(BOOST_PP_BOOL(p(72, s)), p, o, s)
+#define BOOST_PP_WHILE_72(p,o,s) BOOST_PP_WHILE_72_C(BOOST_PP_BOOL(p(73, s)), p, o, s)
+#define BOOST_PP_WHILE_73(p,o,s) BOOST_PP_WHILE_73_C(BOOST_PP_BOOL(p(74, s)), p, o, s)
+#define BOOST_PP_WHILE_74(p,o,s) BOOST_PP_WHILE_74_C(BOOST_PP_BOOL(p(75, s)), p, o, s)
+#define BOOST_PP_WHILE_75(p,o,s) BOOST_PP_WHILE_75_C(BOOST_PP_BOOL(p(76, s)), p, o, s)
+#define BOOST_PP_WHILE_76(p,o,s) BOOST_PP_WHILE_76_C(BOOST_PP_BOOL(p(77, s)), p, o, s)
+#define BOOST_PP_WHILE_77(p,o,s) BOOST_PP_WHILE_77_C(BOOST_PP_BOOL(p(78, s)), p, o, s)
+#define BOOST_PP_WHILE_78(p,o,s) BOOST_PP_WHILE_78_C(BOOST_PP_BOOL(p(79, s)), p, o, s)
+#define BOOST_PP_WHILE_79(p,o,s) BOOST_PP_WHILE_79_C(BOOST_PP_BOOL(p(80, s)), p, o, s)
+#define BOOST_PP_WHILE_80(p,o,s) BOOST_PP_WHILE_80_C(BOOST_PP_BOOL(p(81, s)), p, o, s)
+#define BOOST_PP_WHILE_81(p,o,s) BOOST_PP_WHILE_81_C(BOOST_PP_BOOL(p(82, s)), p, o, s)
+#define BOOST_PP_WHILE_82(p,o,s) BOOST_PP_WHILE_82_C(BOOST_PP_BOOL(p(83, s)), p, o, s)
+#define BOOST_PP_WHILE_83(p,o,s) BOOST_PP_WHILE_83_C(BOOST_PP_BOOL(p(84, s)), p, o, s)
+#define BOOST_PP_WHILE_84(p,o,s) BOOST_PP_WHILE_84_C(BOOST_PP_BOOL(p(85, s)), p, o, s)
+#define BOOST_PP_WHILE_85(p,o,s) BOOST_PP_WHILE_85_C(BOOST_PP_BOOL(p(86, s)), p, o, s)
+#define BOOST_PP_WHILE_86(p,o,s) BOOST_PP_WHILE_86_C(BOOST_PP_BOOL(p(87, s)), p, o, s)
+#define BOOST_PP_WHILE_87(p,o,s) BOOST_PP_WHILE_87_C(BOOST_PP_BOOL(p(88, s)), p, o, s)
+#define BOOST_PP_WHILE_88(p,o,s) BOOST_PP_WHILE_88_C(BOOST_PP_BOOL(p(89, s)), p, o, s)
+#define BOOST_PP_WHILE_89(p,o,s) BOOST_PP_WHILE_89_C(BOOST_PP_BOOL(p(90, s)), p, o, s)
+#define BOOST_PP_WHILE_90(p,o,s) BOOST_PP_WHILE_90_C(BOOST_PP_BOOL(p(91, s)), p, o, s)
+#define BOOST_PP_WHILE_91(p,o,s) BOOST_PP_WHILE_91_C(BOOST_PP_BOOL(p(92, s)), p, o, s)
+#define BOOST_PP_WHILE_92(p,o,s) BOOST_PP_WHILE_92_C(BOOST_PP_BOOL(p(93, s)), p, o, s)
+#define BOOST_PP_WHILE_93(p,o,s) BOOST_PP_WHILE_93_C(BOOST_PP_BOOL(p(94, s)), p, o, s)
+#define BOOST_PP_WHILE_94(p,o,s) BOOST_PP_WHILE_94_C(BOOST_PP_BOOL(p(95, s)), p, o, s)
+#define BOOST_PP_WHILE_95(p,o,s) BOOST_PP_WHILE_95_C(BOOST_PP_BOOL(p(96, s)), p, o, s)
+#define BOOST_PP_WHILE_96(p,o,s) BOOST_PP_WHILE_96_C(BOOST_PP_BOOL(p(97, s)), p, o, s)
+#define BOOST_PP_WHILE_97(p,o,s) BOOST_PP_WHILE_97_C(BOOST_PP_BOOL(p(98, s)), p, o, s)
+#define BOOST_PP_WHILE_98(p,o,s) BOOST_PP_WHILE_98_C(BOOST_PP_BOOL(p(99, s)), p, o, s)
+#define BOOST_PP_WHILE_99(p,o,s) BOOST_PP_WHILE_99_C(BOOST_PP_BOOL(p(100, s)), p, o, s)
+#define BOOST_PP_WHILE_100(p,o,s) BOOST_PP_WHILE_100_C(BOOST_PP_BOOL(p(101, s)), p, o, s)
+#define BOOST_PP_WHILE_101(p,o,s) BOOST_PP_WHILE_101_C(BOOST_PP_BOOL(p(102, s)), p, o, s)
+#define BOOST_PP_WHILE_102(p,o,s) BOOST_PP_WHILE_102_C(BOOST_PP_BOOL(p(103, s)), p, o, s)
+#define BOOST_PP_WHILE_103(p,o,s) BOOST_PP_WHILE_103_C(BOOST_PP_BOOL(p(104, s)), p, o, s)
+#define BOOST_PP_WHILE_104(p,o,s) BOOST_PP_WHILE_104_C(BOOST_PP_BOOL(p(105, s)), p, o, s)
+#define BOOST_PP_WHILE_105(p,o,s) BOOST_PP_WHILE_105_C(BOOST_PP_BOOL(p(106, s)), p, o, s)
+#define BOOST_PP_WHILE_106(p,o,s) BOOST_PP_WHILE_106_C(BOOST_PP_BOOL(p(107, s)), p, o, s)
+#define BOOST_PP_WHILE_107(p,o,s) BOOST_PP_WHILE_107_C(BOOST_PP_BOOL(p(108, s)), p, o, s)
+#define BOOST_PP_WHILE_108(p,o,s) BOOST_PP_WHILE_108_C(BOOST_PP_BOOL(p(109, s)), p, o, s)
+#define BOOST_PP_WHILE_109(p,o,s) BOOST_PP_WHILE_109_C(BOOST_PP_BOOL(p(110, s)), p, o, s)
+#define BOOST_PP_WHILE_110(p,o,s) BOOST_PP_WHILE_110_C(BOOST_PP_BOOL(p(111, s)), p, o, s)
+#define BOOST_PP_WHILE_111(p,o,s) BOOST_PP_WHILE_111_C(BOOST_PP_BOOL(p(112, s)), p, o, s)
+#define BOOST_PP_WHILE_112(p,o,s) BOOST_PP_WHILE_112_C(BOOST_PP_BOOL(p(113, s)), p, o, s)
+#define BOOST_PP_WHILE_113(p,o,s) BOOST_PP_WHILE_113_C(BOOST_PP_BOOL(p(114, s)), p, o, s)
+#define BOOST_PP_WHILE_114(p,o,s) BOOST_PP_WHILE_114_C(BOOST_PP_BOOL(p(115, s)), p, o, s)
+#define BOOST_PP_WHILE_115(p,o,s) BOOST_PP_WHILE_115_C(BOOST_PP_BOOL(p(116, s)), p, o, s)
+#define BOOST_PP_WHILE_116(p,o,s) BOOST_PP_WHILE_116_C(BOOST_PP_BOOL(p(117, s)), p, o, s)
+#define BOOST_PP_WHILE_117(p,o,s) BOOST_PP_WHILE_117_C(BOOST_PP_BOOL(p(118, s)), p, o, s)
+#define BOOST_PP_WHILE_118(p,o,s) BOOST_PP_WHILE_118_C(BOOST_PP_BOOL(p(119, s)), p, o, s)
+#define BOOST_PP_WHILE_119(p,o,s) BOOST_PP_WHILE_119_C(BOOST_PP_BOOL(p(120, s)), p, o, s)
+#define BOOST_PP_WHILE_120(p,o,s) BOOST_PP_WHILE_120_C(BOOST_PP_BOOL(p(121, s)), p, o, s)
+#define BOOST_PP_WHILE_121(p,o,s) BOOST_PP_WHILE_121_C(BOOST_PP_BOOL(p(122, s)), p, o, s)
+#define BOOST_PP_WHILE_122(p,o,s) BOOST_PP_WHILE_122_C(BOOST_PP_BOOL(p(123, s)), p, o, s)
+#define BOOST_PP_WHILE_123(p,o,s) BOOST_PP_WHILE_123_C(BOOST_PP_BOOL(p(124, s)), p, o, s)
+#define BOOST_PP_WHILE_124(p,o,s) BOOST_PP_WHILE_124_C(BOOST_PP_BOOL(p(125, s)), p, o, s)
+#define BOOST_PP_WHILE_125(p,o,s) BOOST_PP_WHILE_125_C(BOOST_PP_BOOL(p(126, s)), p, o, s)
+#define BOOST_PP_WHILE_126(p,o,s) BOOST_PP_WHILE_126_C(BOOST_PP_BOOL(p(127, s)), p, o, s)
+#define BOOST_PP_WHILE_127(p,o,s) BOOST_PP_WHILE_127_C(BOOST_PP_BOOL(p(128, s)), p, o, s)
+#define BOOST_PP_WHILE_128(p,o,s) BOOST_PP_WHILE_128_C(BOOST_PP_BOOL(p(129, s)), p, o, s)
+#define BOOST_PP_WHILE_129(p,o,s) BOOST_PP_WHILE_129_C(BOOST_PP_BOOL(p(130, s)), p, o, s)
+#define BOOST_PP_WHILE_130(p,o,s) BOOST_PP_WHILE_130_C(BOOST_PP_BOOL(p(131, s)), p, o, s)
+#define BOOST_PP_WHILE_131(p,o,s) BOOST_PP_WHILE_131_C(BOOST_PP_BOOL(p(132, s)), p, o, s)
+#define BOOST_PP_WHILE_132(p,o,s) BOOST_PP_WHILE_132_C(BOOST_PP_BOOL(p(133, s)), p, o, s)
+#define BOOST_PP_WHILE_133(p,o,s) BOOST_PP_WHILE_133_C(BOOST_PP_BOOL(p(134, s)), p, o, s)
+#define BOOST_PP_WHILE_134(p,o,s) BOOST_PP_WHILE_134_C(BOOST_PP_BOOL(p(135, s)), p, o, s)
+#define BOOST_PP_WHILE_135(p,o,s) BOOST_PP_WHILE_135_C(BOOST_PP_BOOL(p(136, s)), p, o, s)
+#define BOOST_PP_WHILE_136(p,o,s) BOOST_PP_WHILE_136_C(BOOST_PP_BOOL(p(137, s)), p, o, s)
+#define BOOST_PP_WHILE_137(p,o,s) BOOST_PP_WHILE_137_C(BOOST_PP_BOOL(p(138, s)), p, o, s)
+#define BOOST_PP_WHILE_138(p,o,s) BOOST_PP_WHILE_138_C(BOOST_PP_BOOL(p(139, s)), p, o, s)
+#define BOOST_PP_WHILE_139(p,o,s) BOOST_PP_WHILE_139_C(BOOST_PP_BOOL(p(140, s)), p, o, s)
+#define BOOST_PP_WHILE_140(p,o,s) BOOST_PP_WHILE_140_C(BOOST_PP_BOOL(p(141, s)), p, o, s)
+#define BOOST_PP_WHILE_141(p,o,s) BOOST_PP_WHILE_141_C(BOOST_PP_BOOL(p(142, s)), p, o, s)
+#define BOOST_PP_WHILE_142(p,o,s) BOOST_PP_WHILE_142_C(BOOST_PP_BOOL(p(143, s)), p, o, s)
+#define BOOST_PP_WHILE_143(p,o,s) BOOST_PP_WHILE_143_C(BOOST_PP_BOOL(p(144, s)), p, o, s)
+#define BOOST_PP_WHILE_144(p,o,s) BOOST_PP_WHILE_144_C(BOOST_PP_BOOL(p(145, s)), p, o, s)
+#define BOOST_PP_WHILE_145(p,o,s) BOOST_PP_WHILE_145_C(BOOST_PP_BOOL(p(146, s)), p, o, s)
+#define BOOST_PP_WHILE_146(p,o,s) BOOST_PP_WHILE_146_C(BOOST_PP_BOOL(p(147, s)), p, o, s)
+#define BOOST_PP_WHILE_147(p,o,s) BOOST_PP_WHILE_147_C(BOOST_PP_BOOL(p(148, s)), p, o, s)
+#define BOOST_PP_WHILE_148(p,o,s) BOOST_PP_WHILE_148_C(BOOST_PP_BOOL(p(149, s)), p, o, s)
+#define BOOST_PP_WHILE_149(p,o,s) BOOST_PP_WHILE_149_C(BOOST_PP_BOOL(p(150, s)), p, o, s)
+#define BOOST_PP_WHILE_150(p,o,s) BOOST_PP_WHILE_150_C(BOOST_PP_BOOL(p(151, s)), p, o, s)
+#define BOOST_PP_WHILE_151(p,o,s) BOOST_PP_WHILE_151_C(BOOST_PP_BOOL(p(152, s)), p, o, s)
+#define BOOST_PP_WHILE_152(p,o,s) BOOST_PP_WHILE_152_C(BOOST_PP_BOOL(p(153, s)), p, o, s)
+#define BOOST_PP_WHILE_153(p,o,s) BOOST_PP_WHILE_153_C(BOOST_PP_BOOL(p(154, s)), p, o, s)
+#define BOOST_PP_WHILE_154(p,o,s) BOOST_PP_WHILE_154_C(BOOST_PP_BOOL(p(155, s)), p, o, s)
+#define BOOST_PP_WHILE_155(p,o,s) BOOST_PP_WHILE_155_C(BOOST_PP_BOOL(p(156, s)), p, o, s)
+#define BOOST_PP_WHILE_156(p,o,s) BOOST_PP_WHILE_156_C(BOOST_PP_BOOL(p(157, s)), p, o, s)
+#define BOOST_PP_WHILE_157(p,o,s) BOOST_PP_WHILE_157_C(BOOST_PP_BOOL(p(158, s)), p, o, s)
+#define BOOST_PP_WHILE_158(p,o,s) BOOST_PP_WHILE_158_C(BOOST_PP_BOOL(p(159, s)), p, o, s)
+#define BOOST_PP_WHILE_159(p,o,s) BOOST_PP_WHILE_159_C(BOOST_PP_BOOL(p(160, s)), p, o, s)
+#define BOOST_PP_WHILE_160(p,o,s) BOOST_PP_WHILE_160_C(BOOST_PP_BOOL(p(161, s)), p, o, s)
+#define BOOST_PP_WHILE_161(p,o,s) BOOST_PP_WHILE_161_C(BOOST_PP_BOOL(p(162, s)), p, o, s)
+#define BOOST_PP_WHILE_162(p,o,s) BOOST_PP_WHILE_162_C(BOOST_PP_BOOL(p(163, s)), p, o, s)
+#define BOOST_PP_WHILE_163(p,o,s) BOOST_PP_WHILE_163_C(BOOST_PP_BOOL(p(164, s)), p, o, s)
+#define BOOST_PP_WHILE_164(p,o,s) BOOST_PP_WHILE_164_C(BOOST_PP_BOOL(p(165, s)), p, o, s)
+#define BOOST_PP_WHILE_165(p,o,s) BOOST_PP_WHILE_165_C(BOOST_PP_BOOL(p(166, s)), p, o, s)
+#define BOOST_PP_WHILE_166(p,o,s) BOOST_PP_WHILE_166_C(BOOST_PP_BOOL(p(167, s)), p, o, s)
+#define BOOST_PP_WHILE_167(p,o,s) BOOST_PP_WHILE_167_C(BOOST_PP_BOOL(p(168, s)), p, o, s)
+#define BOOST_PP_WHILE_168(p,o,s) BOOST_PP_WHILE_168_C(BOOST_PP_BOOL(p(169, s)), p, o, s)
+#define BOOST_PP_WHILE_169(p,o,s) BOOST_PP_WHILE_169_C(BOOST_PP_BOOL(p(170, s)), p, o, s)
+#define BOOST_PP_WHILE_170(p,o,s) BOOST_PP_WHILE_170_C(BOOST_PP_BOOL(p(171, s)), p, o, s)
+#define BOOST_PP_WHILE_171(p,o,s) BOOST_PP_WHILE_171_C(BOOST_PP_BOOL(p(172, s)), p, o, s)
+#define BOOST_PP_WHILE_172(p,o,s) BOOST_PP_WHILE_172_C(BOOST_PP_BOOL(p(173, s)), p, o, s)
+#define BOOST_PP_WHILE_173(p,o,s) BOOST_PP_WHILE_173_C(BOOST_PP_BOOL(p(174, s)), p, o, s)
+#define BOOST_PP_WHILE_174(p,o,s) BOOST_PP_WHILE_174_C(BOOST_PP_BOOL(p(175, s)), p, o, s)
+#define BOOST_PP_WHILE_175(p,o,s) BOOST_PP_WHILE_175_C(BOOST_PP_BOOL(p(176, s)), p, o, s)
+#define BOOST_PP_WHILE_176(p,o,s) BOOST_PP_WHILE_176_C(BOOST_PP_BOOL(p(177, s)), p, o, s)
+#define BOOST_PP_WHILE_177(p,o,s) BOOST_PP_WHILE_177_C(BOOST_PP_BOOL(p(178, s)), p, o, s)
+#define BOOST_PP_WHILE_178(p,o,s) BOOST_PP_WHILE_178_C(BOOST_PP_BOOL(p(179, s)), p, o, s)
+#define BOOST_PP_WHILE_179(p,o,s) BOOST_PP_WHILE_179_C(BOOST_PP_BOOL(p(180, s)), p, o, s)
+#define BOOST_PP_WHILE_180(p,o,s) BOOST_PP_WHILE_180_C(BOOST_PP_BOOL(p(181, s)), p, o, s)
+#define BOOST_PP_WHILE_181(p,o,s) BOOST_PP_WHILE_181_C(BOOST_PP_BOOL(p(182, s)), p, o, s)
+#define BOOST_PP_WHILE_182(p,o,s) BOOST_PP_WHILE_182_C(BOOST_PP_BOOL(p(183, s)), p, o, s)
+#define BOOST_PP_WHILE_183(p,o,s) BOOST_PP_WHILE_183_C(BOOST_PP_BOOL(p(184, s)), p, o, s)
+#define BOOST_PP_WHILE_184(p,o,s) BOOST_PP_WHILE_184_C(BOOST_PP_BOOL(p(185, s)), p, o, s)
+#define BOOST_PP_WHILE_185(p,o,s) BOOST_PP_WHILE_185_C(BOOST_PP_BOOL(p(186, s)), p, o, s)
+#define BOOST_PP_WHILE_186(p,o,s) BOOST_PP_WHILE_186_C(BOOST_PP_BOOL(p(187, s)), p, o, s)
+#define BOOST_PP_WHILE_187(p,o,s) BOOST_PP_WHILE_187_C(BOOST_PP_BOOL(p(188, s)), p, o, s)
+#define BOOST_PP_WHILE_188(p,o,s) BOOST_PP_WHILE_188_C(BOOST_PP_BOOL(p(189, s)), p, o, s)
+#define BOOST_PP_WHILE_189(p,o,s) BOOST_PP_WHILE_189_C(BOOST_PP_BOOL(p(190, s)), p, o, s)
+#define BOOST_PP_WHILE_190(p,o,s) BOOST_PP_WHILE_190_C(BOOST_PP_BOOL(p(191, s)), p, o, s)
+#define BOOST_PP_WHILE_191(p,o,s) BOOST_PP_WHILE_191_C(BOOST_PP_BOOL(p(192, s)), p, o, s)
+#define BOOST_PP_WHILE_192(p,o,s) BOOST_PP_WHILE_192_C(BOOST_PP_BOOL(p(193, s)), p, o, s)
+#define BOOST_PP_WHILE_193(p,o,s) BOOST_PP_WHILE_193_C(BOOST_PP_BOOL(p(194, s)), p, o, s)
+#define BOOST_PP_WHILE_194(p,o,s) BOOST_PP_WHILE_194_C(BOOST_PP_BOOL(p(195, s)), p, o, s)
+#define BOOST_PP_WHILE_195(p,o,s) BOOST_PP_WHILE_195_C(BOOST_PP_BOOL(p(196, s)), p, o, s)
+#define BOOST_PP_WHILE_196(p,o,s) BOOST_PP_WHILE_196_C(BOOST_PP_BOOL(p(197, s)), p, o, s)
+#define BOOST_PP_WHILE_197(p,o,s) BOOST_PP_WHILE_197_C(BOOST_PP_BOOL(p(198, s)), p, o, s)
+#define BOOST_PP_WHILE_198(p,o,s) BOOST_PP_WHILE_198_C(BOOST_PP_BOOL(p(199, s)), p, o, s)
+#define BOOST_PP_WHILE_199(p,o,s) BOOST_PP_WHILE_199_C(BOOST_PP_BOOL(p(200, s)), p, o, s)
+#define BOOST_PP_WHILE_200(p,o,s) BOOST_PP_WHILE_200_C(BOOST_PP_BOOL(p(201, s)), p, o, s)
+#define BOOST_PP_WHILE_201(p,o,s) BOOST_PP_WHILE_201_C(BOOST_PP_BOOL(p(202, s)), p, o, s)
+#define BOOST_PP_WHILE_202(p,o,s) BOOST_PP_WHILE_202_C(BOOST_PP_BOOL(p(203, s)), p, o, s)
+#define BOOST_PP_WHILE_203(p,o,s) BOOST_PP_WHILE_203_C(BOOST_PP_BOOL(p(204, s)), p, o, s)
+#define BOOST_PP_WHILE_204(p,o,s) BOOST_PP_WHILE_204_C(BOOST_PP_BOOL(p(205, s)), p, o, s)
+#define BOOST_PP_WHILE_205(p,o,s) BOOST_PP_WHILE_205_C(BOOST_PP_BOOL(p(206, s)), p, o, s)
+#define BOOST_PP_WHILE_206(p,o,s) BOOST_PP_WHILE_206_C(BOOST_PP_BOOL(p(207, s)), p, o, s)
+#define BOOST_PP_WHILE_207(p,o,s) BOOST_PP_WHILE_207_C(BOOST_PP_BOOL(p(208, s)), p, o, s)
+#define BOOST_PP_WHILE_208(p,o,s) BOOST_PP_WHILE_208_C(BOOST_PP_BOOL(p(209, s)), p, o, s)
+#define BOOST_PP_WHILE_209(p,o,s) BOOST_PP_WHILE_209_C(BOOST_PP_BOOL(p(210, s)), p, o, s)
+#define BOOST_PP_WHILE_210(p,o,s) BOOST_PP_WHILE_210_C(BOOST_PP_BOOL(p(211, s)), p, o, s)
+#define BOOST_PP_WHILE_211(p,o,s) BOOST_PP_WHILE_211_C(BOOST_PP_BOOL(p(212, s)), p, o, s)
+#define BOOST_PP_WHILE_212(p,o,s) BOOST_PP_WHILE_212_C(BOOST_PP_BOOL(p(213, s)), p, o, s)
+#define BOOST_PP_WHILE_213(p,o,s) BOOST_PP_WHILE_213_C(BOOST_PP_BOOL(p(214, s)), p, o, s)
+#define BOOST_PP_WHILE_214(p,o,s) BOOST_PP_WHILE_214_C(BOOST_PP_BOOL(p(215, s)), p, o, s)
+#define BOOST_PP_WHILE_215(p,o,s) BOOST_PP_WHILE_215_C(BOOST_PP_BOOL(p(216, s)), p, o, s)
+#define BOOST_PP_WHILE_216(p,o,s) BOOST_PP_WHILE_216_C(BOOST_PP_BOOL(p(217, s)), p, o, s)
+#define BOOST_PP_WHILE_217(p,o,s) BOOST_PP_WHILE_217_C(BOOST_PP_BOOL(p(218, s)), p, o, s)
+#define BOOST_PP_WHILE_218(p,o,s) BOOST_PP_WHILE_218_C(BOOST_PP_BOOL(p(219, s)), p, o, s)
+#define BOOST_PP_WHILE_219(p,o,s) BOOST_PP_WHILE_219_C(BOOST_PP_BOOL(p(220, s)), p, o, s)
+#define BOOST_PP_WHILE_220(p,o,s) BOOST_PP_WHILE_220_C(BOOST_PP_BOOL(p(221, s)), p, o, s)
+#define BOOST_PP_WHILE_221(p,o,s) BOOST_PP_WHILE_221_C(BOOST_PP_BOOL(p(222, s)), p, o, s)
+#define BOOST_PP_WHILE_222(p,o,s) BOOST_PP_WHILE_222_C(BOOST_PP_BOOL(p(223, s)), p, o, s)
+#define BOOST_PP_WHILE_223(p,o,s) BOOST_PP_WHILE_223_C(BOOST_PP_BOOL(p(224, s)), p, o, s)
+#define BOOST_PP_WHILE_224(p,o,s) BOOST_PP_WHILE_224_C(BOOST_PP_BOOL(p(225, s)), p, o, s)
+#define BOOST_PP_WHILE_225(p,o,s) BOOST_PP_WHILE_225_C(BOOST_PP_BOOL(p(226, s)), p, o, s)
+#define BOOST_PP_WHILE_226(p,o,s) BOOST_PP_WHILE_226_C(BOOST_PP_BOOL(p(227, s)), p, o, s)
+#define BOOST_PP_WHILE_227(p,o,s) BOOST_PP_WHILE_227_C(BOOST_PP_BOOL(p(228, s)), p, o, s)
+#define BOOST_PP_WHILE_228(p,o,s) BOOST_PP_WHILE_228_C(BOOST_PP_BOOL(p(229, s)), p, o, s)
+#define BOOST_PP_WHILE_229(p,o,s) BOOST_PP_WHILE_229_C(BOOST_PP_BOOL(p(230, s)), p, o, s)
+#define BOOST_PP_WHILE_230(p,o,s) BOOST_PP_WHILE_230_C(BOOST_PP_BOOL(p(231, s)), p, o, s)
+#define BOOST_PP_WHILE_231(p,o,s) BOOST_PP_WHILE_231_C(BOOST_PP_BOOL(p(232, s)), p, o, s)
+#define BOOST_PP_WHILE_232(p,o,s) BOOST_PP_WHILE_232_C(BOOST_PP_BOOL(p(233, s)), p, o, s)
+#define BOOST_PP_WHILE_233(p,o,s) BOOST_PP_WHILE_233_C(BOOST_PP_BOOL(p(234, s)), p, o, s)
+#define BOOST_PP_WHILE_234(p,o,s) BOOST_PP_WHILE_234_C(BOOST_PP_BOOL(p(235, s)), p, o, s)
+#define BOOST_PP_WHILE_235(p,o,s) BOOST_PP_WHILE_235_C(BOOST_PP_BOOL(p(236, s)), p, o, s)
+#define BOOST_PP_WHILE_236(p,o,s) BOOST_PP_WHILE_236_C(BOOST_PP_BOOL(p(237, s)), p, o, s)
+#define BOOST_PP_WHILE_237(p,o,s) BOOST_PP_WHILE_237_C(BOOST_PP_BOOL(p(238, s)), p, o, s)
+#define BOOST_PP_WHILE_238(p,o,s) BOOST_PP_WHILE_238_C(BOOST_PP_BOOL(p(239, s)), p, o, s)
+#define BOOST_PP_WHILE_239(p,o,s) BOOST_PP_WHILE_239_C(BOOST_PP_BOOL(p(240, s)), p, o, s)
+#define BOOST_PP_WHILE_240(p,o,s) BOOST_PP_WHILE_240_C(BOOST_PP_BOOL(p(241, s)), p, o, s)
+#define BOOST_PP_WHILE_241(p,o,s) BOOST_PP_WHILE_241_C(BOOST_PP_BOOL(p(242, s)), p, o, s)
+#define BOOST_PP_WHILE_242(p,o,s) BOOST_PP_WHILE_242_C(BOOST_PP_BOOL(p(243, s)), p, o, s)
+#define BOOST_PP_WHILE_243(p,o,s) BOOST_PP_WHILE_243_C(BOOST_PP_BOOL(p(244, s)), p, o, s)
+#define BOOST_PP_WHILE_244(p,o,s) BOOST_PP_WHILE_244_C(BOOST_PP_BOOL(p(245, s)), p, o, s)
+#define BOOST_PP_WHILE_245(p,o,s) BOOST_PP_WHILE_245_C(BOOST_PP_BOOL(p(246, s)), p, o, s)
+#define BOOST_PP_WHILE_246(p,o,s) BOOST_PP_WHILE_246_C(BOOST_PP_BOOL(p(247, s)), p, o, s)
+#define BOOST_PP_WHILE_247(p,o,s) BOOST_PP_WHILE_247_C(BOOST_PP_BOOL(p(248, s)), p, o, s)
+#define BOOST_PP_WHILE_248(p,o,s) BOOST_PP_WHILE_248_C(BOOST_PP_BOOL(p(249, s)), p, o, s)
+#define BOOST_PP_WHILE_249(p,o,s) BOOST_PP_WHILE_249_C(BOOST_PP_BOOL(p(250, s)), p, o, s)
+#define BOOST_PP_WHILE_250(p,o,s) BOOST_PP_WHILE_250_C(BOOST_PP_BOOL(p(251, s)), p, o, s)
+#define BOOST_PP_WHILE_251(p,o,s) BOOST_PP_WHILE_251_C(BOOST_PP_BOOL(p(252, s)), p, o, s)
+#define BOOST_PP_WHILE_252(p,o,s) BOOST_PP_WHILE_252_C(BOOST_PP_BOOL(p(253, s)), p, o, s)
+#define BOOST_PP_WHILE_253(p,o,s) BOOST_PP_WHILE_253_C(BOOST_PP_BOOL(p(254, s)), p, o, s)
+#define BOOST_PP_WHILE_254(p,o,s) BOOST_PP_WHILE_254_C(BOOST_PP_BOOL(p(255, s)), p, o, s)
+#define BOOST_PP_WHILE_255(p,o,s) BOOST_PP_WHILE_255_C(BOOST_PP_BOOL(p(256, s)), p, o, s)
+#define BOOST_PP_WHILE_256(p,o,s) BOOST_PP_WHILE_256_C(BOOST_PP_BOOL(p(257, s)), p, o, s)
+
+#define BOOST_PP_WHILE_1_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_2, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(2, s))
+#define BOOST_PP_WHILE_2_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_3, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(3, s))
+#define BOOST_PP_WHILE_3_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_4, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(4, s))
+#define BOOST_PP_WHILE_4_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_5, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(5, s))
+#define BOOST_PP_WHILE_5_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_6, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(6, s))
+#define BOOST_PP_WHILE_6_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_7, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(7, s))
+#define BOOST_PP_WHILE_7_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_8, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(8, s))
+#define BOOST_PP_WHILE_8_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_9, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(9, s))
+#define BOOST_PP_WHILE_9_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_10, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(10, s))
+#define BOOST_PP_WHILE_10_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_11, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(11, s))
+#define BOOST_PP_WHILE_11_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_12, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(12, s))
+#define BOOST_PP_WHILE_12_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_13, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(13, s))
+#define BOOST_PP_WHILE_13_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_14, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(14, s))
+#define BOOST_PP_WHILE_14_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_15, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(15, s))
+#define BOOST_PP_WHILE_15_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_16, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(16, s))
+#define BOOST_PP_WHILE_16_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_17, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(17, s))
+#define BOOST_PP_WHILE_17_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_18, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(18, s))
+#define BOOST_PP_WHILE_18_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_19, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(19, s))
+#define BOOST_PP_WHILE_19_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_20, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(20, s))
+#define BOOST_PP_WHILE_20_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_21, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(21, s))
+#define BOOST_PP_WHILE_21_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_22, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(22, s))
+#define BOOST_PP_WHILE_22_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_23, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(23, s))
+#define BOOST_PP_WHILE_23_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_24, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(24, s))
+#define BOOST_PP_WHILE_24_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_25, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(25, s))
+#define BOOST_PP_WHILE_25_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_26, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(26, s))
+#define BOOST_PP_WHILE_26_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_27, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(27, s))
+#define BOOST_PP_WHILE_27_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_28, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(28, s))
+#define BOOST_PP_WHILE_28_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_29, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(29, s))
+#define BOOST_PP_WHILE_29_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_30, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(30, s))
+#define BOOST_PP_WHILE_30_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_31, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(31, s))
+#define BOOST_PP_WHILE_31_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_32, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(32, s))
+#define BOOST_PP_WHILE_32_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_33, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(33, s))
+#define BOOST_PP_WHILE_33_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_34, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(34, s))
+#define BOOST_PP_WHILE_34_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_35, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(35, s))
+#define BOOST_PP_WHILE_35_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_36, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(36, s))
+#define BOOST_PP_WHILE_36_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_37, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(37, s))
+#define BOOST_PP_WHILE_37_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_38, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(38, s))
+#define BOOST_PP_WHILE_38_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_39, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(39, s))
+#define BOOST_PP_WHILE_39_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_40, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(40, s))
+#define BOOST_PP_WHILE_40_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_41, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(41, s))
+#define BOOST_PP_WHILE_41_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_42, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(42, s))
+#define BOOST_PP_WHILE_42_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_43, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(43, s))
+#define BOOST_PP_WHILE_43_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_44, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(44, s))
+#define BOOST_PP_WHILE_44_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_45, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(45, s))
+#define BOOST_PP_WHILE_45_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_46, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(46, s))
+#define BOOST_PP_WHILE_46_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_47, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(47, s))
+#define BOOST_PP_WHILE_47_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_48, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(48, s))
+#define BOOST_PP_WHILE_48_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_49, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(49, s))
+#define BOOST_PP_WHILE_49_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_50, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(50, s))
+#define BOOST_PP_WHILE_50_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_51, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(51, s))
+#define BOOST_PP_WHILE_51_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_52, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(52, s))
+#define BOOST_PP_WHILE_52_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_53, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(53, s))
+#define BOOST_PP_WHILE_53_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_54, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(54, s))
+#define BOOST_PP_WHILE_54_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_55, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(55, s))
+#define BOOST_PP_WHILE_55_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_56, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(56, s))
+#define BOOST_PP_WHILE_56_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_57, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(57, s))
+#define BOOST_PP_WHILE_57_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_58, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(58, s))
+#define BOOST_PP_WHILE_58_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_59, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(59, s))
+#define BOOST_PP_WHILE_59_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_60, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(60, s))
+#define BOOST_PP_WHILE_60_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_61, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(61, s))
+#define BOOST_PP_WHILE_61_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_62, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(62, s))
+#define BOOST_PP_WHILE_62_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_63, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(63, s))
+#define BOOST_PP_WHILE_63_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_64, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(64, s))
+#define BOOST_PP_WHILE_64_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_65, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(65, s))
+#define BOOST_PP_WHILE_65_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_66, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(66, s))
+#define BOOST_PP_WHILE_66_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_67, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(67, s))
+#define BOOST_PP_WHILE_67_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_68, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(68, s))
+#define BOOST_PP_WHILE_68_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_69, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(69, s))
+#define BOOST_PP_WHILE_69_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_70, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(70, s))
+#define BOOST_PP_WHILE_70_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_71, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(71, s))
+#define BOOST_PP_WHILE_71_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_72, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(72, s))
+#define BOOST_PP_WHILE_72_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_73, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(73, s))
+#define BOOST_PP_WHILE_73_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_74, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(74, s))
+#define BOOST_PP_WHILE_74_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_75, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(75, s))
+#define BOOST_PP_WHILE_75_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_76, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(76, s))
+#define BOOST_PP_WHILE_76_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_77, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(77, s))
+#define BOOST_PP_WHILE_77_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_78, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(78, s))
+#define BOOST_PP_WHILE_78_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_79, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(79, s))
+#define BOOST_PP_WHILE_79_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_80, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(80, s))
+#define BOOST_PP_WHILE_80_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_81, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(81, s))
+#define BOOST_PP_WHILE_81_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_82, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(82, s))
+#define BOOST_PP_WHILE_82_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_83, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(83, s))
+#define BOOST_PP_WHILE_83_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_84, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(84, s))
+#define BOOST_PP_WHILE_84_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_85, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(85, s))
+#define BOOST_PP_WHILE_85_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_86, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(86, s))
+#define BOOST_PP_WHILE_86_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_87, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(87, s))
+#define BOOST_PP_WHILE_87_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_88, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(88, s))
+#define BOOST_PP_WHILE_88_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_89, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(89, s))
+#define BOOST_PP_WHILE_89_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_90, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(90, s))
+#define BOOST_PP_WHILE_90_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_91, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(91, s))
+#define BOOST_PP_WHILE_91_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_92, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(92, s))
+#define BOOST_PP_WHILE_92_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_93, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(93, s))
+#define BOOST_PP_WHILE_93_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_94, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(94, s))
+#define BOOST_PP_WHILE_94_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_95, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(95, s))
+#define BOOST_PP_WHILE_95_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_96, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(96, s))
+#define BOOST_PP_WHILE_96_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_97, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(97, s))
+#define BOOST_PP_WHILE_97_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_98, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(98, s))
+#define BOOST_PP_WHILE_98_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_99, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(99, s))
+#define BOOST_PP_WHILE_99_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_100, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(100, s))
+#define BOOST_PP_WHILE_100_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_101, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(101, s))
+#define BOOST_PP_WHILE_101_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_102, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(102, s))
+#define BOOST_PP_WHILE_102_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_103, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(103, s))
+#define BOOST_PP_WHILE_103_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_104, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(104, s))
+#define BOOST_PP_WHILE_104_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_105, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(105, s))
+#define BOOST_PP_WHILE_105_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_106, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(106, s))
+#define BOOST_PP_WHILE_106_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_107, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(107, s))
+#define BOOST_PP_WHILE_107_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_108, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(108, s))
+#define BOOST_PP_WHILE_108_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_109, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(109, s))
+#define BOOST_PP_WHILE_109_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_110, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(110, s))
+#define BOOST_PP_WHILE_110_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_111, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(111, s))
+#define BOOST_PP_WHILE_111_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_112, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(112, s))
+#define BOOST_PP_WHILE_112_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_113, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(113, s))
+#define BOOST_PP_WHILE_113_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_114, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(114, s))
+#define BOOST_PP_WHILE_114_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_115, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(115, s))
+#define BOOST_PP_WHILE_115_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_116, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(116, s))
+#define BOOST_PP_WHILE_116_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_117, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(117, s))
+#define BOOST_PP_WHILE_117_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_118, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(118, s))
+#define BOOST_PP_WHILE_118_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_119, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(119, s))
+#define BOOST_PP_WHILE_119_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_120, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(120, s))
+#define BOOST_PP_WHILE_120_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_121, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(121, s))
+#define BOOST_PP_WHILE_121_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_122, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(122, s))
+#define BOOST_PP_WHILE_122_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_123, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(123, s))
+#define BOOST_PP_WHILE_123_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_124, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(124, s))
+#define BOOST_PP_WHILE_124_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_125, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(125, s))
+#define BOOST_PP_WHILE_125_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_126, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(126, s))
+#define BOOST_PP_WHILE_126_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_127, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(127, s))
+#define BOOST_PP_WHILE_127_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_128, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(128, s))
+#define BOOST_PP_WHILE_128_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_129, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(129, s))
+#define BOOST_PP_WHILE_129_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_130, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(130, s))
+#define BOOST_PP_WHILE_130_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_131, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(131, s))
+#define BOOST_PP_WHILE_131_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_132, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(132, s))
+#define BOOST_PP_WHILE_132_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_133, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(133, s))
+#define BOOST_PP_WHILE_133_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_134, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(134, s))
+#define BOOST_PP_WHILE_134_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_135, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(135, s))
+#define BOOST_PP_WHILE_135_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_136, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(136, s))
+#define BOOST_PP_WHILE_136_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_137, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(137, s))
+#define BOOST_PP_WHILE_137_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_138, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(138, s))
+#define BOOST_PP_WHILE_138_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_139, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(139, s))
+#define BOOST_PP_WHILE_139_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_140, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(140, s))
+#define BOOST_PP_WHILE_140_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_141, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(141, s))
+#define BOOST_PP_WHILE_141_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_142, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(142, s))
+#define BOOST_PP_WHILE_142_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_143, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(143, s))
+#define BOOST_PP_WHILE_143_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_144, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(144, s))
+#define BOOST_PP_WHILE_144_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_145, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(145, s))
+#define BOOST_PP_WHILE_145_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_146, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(146, s))
+#define BOOST_PP_WHILE_146_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_147, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(147, s))
+#define BOOST_PP_WHILE_147_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_148, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(148, s))
+#define BOOST_PP_WHILE_148_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_149, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(149, s))
+#define BOOST_PP_WHILE_149_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_150, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(150, s))
+#define BOOST_PP_WHILE_150_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_151, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(151, s))
+#define BOOST_PP_WHILE_151_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_152, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(152, s))
+#define BOOST_PP_WHILE_152_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_153, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(153, s))
+#define BOOST_PP_WHILE_153_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_154, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(154, s))
+#define BOOST_PP_WHILE_154_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_155, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(155, s))
+#define BOOST_PP_WHILE_155_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_156, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(156, s))
+#define BOOST_PP_WHILE_156_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_157, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(157, s))
+#define BOOST_PP_WHILE_157_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_158, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(158, s))
+#define BOOST_PP_WHILE_158_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_159, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(159, s))
+#define BOOST_PP_WHILE_159_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_160, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(160, s))
+#define BOOST_PP_WHILE_160_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_161, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(161, s))
+#define BOOST_PP_WHILE_161_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_162, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(162, s))
+#define BOOST_PP_WHILE_162_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_163, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(163, s))
+#define BOOST_PP_WHILE_163_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_164, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(164, s))
+#define BOOST_PP_WHILE_164_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_165, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(165, s))
+#define BOOST_PP_WHILE_165_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_166, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(166, s))
+#define BOOST_PP_WHILE_166_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_167, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(167, s))
+#define BOOST_PP_WHILE_167_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_168, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(168, s))
+#define BOOST_PP_WHILE_168_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_169, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(169, s))
+#define BOOST_PP_WHILE_169_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_170, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(170, s))
+#define BOOST_PP_WHILE_170_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_171, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(171, s))
+#define BOOST_PP_WHILE_171_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_172, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(172, s))
+#define BOOST_PP_WHILE_172_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_173, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(173, s))
+#define BOOST_PP_WHILE_173_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_174, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(174, s))
+#define BOOST_PP_WHILE_174_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_175, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(175, s))
+#define BOOST_PP_WHILE_175_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_176, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(176, s))
+#define BOOST_PP_WHILE_176_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_177, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(177, s))
+#define BOOST_PP_WHILE_177_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_178, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(178, s))
+#define BOOST_PP_WHILE_178_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_179, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(179, s))
+#define BOOST_PP_WHILE_179_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_180, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(180, s))
+#define BOOST_PP_WHILE_180_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_181, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(181, s))
+#define BOOST_PP_WHILE_181_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_182, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(182, s))
+#define BOOST_PP_WHILE_182_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_183, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(183, s))
+#define BOOST_PP_WHILE_183_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_184, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(184, s))
+#define BOOST_PP_WHILE_184_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_185, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(185, s))
+#define BOOST_PP_WHILE_185_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_186, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(186, s))
+#define BOOST_PP_WHILE_186_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_187, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(187, s))
+#define BOOST_PP_WHILE_187_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_188, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(188, s))
+#define BOOST_PP_WHILE_188_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_189, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(189, s))
+#define BOOST_PP_WHILE_189_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_190, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(190, s))
+#define BOOST_PP_WHILE_190_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_191, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(191, s))
+#define BOOST_PP_WHILE_191_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_192, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(192, s))
+#define BOOST_PP_WHILE_192_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_193, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(193, s))
+#define BOOST_PP_WHILE_193_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_194, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(194, s))
+#define BOOST_PP_WHILE_194_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_195, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(195, s))
+#define BOOST_PP_WHILE_195_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_196, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(196, s))
+#define BOOST_PP_WHILE_196_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_197, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(197, s))
+#define BOOST_PP_WHILE_197_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_198, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(198, s))
+#define BOOST_PP_WHILE_198_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_199, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(199, s))
+#define BOOST_PP_WHILE_199_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_200, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(200, s))
+#define BOOST_PP_WHILE_200_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_201, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(201, s))
+#define BOOST_PP_WHILE_201_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_202, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(202, s))
+#define BOOST_PP_WHILE_202_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_203, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(203, s))
+#define BOOST_PP_WHILE_203_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_204, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(204, s))
+#define BOOST_PP_WHILE_204_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_205, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(205, s))
+#define BOOST_PP_WHILE_205_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_206, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(206, s))
+#define BOOST_PP_WHILE_206_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_207, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(207, s))
+#define BOOST_PP_WHILE_207_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_208, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(208, s))
+#define BOOST_PP_WHILE_208_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_209, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(209, s))
+#define BOOST_PP_WHILE_209_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_210, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(210, s))
+#define BOOST_PP_WHILE_210_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_211, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(211, s))
+#define BOOST_PP_WHILE_211_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_212, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(212, s))
+#define BOOST_PP_WHILE_212_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_213, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(213, s))
+#define BOOST_PP_WHILE_213_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_214, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(214, s))
+#define BOOST_PP_WHILE_214_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_215, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(215, s))
+#define BOOST_PP_WHILE_215_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_216, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(216, s))
+#define BOOST_PP_WHILE_216_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_217, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(217, s))
+#define BOOST_PP_WHILE_217_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_218, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(218, s))
+#define BOOST_PP_WHILE_218_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_219, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(219, s))
+#define BOOST_PP_WHILE_219_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_220, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(220, s))
+#define BOOST_PP_WHILE_220_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_221, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(221, s))
+#define BOOST_PP_WHILE_221_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_222, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(222, s))
+#define BOOST_PP_WHILE_222_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_223, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(223, s))
+#define BOOST_PP_WHILE_223_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_224, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(224, s))
+#define BOOST_PP_WHILE_224_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_225, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(225, s))
+#define BOOST_PP_WHILE_225_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_226, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(226, s))
+#define BOOST_PP_WHILE_226_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_227, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(227, s))
+#define BOOST_PP_WHILE_227_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_228, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(228, s))
+#define BOOST_PP_WHILE_228_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_229, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(229, s))
+#define BOOST_PP_WHILE_229_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_230, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(230, s))
+#define BOOST_PP_WHILE_230_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_231, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(231, s))
+#define BOOST_PP_WHILE_231_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_232, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(232, s))
+#define BOOST_PP_WHILE_232_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_233, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(233, s))
+#define BOOST_PP_WHILE_233_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_234, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(234, s))
+#define BOOST_PP_WHILE_234_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_235, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(235, s))
+#define BOOST_PP_WHILE_235_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_236, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(236, s))
+#define BOOST_PP_WHILE_236_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_237, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(237, s))
+#define BOOST_PP_WHILE_237_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_238, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(238, s))
+#define BOOST_PP_WHILE_238_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_239, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(239, s))
+#define BOOST_PP_WHILE_239_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_240, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(240, s))
+#define BOOST_PP_WHILE_240_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_241, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(241, s))
+#define BOOST_PP_WHILE_241_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_242, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(242, s))
+#define BOOST_PP_WHILE_242_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_243, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(243, s))
+#define BOOST_PP_WHILE_243_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_244, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(244, s))
+#define BOOST_PP_WHILE_244_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_245, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(245, s))
+#define BOOST_PP_WHILE_245_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_246, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(246, s))
+#define BOOST_PP_WHILE_246_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_247, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(247, s))
+#define BOOST_PP_WHILE_247_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_248, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(248, s))
+#define BOOST_PP_WHILE_248_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_249, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(249, s))
+#define BOOST_PP_WHILE_249_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_250, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(250, s))
+#define BOOST_PP_WHILE_250_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_251, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(251, s))
+#define BOOST_PP_WHILE_251_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_252, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(252, s))
+#define BOOST_PP_WHILE_252_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_253, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(253, s))
+#define BOOST_PP_WHILE_253_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_254, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(254, s))
+#define BOOST_PP_WHILE_254_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_255, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(255, s))
+#define BOOST_PP_WHILE_255_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_256, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(256, s))
+#define BOOST_PP_WHILE_256_C(c,p,o,s) BOOST_PP_IIF(c, BOOST_PP_WHILE_257, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(257, s))
+# 49 "/usr/include/boost/preprocessor/control/while.hpp" 2 3 4
+
+
+#define BOOST_PP_WHILE_257(p,o,s) BOOST_PP_ERROR(0x0001)
+
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_NIL 1
+
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_1(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_2(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_3(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_4(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_5(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_6(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_7(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_8(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_9(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_10(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_11(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_12(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_13(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_14(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_15(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_16(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_17(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_18(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_19(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_20(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_21(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_22(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_23(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_24(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_25(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_26(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_27(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_28(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_29(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_30(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_31(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_32(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_33(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_34(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_35(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_36(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_37(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_38(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_39(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_40(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_41(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_42(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_43(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_44(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_45(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_46(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_47(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_48(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_49(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_50(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_51(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_52(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_53(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_54(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_55(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_56(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_57(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_58(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_59(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_60(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_61(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_62(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_63(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_64(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_65(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_66(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_67(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_68(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_69(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_70(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_71(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_72(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_73(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_74(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_75(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_76(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_77(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_78(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_79(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_80(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_81(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_82(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_83(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_84(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_85(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_86(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_87(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_88(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_89(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_90(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_91(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_92(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_93(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_94(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_95(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_96(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_97(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_98(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_99(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_100(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_101(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_102(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_103(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_104(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_105(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_106(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_107(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_108(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_109(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_110(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_111(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_112(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_113(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_114(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_115(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_116(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_117(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_118(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_119(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_120(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_121(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_122(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_123(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_124(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_125(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_126(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_127(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_128(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_129(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_130(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_131(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_132(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_133(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_134(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_135(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_136(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_137(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_138(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_139(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_140(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_141(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_142(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_143(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_144(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_145(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_146(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_147(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_148(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_149(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_150(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_151(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_152(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_153(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_154(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_155(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_156(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_157(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_158(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_159(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_160(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_161(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_162(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_163(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_164(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_165(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_166(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_167(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_168(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_169(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_170(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_171(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_172(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_173(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_174(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_175(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_176(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_177(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_178(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_179(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_180(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_181(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_182(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_183(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_184(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_185(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_186(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_187(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_188(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_189(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_190(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_191(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_192(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_193(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_194(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_195(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_196(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_197(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_198(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_199(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_200(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_201(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_202(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_203(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_204(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_205(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_206(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_207(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_208(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_209(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_210(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_211(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_212(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_213(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_214(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_215(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_216(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_217(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_218(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_219(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_220(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_221(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_222(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_223(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_224(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_225(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_226(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_227(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_228(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_229(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_230(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_231(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_232(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_233(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_234(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_235(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_236(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_237(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_238(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_239(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_240(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_241(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_242(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_243(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_244(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_245(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_246(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_247(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_248(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_249(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_250(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_251(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_252(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_253(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_254(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_255(p,o,s) 0
+#define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_256(p,o,s) 0
+# 21 "/usr/include/boost/preprocessor/arithmetic/add.hpp" 2 3 4
+
+
+
+
+
+#define BOOST_PP_ADD(x,y) BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_WHILE(BOOST_PP_ADD_P, BOOST_PP_ADD_O, (x, y)))
+
+
+
+
+
+#define BOOST_PP_ADD_P(d,xy) BOOST_PP_TUPLE_ELEM(2, 1, xy)
+
+
+#define BOOST_PP_ADD_O(d,xy) BOOST_PP_ADD_O_I xy
+
+
+
+
+#define BOOST_PP_ADD_O_I(x,y) (BOOST_PP_INC(x), BOOST_PP_DEC(y))
+
+
+
+
+#define BOOST_PP_ADD_D(d,x,y) BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_WHILE_ ## d(BOOST_PP_ADD_P, BOOST_PP_ADD_O, (x, y)))
+# 67 "/usr/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 2 3 4
+# 1 "/usr/include/boost/preprocessor/arithmetic/sub.hpp" 1 3 4
+# 15 "/usr/include/boost/preprocessor/arithmetic/sub.hpp" 3 4
+#define BOOST_PREPROCESSOR_ARITHMETIC_SUB_HPP 
+# 25 "/usr/include/boost/preprocessor/arithmetic/sub.hpp" 3 4
+#define BOOST_PP_SUB(x,y) BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_WHILE(BOOST_PP_SUB_P, BOOST_PP_SUB_O, (x, y)))
+
+
+
+
+
+#define BOOST_PP_SUB_P(d,xy) BOOST_PP_TUPLE_ELEM(2, 1, xy)
+
+
+#define BOOST_PP_SUB_O(d,xy) BOOST_PP_SUB_O_I xy
+
+
+
+
+#define BOOST_PP_SUB_O_I(x,y) (BOOST_PP_DEC(x), BOOST_PP_DEC(y))
+
+
+
+
+#define BOOST_PP_SUB_D(d,x,y) BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_WHILE_ ## d(BOOST_PP_SUB_P, BOOST_PP_SUB_O, (x, y)))
+# 68 "/usr/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 2 3 4
+
+
+
+
+
+#define BOOST_MPL_PP_AUX_TAIL_PARAM_FUNC(unused,i,op) , BOOST_PP_CAT( BOOST_PP_TUPLE_ELEM(3, 1, op) , BOOST_PP_ADD_D(1, i, BOOST_PP_INC(BOOST_PP_TUPLE_ELEM(3, 0, op))) ) BOOST_PP_TUPLE_ELEM(3, 2, op)()
+
+
+
+
+
+
+#define BOOST_MPL_PP_DEF_PARAMS_TAIL_IMPL(i,param,value_func) BOOST_PP_REPEAT( BOOST_PP_SUB_D(1, BOOST_MPL_LIMIT_METAFUNCTION_ARITY, i) , BOOST_MPL_PP_AUX_TAIL_PARAM_FUNC , (i, param, value_func) )
+# 91 "/usr/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 3 4
+#define BOOST_MPL_PP_DEF_PARAMS_TAIL(i,param,value) BOOST_MPL_PP_DEF_PARAMS_TAIL_IMPL(i, param, BOOST_PP_IDENTITY(=value))
+
+
+
+
+#define BOOST_MPL_PP_NESTED_DEF_PARAMS_TAIL(i,param,value) BOOST_MPL_PP_DEF_PARAMS_TAIL_IMPL(i, param, BOOST_PP_IDENTITY(=value))
+# 29 "/usr/include/boost/mpl/aux_/na_spec.hpp" 2 3 4
+
+
+
+
+
+
+# 1 "/usr/include/boost/mpl/aux_/config/overload_resolution.hpp" 1 3 4
+
+
+#define BOOST_MPL_AUX_CONFIG_OVERLOAD_RESOLUTION_HPP_INCLUDED 
+# 36 "/usr/include/boost/mpl/aux_/na_spec.hpp" 2 3 4
+
+
+#define BOOST_MPL_AUX_NA_PARAMS(i) BOOST_MPL_PP_ENUM(i, na)
+# 56 "/usr/include/boost/mpl/aux_/na_spec.hpp" 3 4
+#define BOOST_MPL_AUX_NA_SPEC_ARITY(i,name) 
+
+
+#define BOOST_MPL_AUX_NA_SPEC_MAIN(i,name) template<> struct name< BOOST_MPL_AUX_NA_PARAMS(i) > { template< BOOST_MPL_PP_PARAMS(i, typename T) BOOST_MPL_PP_NESTED_DEF_PARAMS_TAIL(i, typename T, na) > struct apply : name< BOOST_MPL_PP_PARAMS(i, T) > { }; };
+# 98 "/usr/include/boost/mpl/aux_/na_spec.hpp" 3 4
+#define BOOST_MPL_AUX_NA_SPEC_LAMBDA(i,name) template< typename Tag > struct lambda< name< BOOST_MPL_AUX_NA_PARAMS(i) > , Tag BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(int_<-1>) > { typedef false_ is_le; typedef name< BOOST_MPL_AUX_NA_PARAMS(i) > result_; typedef name< BOOST_MPL_AUX_NA_PARAMS(i) > type; };
+# 116 "/usr/include/boost/mpl/aux_/na_spec.hpp" 3 4
+#define BOOST_MPL_AUX_NA_SPEC_TEMPLATE_ARITY(i,j,name) namespace aux { template< BOOST_MPL_PP_PARAMS(j, typename T) > struct template_arity< name< BOOST_MPL_PP_PARAMS(j, T) > > : int_<j> { }; template<> struct template_arity< name< BOOST_MPL_PP_ENUM(i, na) > > : int_<-1> { }; }
+# 149 "/usr/include/boost/mpl/aux_/na_spec.hpp" 3 4
+#define BOOST_MPL_AUX_NA_SPEC_ETI(i,name) 
+
+
+#define BOOST_MPL_AUX_NA_PARAM(param) param = na
+
+#define BOOST_MPL_AUX_NA_SPEC_NO_ETI(i,name) BOOST_MPL_AUX_NA_SPEC_MAIN(i, name) BOOST_MPL_AUX_NA_SPEC_LAMBDA(i, name) BOOST_MPL_AUX_NA_SPEC_ARITY(i, name) BOOST_MPL_AUX_NA_SPEC_TEMPLATE_ARITY(i, i, name)
+
+
+
+
+
+
+#define BOOST_MPL_AUX_NA_SPEC(i,name) BOOST_MPL_AUX_NA_SPEC_NO_ETI(i, name) BOOST_MPL_AUX_NA_SPEC_ETI(i, name)
+
+
+
+
+#define BOOST_MPL_AUX_NA_SPEC2(i,j,name) BOOST_MPL_AUX_NA_SPEC_MAIN(i, name) BOOST_MPL_AUX_NA_SPEC_ETI(i, name) BOOST_MPL_AUX_NA_SPEC_LAMBDA(i, name) BOOST_MPL_AUX_NA_SPEC_ARITY(i, name) BOOST_MPL_AUX_NA_SPEC_TEMPLATE_ARITY(i, j, name)
+# 20 "/usr/include/boost/mpl/if.hpp" 2 3 4
+# 1 "/usr/include/boost/mpl/aux_/lambda_support.hpp" 1 3 4
+
+
+#define BOOST_MPL_AUX_LAMBDA_SUPPORT_HPP_INCLUDED 
+# 21 "/usr/include/boost/mpl/aux_/lambda_support.hpp" 3 4
+#define BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(i,name,params) 
+#define BOOST_MPL_AUX_LAMBDA_SUPPORT(i,name,params) 
+# 21 "/usr/include/boost/mpl/if.hpp" 2 3 4
+
+
+
+
+namespace boost { namespace mpl {
+
+
+
+template<
+      bool C
+    , typename T1
+    , typename T2
+    >
+struct if_c
+{
+    typedef T1 type;
+};
+
+template<
+      typename T1
+    , typename T2
+    >
+struct if_c<false,T1,T2>
+{
+    typedef T2 type;
+};
+
+
+
+template<
+      typename T1 = na
+    , typename T2 = na
+    , typename T3 = na
+    >
+struct if_
+{
+ private:
+
+    typedef if_c<
+
+
+
+          static_cast<bool>(T1::value)
+
+        , T2
+        , T3
+        > almost_type_;
+
+ public:
+    typedef typename almost_type_::type type;
+
+   
+};
+# 131 "/usr/include/boost/mpl/if.hpp" 3 4
+template<> struct if_< na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 =na , typename T5 =na > struct apply : if_< T1 , T2 , T3 > { }; }; template< typename Tag > struct lambda< if_< na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef if_< na , na , na > result_; typedef if_< na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< if_< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< if_< na , na , na > > : int_<-1> { }; }
+
+}}
+# 18 "/usr/include/boost/mpl/eval_if.hpp" 2 3 4
+
+
+
+
+
+
+namespace boost { namespace mpl {
+
+template<
+      typename C = na
+    , typename F1 = na
+    , typename F2 = na
+    >
+struct eval_if
+
+
+
+
+{
+    typedef typename if_<C,F1,F2>::type f_;
+    typedef typename f_::type type;
+
+
+
+
+   
+};
+
+
+
+template<
+      bool C
+    , typename F1
+    , typename F2
+    >
+struct eval_if_c
+
+
+
+
+{
+    typedef typename if_c<C,F1,F2>::type f_;
+    typedef typename f_::type type;
+
+
+
+
+};
+
+template<> struct eval_if< na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 =na , typename T5 =na > struct apply : eval_if< T1 , T2 , T3 > { }; }; template< typename Tag > struct lambda< eval_if< na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef eval_if< na , na , na > result_; typedef eval_if< na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< eval_if< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< eval_if< na , na , na > > : int_<-1> { }; }
+
+}}
+# 15 "/usr/include/boost/iterator/iterator_categories.hpp" 2 3 4
+# 1 "/usr/include/boost/mpl/identity.hpp" 1 3 4
+
+
+#define BOOST_MPL_IDENTITY_HPP_INCLUDED 
+# 20 "/usr/include/boost/mpl/identity.hpp" 3 4
+namespace boost { namespace mpl {
+
+template<
+      typename T = na
+    >
+struct identity
+{
+    typedef T type;
+   
+};
+
+template<
+      typename T = na
+    >
+struct make_identity
+{
+    typedef identity<T> type;
+   
+};
+
+template<> struct identity< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : identity< T1 > { }; }; template< typename Tag > struct lambda< identity< na > , Tag , int_<-1> > { typedef false_ is_le; typedef identity< na > result_; typedef identity< na > type; }; namespace aux { template< typename T1 > struct template_arity< identity< T1 > > : int_<1> { }; template<> struct template_arity< identity< na > > : int_<-1> { }; }
+template<> struct make_identity< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : make_identity< T1 > { }; }; template< typename Tag > struct lambda< make_identity< na > , Tag , int_<-1> > { typedef false_ is_le; typedef make_identity< na > result_; typedef make_identity< na > type; }; namespace aux { template< typename T1 > struct template_arity< make_identity< T1 > > : int_<1> { }; template<> struct template_arity< make_identity< na > > : int_<-1> { }; }
+
+}}
+# 16 "/usr/include/boost/iterator/iterator_categories.hpp" 2 3 4
+# 1 "/usr/include/boost/mpl/placeholders.hpp" 1 3 4
+
+
+
+
+
+
+#define BOOST_MPL_PLACEHOLDERS_HPP_INCLUDED 
+# 24 "/usr/include/boost/mpl/placeholders.hpp" 3 4
+# 1 "/usr/include/boost/mpl/arg.hpp" 1 3 4
+
+
+
+
+
+
+#define BOOST_MPL_ARG_HPP_INCLUDED 
+# 23 "/usr/include/boost/mpl/arg.hpp" 3 4
+# 1 "/usr/include/boost/mpl/arg_fwd.hpp" 1 3 4
+
+
+#define BOOST_MPL_ARG_FWD_HPP_INCLUDED 
+# 21 "/usr/include/boost/mpl/arg_fwd.hpp" 3 4
+namespace mpl_ {
+
+template< int N > struct arg;
+
+}
+namespace boost { namespace mpl { using ::mpl_::arg; } }
+# 24 "/usr/include/boost/mpl/arg.hpp" 2 3 4
+
+# 1 "/usr/include/boost/mpl/aux_/na_assert.hpp" 1 3 4
+
+
+#define BOOST_MPL_AUX_NA_ASSERT_HPP_INCLUDED 
+# 23 "/usr/include/boost/mpl/aux_/na_assert.hpp" 3 4
+# 1 "/usr/include/boost/mpl/assert.hpp" 1 3 4
+
+
+#define BOOST_MPL_ASSERT_HPP_INCLUDED 
+# 17 "/usr/include/boost/mpl/assert.hpp" 3 4
+# 1 "/usr/include/boost/mpl/not.hpp" 1 3 4
+
+
+#define BOOST_MPL_NOT_HPP_INCLUDED 
+# 19 "/usr/include/boost/mpl/not.hpp" 3 4
+# 1 "/usr/include/boost/mpl/aux_/nested_type_wknd.hpp" 1 3 4
+
+
+#define BOOST_MPL_AUX_NESTED_TYPE_WKND_HPP_INCLUDED 
+# 25 "/usr/include/boost/mpl/aux_/nested_type_wknd.hpp" 3 4
+namespace boost { namespace mpl { namespace aux {
+template< typename T > struct nested_type_wknd
+    : T::type
+{
+};
+}}}
+
+
+
+
+
+
+#define BOOST_MPL_AUX_NESTED_TYPE_WKND(T) ::boost::mpl::aux::nested_type_wknd<T>
+# 20 "/usr/include/boost/mpl/not.hpp" 2 3 4
+
+
+
+namespace boost { namespace mpl {
+
+namespace aux {
+
+template< long C_ >
+struct not_impl
+    : bool_<!C_>
+{
+};
+
+}
+
+
+template<
+      typename T = na
+    >
+struct not_
+    : aux::not_impl<
+          ::boost::mpl::aux::nested_type_wknd<T>::value
+        >
+{
+   
+};
+
+template<> struct not_< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : not_< T1 > { }; }; template< typename Tag > struct lambda< not_< na > , Tag , int_<-1> > { typedef false_ is_le; typedef not_< na > result_; typedef not_< na > type; }; namespace aux { template< typename T1 > struct template_arity< not_< T1 > > : int_<1> { }; template<> struct template_arity< not_< na > > : int_<-1> { }; }
+
+}}
+# 18 "/usr/include/boost/mpl/assert.hpp" 2 3 4
+
+
+# 1 "/usr/include/boost/mpl/aux_/yes_no.hpp" 1 3 4
+
+
+#define BOOST_MPL_AUX_YES_NO_HPP_INCLUDED 
+# 18 "/usr/include/boost/mpl/aux_/yes_no.hpp" 3 4
+# 1 "/usr/include/boost/mpl/aux_/config/arrays.hpp" 1 3 4
+
+
+#define BOOST_MPL_AUX_CONFIG_ARRAYS_HPP_INCLUDED 
+# 19 "/usr/include/boost/mpl/aux_/yes_no.hpp" 2 3 4
+
+
+
+
+namespace boost { namespace mpl { namespace aux {
+
+typedef char (&no_tag)[1];
+typedef char (&yes_tag)[2];
+
+template< bool C_ > struct yes_no_tag
+{
+    typedef no_tag type;
+};
+
+template<> struct yes_no_tag<true>
+{
+    typedef yes_tag type;
+};
+
+
+template< long n > struct weighted_tag
+{
+
+    typedef char (&type)[n];
+
+
+
+
+};
+# 56 "/usr/include/boost/mpl/aux_/yes_no.hpp" 3 4
+}}}
+# 21 "/usr/include/boost/mpl/assert.hpp" 2 3 4
+
+
+
+
+
+
+
+# 1 "/usr/include/boost/mpl/aux_/config/gpu.hpp" 1 3 4
+
+
+#define BOOST_MPL_AUX_CONFIG_GPU_HPP_INCLUDED 
+# 21 "/usr/include/boost/mpl/aux_/config/gpu.hpp" 3 4
+#define BOOST_MPL_CFG_GPU_ENABLED BOOST_GPU_ENABLED
+# 31 "/usr/include/boost/mpl/aux_/config/gpu.hpp" 3 4
+#define BOOST_MPL_CFG_GPU 0
+# 29 "/usr/include/boost/mpl/assert.hpp" 2 3 4
+
+# 1 "/usr/include/boost/mpl/aux_/config/pp_counter.hpp" 1 3 4
+
+
+#define BOOST_MPL_AUX_CONFIG_PP_COUNTER_HPP_INCLUDED 
+# 22 "/usr/include/boost/mpl/aux_/config/pp_counter.hpp" 3 4
+#define BOOST_MPL_AUX_PP_COUNTER() __LINE__
+# 31 "/usr/include/boost/mpl/assert.hpp" 2 3 4
+# 45 "/usr/include/boost/mpl/assert.hpp" 3 4
+#define BOOST_MPL_CFG_ASSERT_USE_RELATION_NAMES 
+# 60 "/usr/include/boost/mpl/assert.hpp" 3 4
+#define BOOST_MPL_AUX_ASSERT_CONSTANT(T,expr) enum { expr }
+
+
+
+
+
+namespace mpl_ {
+
+struct failed {};
+
+
+
+
+
+
+
+#define AUX778076_ASSERT_ARG(x) x
+
+
+template< bool C > struct assert { typedef void* type; };
+template<> struct assert<false> { typedef assert type; };
+
+template< bool C >
+int assertion_failed( typename assert<C>::type );
+
+template< bool C >
+struct assertion
+{
+    static int failed( assert<false> );
+};
+
+template<>
+struct assertion<true>
+{
+    static int failed( void* );
+};
+
+struct assert_
+{
+
+    template< typename T1, typename T2 = na, typename T3 = na, typename T4 = na > struct types {};
+
+    static assert_ const arg;
+    enum relations { equal = 1, not_equal, greater, greater_equal, less, less_equal };
+};
+# 127 "/usr/include/boost/mpl/assert.hpp" 3 4
+boost::mpl::aux::weighted_tag<1>::type operator==( assert_, assert_ );
+boost::mpl::aux::weighted_tag<2>::type operator!=( assert_, assert_ );
+boost::mpl::aux::weighted_tag<3>::type operator>( assert_, assert_ );
+boost::mpl::aux::weighted_tag<4>::type operator>=( assert_, assert_ );
+boost::mpl::aux::weighted_tag<5>::type operator<( assert_, assert_ );
+boost::mpl::aux::weighted_tag<6>::type operator<=( assert_, assert_ );
+
+template< assert_::relations r, long x, long y > struct assert_relation {};
+# 171 "/usr/include/boost/mpl/assert.hpp" 3 4
+template< bool > struct assert_arg_pred_impl { typedef int type; };
+template<> struct assert_arg_pred_impl<true> { typedef void* type; };
+
+template< typename P > struct assert_arg_pred
+{
+    typedef typename P::type p_type;
+    typedef typename assert_arg_pred_impl< p_type::value >::type type;
+};
+
+template< typename P > struct assert_arg_pred_not
+{
+    typedef typename P::type p_type;
+    enum { p = !p_type::value };
+    typedef typename assert_arg_pred_impl<p>::type type;
+};
+
+
+#define BOOST_MPL_IGNORE_PARENTHESES_WARNING 
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wparentheses"
+
+
+template< typename Pred >
+failed ************ (Pred::************
+      assert_arg( void (*)(Pred), typename assert_arg_pred<Pred>::type )
+    );
+
+template< typename Pred >
+failed ************ (boost::mpl::not_<Pred>::************
+      assert_not_arg( void (*)(Pred), typename assert_arg_pred_not<Pred>::type )
+    );
+
+
+#undef BOOST_MPL_IGNORE_PARENTHESES_WARNING
+#pragma GCC diagnostic pop
+
+
+template< typename Pred >
+assert<false>
+assert_arg( void (*)(Pred), typename assert_arg_pred_not<Pred>::type );
+
+template< typename Pred >
+assert<false>
+assert_not_arg( void (*)(Pred), typename assert_arg_pred<Pred>::type );
+# 255 "/usr/include/boost/mpl/assert.hpp" 3 4
+#undef AUX778076_ASSERT_ARG
+
+}
+# 295 "/usr/include/boost/mpl/assert.hpp" 3 4
+#define BOOST_MPL_ASSERT(pred) BOOST_MPL_AUX_ASSERT_CONSTANT( std::size_t , BOOST_PP_CAT(mpl_assertion_in_line_,BOOST_MPL_AUX_PP_COUNTER()) = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_arg( (void (*) pred)0, 1 ) ) ) )
+# 319 "/usr/include/boost/mpl/assert.hpp" 3 4
+#define BOOST_MPL_ASSERT_NOT(pred) BOOST_MPL_AUX_ASSERT_CONSTANT( std::size_t , BOOST_PP_CAT(mpl_assertion_in_line_,BOOST_MPL_AUX_PP_COUNTER()) = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) pred)0, 1 ) ) ) )
+# 339 "/usr/include/boost/mpl/assert.hpp" 3 4
+#define BOOST_MPL_ASSERT_RELATION_IMPL(counter,x,rel,y) enum { BOOST_PP_CAT(mpl_assert_rel_value,counter) = (x rel y) }; BOOST_MPL_AUX_ASSERT_CONSTANT( std::size_t , BOOST_PP_CAT(mpl_assertion_in_line_,counter) = sizeof( boost::mpl::assertion_failed<BOOST_PP_CAT(mpl_assert_rel_value,counter)>( (boost::mpl::failed ************ ( boost::mpl::assert_relation< boost::mpl::assert_::relations( sizeof( boost::mpl::assert_::arg rel boost::mpl::assert_::arg ) ) , x , y >::************)) 0 ) ) )
+# 379 "/usr/include/boost/mpl/assert.hpp" 3 4
+#define BOOST_MPL_ASSERT_RELATION(x,rel,y) BOOST_MPL_ASSERT_RELATION_IMPL(BOOST_MPL_AUX_PP_COUNTER(), x, rel, y)
+# 430 "/usr/include/boost/mpl/assert.hpp" 3 4
+#define BOOST_MPL_ASSERT_MSG_IMPL(counter,c,msg,types_) struct msg; typedef struct BOOST_PP_CAT(msg,counter) : boost::mpl::assert_ { static boost::mpl::failed ************ (msg::************ assert_arg()) types_ { return 0; } } BOOST_PP_CAT(mpl_assert_arg,counter); BOOST_MPL_AUX_ASSERT_CONSTANT( std::size_t , BOOST_PP_CAT(mpl_assertion_in_line_,counter) = sizeof( boost::mpl::assertion_failed<(c)>( BOOST_PP_CAT(mpl_assert_arg,counter)::assert_arg() ) ) )
+# 454 "/usr/include/boost/mpl/assert.hpp" 3 4
+#define BOOST_MPL_ASSERT_MSG(c,msg,types_) BOOST_MPL_ASSERT_MSG_IMPL( BOOST_MPL_AUX_PP_COUNTER(), c, msg, types_ )
+# 24 "/usr/include/boost/mpl/aux_/na_assert.hpp" 2 3 4
+#define BOOST_MPL_AUX_ASSERT_NOT_NA(x) BOOST_MPL_ASSERT_NOT((boost::mpl::is_na<type>))
+# 26 "/usr/include/boost/mpl/arg.hpp" 2 3 4
+# 1 "/usr/include/boost/mpl/aux_/arity_spec.hpp" 1 3 4
+
+
+#define BOOST_MPL_AUX_ARITY_SPEC_HPP_INCLUDED 
+# 43 "/usr/include/boost/mpl/aux_/arity_spec.hpp" 3 4
+#define BOOST_MPL_AUX_NONTYPE_ARITY_SPEC(i,type,name) 
+
+
+#define BOOST_MPL_AUX_ARITY_SPEC(i,name) BOOST_MPL_AUX_NONTYPE_ARITY_SPEC(i,typename,name)
+
+
+
+
+
+
+#define BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(i,name) namespace aux { template< BOOST_MPL_PP_PARAMS(i,typename T) > struct template_arity< name<BOOST_MPL_PP_PARAMS(i,T)> > : int_<i> { }; }
+# 27 "/usr/include/boost/mpl/arg.hpp" 2 3 4
+# 1 "/usr/include/boost/mpl/aux_/arg_typedef.hpp" 1 3 4
+
+
+#define BOOST_MPL_AUX_ARG_TYPEDEF_HPP_INCLUDED 
+# 27 "/usr/include/boost/mpl/aux_/arg_typedef.hpp" 3 4
+#define BOOST_MPL_AUX_ARG_TYPEDEF(T,name) 
+# 28 "/usr/include/boost/mpl/arg.hpp" 2 3 4
+
+
+
+# 1 "/usr/include/boost/mpl/aux_/config/use_preprocessed.hpp" 1 3 4
+
+
+#define BOOST_MPL_AUX_CONFIG_USE_PREPROCESSED_HPP_INCLUDED 
+# 32 "/usr/include/boost/mpl/arg.hpp" 2 3 4
+
+
+
+
+#define BOOST_MPL_PREPROCESSED_HEADER arg.hpp
+# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
+# 16 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
+# 1 "/usr/include/boost/mpl/aux_/config/compiler.hpp" 1 3 4
+
+
+#define BOOST_MPL_AUX_CONFIG_COMPILER_HPP_INCLUDED 
+# 33 "/usr/include/boost/mpl/aux_/config/compiler.hpp" 3 4
+#define BOOST_MPL_CFG_COMPILER_DIR gcc
+# 17 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
+
+
+
+# 1 "/usr/include/boost/preprocessor/stringize.hpp" 1 3 4
+# 15 "/usr/include/boost/preprocessor/stringize.hpp" 3 4
+#define BOOST_PREPROCESSOR_STRINGIZE_HPP 
+# 28 "/usr/include/boost/preprocessor/stringize.hpp" 3 4
+#define BOOST_PP_STRINGIZE(text) BOOST_PP_STRINGIZE_I(text)
+
+
+
+#define BOOST_PP_STRINGIZE_I(...) #__VA_ARGS__
+# 21 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
+
+
+#define AUX778076_PREPROCESSED_HEADER BOOST_MPL_CFG_COMPILER_DIR/BOOST_MPL_PREPROCESSED_HEADER
+# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
+# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/arg.hpp" 1 3 4
+# 13 "/usr/include/boost/mpl/aux_/preprocessed/gcc/arg.hpp" 3 4
+namespace mpl_ {
+template<> struct arg< -1 >
+{
+    static const int value = -1;
+   
+   
+
+    template<
+          typename U1 = na, typename U2 = na, typename U3 = na
+        , typename U4 = na, typename U5 = na
+        >
+    struct apply
+    {
+        typedef U1 type;
+        enum { mpl_assertion_in_line_27 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (boost::mpl::is_na<type>))0, 1 ) ) ) };
+    };
+};
+
+template<> struct arg<1>
+{
+    static const int value = 1;
+    typedef arg<2> next;
+   
+   
+
+    template<
+          typename U1 = na, typename U2 = na, typename U3 = na
+        , typename U4 = na, typename U5 = na
+        >
+    struct apply
+    {
+        typedef U1 type;
+        enum { mpl_assertion_in_line_45 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (boost::mpl::is_na<type>))0, 1 ) ) ) };
+    };
+};
+
+template<> struct arg<2>
+{
+    static const int value = 2;
+    typedef arg<3> next;
+   
+   
+
+    template<
+          typename U1 = na, typename U2 = na, typename U3 = na
+        , typename U4 = na, typename U5 = na
+        >
+    struct apply
+    {
+        typedef U2 type;
+        enum { mpl_assertion_in_line_63 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (boost::mpl::is_na<type>))0, 1 ) ) ) };
+    };
+};
+
+template<> struct arg<3>
+{
+    static const int value = 3;
+    typedef arg<4> next;
+   
+   
+
+    template<
+          typename U1 = na, typename U2 = na, typename U3 = na
+        , typename U4 = na, typename U5 = na
+        >
+    struct apply
+    {
+        typedef U3 type;
+        enum { mpl_assertion_in_line_81 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (boost::mpl::is_na<type>))0, 1 ) ) ) };
+    };
+};
+
+template<> struct arg<4>
+{
+    static const int value = 4;
+    typedef arg<5> next;
+   
+   
+
+    template<
+          typename U1 = na, typename U2 = na, typename U3 = na
+        , typename U4 = na, typename U5 = na
+        >
+    struct apply
+    {
+        typedef U4 type;
+        enum { mpl_assertion_in_line_99 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (boost::mpl::is_na<type>))0, 1 ) ) ) };
+    };
+};
+
+template<> struct arg<5>
+{
+    static const int value = 5;
+    typedef arg<6> next;
+   
+   
+
+    template<
+          typename U1 = na, typename U2 = na, typename U3 = na
+        , typename U4 = na, typename U5 = na
+        >
+    struct apply
+    {
+        typedef U5 type;
+        enum { mpl_assertion_in_line_117 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (boost::mpl::is_na<type>))0, 1 ) ) ) };
+    };
+};
+
+
+
+}
+# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
+
+
+#undef AUX778076_PREPROCESSED_HEADER
+
+#undef BOOST_MPL_PREPROCESSED_HEADER
+# 38 "/usr/include/boost/mpl/arg.hpp" 2 3 4
+# 25 "/usr/include/boost/mpl/placeholders.hpp" 2 3 4
+
+
+
+#define BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(type) using ::BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::type;
+# 42 "/usr/include/boost/mpl/placeholders.hpp" 3 4
+#define BOOST_MPL_PREPROCESSED_HEADER placeholders.hpp
+# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
+# 23 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
+#define AUX778076_PREPROCESSED_HEADER BOOST_MPL_CFG_COMPILER_DIR/BOOST_MPL_PREPROCESSED_HEADER
+# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
+# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/placeholders.hpp" 1 3 4
+# 13 "/usr/include/boost/mpl/aux_/preprocessed/gcc/placeholders.hpp" 3 4
+namespace mpl_ {
+typedef arg< -1 > _;
+}
+namespace boost { namespace mpl {
+
+using ::mpl_::_;
+
+namespace placeholders {
+using mpl_::_;
+}
+
+}}
+
+
+
+namespace mpl_ {
+typedef arg<1> _1;
+
+}
+namespace boost { namespace mpl {
+
+using ::mpl_::_1;
+
+namespace placeholders {
+using mpl_::_1;
+}
+
+}}
+namespace mpl_ {
+typedef arg<2> _2;
+
+}
+namespace boost { namespace mpl {
+
+using ::mpl_::_2;
+
+namespace placeholders {
+using mpl_::_2;
+}
+
+}}
+namespace mpl_ {
+typedef arg<3> _3;
+
+}
+namespace boost { namespace mpl {
+
+using ::mpl_::_3;
+
+namespace placeholders {
+using mpl_::_3;
+}
+
+}}
+namespace mpl_ {
+typedef arg<4> _4;
+
+}
+namespace boost { namespace mpl {
+
+using ::mpl_::_4;
+
+namespace placeholders {
+using mpl_::_4;
+}
+
+}}
+namespace mpl_ {
+typedef arg<5> _5;
+
+}
+namespace boost { namespace mpl {
+
+using ::mpl_::_5;
+
+namespace placeholders {
+using mpl_::_5;
+}
+
+}}
+namespace mpl_ {
+typedef arg<6> _6;
+
+}
+namespace boost { namespace mpl {
+
+using ::mpl_::_6;
+
+namespace placeholders {
+using mpl_::_6;
+}
+
+}}
+# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
+
+
+#undef AUX778076_PREPROCESSED_HEADER
+
+#undef BOOST_MPL_PREPROCESSED_HEADER
+# 44 "/usr/include/boost/mpl/placeholders.hpp" 2 3 4
+# 17 "/usr/include/boost/iterator/iterator_categories.hpp" 2 3 4
+
+
+# 1 "/usr/include/boost/type_traits/is_convertible.hpp" 1 3 4
+# 13 "/usr/include/boost/type_traits/is_convertible.hpp" 3 4
+#define BOOST_TT_IS_CONVERTIBLE_HPP_INCLUDED 
+# 28 "/usr/include/boost/type_traits/is_convertible.hpp" 3 4
+# 1 "/usr/include/boost/type_traits/is_abstract.hpp" 1 3 4
+
+#define BOOST_TT_IS_ABSTRACT_CLASS_HPP 
+# 63 "/usr/include/boost/type_traits/is_abstract.hpp" 3 4
+namespace boost {
+
+namespace detail{
+
+
+template <class T>
+struct is_abstract_imp
+{
+   static const bool value = __is_abstract(T);
+};
+# 140 "/usr/include/boost/type_traits/is_abstract.hpp" 3 4
+}
+
+
+template <class T> struct is_abstract : public integral_constant<bool, ::boost::detail::is_abstract_imp<T>::value> {};
+
+
+
+
+}
+# 29 "/usr/include/boost/type_traits/is_convertible.hpp" 2 3 4
+
+# 1 "/usr/include/boost/type_traits/add_lvalue_reference.hpp" 1 3 4
+
+
+
+
+
+
+#define BOOST_TYPE_TRAITS_EXT_ADD_LVALUE_REFERENCE__HPP 
+
+# 1 "/usr/include/boost/type_traits/add_reference.hpp" 1 3 4
+# 10 "/usr/include/boost/type_traits/add_reference.hpp" 3 4
+#define BOOST_TT_ADD_REFERENCE_HPP_INCLUDED 
+
+
+
+
+namespace boost {
+
+namespace detail {
+
+
+
+
+
+
+template <typename T>
+struct add_reference_impl
+{
+    typedef T& type;
+};
+
+
+template <typename T>
+struct add_reference_impl<T&&>
+{
+    typedef T&& type;
+};
+
+
+}
+
+template <class T> struct add_reference
+{
+   typedef typename boost::detail::add_reference_impl<T>::type type;
+};
+template <class T> struct add_reference<T&>
+{
+   typedef T& type;
+};
+
+
+template <> struct add_reference<void> { typedef void type; };
+
+template <> struct add_reference<const void> { typedef const void type; };
+template <> struct add_reference<const volatile void> { typedef const volatile void type; };
+template <> struct add_reference<volatile void> { typedef volatile void type; };
+
+
+
+
+template <class T> using add_reference_t = typename add_reference<T>::type;
+
+
+
+
+}
+# 10 "/usr/include/boost/type_traits/add_lvalue_reference.hpp" 2 3 4
+
+namespace boost{
+
+template <class T> struct add_lvalue_reference
+{
+   typedef typename boost::add_reference<T>::type type;
+};
+
+
+template <class T> struct add_lvalue_reference<T&&>
+{
+   typedef T& type;
+};
+
+
+
+
+   template <class T> using add_lvalue_reference_t = typename add_lvalue_reference<T>::type;
+
+
+
+}
+# 31 "/usr/include/boost/type_traits/is_convertible.hpp" 2 3 4
+# 45 "/usr/include/boost/type_traits/is_convertible.hpp" 3 4
+namespace boost {
+# 59 "/usr/include/boost/type_traits/is_convertible.hpp" 3 4
+namespace detail {
+
+
+
+
+
+#define BOOST_TT_CXX11_IS_CONVERTIBLE 
+
+   template <class A, class B, class C>
+   struct or_helper
+   {
+      static const bool value = (A::value || B::value || C::value);
+   };
+
+   template<typename From, typename To, bool b = or_helper<boost::is_void<From>, boost::is_function<To>, boost::is_array<To> >::value>
+   struct is_convertible_basic_impl
+   {
+
+      static const bool value = is_void<To>::value;
+   };
+
+   template<typename From, typename To>
+   class is_convertible_basic_impl<From, To, false>
+   {
+      typedef char one;
+      typedef int two;
+
+      template<typename To1>
+      static void test_aux(To1);
+
+      template<typename From1, typename To1>
+      static decltype(test_aux<To1>(boost::declval<From1>()), one()) test(int);
+
+      template<typename, typename>
+      static two test(...);
+
+   public:
+      static const bool value = sizeof(test<From, To>(0)) == 1;
+   };
+# 362 "/usr/include/boost/type_traits/is_convertible.hpp" 3 4
+template <typename From, typename To>
+struct is_convertible_impl
+{
+   static const bool value = ( ::boost::detail::is_convertible_basic_impl<From, To>::value && !::boost::is_array<To>::value && !::boost::is_function<To>::value);
+};
+
+
+template <bool trivial1, bool trivial2, bool abstract_target>
+struct is_convertible_impl_select
+{
+   template <class From, class To>
+   struct rebind
+   {
+      typedef is_convertible_impl<From, To> type;
+   };
+};
+
+template <>
+struct is_convertible_impl_select<true, true, false>
+{
+   template <class From, class To>
+   struct rebind
+   {
+      typedef true_type type;
+   };
+};
+
+template <>
+struct is_convertible_impl_select<false, false, true>
+{
+   template <class From, class To>
+   struct rebind
+   {
+      typedef false_type type;
+   };
+};
+
+template <>
+struct is_convertible_impl_select<true, false, true>
+{
+   template <class From, class To>
+   struct rebind
+   {
+      typedef false_type type;
+   };
+};
+
+template <typename From, typename To>
+struct is_convertible_impl_dispatch_base
+{
+
+   typedef is_convertible_impl_select<
+      ::boost::is_arithmetic<From>::value,
+      ::boost::is_arithmetic<To>::value,
+
+
+
+
+      false
+
+   > selector;
+
+
+
+   typedef typename selector::template rebind<From, To> isc_binder;
+   typedef typename isc_binder::type type;
+};
+
+template <typename From, typename To>
+struct is_convertible_impl_dispatch
+   : public is_convertible_impl_dispatch_base<From, To>::type
+{};
+# 442 "/usr/include/boost/type_traits/is_convertible.hpp" 3 4
+template <> struct is_convertible_impl_dispatch<void, void> : public true_type{};
+template <> struct is_convertible_impl_dispatch<void, void const> : public true_type{};
+template <> struct is_convertible_impl_dispatch<void, void const volatile> : public true_type{};
+template <> struct is_convertible_impl_dispatch<void, void volatile> : public true_type{};
+
+template <> struct is_convertible_impl_dispatch<void const, void> : public true_type{};
+template <> struct is_convertible_impl_dispatch<void const, void const> : public true_type{};
+template <> struct is_convertible_impl_dispatch<void const, void const volatile> : public true_type{};
+template <> struct is_convertible_impl_dispatch<void const, void volatile> : public true_type{};
+
+template <> struct is_convertible_impl_dispatch<void const volatile, void> : public true_type{};
+template <> struct is_convertible_impl_dispatch<void const volatile, void const> : public true_type{};
+template <> struct is_convertible_impl_dispatch<void const volatile, void const volatile> : public true_type{};
+template <> struct is_convertible_impl_dispatch<void const volatile, void volatile> : public true_type{};
+
+template <> struct is_convertible_impl_dispatch<void volatile, void> : public true_type{};
+template <> struct is_convertible_impl_dispatch<void volatile, void const> : public true_type{};
+template <> struct is_convertible_impl_dispatch<void volatile, void const volatile> : public true_type{};
+template <> struct is_convertible_impl_dispatch<void volatile, void volatile> : public true_type{};
+
+
+
+
+
+template <class To> struct is_convertible_impl_dispatch<void, To> : public false_type{};
+template <class From> struct is_convertible_impl_dispatch<From, void> : public false_type{};
+
+
+template <class To> struct is_convertible_impl_dispatch<void const, To> : public false_type{};
+template <class From> struct is_convertible_impl_dispatch<From, void const> : public false_type{};
+template <class To> struct is_convertible_impl_dispatch<void const volatile, To> : public false_type{};
+template <class From> struct is_convertible_impl_dispatch<From, void const volatile> : public false_type{};
+template <class To> struct is_convertible_impl_dispatch<void volatile, To> : public false_type{};
+template <class From> struct is_convertible_impl_dispatch<From, void volatile> : public false_type{};
+
+
+}
+
+template <class From, class To>
+struct is_convertible : public integral_constant<bool, ::boost::detail::is_convertible_impl_dispatch<From, To>::value>
+{
+   static_assert(boost::is_complete<To>::value || boost::is_void<To>::value || boost::is_array<To>::value, "Destination argument type to is_convertible must be a complete type");
+   static_assert(boost::is_complete<From>::value || boost::is_void<From>::value || boost::is_array<From>::value, "From argument type to is_convertible must be a complete type");
+};
+# 504 "/usr/include/boost/type_traits/is_convertible.hpp" 3 4
+}
+# 20 "/usr/include/boost/iterator/iterator_categories.hpp" 2 3 4
+
+
+
+# 1 "/usr/include/c++/10.2.0/iterator" 1 3 4
+# 56 "/usr/include/c++/10.2.0/iterator" 3 4
+#define _GLIBCXX_ITERATOR 1
+
+       
+# 59 "/usr/include/c++/10.2.0/iterator" 3
+
+
+
+
+
+
+# 1 "/usr/include/c++/10.2.0/bits/stream_iterator.h" 1 3
+# 31 "/usr/include/c++/10.2.0/bits/stream_iterator.h" 3
+#define _STREAM_ITERATOR_H 1
+
+       
+# 34 "/usr/include/c++/10.2.0/bits/stream_iterator.h" 3
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+
+
+
+  template<typename _Tp, typename _CharT = char,
+           typename _Traits = char_traits<_CharT>, typename _Dist = ptrdiff_t>
+    class istream_iterator
+    : public iterator<input_iterator_tag, _Tp, _Dist, const _Tp*, const _Tp&>
+    {
+    public:
+      typedef _CharT char_type;
+      typedef _Traits traits_type;
+      typedef basic_istream<_CharT, _Traits> istream_type;
+
+    private:
+      istream_type* _M_stream;
+      _Tp _M_value;
+
+
+
+      bool _M_ok;
+
+    public:
+
+      constexpr istream_iterator()
+      : _M_stream(0), _M_value(), _M_ok(false) {}
+
+
+      istream_iterator(istream_type& __s)
+      : _M_stream(std::__addressof(__s)), _M_ok(true)
+      { _M_read(); }
+
+      istream_iterator(const istream_iterator& __obj)
+      : _M_stream(__obj._M_stream), _M_value(__obj._M_value),
+        _M_ok(__obj._M_ok)
+      { }
+# 88 "/usr/include/c++/10.2.0/bits/stream_iterator.h" 3
+      istream_iterator& operator=(const istream_iterator&) = default;
+      ~istream_iterator() = default;
+
+
+      const _Tp&
+      operator*() const
+      {
+
+
+                        ;
+ return _M_value;
+      }
+
+      const _Tp*
+      operator->() const { return std::__addressof((operator*())); }
+
+      istream_iterator&
+      operator++()
+      {
+
+
+                        ;
+ _M_read();
+ return *this;
+      }
+
+      istream_iterator
+      operator++(int)
+      {
+
+
+                        ;
+ istream_iterator __tmp = *this;
+ _M_read();
+ return __tmp;
+      }
+
+    private:
+      bool
+      _M_equal(const istream_iterator& __x) const
+      {
+
+
+ return (_M_ok == __x._M_ok) && (!_M_ok || _M_stream == __x._M_stream);
+      }
+
+      void
+      _M_read()
+      {
+        if (_M_stream && !(*_M_stream >> _M_value))
+          {
+            _M_stream = 0;
+            _M_ok = false;
+          }
+      }
+
+
+
+      friend bool
+      operator==(const istream_iterator& __x, const istream_iterator& __y)
+      { return __x._M_equal(__y); }
+
+
+
+      friend bool
+      operator!=(const istream_iterator& __x, const istream_iterator& __y)
+      { return !__x._M_equal(__y); }
+
+
+
+
+
+
+    };
+# 174 "/usr/include/c++/10.2.0/bits/stream_iterator.h" 3
+  template<typename _Tp, typename _CharT = char,
+           typename _Traits = char_traits<_CharT> >
+    class ostream_iterator
+    : public iterator<output_iterator_tag, void, void, void, void>
+    {
+    public:
+
+
+
+
+
+      typedef _CharT char_type;
+      typedef _Traits traits_type;
+      typedef basic_ostream<_CharT, _Traits> ostream_type;
+
+
+    private:
+      ostream_type* _M_stream;
+      const _CharT* _M_string;
+
+    public:
+
+
+
+
+
+
+      ostream_iterator(ostream_type& __s)
+      : _M_stream(std::__addressof(__s)), _M_string(0) {}
+# 214 "/usr/include/c++/10.2.0/bits/stream_iterator.h" 3
+      ostream_iterator(ostream_type& __s, const _CharT* __c)
+      : _M_stream(std::__addressof(__s)), _M_string(__c) { }
+
+
+      ostream_iterator(const ostream_iterator& __obj)
+      : _M_stream(__obj._M_stream), _M_string(__obj._M_string) { }
+
+
+      ostream_iterator& operator=(const ostream_iterator&) = default;
+
+
+
+
+      ostream_iterator&
+      operator=(const _Tp& __value)
+      {
+
+
+                        ;
+ *_M_stream << __value;
+ if (_M_string)
+          *_M_stream << _M_string;
+ return *this;
+      }
+
+      ostream_iterator&
+      operator*()
+      { return *this; }
+
+      ostream_iterator&
+      operator++()
+      { return *this; }
+
+      ostream_iterator&
+      operator++(int)
+      { return *this; }
+    };
+
+
+
+
+}
+# 66 "/usr/include/c++/10.2.0/iterator" 2 3
+
+
+
+
+#define __cpp_lib_null_iterators 201304L
+# 24 "/usr/include/boost/iterator/iterator_categories.hpp" 2 3 4
+
+namespace boost {
+namespace iterators {
+
+
+
+
+
+struct no_traversal_tag {};
+
+struct incrementable_traversal_tag
+  : no_traversal_tag
+{
+
+
+};
+
+struct single_pass_traversal_tag
+  : incrementable_traversal_tag
+{
+
+
+};
+
+struct forward_traversal_tag
+  : single_pass_traversal_tag
+{
+
+
+};
+
+struct bidirectional_traversal_tag
+  : forward_traversal_tag
+{
+
+
+};
+
+struct random_access_traversal_tag
+  : bidirectional_traversal_tag
+{
+
+
+};
+
+namespace detail
+{
+
+
+
+
+
+
+  template <class Cat>
+  struct old_category_to_traversal
+    : mpl::eval_if<
+          is_convertible<Cat,std::random_access_iterator_tag>
+        , mpl::identity<random_access_traversal_tag>
+        , mpl::eval_if<
+              is_convertible<Cat,std::bidirectional_iterator_tag>
+            , mpl::identity<bidirectional_traversal_tag>
+            , mpl::eval_if<
+                  is_convertible<Cat,std::forward_iterator_tag>
+                , mpl::identity<forward_traversal_tag>
+                , mpl::eval_if<
+                      is_convertible<Cat,std::input_iterator_tag>
+                    , mpl::identity<single_pass_traversal_tag>
+                    , mpl::eval_if<
+                          is_convertible<Cat,std::output_iterator_tag>
+                        , mpl::identity<incrementable_traversal_tag>
+                        , void
+                      >
+                  >
+              >
+          >
+      >
+  {};
+
+}
+
+
+
+
+template <class Cat>
+struct iterator_category_to_traversal
+  : mpl::eval_if<
+        is_convertible<Cat,incrementable_traversal_tag>
+      , mpl::identity<Cat>
+      , boost::iterators::detail::old_category_to_traversal<Cat>
+    >
+{};
+
+
+template <class Iterator = mpl::_1>
+struct iterator_traversal
+  : iterator_category_to_traversal<
+        typename std::iterator_traits<Iterator>::iterator_category
+    >
+{};
+# 146 "/usr/include/boost/iterator/iterator_categories.hpp" 3 4
+template <class Traversal>
+struct pure_traversal_tag
+  : mpl::eval_if<
+        is_convertible<Traversal,random_access_traversal_tag>
+      , mpl::identity<random_access_traversal_tag>
+      , mpl::eval_if<
+            is_convertible<Traversal,bidirectional_traversal_tag>
+          , mpl::identity<bidirectional_traversal_tag>
+          , mpl::eval_if<
+                is_convertible<Traversal,forward_traversal_tag>
+              , mpl::identity<forward_traversal_tag>
+              , mpl::eval_if<
+                    is_convertible<Traversal,single_pass_traversal_tag>
+                  , mpl::identity<single_pass_traversal_tag>
+                  , mpl::eval_if<
+                        is_convertible<Traversal,incrementable_traversal_tag>
+                      , mpl::identity<incrementable_traversal_tag>
+                      , void
+                    >
+                >
+            >
+        >
+    >
+{
+};
+
+
+
+
+template <class Iterator = mpl::_1>
+struct pure_iterator_traversal
+  : pure_traversal_tag<typename iterator_traversal<Iterator>::type>
+{};
+# 194 "/usr/include/boost/iterator/iterator_categories.hpp" 3 4
+}
+
+using iterators::no_traversal_tag;
+using iterators::incrementable_traversal_tag;
+using iterators::single_pass_traversal_tag;
+using iterators::forward_traversal_tag;
+using iterators::bidirectional_traversal_tag;
+using iterators::random_access_traversal_tag;
+using iterators::iterator_category_to_traversal;
+using iterators::iterator_traversal;
+
+
+
+
+namespace detail {
+using iterators::pure_traversal_tag;
+}
+
+}
+
+# 1 "/usr/include/boost/iterator/detail/config_undef.hpp" 1 3 4
+# 14 "/usr/include/boost/iterator/detail/config_undef.hpp" 3 4
+#undef BOOST_NO_IS_CONVERTIBLE
+#undef BOOST_NO_IS_CONVERTIBLE_TEMPLATE
+#undef BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY
+#undef BOOST_NO_LVALUE_RETURN_DETECTION
+#undef BOOST_NO_ONE_WAY_ITERATOR_INTEROP
+
+
+#undef BOOST_ITERATOR_CONFIG_DEF
+# 215 "/usr/include/boost/iterator/iterator_categories.hpp" 2 3 4
+# 23 "/usr/include/boost/test/utils/iterator/token_iterator.hpp" 2 3 4
+# 1 "/usr/include/boost/iterator/iterator_traits.hpp" 1 3 4
+
+
+
+
+
+#define ITERATOR_TRAITS_DWA200347_HPP 
+
+
+
+
+
+namespace boost {
+namespace iterators {
+
+
+
+#define BOOST_ITERATOR_CATEGORY iterator_category
+
+
+template <class Iterator>
+struct iterator_value
+{
+    typedef typename std::iterator_traits<Iterator>::value_type type;
+};
+
+template <class Iterator>
+struct iterator_reference
+{
+    typedef typename std::iterator_traits<Iterator>::reference type;
+};
+
+
+template <class Iterator>
+struct iterator_pointer
+{
+    typedef typename std::iterator_traits<Iterator>::pointer type;
+};
+
+template <class Iterator>
+struct iterator_difference
+{
+    typedef typename std::iterator_traits<Iterator>::difference_type type;
+};
+
+template <class Iterator>
+struct iterator_category
+{
+    typedef typename std::iterator_traits<Iterator>::iterator_category type;
+};
+
+}
+
+using iterators::iterator_value;
+using iterators::iterator_reference;
+using iterators::iterator_pointer;
+using iterators::iterator_difference;
+using iterators::iterator_category;
+
+}
+# 24 "/usr/include/boost/test/utils/iterator/token_iterator.hpp" 2 3 4
+
+# 1 "/usr/include/boost/test/utils/iterator/input_iterator_facade.hpp" 1 3 4
+# 13 "/usr/include/boost/test/utils/iterator/input_iterator_facade.hpp" 3 4
+#define BOOST_TEST_UTILS_INPUT_ITERATOR_FACADE_HPP 
+
+
+# 1 "/usr/include/boost/iterator/iterator_facade.hpp" 1 3 4
+
+
+
+
+
+
+
+#define BOOST_ITERATOR_FACADE_23022003THW_HPP 
+
+
+# 1 "/usr/include/boost/iterator/interoperable.hpp" 1 3 4
+
+
+
+
+
+
+
+#define BOOST_INTEROPERABLE_23022003THW_HPP 
+
+
+# 1 "/usr/include/boost/mpl/or.hpp" 1 3 4
+
+
+#define BOOST_MPL_OR_HPP_INCLUDED 
+# 42 "/usr/include/boost/mpl/or.hpp" 3 4
+#define BOOST_MPL_PREPROCESSED_HEADER or.hpp
+# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
+# 23 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
+#define AUX778076_PREPROCESSED_HEADER BOOST_MPL_CFG_COMPILER_DIR/BOOST_MPL_PREPROCESSED_HEADER
+# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
+# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/or.hpp" 1 3 4
+# 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/or.hpp" 3 4
+namespace boost { namespace mpl {
+
+namespace aux {
+
+template< bool C_, typename T1, typename T2, typename T3, typename T4 >
+struct or_impl
+    : true_
+{
+};
+
+template< typename T1, typename T2, typename T3, typename T4 >
+struct or_impl< false,T1,T2,T3,T4 >
+    : or_impl<
+          ::boost::mpl::aux::nested_type_wknd<T1>::value
+        , T2, T3, T4
+        , false_
+        >
+{
+};
+
+template<>
+struct or_impl<
+          false
+        , false_, false_, false_, false_
+        >
+    : false_
+{
+};
+
+}
+
+template<
+      typename T1 = na
+    , typename T2 = na
+    , typename T3 = false_, typename T4 = false_, typename T5 = false_
+    >
+struct or_
+
+    : aux::or_impl<
+          ::boost::mpl::aux::nested_type_wknd<T1>::value
+        , T2, T3, T4, T5
+        >
+
+{
+   
+
+
+
+
+};
+
+template<> struct or_< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : or_< T1 , T2 > { }; }; template< typename Tag > struct lambda< or_< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef or_< na , na > result_; typedef or_< na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > struct template_arity< or_< T1 , T2 , T3 , T4 , T5 > > : int_<5> { }; template<> struct template_arity< or_< na , na > > : int_<-1> { }; }
+
+
+
+
+
+}}
+# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
+
+
+#undef AUX778076_PREPROCESSED_HEADER
+
+#undef BOOST_MPL_PREPROCESSED_HEADER
+# 44 "/usr/include/boost/mpl/or.hpp" 2 3 4
+# 12 "/usr/include/boost/iterator/interoperable.hpp" 2 3 4
+
+
+
+# 1 "/usr/include/boost/iterator/detail/config_def.hpp" 1 3 4
+# 22 "/usr/include/boost/iterator/detail/config_def.hpp" 3 4
+#define BOOST_ITERATOR_CONFIG_DEF 
+# 45 "/usr/include/boost/iterator/detail/config_def.hpp" 3 4
+#define BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY 1
+# 16 "/usr/include/boost/iterator/interoperable.hpp" 2 3 4
+
+namespace boost {
+namespace iterators {
+# 34 "/usr/include/boost/iterator/interoperable.hpp" 3 4
+  template <typename A, typename B>
+  struct is_interoperable
+
+
+
+    : mpl::or_<
+          is_convertible< A, B >
+        , is_convertible< B, A > >
+
+  {
+  };
+
+}
+
+using iterators::is_interoperable;
+
+}
+
+# 1 "/usr/include/boost/iterator/detail/config_undef.hpp" 1 3 4
+# 14 "/usr/include/boost/iterator/detail/config_undef.hpp" 3 4
+#undef BOOST_NO_IS_CONVERTIBLE
+#undef BOOST_NO_IS_CONVERTIBLE_TEMPLATE
+#undef BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY
+#undef BOOST_NO_LVALUE_RETURN_DETECTION
+#undef BOOST_NO_ONE_WAY_ITERATOR_INTEROP
+
+
+#undef BOOST_ITERATOR_CONFIG_DEF
+# 53 "/usr/include/boost/iterator/interoperable.hpp" 2 3 4
+# 12 "/usr/include/boost/iterator/iterator_facade.hpp" 2 3 4
+
+
+
+# 1 "/usr/include/boost/iterator/detail/facade_iterator_category.hpp" 1 3 4
+
+
+
+
+#define FACADE_ITERATOR_CATEGORY_DWA20031118_HPP 
+
+# 1 "/usr/include/boost/core/use_default.hpp" 1 3 4
+# 9 "/usr/include/boost/core/use_default.hpp" 3 4
+#define BOOST_CORE_USE_DEFAULT_HPP 
+
+namespace boost {
+
+struct use_default { };
+
+}
+# 8 "/usr/include/boost/iterator/detail/facade_iterator_category.hpp" 2 3 4
+
+
+
+
+# 1 "/usr/include/boost/mpl/and.hpp" 1 3 4
+
+
+#define BOOST_MPL_AND_HPP_INCLUDED 
+# 41 "/usr/include/boost/mpl/and.hpp" 3 4
+#define BOOST_MPL_PREPROCESSED_HEADER and.hpp
+# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
+# 23 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
+#define AUX778076_PREPROCESSED_HEADER BOOST_MPL_CFG_COMPILER_DIR/BOOST_MPL_PREPROCESSED_HEADER
+# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
+# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/and.hpp" 1 3 4
+# 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/and.hpp" 3 4
+namespace boost { namespace mpl {
+
+namespace aux {
+
+template< bool C_, typename T1, typename T2, typename T3, typename T4 >
+struct and_impl
+    : false_
+{
+};
+
+template< typename T1, typename T2, typename T3, typename T4 >
+struct and_impl< true,T1,T2,T3,T4 >
+    : and_impl<
+          ::boost::mpl::aux::nested_type_wknd<T1>::value
+        , T2, T3, T4
+        , true_
+        >
+{
+};
+
+template<>
+struct and_impl<
+          true
+        , true_, true_, true_, true_
+        >
+    : true_
+{
+};
+
+}
+
+template<
+      typename T1 = na
+    , typename T2 = na
+    , typename T3 = true_, typename T4 = true_, typename T5 = true_
+    >
+struct and_
+
+    : aux::and_impl<
+          ::boost::mpl::aux::nested_type_wknd<T1>::value
+        , T2, T3, T4, T5
+        >
+
+{
+   
+
+
+
+
+};
+
+template<> struct and_< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : and_< T1 , T2 > { }; }; template< typename Tag > struct lambda< and_< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef and_< na , na > result_; typedef and_< na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > struct template_arity< and_< T1 , T2 , T3 , T4 , T5 > > : int_<5> { }; template<> struct template_arity< and_< na , na > > : int_<-1> { }; }
+
+
+
+
+
+}}
+# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
+
+
+#undef AUX778076_PREPROCESSED_HEADER
+
+#undef BOOST_MPL_PREPROCESSED_HEADER
+# 43 "/usr/include/boost/mpl/and.hpp" 2 3 4
+# 13 "/usr/include/boost/iterator/detail/facade_iterator_category.hpp" 2 3 4
+
+
+
+
+
+# 1 "/usr/include/boost/type_traits/is_same.hpp" 1 3 4
+# 22 "/usr/include/boost/type_traits/is_same.hpp" 3 4
+#define BOOST_TT_IS_SAME_HPP_INCLUDED 
+
+
+
+namespace boost {
+
+
+   template <class T, class U> struct is_same : public false_type {};
+   template <class T> struct is_same<T,T> : public true_type {};
+
+
+
+
+
+
+
+}
+# 19 "/usr/include/boost/iterator/detail/facade_iterator_category.hpp" 2 3 4
+
+
+
+
+
+
+# 1 "/usr/include/boost/iterator/detail/config_def.hpp" 1 3 4
+# 22 "/usr/include/boost/iterator/detail/config_def.hpp" 3 4
+#define BOOST_ITERATOR_CONFIG_DEF 
+# 45 "/usr/include/boost/iterator/detail/config_def.hpp" 3 4
+#define BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY 1
+# 26 "/usr/include/boost/iterator/detail/facade_iterator_category.hpp" 2 3 4
+
+
+# 1 "/usr/include/boost/detail/indirect_traits.hpp" 1 3 4
+
+
+
+
+
+#define INDIRECT_TRAITS_DWA2002131_HPP 
+
+
+
+
+# 1 "/usr/include/boost/type_traits/is_class.hpp" 1 3 4
+# 11 "/usr/include/boost/type_traits/is_class.hpp" 3 4
+#define BOOST_TT_IS_CLASS_HPP_INCLUDED 
+# 31 "/usr/include/boost/type_traits/is_class.hpp" 3 4
+namespace boost {
+
+namespace detail {
+# 96 "/usr/include/boost/type_traits/is_class.hpp" 3 4
+template <typename T>
+struct is_class_impl
+{
+    static const bool value = __is_class(T);
+};
+
+
+}
+
+template <class T> struct is_class : public integral_constant<bool, ::boost::detail::is_class_impl<T>::value> {};
+
+
+
+
+
+
+}
+# 12 "/usr/include/boost/detail/indirect_traits.hpp" 2 3 4
+
+
+
+
+
+
+# 1 "/usr/include/boost/type_traits/remove_pointer.hpp" 1 3 4
+# 10 "/usr/include/boost/type_traits/remove_pointer.hpp" 3 4
+#define BOOST_TT_REMOVE_POINTER_HPP_INCLUDED 
+# 20 "/usr/include/boost/type_traits/remove_pointer.hpp" 3 4
+namespace boost {
+# 68 "/usr/include/boost/type_traits/remove_pointer.hpp" 3 4
+template <class T> struct remove_pointer{ typedef T type; };
+template <class T> struct remove_pointer<T*>{ typedef T type; };
+template <class T> struct remove_pointer<T*const>{ typedef T type; };
+template <class T> struct remove_pointer<T*volatile>{ typedef T type; };
+template <class T> struct remove_pointer<T*const volatile>{ typedef T type; };
+
+
+
+
+
+   template <class T> using remove_pointer_t = typename remove_pointer<T>::type;
+
+
+
+}
+# 19 "/usr/include/boost/detail/indirect_traits.hpp" 2 3 4
+
+
+# 1 "/usr/include/boost/detail/select_type.hpp" 1 3 4
+# 14 "/usr/include/boost/detail/select_type.hpp" 3 4
+#define SELECT_TYPE_DWA20010206_HPP 
+
+namespace boost { namespace detail {
+
+
+
+
+
+
+  template <bool b> struct if_true
+  {
+      template <class T, class F>
+      struct then { typedef T type; };
+  };
+
+  template <>
+  struct if_true<false>
+  {
+      template <class T, class F>
+      struct then { typedef F type; };
+  };
+}}
+# 22 "/usr/include/boost/detail/indirect_traits.hpp" 2 3 4
+
+
+namespace boost { namespace detail {
+
+namespace indirect_traits {
+
+template <class T>
+struct is_reference_to_const : boost::false_type
+{
+};
+
+template <class T>
+struct is_reference_to_const<T const&> : boost::true_type
+{
+};
+# 45 "/usr/include/boost/detail/indirect_traits.hpp" 3 4
+template <class T>
+struct is_reference_to_function : boost::false_type
+{
+};
+
+template <class T>
+struct is_reference_to_function<T&> : is_function<T>
+{
+};
+
+template <class T>
+struct is_pointer_to_function : boost::false_type
+{
+};
+
+
+
+template <class T>
+struct is_pointer_to_function<T*> : is_function<T>
+{
+};
+
+template <class T>
+struct is_reference_to_member_function_pointer_impl : boost::false_type
+{
+};
+
+template <class T>
+struct is_reference_to_member_function_pointer_impl<T&>
+    : is_member_function_pointer<typename remove_cv<T>::type>
+{
+};
+
+
+template <class T>
+struct is_reference_to_member_function_pointer
+    : is_reference_to_member_function_pointer_impl<T>
+{
+};
+
+template <class T>
+struct is_reference_to_function_pointer_aux
+    : boost::integral_constant<bool,
+          is_reference<T>::value &&
+          is_pointer_to_function<
+              typename remove_cv<
+                  typename remove_reference<T>::type
+              >::type
+          >::value
+      >
+{
+
+};
+
+template <class T>
+struct is_reference_to_function_pointer
+    : boost::detail::if_true<
+          is_reference_to_function<T>::value
+      >::template then<
+          boost::false_type
+        , is_reference_to_function_pointer_aux<T>
+      >::type
+{
+};
+
+template <class T>
+struct is_reference_to_non_const
+    : boost::integral_constant<bool,
+          is_reference<T>::value &&
+          !is_reference_to_const<T>::value
+      >
+{
+};
+
+template <class T>
+struct is_reference_to_volatile : boost::false_type
+{
+};
+
+template <class T>
+struct is_reference_to_volatile<T volatile&> : boost::true_type
+{
+};
+# 137 "/usr/include/boost/detail/indirect_traits.hpp" 3 4
+template <class T>
+struct is_reference_to_pointer : boost::false_type
+{
+};
+
+template <class T>
+struct is_reference_to_pointer<T*&> : boost::true_type
+{
+};
+
+template <class T>
+struct is_reference_to_pointer<T* const&> : boost::true_type
+{
+};
+
+template <class T>
+struct is_reference_to_pointer<T* volatile&> : boost::true_type
+{
+};
+
+template <class T>
+struct is_reference_to_pointer<T* const volatile&> : boost::true_type
+{
+};
+
+template <class T>
+struct is_reference_to_class
+    : boost::integral_constant<bool,
+          is_reference<T>::value &&
+          is_class<
+              typename remove_cv<
+                  typename remove_reference<T>::type
+              >::type
+          >::value
+      >
+{
+};
+
+template <class T>
+struct is_pointer_to_class
+    : boost::integral_constant<bool,
+          is_pointer<T>::value &&
+          is_class<
+              typename remove_cv<
+                  typename remove_pointer<T>::type
+              >::type
+          >::value
+      >
+{
+};
+
+
+}
+
+using namespace indirect_traits;
+
+}}
+# 29 "/usr/include/boost/iterator/detail/facade_iterator_category.hpp" 2 3 4
+
+
+
+
+
+
+namespace boost {
+namespace iterators {
+
+using boost::use_default;
+
+namespace detail {
+
+struct input_output_iterator_tag
+  : std::input_iterator_tag
+{
+
+
+
+
+
+
+    operator std::output_iterator_tag() const
+    {
+        return std::output_iterator_tag();
+    }
+};
+
+
+
+
+
+
+template <class ValueParam, class Reference>
+struct iterator_writability_disabled
+
+  : mpl::or_<
+        is_const<Reference>
+      , boost::detail::indirect_traits::is_reference_to_const<Reference>
+      , is_const<ValueParam>
+    >
+
+
+
+{};
+# 84 "/usr/include/boost/iterator/detail/facade_iterator_category.hpp" 3 4
+template <class Traversal, class ValueParam, class Reference>
+struct iterator_facade_default_category
+  : mpl::eval_if<
+        mpl::and_<
+            is_reference<Reference>
+          , is_convertible<Traversal,forward_traversal_tag>
+        >
+      , mpl::eval_if<
+            is_convertible<Traversal,random_access_traversal_tag>
+          , mpl::identity<std::random_access_iterator_tag>
+          , mpl::if_<
+                is_convertible<Traversal,bidirectional_traversal_tag>
+              , std::bidirectional_iterator_tag
+              , std::forward_iterator_tag
+            >
+        >
+      , typename mpl::eval_if<
+            mpl::and_<
+                is_convertible<Traversal, single_pass_traversal_tag>
+
+
+              , is_convertible<Reference, ValueParam>
+            >
+          , mpl::identity<std::input_iterator_tag>
+          , mpl::identity<Traversal>
+        >
+    >
+{
+};
+
+
+template <class T>
+struct is_iterator_category
+  : mpl::or_<
+        is_convertible<T,std::input_iterator_tag>
+      , is_convertible<T,std::output_iterator_tag>
+    >
+{
+};
+
+template <class T>
+struct is_iterator_traversal
+  : is_convertible<T,incrementable_traversal_tag>
+{};
+
+
+
+
+
+
+
+template <class Category, class Traversal>
+struct iterator_category_with_traversal
+  : Category, Traversal
+{
+
+
+
+    enum { mpl_assertion_in_line_142 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) ( is_convertible< typename iterator_category_to_traversal<Category>::type , Traversal >))0, 1 ) ) ) }
+
+
+
+             ;
+
+    enum { mpl_assertion_in_line_148 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_arg( (void (*) (is_iterator_category<Category>))0, 1 ) ) ) };
+    enum { mpl_assertion_in_line_149 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (is_iterator_category<Traversal>))0, 1 ) ) ) };
+    enum { mpl_assertion_in_line_150 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (is_iterator_traversal<Category>))0, 1 ) ) ) };
+
+    enum { mpl_assertion_in_line_152 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_arg( (void (*) (is_iterator_traversal<Traversal>))0, 1 ) ) ) };
+
+};
+
+
+
+template <class Traversal, class ValueParam, class Reference>
+struct facade_iterator_category_impl
+{
+    enum { mpl_assertion_in_line_161 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (is_iterator_category<Traversal>))0, 1 ) ) ) };
+
+    typedef typename iterator_facade_default_category<
+        Traversal,ValueParam,Reference
+    >::type category;
+
+    typedef typename mpl::if_<
+        is_same<
+            Traversal
+          , typename iterator_category_to_traversal<category>::type
+        >
+      , category
+      , iterator_category_with_traversal<category,Traversal>
+    >::type type;
+};
+
+
+
+
+template <class CategoryOrTraversal, class ValueParam, class Reference>
+struct facade_iterator_category
+  : mpl::eval_if<
+        is_iterator_category<CategoryOrTraversal>
+      , mpl::identity<CategoryOrTraversal>
+      , facade_iterator_category_impl<CategoryOrTraversal,ValueParam,Reference>
+    >
+{
+};
+
+}}}
+
+# 1 "/usr/include/boost/iterator/detail/config_undef.hpp" 1 3 4
+# 14 "/usr/include/boost/iterator/detail/config_undef.hpp" 3 4
+#undef BOOST_NO_IS_CONVERTIBLE
+#undef BOOST_NO_IS_CONVERTIBLE_TEMPLATE
+#undef BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY
+#undef BOOST_NO_LVALUE_RETURN_DETECTION
+#undef BOOST_NO_ONE_WAY_ITERATOR_INTEROP
+
+
+#undef BOOST_ITERATOR_CONFIG_DEF
+# 193 "/usr/include/boost/iterator/detail/facade_iterator_category.hpp" 2 3 4
+# 16 "/usr/include/boost/iterator/iterator_facade.hpp" 2 3 4
+# 1 "/usr/include/boost/iterator/detail/enable_if.hpp" 1 3 4
+
+
+
+
+
+
+
+#define BOOST_ENABLE_IF_23022003THW_HPP 
+
+
+
+
+# 1 "/usr/include/boost/iterator/detail/config_def.hpp" 1 3 4
+# 22 "/usr/include/boost/iterator/detail/config_def.hpp" 3 4
+#define BOOST_ITERATOR_CONFIG_DEF 
+# 45 "/usr/include/boost/iterator/detail/config_def.hpp" 3 4
+#define BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY 1
+# 14 "/usr/include/boost/iterator/detail/enable_if.hpp" 2 3 4
+
+
+
+
+
+
+
+namespace boost
+{
+
+  namespace iterators
+  {
+
+
+
+    template<bool>
+    struct enabled
+    {
+      template<typename T>
+      struct base
+      {
+        typedef T type;
+      };
+    };
+
+
+
+
+
+
+    template<>
+    struct enabled<false>
+    {
+      template<typename T>
+      struct base
+      {
+# 62 "/usr/include/boost/iterator/detail/enable_if.hpp" 3 4
+      };
+    };
+
+
+    template <class Cond,
+              class Return>
+    struct enable_if
+
+      : enabled<(Cond::value)>::template base<Return>
+
+
+
+    {
+    };
+
+  }
+
+}
+
+# 1 "/usr/include/boost/iterator/detail/config_undef.hpp" 1 3 4
+# 14 "/usr/include/boost/iterator/detail/config_undef.hpp" 3 4
+#undef BOOST_NO_IS_CONVERTIBLE
+#undef BOOST_NO_IS_CONVERTIBLE_TEMPLATE
+#undef BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY
+#undef BOOST_NO_LVALUE_RETURN_DETECTION
+#undef BOOST_NO_ONE_WAY_ITERATOR_INTEROP
+
+
+#undef BOOST_ITERATOR_CONFIG_DEF
+# 82 "/usr/include/boost/iterator/detail/enable_if.hpp" 2 3 4
+# 17 "/usr/include/boost/iterator/iterator_facade.hpp" 2 3 4
+# 25 "/usr/include/boost/iterator/iterator_facade.hpp" 3 4
+# 1 "/usr/include/boost/type_traits/remove_const.hpp" 1 3 4
+# 12 "/usr/include/boost/type_traits/remove_const.hpp" 3 4
+#define BOOST_TT_REMOVE_CONST_HPP_INCLUDED 
+
+
+
+
+
+namespace boost {
+
+
+   template <class T> struct remove_const{ typedef T type; };
+   template <class T> struct remove_const<T const>{ typedef T type; };
+
+
+   template <class T, std::size_t N> struct remove_const<T const[N]>{ typedef T type[N]; };
+
+   template <class T> struct remove_const<T const[]>{ typedef T type[]; };
+
+
+
+
+
+   template <class T> using remove_const_t = typename remove_const<T>::type;
+
+
+
+}
+# 26 "/usr/include/boost/iterator/iterator_facade.hpp" 2 3 4
+# 35 "/usr/include/boost/iterator/iterator_facade.hpp" 3 4
+# 1 "/usr/include/boost/mpl/always.hpp" 1 3 4
+
+
+#define BOOST_MPL_ALWAYS_HPP_INCLUDED 
+# 17 "/usr/include/boost/mpl/always.hpp" 3 4
+# 1 "/usr/include/boost/mpl/aux_/preprocessor/default_params.hpp" 1 3 4
+
+
+#define BOOST_MPL_AUX_PREPROCESSOR_DEFAULT_PARAMS_HPP_INCLUDED 
+# 51 "/usr/include/boost/mpl/aux_/preprocessor/default_params.hpp" 3 4
+#define BOOST_MPL_PP_AUX_DEFAULT_PARAM_FUNC(unused,i,pv) BOOST_PP_COMMA_IF(i) BOOST_PP_CAT( BOOST_PP_TUPLE_ELEM(2,0,pv), BOOST_PP_INC(i) ) = BOOST_PP_TUPLE_ELEM(2,1,pv)
+
+
+
+
+
+#define BOOST_MPL_PP_DEFAULT_PARAMS(n,param,value) BOOST_PP_REPEAT( n , BOOST_MPL_PP_AUX_DEFAULT_PARAM_FUNC , (param,value) )
+# 18 "/usr/include/boost/mpl/always.hpp" 2 3 4
+
+
+
+namespace boost { namespace mpl {
+
+template< typename Value > struct always
+{
+    template<
+        typename T1 = na , typename T2 = na , typename T3 = na , typename T4 = na , typename T5 = na
+        >
+    struct apply
+    {
+        typedef Value type;
+    };
+};
+
+
+
+}}
+# 36 "/usr/include/boost/iterator/iterator_facade.hpp" 2 3 4
+# 1 "/usr/include/boost/mpl/apply.hpp" 1 3 4
+
+
+
+
+
+
+#define BOOST_MPL_APPLY_HPP_INCLUDED 
+# 22 "/usr/include/boost/mpl/apply.hpp" 3 4
+# 1 "/usr/include/boost/mpl/apply_fwd.hpp" 1 3 4
+
+
+
+
+
+
+#define BOOST_MPL_APPLY_FWD_HPP_INCLUDED 
+# 30 "/usr/include/boost/mpl/apply_fwd.hpp" 3 4
+#define BOOST_MPL_PREPROCESSED_HEADER apply_fwd.hpp
+# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
+# 23 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
+#define AUX778076_PREPROCESSED_HEADER BOOST_MPL_CFG_COMPILER_DIR/BOOST_MPL_PREPROCESSED_HEADER
+# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
+# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/apply_fwd.hpp" 1 3 4
+# 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/apply_fwd.hpp" 3 4
+namespace boost { namespace mpl {
+
+template<
+      typename F, typename T1 = na, typename T2 = na, typename T3 = na
+    , typename T4 = na, typename T5 = na
+    >
+struct apply;
+
+template<
+      typename F
+    >
+struct apply0;
+
+template<
+      typename F, typename T1
+    >
+struct apply1;
+
+template<
+      typename F, typename T1, typename T2
+    >
+struct apply2;
+
+template<
+      typename F, typename T1, typename T2, typename T3
+    >
+struct apply3;
+
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    >
+struct apply4;
+
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    , typename T5
+    >
+struct apply5;
+
+}}
+# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
+
+
+#undef AUX778076_PREPROCESSED_HEADER
+
+#undef BOOST_MPL_PREPROCESSED_HEADER
+# 32 "/usr/include/boost/mpl/apply_fwd.hpp" 2 3 4
+# 23 "/usr/include/boost/mpl/apply.hpp" 2 3 4
+# 1 "/usr/include/boost/mpl/apply_wrap.hpp" 1 3 4
+
+
+
+
+
+
+#define BOOST_MPL_APPLY_WRAP_HPP_INCLUDED 
+# 23 "/usr/include/boost/mpl/apply_wrap.hpp" 3 4
+# 1 "/usr/include/boost/mpl/aux_/has_apply.hpp" 1 3 4
+
+
+#define BOOST_MPL_AUX_HAS_APPLY_HPP_INCLUDED 
+# 17 "/usr/include/boost/mpl/aux_/has_apply.hpp" 3 4
+# 1 "/usr/include/boost/mpl/has_xxx.hpp" 1 3 4
+
+
+#define BOOST_MPL_HAS_XXX_HPP_INCLUDED 
+# 21 "/usr/include/boost/mpl/has_xxx.hpp" 3 4
+# 1 "/usr/include/boost/mpl/aux_/type_wrapper.hpp" 1 3 4
+
+
+#define BOOST_MPL_AUX_TYPE_WRAPPER_HPP_INCLUDED 
+# 20 "/usr/include/boost/mpl/aux_/type_wrapper.hpp" 3 4
+namespace boost { namespace mpl { namespace aux {
+
+template< typename T > struct type_wrapper
+{
+    typedef T type;
+};
+
+
+
+
+
+
+template< typename T > struct wrapped_type;
+
+template< typename T > struct wrapped_type< type_wrapper<T> >
+{
+    typedef T type;
+};
+
+
+
+
+
+
+
+}}}
+# 22 "/usr/include/boost/mpl/has_xxx.hpp" 2 3 4
+
+
+# 1 "/usr/include/boost/mpl/aux_/config/has_xxx.hpp" 1 3 4
+
+
+#define BOOST_MPL_AUX_CONFIG_HAS_XXX_HPP_INCLUDED 
+# 25 "/usr/include/boost/mpl/has_xxx.hpp" 2 3 4
+# 1 "/usr/include/boost/mpl/aux_/config/msvc_typename.hpp" 1 3 4
+
+
+#define BOOST_MPL_AUX_CONFIG_MSVC_TYPENAME_HPP_INCLUDED 
+# 23 "/usr/include/boost/mpl/aux_/config/msvc_typename.hpp" 3 4
+#define BOOST_MSVC_TYPENAME typename
+# 26 "/usr/include/boost/mpl/has_xxx.hpp" 2 3 4
+
+
+
+
+# 1 "/usr/include/boost/preprocessor/array/elem.hpp" 1 3 4
+# 13 "/usr/include/boost/preprocessor/array/elem.hpp" 3 4
+#define BOOST_PREPROCESSOR_ARRAY_ELEM_HPP 
+
+# 1 "/usr/include/boost/preprocessor/array/data.hpp" 1 3 4
+# 13 "/usr/include/boost/preprocessor/array/data.hpp" 3 4
+#define BOOST_PREPROCESSOR_ARRAY_DATA_HPP 
+
+
+
+
+
+
+
+#define BOOST_PP_ARRAY_DATA(array) BOOST_PP_TUPLE_ELEM(2, 1, array)
+# 16 "/usr/include/boost/preprocessor/array/elem.hpp" 2 3 4
+# 1 "/usr/include/boost/preprocessor/array/size.hpp" 1 3 4
+# 13 "/usr/include/boost/preprocessor/array/size.hpp" 3 4
+#define BOOST_PREPROCESSOR_ARRAY_SIZE_HPP 
+
+
+
+
+
+
+
+#define BOOST_PP_ARRAY_SIZE(array) BOOST_PP_TUPLE_ELEM(2, 0, array)
+# 17 "/usr/include/boost/preprocessor/array/elem.hpp" 2 3 4
+
+
+
+
+
+
+#define BOOST_PP_ARRAY_ELEM(i,array) BOOST_PP_TUPLE_ELEM(BOOST_PP_ARRAY_SIZE(array), i, BOOST_PP_ARRAY_DATA(array))
+# 31 "/usr/include/boost/mpl/has_xxx.hpp" 2 3 4
+
+
+
+# 1 "/usr/include/boost/preprocessor/repetition/enum_trailing_params.hpp" 1 3 4
+# 13 "/usr/include/boost/preprocessor/repetition/enum_trailing_params.hpp" 3 4
+#define BOOST_PREPROCESSOR_REPETITION_ENUM_TRAILING_PARAMS_HPP 
+
+
+
+
+
+
+
+#define BOOST_PP_ENUM_TRAILING_PARAMS(count,param) BOOST_PP_REPEAT(count, BOOST_PP_ENUM_TRAILING_PARAMS_M, param)
+
+
+
+
+
+#define BOOST_PP_ENUM_TRAILING_PARAMS_M(z,n,param) , param ## n
+
+
+
+
+#define BOOST_PP_ENUM_TRAILING_PARAMS_Z(z,count,param) BOOST_PP_REPEAT_ ## z(count, BOOST_PP_ENUM_TRAILING_PARAMS_M, param)
+# 35 "/usr/include/boost/mpl/has_xxx.hpp" 2 3 4
+# 236 "/usr/include/boost/mpl/has_xxx.hpp" 3 4
+#define BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(trait,name,default_) template< typename T, typename fallback_ = boost::mpl::bool_<default_> > struct trait { struct gcc_3_2_wknd { template< typename U > static boost::mpl::aux::yes_tag test( boost::mpl::aux::type_wrapper<U> const volatile* , boost::mpl::aux::type_wrapper<BOOST_MSVC_TYPENAME U::name>* = 0 ); static boost::mpl::aux::no_tag test(...); }; typedef boost::mpl::aux::type_wrapper<T> t_; BOOST_STATIC_CONSTANT(bool, value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::aux::yes_tag) ); typedef boost::mpl::bool_<value> type; };
+# 278 "/usr/include/boost/mpl/has_xxx.hpp" 3 4
+#define BOOST_MPL_HAS_XXX_TRAIT_DEF(name) BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(BOOST_PP_CAT(has_,name), name, false)
+# 295 "/usr/include/boost/mpl/has_xxx.hpp" 3 4
+#define BOOST_MPL_HAS_XXX_NO_WRAPPED_TYPES 0
+
+
+
+
+
+
+
+#define BOOST_MPL_HAS_XXX_NO_EXPLICIT_TEST_FUNCTION 0
+
+
+
+
+
+
+
+#define BOOST_MPL_HAS_XXX_NEEDS_TEMPLATE_SFINAE 0
+
+
+
+
+
+
+
+#define BOOST_MPL_HAS_MEMBER_INTROSPECTION_NAME(args) BOOST_PP_CAT(BOOST_PP_ARRAY_ELEM(0, args) , _introspect)
+
+
+
+#define BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_NAME(args,n) BOOST_PP_CAT(BOOST_PP_CAT(BOOST_PP_ARRAY_ELEM(0, args) , _substitute), n)
+
+
+
+#define BOOST_MPL_HAS_MEMBER_INTROSPECTION_TEST_NAME(args) BOOST_PP_CAT(BOOST_PP_ARRAY_ELEM(0, args) , _test)
+
+
+
+
+
+
+
+#define BOOST_MPL_HAS_MEMBER_MULTI_SUBSTITUTE(z,n,args) template< template< BOOST_PP_ENUM_PARAMS(BOOST_PP_INC(n), typename V) > class V > struct BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_NAME(args, n) { };
+
+
+
+
+
+
+
+#define BOOST_MPL_HAS_MEMBER_SUBSTITUTE(args,substitute_macro) BOOST_PP_REPEAT( BOOST_PP_ARRAY_ELEM(2, args) , BOOST_MPL_HAS_MEMBER_MULTI_SUBSTITUTE , args )
+# 352 "/usr/include/boost/mpl/has_xxx.hpp" 3 4
+#define BOOST_MPL_HAS_MEMBER_REJECT(args,member_macro) template< typename V > static boost::mpl::aux::no_tag BOOST_MPL_HAS_MEMBER_INTROSPECTION_TEST_NAME(args)(...);
+# 365 "/usr/include/boost/mpl/has_xxx.hpp" 3 4
+#define BOOST_MPL_HAS_MEMBER_MULTI_ACCEPT(z,n,args) template< typename V > static boost::mpl::aux::yes_tag BOOST_MPL_HAS_MEMBER_INTROSPECTION_TEST_NAME(args)( boost::mpl::aux::type_wrapper< V > const volatile* , BOOST_MPL_HAS_MEMBER_INTROSPECTION_SUBSTITUTE_NAME(args, n) < V::template BOOST_PP_ARRAY_ELEM(1, args) >* = 0 );
+# 375 "/usr/include/boost/mpl/has_xxx.hpp" 3 4
+#define BOOST_MPL_HAS_MEMBER_ACCEPT(args,member_macro) BOOST_PP_REPEAT( BOOST_PP_ARRAY_ELEM(2, args) , BOOST_MPL_HAS_MEMBER_MULTI_ACCEPT , args )
+# 394 "/usr/include/boost/mpl/has_xxx.hpp" 3 4
+#define BOOST_MPL_HAS_MEMBER_TEST(args) sizeof(BOOST_MPL_HAS_MEMBER_INTROSPECTION_TEST_NAME(args)< U >(0)) == sizeof(boost::mpl::aux::yes_tag)
+# 418 "/usr/include/boost/mpl/has_xxx.hpp" 3 4
+#define BOOST_MPL_HAS_MEMBER_INTROSPECT(args,substitute_macro,member_macro) template< typename U > struct BOOST_MPL_HAS_MEMBER_INTROSPECTION_NAME(args) { BOOST_MPL_HAS_MEMBER_SUBSTITUTE(args, substitute_macro) BOOST_MPL_HAS_MEMBER_REJECT(args, member_macro) BOOST_MPL_HAS_MEMBER_ACCEPT(args, member_macro) BOOST_STATIC_CONSTANT( bool, value = BOOST_MPL_HAS_MEMBER_TEST(args) ); typedef boost::mpl::bool_< value > type; };
+# 433 "/usr/include/boost/mpl/has_xxx.hpp" 3 4
+#define BOOST_MPL_HAS_MEMBER_IMPLEMENTATION(args,introspect_macro,substitute_macro,member_macro) template< typename T , typename fallback_ = boost::mpl::bool_< BOOST_PP_ARRAY_ELEM(3, args) > > class BOOST_PP_ARRAY_ELEM(0, args) { introspect_macro(args, substitute_macro, member_macro) public: static const bool value = BOOST_MPL_HAS_MEMBER_INTROSPECTION_NAME(args)< T >::value; typedef typename BOOST_MPL_HAS_MEMBER_INTROSPECTION_NAME(args)< T >::type type; };
+# 455 "/usr/include/boost/mpl/has_xxx.hpp" 3 4
+#define BOOST_MPL_HAS_MEMBER_WITH_FUNCTION_SFINAE(args,substitute_macro,member_macro) BOOST_MPL_HAS_MEMBER_IMPLEMENTATION( args , BOOST_MPL_HAS_MEMBER_INTROSPECT , substitute_macro , member_macro )
+# 609 "/usr/include/boost/mpl/has_xxx.hpp" 3 4
+#define BOOST_MPL_HAS_XXX_TEMPLATE_NAMED_DEF(trait,name,default_) BOOST_MPL_HAS_MEMBER_WITH_FUNCTION_SFINAE( ( 4, ( trait, name, BOOST_MPL_LIMIT_METAFUNCTION_ARITY, default_ ) ) , BOOST_MPL_HAS_MEMBER_TEMPLATE_SUBSTITUTE_PARAMETER , BOOST_MPL_HAS_MEMBER_TEMPLATE_ACCESS )
+# 641 "/usr/include/boost/mpl/has_xxx.hpp" 3 4
+#define BOOST_MPL_HAS_XXX_TEMPLATE_DEF(name) BOOST_MPL_HAS_XXX_TEMPLATE_NAMED_DEF( BOOST_PP_CAT(has_, name), name, false )
+# 18 "/usr/include/boost/mpl/aux_/has_apply.hpp" 2 3 4
+# 1 "/usr/include/boost/mpl/aux_/config/has_apply.hpp" 1 3 4
+
+
+#define BOOST_MPL_AUX_CONFIG_HAS_APPLY_HPP_INCLUDED 
+# 19 "/usr/include/boost/mpl/aux_/has_apply.hpp" 2 3 4
+
+namespace boost { namespace mpl { namespace aux {
+
+template< typename T, typename fallback_ = boost::mpl::bool_<false> > struct has_apply { struct gcc_3_2_wknd { template< typename U > static boost::mpl::aux::yes_tag test( boost::mpl::aux::type_wrapper<U> const volatile* , boost::mpl::aux::type_wrapper<typename U::apply>* = 0 ); static boost::mpl::aux::no_tag test(...); }; typedef boost::mpl::aux::type_wrapper<T> t_; static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::aux::yes_tag); typedef boost::mpl::bool_<value> type; };
+
+
+
+
+
+
+
+}}}
+# 24 "/usr/include/boost/mpl/apply_wrap.hpp" 2 3 4
+
+# 1 "/usr/include/boost/mpl/aux_/msvc_never_true.hpp" 1 3 4
+
+
+#define BOOST_MPL_AUX_MSVC_NEVER_TRUE_HPP_INCLUDED 
+# 26 "/usr/include/boost/mpl/apply_wrap.hpp" 2 3 4
+
+
+
+
+
+
+
+#define BOOST_MPL_PREPROCESSED_HEADER apply_wrap.hpp
+# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
+# 23 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
+#define AUX778076_PREPROCESSED_HEADER BOOST_MPL_CFG_COMPILER_DIR/BOOST_MPL_PREPROCESSED_HEADER
+# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
+# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/apply_wrap.hpp" 1 3 4
+# 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/apply_wrap.hpp" 3 4
+namespace boost { namespace mpl {
+
+template<
+      typename F
+
+    , typename has_apply_ = typename aux::has_apply<F>::type
+
+    >
+struct apply_wrap0
+
+    : F::template apply< >
+{
+};
+
+template< typename F >
+struct apply_wrap0< F,true_ >
+    : F::apply
+{
+};
+
+template<
+      typename F, typename T1
+
+    >
+struct apply_wrap1
+
+    : F::template apply<T1>
+{
+};
+
+template<
+      typename F, typename T1, typename T2
+
+    >
+struct apply_wrap2
+
+    : F::template apply< T1,T2 >
+{
+};
+
+template<
+      typename F, typename T1, typename T2, typename T3
+
+    >
+struct apply_wrap3
+
+    : F::template apply< T1,T2,T3 >
+{
+};
+
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+
+    >
+struct apply_wrap4
+
+    : F::template apply< T1,T2,T3,T4 >
+{
+};
+
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    , typename T5
+
+    >
+struct apply_wrap5
+
+    : F::template apply< T1,T2,T3,T4,T5 >
+{
+};
+
+}}
+# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
+
+
+#undef AUX778076_PREPROCESSED_HEADER
+
+#undef BOOST_MPL_PREPROCESSED_HEADER
+# 35 "/usr/include/boost/mpl/apply_wrap.hpp" 2 3 4
+# 24 "/usr/include/boost/mpl/apply.hpp" 2 3 4
+# 1 "/usr/include/boost/mpl/placeholders.hpp" 1 3 4
+# 25 "/usr/include/boost/mpl/apply.hpp" 2 3 4
+# 1 "/usr/include/boost/mpl/lambda.hpp" 1 3 4
+
+
+#define BOOST_MPL_LAMBDA_HPP_INCLUDED 
+# 18 "/usr/include/boost/mpl/lambda.hpp" 3 4
+# 1 "/usr/include/boost/mpl/bind.hpp" 1 3 4
+
+
+
+
+
+
+#define BOOST_MPL_BIND_HPP_INCLUDED 
+# 23 "/usr/include/boost/mpl/bind.hpp" 3 4
+# 1 "/usr/include/boost/mpl/bind_fwd.hpp" 1 3 4
+
+
+
+
+
+
+#define BOOST_MPL_BIND_FWD_HPP_INCLUDED 
+# 25 "/usr/include/boost/mpl/bind_fwd.hpp" 3 4
+# 1 "/usr/include/boost/mpl/aux_/config/bind.hpp" 1 3 4
+
+
+#define BOOST_MPL_AUX_CONFIG_BIND_HPP_INCLUDED 
+# 26 "/usr/include/boost/mpl/bind_fwd.hpp" 2 3 4
+
+
+
+
+
+#define BOOST_MPL_PREPROCESSED_HEADER bind_fwd.hpp
+# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
+# 23 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
+#define AUX778076_PREPROCESSED_HEADER BOOST_MPL_CFG_COMPILER_DIR/BOOST_MPL_PREPROCESSED_HEADER
+# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
+# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/bind_fwd.hpp" 1 3 4
+# 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/bind_fwd.hpp" 3 4
+namespace boost { namespace mpl {
+
+template<
+      typename F, typename T1 = na, typename T2 = na, typename T3 = na
+    , typename T4 = na, typename T5 = na
+    >
+struct bind;
+
+template<
+      typename F
+    >
+struct bind0;
+
+template<
+      typename F, typename T1
+    >
+struct bind1;
+
+template<
+      typename F, typename T1, typename T2
+    >
+struct bind2;
+
+template<
+      typename F, typename T1, typename T2, typename T3
+    >
+struct bind3;
+
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    >
+struct bind4;
+
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    , typename T5
+    >
+struct bind5;
+
+}}
+# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
+
+
+#undef AUX778076_PREPROCESSED_HEADER
+
+#undef BOOST_MPL_PREPROCESSED_HEADER
+# 33 "/usr/include/boost/mpl/bind_fwd.hpp" 2 3 4
+# 24 "/usr/include/boost/mpl/bind.hpp" 2 3 4
+# 1 "/usr/include/boost/mpl/placeholders.hpp" 1 3 4
+# 25 "/usr/include/boost/mpl/bind.hpp" 2 3 4
+# 1 "/usr/include/boost/mpl/next.hpp" 1 3 4
+
+
+#define BOOST_MPL_NEXT_HPP_INCLUDED 
+# 17 "/usr/include/boost/mpl/next.hpp" 3 4
+# 1 "/usr/include/boost/mpl/next_prior.hpp" 1 3 4
+
+
+#define BOOST_MPL_NEXT_PRIOR_HPP_INCLUDED 
+# 17 "/usr/include/boost/mpl/next_prior.hpp" 3 4
+# 1 "/usr/include/boost/mpl/aux_/common_name_wknd.hpp" 1 3 4
+
+
+#define BOOST_MPL_AUX_COMMON_NAME_WKND_HPP_INCLUDED 
+# 30 "/usr/include/boost/mpl/aux_/common_name_wknd.hpp" 3 4
+#define BOOST_MPL_AUX_COMMON_NAME_WKND(name) 
+# 18 "/usr/include/boost/mpl/next_prior.hpp" 2 3 4
+
+
+
+namespace boost { namespace mpl {
+
+
+
+
+template<
+      typename T = na
+    >
+struct next
+{
+    typedef typename T::next type;
+   
+};
+
+template<
+      typename T = na
+    >
+struct prior
+{
+    typedef typename T::prior type;
+   
+};
+
+template<> struct next< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : next< T1 > { }; }; template< typename Tag > struct lambda< next< na > , Tag , int_<-1> > { typedef false_ is_le; typedef next< na > result_; typedef next< na > type; }; namespace aux { template< typename T1 > struct template_arity< next< T1 > > : int_<1> { }; template<> struct template_arity< next< na > > : int_<-1> { }; }
+template<> struct prior< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : prior< T1 > { }; }; template< typename Tag > struct lambda< prior< na > , Tag , int_<-1> > { typedef false_ is_le; typedef prior< na > result_; typedef prior< na > type; }; namespace aux { template< typename T1 > struct template_arity< prior< T1 > > : int_<1> { }; template<> struct template_arity< prior< na > > : int_<-1> { }; }
+
+}}
+# 18 "/usr/include/boost/mpl/next.hpp" 2 3 4
+# 26 "/usr/include/boost/mpl/bind.hpp" 2 3 4
+# 1 "/usr/include/boost/mpl/protect.hpp" 1 3 4
+
+
+#define BOOST_MPL_PROTECT_HPP_INCLUDED 
+# 23 "/usr/include/boost/mpl/protect.hpp" 3 4
+namespace boost { namespace mpl {
+
+template<
+      typename T = na
+    , int not_le_ = 0
+    >
+struct protect : T
+{
+
+
+
+    typedef protect type;
+
+};
+# 48 "/usr/include/boost/mpl/protect.hpp" 3 4
+template<> struct protect< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : protect< T1 > { }; };
+
+namespace aux { template< typename T1 > struct template_arity< protect< T1 > > : int_<1> { }; template<> struct template_arity< protect< na > > : int_<-1> { }; }
+
+
+}}
+# 27 "/usr/include/boost/mpl/bind.hpp" 2 3 4
+# 1 "/usr/include/boost/mpl/apply_wrap.hpp" 1 3 4
+# 28 "/usr/include/boost/mpl/bind.hpp" 2 3 4
+# 48 "/usr/include/boost/mpl/bind.hpp" 3 4
+#define BOOST_MPL_PREPROCESSED_HEADER bind.hpp
+
+# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
+# 23 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
+#define AUX778076_PREPROCESSED_HEADER BOOST_MPL_CFG_COMPILER_DIR/BOOST_MPL_PREPROCESSED_HEADER
+# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
+# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/bind.hpp" 1 3 4
+# 13 "/usr/include/boost/mpl/aux_/preprocessed/gcc/bind.hpp" 3 4
+namespace boost { namespace mpl {
+
+namespace aux {
+
+template<
+      typename T, typename U1, typename U2, typename U3, typename U4
+    , typename U5
+    >
+struct resolve_bind_arg
+{
+    typedef T type;
+};
+
+template<
+      typename T
+    , typename Arg
+    >
+struct replace_unnamed_arg
+{
+    typedef Arg next;
+    typedef T type;
+};
+
+template<
+      typename Arg
+    >
+struct replace_unnamed_arg< arg< -1 >, Arg >
+{
+    typedef typename Arg::next next;
+    typedef Arg type;
+};
+
+template<
+      int N, typename U1, typename U2, typename U3, typename U4, typename U5
+    >
+struct resolve_bind_arg< arg<N>, U1, U2, U3, U4, U5 >
+{
+    typedef typename apply_wrap5<mpl::arg<N>, U1, U2, U3, U4, U5>::type type;
+};
+
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename U1, typename U2, typename U3, typename U4
+    , typename U5
+    >
+struct resolve_bind_arg< bind< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5 >
+{
+    typedef bind< F,T1,T2,T3,T4,T5 > f_;
+    typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type;
+};
+
+}
+
+template<
+      typename F
+    >
+struct bind0
+{
+    template<
+          typename U1 = na, typename U2 = na, typename U3 = na
+        , typename U4 = na, typename U5 = na
+        >
+    struct apply
+    {
+     private:
+        typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0;
+        typedef typename r0::type a0;
+        typedef typename r0::next n1;
+        typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_;
+
+     public:
+        typedef typename apply_wrap0<
+              f_
+            >::type type;
+
+    };
+};
+
+namespace aux {
+
+template<
+      typename F, typename U1, typename U2, typename U3, typename U4
+    , typename U5
+    >
+struct resolve_bind_arg<
+      bind0<F>, U1, U2, U3, U4, U5
+    >
+{
+    typedef bind0<F> f_;
+    typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type;
+};
+
+}
+
+
+namespace aux { template< typename T1 > struct template_arity< bind0< T1> > : int_<1> { }; }
+
+template<
+      typename F
+    >
+struct bind< F,na,na,na,na,na >
+    : bind0<F>
+{
+};
+
+template<
+      typename F, typename T1
+    >
+struct bind1
+{
+    template<
+          typename U1 = na, typename U2 = na, typename U3 = na
+        , typename U4 = na, typename U5 = na
+        >
+    struct apply
+    {
+     private:
+        typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0;
+        typedef typename r0::type a0;
+        typedef typename r0::next n1;
+        typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_;
+
+        typedef aux::replace_unnamed_arg< T1,n1 > r1;
+        typedef typename r1::type a1;
+        typedef typename r1::next n2;
+        typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1;
+
+     public:
+        typedef typename apply_wrap1<
+              f_
+            , typename t1::type
+            >::type type;
+
+    };
+};
+
+namespace aux {
+
+template<
+      typename F, typename T1, typename U1, typename U2, typename U3
+    , typename U4, typename U5
+    >
+struct resolve_bind_arg<
+      bind1< F,T1 >, U1, U2, U3, U4, U5
+    >
+{
+    typedef bind1< F,T1 > f_;
+    typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type;
+};
+
+}
+
+
+namespace aux { template< typename T1 , typename T2 > struct template_arity< bind1< T1 , T2> > : int_<2> { }; }
+
+template<
+      typename F, typename T1
+    >
+struct bind< F,T1,na,na,na,na >
+    : bind1< F,T1 >
+{
+};
+
+template<
+      typename F, typename T1, typename T2
+    >
+struct bind2
+{
+    template<
+          typename U1 = na, typename U2 = na, typename U3 = na
+        , typename U4 = na, typename U5 = na
+        >
+    struct apply
+    {
+     private:
+        typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0;
+        typedef typename r0::type a0;
+        typedef typename r0::next n1;
+        typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_;
+
+        typedef aux::replace_unnamed_arg< T1,n1 > r1;
+        typedef typename r1::type a1;
+        typedef typename r1::next n2;
+        typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1;
+
+        typedef aux::replace_unnamed_arg< T2,n2 > r2;
+        typedef typename r2::type a2;
+        typedef typename r2::next n3;
+        typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2;
+
+     public:
+        typedef typename apply_wrap2<
+              f_
+            , typename t1::type, typename t2::type
+            >::type type;
+
+    };
+};
+
+namespace aux {
+
+template<
+      typename F, typename T1, typename T2, typename U1, typename U2
+    , typename U3, typename U4, typename U5
+    >
+struct resolve_bind_arg<
+      bind2< F,T1,T2 >, U1, U2, U3, U4, U5
+    >
+{
+    typedef bind2< F,T1,T2 > f_;
+    typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type;
+};
+
+}
+
+
+namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< bind2< T1 , T2 , T3> > : int_<3> { }; }
+
+template<
+      typename F, typename T1, typename T2
+    >
+struct bind< F,T1,T2,na,na,na >
+    : bind2< F,T1,T2 >
+{
+};
+
+template<
+      typename F, typename T1, typename T2, typename T3
+    >
+struct bind3
+{
+    template<
+          typename U1 = na, typename U2 = na, typename U3 = na
+        , typename U4 = na, typename U5 = na
+        >
+    struct apply
+    {
+     private:
+        typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0;
+        typedef typename r0::type a0;
+        typedef typename r0::next n1;
+        typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_;
+
+        typedef aux::replace_unnamed_arg< T1,n1 > r1;
+        typedef typename r1::type a1;
+        typedef typename r1::next n2;
+        typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1;
+
+        typedef aux::replace_unnamed_arg< T2,n2 > r2;
+        typedef typename r2::type a2;
+        typedef typename r2::next n3;
+        typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2;
+
+        typedef aux::replace_unnamed_arg< T3,n3 > r3;
+        typedef typename r3::type a3;
+        typedef typename r3::next n4;
+        typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3;
+
+     public:
+        typedef typename apply_wrap3<
+              f_
+            , typename t1::type, typename t2::type, typename t3::type
+            >::type type;
+
+    };
+};
+
+namespace aux {
+
+template<
+      typename F, typename T1, typename T2, typename T3, typename U1
+    , typename U2, typename U3, typename U4, typename U5
+    >
+struct resolve_bind_arg<
+      bind3< F,T1,T2,T3 >, U1, U2, U3, U4, U5
+    >
+{
+    typedef bind3< F,T1,T2,T3 > f_;
+    typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type;
+};
+
+}
+
+
+namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 > struct template_arity< bind3< T1 , T2 , T3 , T4> > : int_<4> { }; }
+
+template<
+      typename F, typename T1, typename T2, typename T3
+    >
+struct bind< F,T1,T2,T3,na,na >
+    : bind3< F,T1,T2,T3 >
+{
+};
+
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    >
+struct bind4
+{
+    template<
+          typename U1 = na, typename U2 = na, typename U3 = na
+        , typename U4 = na, typename U5 = na
+        >
+    struct apply
+    {
+     private:
+        typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0;
+        typedef typename r0::type a0;
+        typedef typename r0::next n1;
+        typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_;
+
+        typedef aux::replace_unnamed_arg< T1,n1 > r1;
+        typedef typename r1::type a1;
+        typedef typename r1::next n2;
+        typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1;
+
+        typedef aux::replace_unnamed_arg< T2,n2 > r2;
+        typedef typename r2::type a2;
+        typedef typename r2::next n3;
+        typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2;
+
+        typedef aux::replace_unnamed_arg< T3,n3 > r3;
+        typedef typename r3::type a3;
+        typedef typename r3::next n4;
+        typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3;
+
+        typedef aux::replace_unnamed_arg< T4,n4 > r4;
+        typedef typename r4::type a4;
+        typedef typename r4::next n5;
+        typedef aux::resolve_bind_arg< a4,U1,U2,U3,U4,U5 > t4;
+
+     public:
+        typedef typename apply_wrap4<
+              f_
+            , typename t1::type, typename t2::type, typename t3::type
+            , typename t4::type
+            >::type type;
+
+    };
+};
+
+namespace aux {
+
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    , typename U1, typename U2, typename U3, typename U4, typename U5
+    >
+struct resolve_bind_arg<
+      bind4< F,T1,T2,T3,T4 >, U1, U2, U3, U4, U5
+    >
+{
+    typedef bind4< F,T1,T2,T3,T4 > f_;
+    typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type;
+};
+
+}
+
+
+namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > struct template_arity< bind4< T1 , T2 , T3 , T4 , T5> > : int_<5> { }; }
+
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    >
+struct bind< F,T1,T2,T3,T4,na >
+    : bind4< F,T1,T2,T3,T4 >
+{
+};
+
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    , typename T5
+    >
+struct bind5
+{
+    template<
+          typename U1 = na, typename U2 = na, typename U3 = na
+        , typename U4 = na, typename U5 = na
+        >
+    struct apply
+    {
+     private:
+        typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0;
+        typedef typename r0::type a0;
+        typedef typename r0::next n1;
+        typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_;
+
+        typedef aux::replace_unnamed_arg< T1,n1 > r1;
+        typedef typename r1::type a1;
+        typedef typename r1::next n2;
+        typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1;
+
+        typedef aux::replace_unnamed_arg< T2,n2 > r2;
+        typedef typename r2::type a2;
+        typedef typename r2::next n3;
+        typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2;
+
+        typedef aux::replace_unnamed_arg< T3,n3 > r3;
+        typedef typename r3::type a3;
+        typedef typename r3::next n4;
+        typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3;
+
+        typedef aux::replace_unnamed_arg< T4,n4 > r4;
+        typedef typename r4::type a4;
+        typedef typename r4::next n5;
+        typedef aux::resolve_bind_arg< a4,U1,U2,U3,U4,U5 > t4;
+
+        typedef aux::replace_unnamed_arg< T5,n5 > r5;
+        typedef typename r5::type a5;
+        typedef typename r5::next n6;
+        typedef aux::resolve_bind_arg< a5,U1,U2,U3,U4,U5 > t5;
+
+     public:
+        typedef typename apply_wrap5<
+              f_
+            , typename t1::type, typename t2::type, typename t3::type
+            , typename t4::type, typename t5::type
+            >::type type;
+
+    };
+};
+
+namespace aux {
+
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename U1, typename U2, typename U3, typename U4
+    , typename U5
+    >
+struct resolve_bind_arg<
+      bind5< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5
+    >
+{
+    typedef bind5< F,T1,T2,T3,T4,T5 > f_;
+    typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type;
+};
+
+}
+
+
+namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 > struct template_arity< bind5< T1 , T2 , T3 , T4 , T5 , T6> > : int_<6> { }; }
+
+
+
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    , typename T5
+    >
+struct bind
+    : bind5< F,T1,T2,T3,T4,T5 >
+{
+};
+
+
+template< template< typename T1, typename T2, typename T3 > class F, typename Tag >
+struct quote3;
+
+template< typename T1, typename T2, typename T3 > struct if_;
+
+template<
+      typename Tag, typename T1, typename T2, typename T3
+    >
+struct bind3<
+      quote3< if_,Tag >
+    , T1, T2, T3
+    >
+{
+    template<
+          typename U1 = na, typename U2 = na, typename U3 = na
+        , typename U4 = na, typename U5 = na
+        >
+    struct apply
+    {
+     private:
+        typedef mpl::arg<1> n1;
+        typedef aux::replace_unnamed_arg< T1,n1 > r1;
+        typedef typename r1::type a1;
+        typedef typename r1::next n2;
+        typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1;
+
+        typedef aux::replace_unnamed_arg< T2,n2 > r2;
+        typedef typename r2::type a2;
+        typedef typename r2::next n3;
+        typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2;
+
+        typedef aux::replace_unnamed_arg< T3,n3 > r3;
+        typedef typename r3::type a3;
+        typedef typename r3::next n4;
+        typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3;
+
+        typedef typename if_<
+              typename t1::type
+            , t2, t3
+            >::type f_;
+
+     public:
+        typedef typename f_::type type;
+    };
+};
+
+template<
+      template< typename T1, typename T2, typename T3 > class F, typename Tag
+    >
+struct quote3;
+
+template< typename T1, typename T2, typename T3 > struct eval_if;
+
+template<
+      typename Tag, typename T1, typename T2, typename T3
+    >
+struct bind3<
+      quote3< eval_if,Tag >
+    , T1, T2, T3
+    >
+{
+    template<
+          typename U1 = na, typename U2 = na, typename U3 = na
+        , typename U4 = na, typename U5 = na
+        >
+    struct apply
+    {
+     private:
+        typedef mpl::arg<1> n1;
+        typedef aux::replace_unnamed_arg< T1,n1 > r1;
+        typedef typename r1::type a1;
+        typedef typename r1::next n2;
+        typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1;
+
+        typedef aux::replace_unnamed_arg< T2,n2 > r2;
+        typedef typename r2::type a2;
+        typedef typename r2::next n3;
+        typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2;
+
+        typedef aux::replace_unnamed_arg< T3,n3 > r3;
+        typedef typename r3::type a3;
+        typedef typename r3::next n4;
+        typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3;
+
+        typedef typename eval_if<
+              typename t1::type
+            , t2, t3
+            >::type f_;
+
+     public:
+        typedef typename f_::type type;
+    };
+};
+
+}}
+# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
+
+
+#undef AUX778076_PREPROCESSED_HEADER
+
+#undef BOOST_MPL_PREPROCESSED_HEADER
+# 51 "/usr/include/boost/mpl/bind.hpp" 2 3 4
+# 19 "/usr/include/boost/mpl/lambda.hpp" 2 3 4
+
+
+
+# 1 "/usr/include/boost/mpl/aux_/full_lambda.hpp" 1 3 4
+
+
+
+
+
+
+#define BOOST_MPL_AUX_FULL_LAMBDA_HPP_INCLUDED 
+# 23 "/usr/include/boost/mpl/aux_/full_lambda.hpp" 3 4
+# 1 "/usr/include/boost/mpl/bind_fwd.hpp" 1 3 4
+# 24 "/usr/include/boost/mpl/aux_/full_lambda.hpp" 2 3 4
+
+# 1 "/usr/include/boost/mpl/quote.hpp" 1 3 4
+
+
+
+
+
+
+#define BOOST_MPL_QUOTE_HPP_INCLUDED 
+# 22 "/usr/include/boost/mpl/quote.hpp" 3 4
+# 1 "/usr/include/boost/mpl/void.hpp" 1 3 4
+
+
+#define BOOST_MPL_VOID_HPP_INCLUDED 
+# 23 "/usr/include/boost/mpl/void.hpp" 3 4
+namespace mpl_ {
+
+
+
+
+
+struct void_ { typedef void_ type; };
+
+}
+
+namespace boost { namespace mpl {
+
+template< typename T >
+struct is_void_
+    : false_
+{
+
+
+
+};
+
+template<>
+struct is_void_<void_>
+    : true_
+{
+
+
+
+};
+
+template< typename T >
+struct is_not_void_
+    : true_
+{
+
+
+
+};
+
+template<>
+struct is_not_void_<void_>
+    : false_
+{
+
+
+
+};
+
+template<> struct is_void_< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : is_void_< T1 > { }; }; template< typename Tag > struct lambda< is_void_< na > , Tag , int_<-1> > { typedef false_ is_le; typedef is_void_< na > result_; typedef is_void_< na > type; }; namespace aux { template< typename T1 > struct template_arity< is_void_< T1 > > : int_<1> { }; template<> struct template_arity< is_void_< na > > : int_<-1> { }; }
+template<> struct is_not_void_< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : is_not_void_< T1 > { }; }; template< typename Tag > struct lambda< is_not_void_< na > , Tag , int_<-1> > { typedef false_ is_le; typedef is_not_void_< na > result_; typedef is_not_void_< na > type; }; namespace aux { template< typename T1 > struct template_arity< is_not_void_< T1 > > : int_<1> { }; template<> struct template_arity< is_not_void_< na > > : int_<-1> { }; }
+
+}}
+# 23 "/usr/include/boost/mpl/quote.hpp" 2 3 4
+# 1 "/usr/include/boost/mpl/aux_/has_type.hpp" 1 3 4
+
+
+#define BOOST_MPL_AUX_HAS_TYPE_HPP_INCLUDED 
+# 19 "/usr/include/boost/mpl/aux_/has_type.hpp" 3 4
+namespace boost { namespace mpl { namespace aux {
+template< typename T, typename fallback_ = boost::mpl::bool_<true> > struct has_type { struct gcc_3_2_wknd { template< typename U > static boost::mpl::aux::yes_tag test( boost::mpl::aux::type_wrapper<U> const volatile* , boost::mpl::aux::type_wrapper<typename U::type>* = 0 ); static boost::mpl::aux::no_tag test(...); }; typedef boost::mpl::aux::type_wrapper<T> t_; static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::aux::yes_tag); typedef boost::mpl::bool_<value> type; };
+}}}
+# 24 "/usr/include/boost/mpl/quote.hpp" 2 3 4
+
+
+# 1 "/usr/include/boost/mpl/aux_/config/bcc.hpp" 1 3 4
+
+
+#define BOOST_MPL_AUX_CONFIG_BCC_HPP_INCLUDED 
+# 27 "/usr/include/boost/mpl/quote.hpp" 2 3 4
+# 44 "/usr/include/boost/mpl/quote.hpp" 3 4
+#define BOOST_MPL_PREPROCESSED_HEADER quote.hpp
+# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
+# 23 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
+#define AUX778076_PREPROCESSED_HEADER BOOST_MPL_CFG_COMPILER_DIR/BOOST_MPL_PREPROCESSED_HEADER
+# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
+# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/quote.hpp" 1 3 4
+# 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/quote.hpp" 3 4
+namespace boost { namespace mpl {
+
+template< typename T, bool has_type_ >
+struct quote_impl
+{
+    typedef typename T::type type;
+};
+
+template< typename T >
+struct quote_impl< T,false >
+{
+    typedef T type;
+};
+
+template<
+      template< typename P1 > class F
+    , typename Tag = void_
+    >
+struct quote1
+{
+    template< typename U1 > struct apply
+
+        : quote_impl<
+              F<U1>
+            , aux::has_type< F<U1> >::value
+            >
+
+    {
+    };
+};
+
+template<
+      template< typename P1, typename P2 > class F
+    , typename Tag = void_
+    >
+struct quote2
+{
+    template< typename U1, typename U2 > struct apply
+
+        : quote_impl<
+              F< U1,U2 >
+            , aux::has_type< F< U1,U2 > >::value
+            >
+
+    {
+    };
+};
+
+template<
+      template< typename P1, typename P2, typename P3 > class F
+    , typename Tag = void_
+    >
+struct quote3
+{
+    template< typename U1, typename U2, typename U3 > struct apply
+
+        : quote_impl<
+              F< U1,U2,U3 >
+            , aux::has_type< F< U1,U2,U3 > >::value
+            >
+
+    {
+    };
+};
+
+template<
+      template< typename P1, typename P2, typename P3, typename P4 > class F
+    , typename Tag = void_
+    >
+struct quote4
+{
+    template<
+          typename U1, typename U2, typename U3, typename U4
+        >
+    struct apply
+
+        : quote_impl<
+              F< U1,U2,U3,U4 >
+            , aux::has_type< F< U1,U2,U3,U4 > >::value
+            >
+
+    {
+    };
+};
+
+template<
+      template<
+          typename P1, typename P2, typename P3, typename P4
+        , typename P5
+        >
+      class F
+    , typename Tag = void_
+    >
+struct quote5
+{
+    template<
+          typename U1, typename U2, typename U3, typename U4
+        , typename U5
+        >
+    struct apply
+
+        : quote_impl<
+              F< U1,U2,U3,U4,U5 >
+            , aux::has_type< F< U1,U2,U3,U4,U5 > >::value
+            >
+
+    {
+    };
+};
+
+}}
+# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
+
+
+#undef AUX778076_PREPROCESSED_HEADER
+
+#undef BOOST_MPL_PREPROCESSED_HEADER
+# 46 "/usr/include/boost/mpl/quote.hpp" 2 3 4
+# 26 "/usr/include/boost/mpl/aux_/full_lambda.hpp" 2 3 4
+# 1 "/usr/include/boost/mpl/arg.hpp" 1 3 4
+# 27 "/usr/include/boost/mpl/aux_/full_lambda.hpp" 2 3 4
+
+
+# 1 "/usr/include/boost/mpl/aux_/template_arity.hpp" 1 3 4
+
+
+
+
+
+
+#define BOOST_MPL_AUX_TEMPLATE_ARITY_HPP_INCLUDED 
+# 42 "/usr/include/boost/mpl/aux_/template_arity.hpp" 3 4
+#define BOOST_MPL_PREPROCESSED_HEADER template_arity.hpp
+# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
+# 23 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
+#define AUX778076_PREPROCESSED_HEADER BOOST_MPL_CFG_COMPILER_DIR/BOOST_MPL_PREPROCESSED_HEADER
+# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
+# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/template_arity.hpp" 1 3 4
+# 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/template_arity.hpp" 3 4
+namespace boost { namespace mpl { namespace aux {
+template< int N > struct arity_tag
+{
+    typedef char (&type)[N + 1];
+};
+
+template<
+      int C1, int C2, int C3, int C4, int C5, int C6
+    >
+struct max_arity
+{
+    static const int value = ( C6 > 0 ? C6 : ( C5 > 0 ? C5 : ( C4 > 0 ? C4 : ( C3 > 0 ? C3 : ( C2 > 0 ? C2 : ( C1 > 0 ? C1 : -1 ) ) ) ) ) )
+
+         ;
+};
+
+arity_tag<0>::type arity_helper(...);
+
+template<
+      template< typename P1 > class F
+    , typename T1
+    >
+typename arity_tag<1>::type
+arity_helper(type_wrapper< F<T1> >, arity_tag<1>);
+
+template<
+      template< typename P1, typename P2 > class F
+    , typename T1, typename T2
+    >
+typename arity_tag<2>::type
+arity_helper(type_wrapper< F< T1,T2 > >, arity_tag<2>);
+
+template<
+      template< typename P1, typename P2, typename P3 > class F
+    , typename T1, typename T2, typename T3
+    >
+typename arity_tag<3>::type
+arity_helper(type_wrapper< F< T1,T2,T3 > >, arity_tag<3>);
+
+template<
+      template< typename P1, typename P2, typename P3, typename P4 > class F
+    , typename T1, typename T2, typename T3, typename T4
+    >
+typename arity_tag<4>::type
+arity_helper(type_wrapper< F< T1,T2,T3,T4 > >, arity_tag<4>);
+
+template<
+      template<
+          typename P1, typename P2, typename P3, typename P4
+        , typename P5
+        >
+      class F
+    , typename T1, typename T2, typename T3, typename T4, typename T5
+    >
+typename arity_tag<5>::type
+arity_helper(type_wrapper< F< T1,T2,T3,T4,T5 > >, arity_tag<5>);
+
+template<
+      template<
+          typename P1, typename P2, typename P3, typename P4
+        , typename P5, typename P6
+        >
+      class F
+    , typename T1, typename T2, typename T3, typename T4, typename T5
+    , typename T6
+    >
+typename arity_tag<6>::type
+arity_helper(type_wrapper< F< T1,T2,T3,T4,T5,T6 > >, arity_tag<6>);
+template< typename F, int N >
+struct template_arity_impl
+{
+    static const int value = sizeof(::boost::mpl::aux::arity_helper(type_wrapper<F>(), arity_tag<N>())) - 1
+
+         ;
+};
+
+template< typename F >
+struct template_arity
+{
+    static const int value = ( max_arity< template_arity_impl< F,1 >::value, template_arity_impl< F,2 >::value, template_arity_impl< F,3 >::value, template_arity_impl< F,4 >::value, template_arity_impl< F,5 >::value, template_arity_impl< F,6 >::value >::value )
+
+          ;
+    typedef mpl::int_<value> type;
+};
+
+}}}
+# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
+
+
+#undef AUX778076_PREPROCESSED_HEADER
+
+#undef BOOST_MPL_PREPROCESSED_HEADER
+# 44 "/usr/include/boost/mpl/aux_/template_arity.hpp" 2 3 4
+# 30 "/usr/include/boost/mpl/aux_/full_lambda.hpp" 2 3 4
+# 43 "/usr/include/boost/mpl/aux_/full_lambda.hpp" 3 4
+#define BOOST_MPL_PREPROCESSED_HEADER full_lambda.hpp
+# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
+# 23 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
+#define AUX778076_PREPROCESSED_HEADER BOOST_MPL_CFG_COMPILER_DIR/BOOST_MPL_PREPROCESSED_HEADER
+# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
+# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/full_lambda.hpp" 1 3 4
+# 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/full_lambda.hpp" 3 4
+namespace boost { namespace mpl {
+
+namespace aux {
+
+template<
+      bool C1 = false, bool C2 = false, bool C3 = false, bool C4 = false
+    , bool C5 = false
+    >
+struct lambda_or
+    : true_
+{
+};
+
+template<>
+struct lambda_or< false,false,false,false,false >
+    : false_
+{
+};
+
+}
+
+template<
+      typename T
+    , typename Tag
+    , typename Arity
+    >
+struct lambda
+{
+    typedef false_ is_le;
+    typedef T result_;
+    typedef T type;
+};
+
+template<
+      typename T
+    >
+struct is_lambda_expression
+    : lambda<T>::is_le
+{
+};
+
+template< int N, typename Tag >
+struct lambda< arg<N>,Tag, int_< -1 > >
+{
+    typedef true_ is_le;
+    typedef mpl::arg<N> result_;
+    typedef mpl::protect<result_> type;
+};
+
+template<
+      typename F
+    , typename Tag
+    >
+struct lambda<
+          bind0<F>
+        , Tag
+        , int_<1>
+        >
+{
+    typedef false_ is_le;
+    typedef bind0<
+          F
+        > result_;
+
+    typedef result_ type;
+};
+
+namespace aux {
+
+template<
+      typename IsLE, typename Tag
+    , template< typename P1 > class F
+    , typename L1
+    >
+struct le_result1
+{
+    typedef F<
+          typename L1::type
+        > result_;
+
+    typedef result_ type;
+};
+
+template<
+      typename Tag
+    , template< typename P1 > class F
+    , typename L1
+    >
+struct le_result1< true_,Tag,F,L1 >
+{
+    typedef bind1<
+          quote1< F,Tag >
+        , typename L1::result_
+        > result_;
+
+    typedef mpl::protect<result_> type;
+};
+
+}
+
+template<
+      template< typename P1 > class F
+    , typename T1
+    , typename Tag
+    >
+struct lambda<
+          F<T1>
+        , Tag
+        , int_<1>
+        >
+{
+    typedef lambda< T1,Tag > l1;
+    typedef typename l1::is_le is_le1;
+    typedef typename aux::lambda_or<
+          is_le1::value
+        >::type is_le;
+
+    typedef aux::le_result1<
+          is_le, Tag, F, l1
+        > le_result_;
+
+    typedef typename le_result_::result_ result_;
+    typedef typename le_result_::type type;
+};
+
+template<
+      typename F, typename T1
+    , typename Tag
+    >
+struct lambda<
+          bind1< F,T1 >
+        , Tag
+        , int_<2>
+        >
+{
+    typedef false_ is_le;
+    typedef bind1<
+          F
+        , T1
+        > result_;
+
+    typedef result_ type;
+};
+
+namespace aux {
+
+template<
+      typename IsLE, typename Tag
+    , template< typename P1, typename P2 > class F
+    , typename L1, typename L2
+    >
+struct le_result2
+{
+    typedef F<
+          typename L1::type, typename L2::type
+        > result_;
+
+    typedef result_ type;
+};
+
+template<
+      typename Tag
+    , template< typename P1, typename P2 > class F
+    , typename L1, typename L2
+    >
+struct le_result2< true_,Tag,F,L1,L2 >
+{
+    typedef bind2<
+          quote2< F,Tag >
+        , typename L1::result_, typename L2::result_
+        > result_;
+
+    typedef mpl::protect<result_> type;
+};
+
+}
+
+template<
+      template< typename P1, typename P2 > class F
+    , typename T1, typename T2
+    , typename Tag
+    >
+struct lambda<
+          F< T1,T2 >
+        , Tag
+        , int_<2>
+        >
+{
+    typedef lambda< T1,Tag > l1;
+    typedef lambda< T2,Tag > l2;
+
+    typedef typename l1::is_le is_le1;
+    typedef typename l2::is_le is_le2;
+
+
+    typedef typename aux::lambda_or<
+          is_le1::value, is_le2::value
+        >::type is_le;
+
+    typedef aux::le_result2<
+          is_le, Tag, F, l1, l2
+        > le_result_;
+
+    typedef typename le_result_::result_ result_;
+    typedef typename le_result_::type type;
+};
+
+template<
+      typename F, typename T1, typename T2
+    , typename Tag
+    >
+struct lambda<
+          bind2< F,T1,T2 >
+        , Tag
+        , int_<3>
+        >
+{
+    typedef false_ is_le;
+    typedef bind2<
+          F
+        , T1, T2
+        > result_;
+
+    typedef result_ type;
+};
+
+namespace aux {
+
+template<
+      typename IsLE, typename Tag
+    , template< typename P1, typename P2, typename P3 > class F
+    , typename L1, typename L2, typename L3
+    >
+struct le_result3
+{
+    typedef F<
+          typename L1::type, typename L2::type, typename L3::type
+        > result_;
+
+    typedef result_ type;
+};
+
+template<
+      typename Tag
+    , template< typename P1, typename P2, typename P3 > class F
+    , typename L1, typename L2, typename L3
+    >
+struct le_result3< true_,Tag,F,L1,L2,L3 >
+{
+    typedef bind3<
+          quote3< F,Tag >
+        , typename L1::result_, typename L2::result_, typename L3::result_
+        > result_;
+
+    typedef mpl::protect<result_> type;
+};
+
+}
+
+template<
+      template< typename P1, typename P2, typename P3 > class F
+    , typename T1, typename T2, typename T3
+    , typename Tag
+    >
+struct lambda<
+          F< T1,T2,T3 >
+        , Tag
+        , int_<3>
+        >
+{
+    typedef lambda< T1,Tag > l1;
+    typedef lambda< T2,Tag > l2;
+    typedef lambda< T3,Tag > l3;
+
+    typedef typename l1::is_le is_le1;
+    typedef typename l2::is_le is_le2;
+    typedef typename l3::is_le is_le3;
+
+
+    typedef typename aux::lambda_or<
+          is_le1::value, is_le2::value, is_le3::value
+        >::type is_le;
+
+    typedef aux::le_result3<
+          is_le, Tag, F, l1, l2, l3
+        > le_result_;
+
+    typedef typename le_result_::result_ result_;
+    typedef typename le_result_::type type;
+};
+
+template<
+      typename F, typename T1, typename T2, typename T3
+    , typename Tag
+    >
+struct lambda<
+          bind3< F,T1,T2,T3 >
+        , Tag
+        , int_<4>
+        >
+{
+    typedef false_ is_le;
+    typedef bind3<
+          F
+        , T1, T2, T3
+        > result_;
+
+    typedef result_ type;
+};
+
+namespace aux {
+
+template<
+      typename IsLE, typename Tag
+    , template< typename P1, typename P2, typename P3, typename P4 > class F
+    , typename L1, typename L2, typename L3, typename L4
+    >
+struct le_result4
+{
+    typedef F<
+          typename L1::type, typename L2::type, typename L3::type
+        , typename L4::type
+        > result_;
+
+    typedef result_ type;
+};
+
+template<
+      typename Tag
+    , template< typename P1, typename P2, typename P3, typename P4 > class F
+    , typename L1, typename L2, typename L3, typename L4
+    >
+struct le_result4< true_,Tag,F,L1,L2,L3,L4 >
+{
+    typedef bind4<
+          quote4< F,Tag >
+        , typename L1::result_, typename L2::result_, typename L3::result_
+        , typename L4::result_
+        > result_;
+
+    typedef mpl::protect<result_> type;
+};
+
+}
+
+template<
+      template< typename P1, typename P2, typename P3, typename P4 > class F
+    , typename T1, typename T2, typename T3, typename T4
+    , typename Tag
+    >
+struct lambda<
+          F< T1,T2,T3,T4 >
+        , Tag
+        , int_<4>
+        >
+{
+    typedef lambda< T1,Tag > l1;
+    typedef lambda< T2,Tag > l2;
+    typedef lambda< T3,Tag > l3;
+    typedef lambda< T4,Tag > l4;
+
+    typedef typename l1::is_le is_le1;
+    typedef typename l2::is_le is_le2;
+    typedef typename l3::is_le is_le3;
+    typedef typename l4::is_le is_le4;
+
+
+    typedef typename aux::lambda_or<
+          is_le1::value, is_le2::value, is_le3::value, is_le4::value
+        >::type is_le;
+
+    typedef aux::le_result4<
+          is_le, Tag, F, l1, l2, l3, l4
+        > le_result_;
+
+    typedef typename le_result_::result_ result_;
+    typedef typename le_result_::type type;
+};
+
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    , typename Tag
+    >
+struct lambda<
+          bind4< F,T1,T2,T3,T4 >
+        , Tag
+        , int_<5>
+        >
+{
+    typedef false_ is_le;
+    typedef bind4<
+          F
+        , T1, T2, T3, T4
+        > result_;
+
+    typedef result_ type;
+};
+
+namespace aux {
+
+template<
+      typename IsLE, typename Tag
+    , template< typename P1, typename P2, typename P3, typename P4, typename P5 > class F
+    , typename L1, typename L2, typename L3, typename L4, typename L5
+    >
+struct le_result5
+{
+    typedef F<
+          typename L1::type, typename L2::type, typename L3::type
+        , typename L4::type, typename L5::type
+        > result_;
+
+    typedef result_ type;
+};
+
+template<
+      typename Tag
+    , template< typename P1, typename P2, typename P3, typename P4, typename P5 > class F
+    , typename L1, typename L2, typename L3, typename L4, typename L5
+    >
+struct le_result5< true_,Tag,F,L1,L2,L3,L4,L5 >
+{
+    typedef bind5<
+          quote5< F,Tag >
+        , typename L1::result_, typename L2::result_, typename L3::result_
+        , typename L4::result_, typename L5::result_
+        > result_;
+
+    typedef mpl::protect<result_> type;
+};
+
+}
+
+template<
+      template<
+          typename P1, typename P2, typename P3, typename P4
+        , typename P5
+        >
+      class F
+    , typename T1, typename T2, typename T3, typename T4, typename T5
+    , typename Tag
+    >
+struct lambda<
+          F< T1,T2,T3,T4,T5 >
+        , Tag
+        , int_<5>
+        >
+{
+    typedef lambda< T1,Tag > l1;
+    typedef lambda< T2,Tag > l2;
+    typedef lambda< T3,Tag > l3;
+    typedef lambda< T4,Tag > l4;
+    typedef lambda< T5,Tag > l5;
+
+    typedef typename l1::is_le is_le1;
+    typedef typename l2::is_le is_le2;
+    typedef typename l3::is_le is_le3;
+    typedef typename l4::is_le is_le4;
+    typedef typename l5::is_le is_le5;
+
+
+    typedef typename aux::lambda_or<
+          is_le1::value, is_le2::value, is_le3::value, is_le4::value
+        , is_le5::value
+        >::type is_le;
+
+    typedef aux::le_result5<
+          is_le, Tag, F, l1, l2, l3, l4, l5
+        > le_result_;
+
+    typedef typename le_result_::result_ result_;
+    typedef typename le_result_::type type;
+};
+
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    , typename T5
+    , typename Tag
+    >
+struct lambda<
+          bind5< F,T1,T2,T3,T4,T5 >
+        , Tag
+        , int_<6>
+        >
+{
+    typedef false_ is_le;
+    typedef bind5<
+          F
+        , T1, T2, T3, T4, T5
+        > result_;
+
+    typedef result_ type;
+};
+
+
+template< typename T, typename Tag >
+struct lambda< mpl::protect<T>,Tag, int_<1> >
+{
+    typedef false_ is_le;
+    typedef mpl::protect<T> result_;
+    typedef result_ type;
+};
+
+
+
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    , typename T5
+    , typename Tag
+    >
+struct lambda<
+          bind< F,T1,T2,T3,T4,T5 >
+        , Tag
+        , int_<6>
+        >
+{
+    typedef false_ is_le;
+    typedef bind< F,T1,T2,T3,T4,T5 > result_;
+    typedef result_ type;
+};
+
+template<
+      typename F
+    , typename Tag1
+    , typename Tag2
+    , typename Arity
+    >
+struct lambda<
+          lambda< F,Tag1,Arity >
+        , Tag2
+        , int_<3>
+        >
+{
+    typedef lambda< F,Tag2 > l1;
+    typedef lambda< Tag1,Tag2 > l2;
+    typedef typename l1::is_le is_le;
+    typedef bind1< quote1<aux::template_arity>, typename l1::result_ > arity_;
+    typedef lambda< typename if_< is_le,arity_,Arity >::type, Tag2 > l3;
+    typedef aux::le_result3<is_le, Tag2, mpl::lambda, l1, l2, l3> le_result_;
+    typedef typename le_result_::result_ result_;
+    typedef typename le_result_::type type;
+};
+
+template<> struct lambda< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : lambda< T1 , T2 > { }; }; template< typename Tag > struct lambda< lambda< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef lambda< na , na > result_; typedef lambda< na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< lambda< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< lambda< na , na > > : int_<-1> { }; }
+
+}}
+# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
+
+
+#undef AUX778076_PREPROCESSED_HEADER
+
+#undef BOOST_MPL_PREPROCESSED_HEADER
+# 45 "/usr/include/boost/mpl/aux_/full_lambda.hpp" 2 3 4
+# 23 "/usr/include/boost/mpl/lambda.hpp" 2 3 4
+# 26 "/usr/include/boost/mpl/apply.hpp" 2 3 4
+# 35 "/usr/include/boost/mpl/apply.hpp" 3 4
+#define BOOST_MPL_PREPROCESSED_HEADER apply.hpp
+# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
+# 23 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
+#define AUX778076_PREPROCESSED_HEADER BOOST_MPL_CFG_COMPILER_DIR/BOOST_MPL_PREPROCESSED_HEADER
+# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
+# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/apply.hpp" 1 3 4
+# 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/apply.hpp" 3 4
+namespace boost { namespace mpl {
+
+template<
+      typename F
+    >
+struct apply0
+
+    : apply_wrap0<
+          typename lambda<F>::type
+
+        >
+{
+   
+
+
+
+
+};
+
+template<
+      typename F
+    >
+struct apply< F,na,na,na,na,na >
+    : apply0<F>
+{
+};
+
+template<
+      typename F, typename T1
+    >
+struct apply1
+
+    : apply_wrap1<
+          typename lambda<F>::type
+        , T1
+        >
+{
+   
+
+
+
+
+};
+
+template<
+      typename F, typename T1
+    >
+struct apply< F,T1,na,na,na,na >
+    : apply1< F,T1 >
+{
+};
+
+template<
+      typename F, typename T1, typename T2
+    >
+struct apply2
+
+    : apply_wrap2<
+          typename lambda<F>::type
+        , T1, T2
+        >
+{
+   
+
+
+
+
+};
+
+template<
+      typename F, typename T1, typename T2
+    >
+struct apply< F,T1,T2,na,na,na >
+    : apply2< F,T1,T2 >
+{
+};
+
+template<
+      typename F, typename T1, typename T2, typename T3
+    >
+struct apply3
+
+    : apply_wrap3<
+          typename lambda<F>::type
+        , T1, T2, T3
+        >
+{
+   
+
+
+
+
+};
+
+template<
+      typename F, typename T1, typename T2, typename T3
+    >
+struct apply< F,T1,T2,T3,na,na >
+    : apply3< F,T1,T2,T3 >
+{
+};
+
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    >
+struct apply4
+
+    : apply_wrap4<
+          typename lambda<F>::type
+        , T1, T2, T3, T4
+        >
+{
+   
+
+
+
+
+};
+
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    >
+struct apply< F,T1,T2,T3,T4,na >
+    : apply4< F,T1,T2,T3,T4 >
+{
+};
+
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    , typename T5
+    >
+struct apply5
+
+    : apply_wrap5<
+          typename lambda<F>::type
+        , T1, T2, T3, T4, T5
+        >
+{
+   
+
+
+
+
+};
+
+
+
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    , typename T5
+    >
+struct apply
+    : apply5< F,T1,T2,T3,T4,T5 >
+{
+};
+
+}}
+# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
+
+
+#undef AUX778076_PREPROCESSED_HEADER
+
+#undef BOOST_MPL_PREPROCESSED_HEADER
+# 37 "/usr/include/boost/mpl/apply.hpp" 2 3 4
+# 37 "/usr/include/boost/iterator/iterator_facade.hpp" 2 3 4
+
+
+
+
+# 1 "/usr/include/boost/iterator/detail/config_def.hpp" 1 3 4
+# 22 "/usr/include/boost/iterator/detail/config_def.hpp" 3 4
+#define BOOST_ITERATOR_CONFIG_DEF 
+# 45 "/usr/include/boost/iterator/detail/config_def.hpp" 3 4
+#define BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY 1
+# 42 "/usr/include/boost/iterator/iterator_facade.hpp" 2 3 4
+
+namespace boost {
+namespace iterators {
+
+
+
+  template <class I, class V, class TC, class R, class D> class iterator_facade;
+
+  namespace detail
+  {
+
+
+
+    struct always_bool2
+    {
+        template <class T, class U>
+        struct apply
+        {
+            typedef bool type;
+        };
+    };
+
+
+    template< typename CategoryOrTraversal, typename Required >
+    struct is_traversal_at_least :
+        public boost::is_convertible< typename iterator_category_to_traversal< CategoryOrTraversal >::type, Required >
+    {};
+
+
+
+
+    template <
+        class Facade1
+      , class Facade2
+      , class Return
+    >
+    struct enable_if_interoperable :
+        public boost::iterators::enable_if<
+            is_interoperable< Facade1, Facade2 >
+          , Return
+        >
+    {};
+
+
+
+
+    template <
+        class Facade1
+      , class Facade2
+      , class Return
+    >
+    struct enable_if_interoperable_and_random_access_traversal :
+        public boost::iterators::enable_if<
+            mpl::and_<
+                is_interoperable< Facade1, Facade2 >
+              , is_traversal_at_least< typename iterator_category< Facade1 >::type, random_access_traversal_tag >
+              , is_traversal_at_least< typename iterator_category< Facade2 >::type, random_access_traversal_tag >
+            >
+          , Return
+        >
+    {};
+
+
+
+
+
+    template <
+        class ValueParam
+      , class CategoryOrTraversal
+      , class Reference
+      , class Difference
+    >
+    struct iterator_facade_types
+    {
+        typedef typename facade_iterator_category<
+            CategoryOrTraversal, ValueParam, Reference
+        >::type iterator_category;
+
+        typedef typename remove_const<ValueParam>::type value_type;
+
+
+        typedef typename mpl::eval_if<
+            boost::iterators::detail::iterator_writability_disabled<ValueParam,Reference>
+          , add_pointer<const value_type>
+          , add_pointer<value_type>
+        >::type pointer;
+# 145 "/usr/include/boost/iterator/iterator_facade.hpp" 3 4
+    };
+
+
+
+
+
+
+
+    template <class Iterator>
+    class postfix_increment_proxy
+    {
+        typedef typename iterator_value<Iterator>::type value_type;
+     public:
+        explicit postfix_increment_proxy(Iterator const& x)
+          : stored_value(*x)
+        {}
+
+
+
+
+
+        value_type&
+        operator*() const
+        {
+            return this->stored_value;
+        }
+     private:
+        mutable value_type stored_value;
+    };
+
+
+
+
+
+    template <class Iterator>
+    class writable_postfix_increment_proxy
+    {
+        typedef typename iterator_value<Iterator>::type value_type;
+     public:
+        explicit writable_postfix_increment_proxy(Iterator const& x)
+          : stored_value(*x)
+          , stored_iterator(x)
+        {}
+
+
+
+
+
+        writable_postfix_increment_proxy const&
+        operator*() const
+        {
+            return *this;
+        }
+
+
+        operator value_type&() const
+        {
+            return stored_value;
+        }
+
+
+        template <class T>
+        T const& operator=(T const& x) const
+        {
+            *this->stored_iterator = x;
+            return x;
+        }
+
+
+        template <class T>
+        T& operator=(T& x) const
+        {
+            *this->stored_iterator = x;
+            return x;
+        }
+
+
+        operator Iterator const&() const
+        {
+            return stored_iterator;
+        }
+
+     private:
+        mutable value_type stored_value;
+        Iterator stored_iterator;
+    };
+# 259 "/usr/include/boost/iterator/iterator_facade.hpp" 3 4
+    template <class Reference, class Value>
+    struct is_non_proxy_reference
+      : is_convertible<
+            typename remove_reference<Reference>::type
+            const volatile*
+          , Value const volatile*
+        >
+    {};
+# 284 "/usr/include/boost/iterator/iterator_facade.hpp" 3 4
+    template <class Iterator, class Value, class Reference, class CategoryOrTraversal>
+    struct postfix_increment_result
+      : mpl::eval_if<
+            mpl::and_<
+
+                is_convertible<
+                    Reference
+
+
+
+
+
+                  , typename add_lvalue_reference<Value const>::type
+                >
+
+
+
+              , mpl::not_<
+                    is_convertible<
+                        typename iterator_category_to_traversal<CategoryOrTraversal>::type
+                      , forward_traversal_tag
+                    >
+                >
+            >
+          , mpl::if_<
+                is_non_proxy_reference<Reference,Value>
+              , postfix_increment_proxy<Iterator>
+              , writable_postfix_increment_proxy<Iterator>
+            >
+          , mpl::identity<Iterator>
+        >
+    {};
+
+
+
+
+
+    template <class Reference, class Pointer>
+    struct operator_arrow_dispatch
+    {
+        struct proxy
+        {
+            explicit proxy(Reference const & x) : m_ref(x) {}
+            Reference* operator->() { return boost::addressof(m_ref); }
+
+
+            operator Reference*() { return boost::addressof(m_ref); }
+            Reference m_ref;
+        };
+        typedef proxy result_type;
+        static result_type apply(Reference const & x)
+        {
+            return result_type(x);
+        }
+    };
+
+    template <class T, class Pointer>
+    struct operator_arrow_dispatch<T&, Pointer>
+    {
+        typedef Pointer result_type;
+        static result_type apply(T& x)
+        {
+            return boost::addressof(x);
+        }
+    };
+
+
+
+
+    template <class Iterator>
+    class operator_brackets_proxy
+    {
+
+
+        typedef typename Iterator::reference reference;
+        typedef typename Iterator::value_type value_type;
+
+     public:
+        operator_brackets_proxy(Iterator const& iter)
+          : m_iter(iter)
+        {}
+
+        operator reference() const
+        {
+            return *m_iter;
+        }
+
+        operator_brackets_proxy& operator=(value_type const& val)
+        {
+            *m_iter = val;
+            return *this;
+        }
+
+     private:
+        Iterator m_iter;
+    };
+
+
+
+    template <class ValueType, class Reference>
+    struct use_operator_brackets_proxy
+      : mpl::not_<
+            mpl::and_<
+
+
+                boost::is_POD<ValueType>
+              , iterator_writability_disabled<ValueType,Reference>
+            >
+        >
+    {};
+
+    template <class Iterator, class Value, class Reference>
+    struct operator_brackets_result
+    {
+        typedef typename mpl::if_<
+            use_operator_brackets_proxy<Value,Reference>
+          , operator_brackets_proxy<Iterator>
+          , Value
+        >::type type;
+    };
+
+    template <class Iterator>
+    operator_brackets_proxy<Iterator> make_operator_brackets_result(Iterator const& iter, mpl::true_)
+    {
+        return operator_brackets_proxy<Iterator>(iter);
+    }
+
+    template <class Iterator>
+    typename Iterator::value_type make_operator_brackets_result(Iterator const& iter, mpl::false_)
+    {
+      return *iter;
+    }
+
+    struct choose_difference_type
+    {
+        template <class I1, class I2>
+        struct apply
+          :
+
+
+
+          mpl::eval_if<
+              is_convertible<I2,I1>
+            , iterator_difference<I1>
+            , iterator_difference<I2>
+          >
+
+        {};
+
+    };
+
+    template <
+        class Derived
+      , class Value
+      , class CategoryOrTraversal
+      , class Reference
+      , class Difference
+      , bool IsBidirectionalTraversal
+      , bool IsRandomAccessTraversal
+    >
+    class iterator_facade_base;
+
+  }
+# 461 "/usr/include/boost/iterator/iterator_facade.hpp" 3 4
+#define BOOST_ITERATOR_FACADE_INTEROP_HEAD_IMPL(prefix,op,result_type,enabler) template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > prefix typename enabler< Derived1, Derived2 , typename mpl::apply2<result_type,Derived1,Derived2>::type >::type operator op( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs)
+# 475 "/usr/include/boost/iterator/iterator_facade.hpp" 3 4
+#define BOOST_ITERATOR_FACADE_INTEROP_HEAD(prefix,op,result_type) BOOST_ITERATOR_FACADE_INTEROP_HEAD_IMPL(prefix, op, result_type, boost::iterators::detail::enable_if_interoperable)
+
+
+#define BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS_HEAD(prefix,op,result_type) BOOST_ITERATOR_FACADE_INTEROP_HEAD_IMPL(prefix, op, result_type, boost::iterators::detail::enable_if_interoperable_and_random_access_traversal)
+
+
+#define BOOST_ITERATOR_FACADE_PLUS_HEAD(prefix,args) template <class Derived, class V, class TC, class R, class D> prefix typename boost::iterators::enable_if< boost::iterators::detail::is_traversal_at_least< TC, boost::iterators::random_access_traversal_tag >, Derived >::type operator+ args
+# 497 "/usr/include/boost/iterator/iterator_facade.hpp" 3 4
+  class iterator_core_access
+  {
+
+
+
+
+
+
+      template <class I, class V, class TC, class R, class D> friend class iterator_facade;
+      template <class I, class V, class TC, class R, class D, bool IsBidirectionalTraversal, bool IsRandomAccessTraversal>
+      friend class detail::iterator_facade_base;
+
+#define BOOST_ITERATOR_FACADE_RELATION(op) BOOST_ITERATOR_FACADE_INTEROP_HEAD(friend,op, boost::iterators::detail::always_bool2);
+
+
+      template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > friend typename boost::iterators::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::iterators::detail::always_bool2,Derived1,Derived2>::type >::type operator ==( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs);
+      template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > friend typename boost::iterators::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::iterators::detail::always_bool2,Derived1,Derived2>::type >::type operator !=( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs);
+
+#undef BOOST_ITERATOR_FACADE_RELATION
+
+#define BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(op) BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS_HEAD(friend,op, boost::iterators::detail::always_bool2);
+
+
+      template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > friend typename boost::iterators::detail::enable_if_interoperable_and_random_access_traversal< Derived1, Derived2 , typename mpl::apply2<boost::iterators::detail::always_bool2,Derived1,Derived2>::type >::type operator <( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs);
+      template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > friend typename boost::iterators::detail::enable_if_interoperable_and_random_access_traversal< Derived1, Derived2 , typename mpl::apply2<boost::iterators::detail::always_bool2,Derived1,Derived2>::type >::type operator >( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs);
+      template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > friend typename boost::iterators::detail::enable_if_interoperable_and_random_access_traversal< Derived1, Derived2 , typename mpl::apply2<boost::iterators::detail::always_bool2,Derived1,Derived2>::type >::type operator <=( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs);
+      template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > friend typename boost::iterators::detail::enable_if_interoperable_and_random_access_traversal< Derived1, Derived2 , typename mpl::apply2<boost::iterators::detail::always_bool2,Derived1,Derived2>::type >::type operator >=( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs);
+
+#undef BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION
+
+      template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > friend typename boost::iterators::detail::enable_if_interoperable_and_random_access_traversal< Derived1, Derived2 , typename mpl::apply2<boost::iterators::detail::choose_difference_type,Derived1,Derived2>::type >::type operator -( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs)
+
+      ;
+
+      template <class Derived, class V, class TC, class R, class D> friend inline typename boost::iterators::enable_if< boost::iterators::detail::is_traversal_at_least< TC, boost::iterators::random_access_traversal_tag >, Derived >::type operator+ (iterator_facade<Derived, V, TC, R, D> const& , typename Derived::difference_type)
+
+
+
+
+      ;
+
+      template <class Derived, class V, class TC, class R, class D> friend inline typename boost::iterators::enable_if< boost::iterators::detail::is_traversal_at_least< TC, boost::iterators::random_access_traversal_tag >, Derived >::type operator+ (typename Derived::difference_type , iterator_facade<Derived, V, TC, R, D> const&)
+
+
+
+
+      ;
+
+
+
+      template <class Facade>
+      static typename Facade::reference dereference(Facade const& f)
+      {
+          return f.dereference();
+      }
+
+      template <class Facade>
+      static void increment(Facade& f)
+      {
+          f.increment();
+      }
+
+      template <class Facade>
+      static void decrement(Facade& f)
+      {
+          f.decrement();
+      }
+
+      template <class Facade1, class Facade2>
+      static bool equal(Facade1 const& f1, Facade2 const& f2, mpl::true_)
+      {
+          return f1.equal(f2);
+      }
+
+      template <class Facade1, class Facade2>
+      static bool equal(Facade1 const& f1, Facade2 const& f2, mpl::false_)
+      {
+          return f2.equal(f1);
+      }
+
+      template <class Facade>
+      static void advance(Facade& f, typename Facade::difference_type n)
+      {
+          f.advance(n);
+      }
+
+      template <class Facade1, class Facade2>
+      static typename Facade1::difference_type distance_from(
+          Facade1 const& f1, Facade2 const& f2, mpl::true_)
+      {
+          return -f1.distance_to(f2);
+      }
+
+      template <class Facade1, class Facade2>
+      static typename Facade2::difference_type distance_from(
+          Facade1 const& f1, Facade2 const& f2, mpl::false_)
+      {
+          return f2.distance_to(f1);
+      }
+
+
+
+
+      template <class I, class V, class TC, class R, class D>
+      static I& derived(iterator_facade<I,V,TC,R,D>& facade)
+      {
+          return *static_cast<I*>(&facade);
+      }
+
+      template <class I, class V, class TC, class R, class D>
+      static I const& derived(iterator_facade<I,V,TC,R,D> const& facade)
+      {
+          return *static_cast<I const*>(&facade);
+      }
+
+
+      iterator_core_access() = delete;
+  };
+
+  namespace detail {
+
+
+    template <
+        class Derived
+      , class Value
+      , class CategoryOrTraversal
+      , class Reference
+      , class Difference
+    >
+    class iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, false, false >
+
+
+
+
+
+
+    {
+    private:
+        typedef boost::iterators::detail::iterator_facade_types<
+            Value, CategoryOrTraversal, Reference, Difference
+        > associated_types;
+
+        typedef boost::iterators::detail::operator_arrow_dispatch<
+            Reference
+          , typename associated_types::pointer
+        > operator_arrow_dispatch_;
+
+    public:
+        typedef typename associated_types::value_type value_type;
+        typedef Reference reference;
+        typedef Difference difference_type;
+
+        typedef typename operator_arrow_dispatch_::result_type pointer;
+
+        typedef typename associated_types::iterator_category iterator_category;
+
+    public:
+        reference operator*() const
+        {
+            return iterator_core_access::dereference(this->derived());
+        }
+
+        pointer operator->() const
+        {
+            return operator_arrow_dispatch_::apply(*this->derived());
+        }
+
+        Derived& operator++()
+        {
+            iterator_core_access::increment(this->derived());
+            return this->derived();
+        }
+
+    protected:
+
+
+
+        Derived& derived()
+        {
+            return *static_cast<Derived*>(this);
+        }
+
+        Derived const& derived() const
+        {
+            return *static_cast<Derived const*>(this);
+        }
+    };
+
+
+    template <
+        class Derived
+      , class Value
+      , class CategoryOrTraversal
+      , class Reference
+      , class Difference
+    >
+    class iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, true, false > :
+        public iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, false, false >
+    {
+    public:
+        Derived& operator--()
+        {
+            iterator_core_access::decrement(this->derived());
+            return this->derived();
+        }
+
+        Derived operator--(int)
+        {
+            Derived tmp(this->derived());
+            --*this;
+            return tmp;
+        }
+    };
+
+
+    template <
+        class Derived
+      , class Value
+      , class CategoryOrTraversal
+      , class Reference
+      , class Difference
+    >
+    class iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, true, true > :
+        public iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, true, false >
+    {
+    private:
+        typedef iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, true, false > base_type;
+
+    public:
+        typedef typename base_type::reference reference;
+        typedef typename base_type::difference_type difference_type;
+
+    public:
+        typename boost::iterators::detail::operator_brackets_result<Derived, Value, reference>::type
+        operator[](difference_type n) const
+        {
+            typedef boost::iterators::detail::use_operator_brackets_proxy<Value, Reference> use_proxy;
+
+            return boost::iterators::detail::make_operator_brackets_result<Derived>(
+                this->derived() + n
+              , use_proxy()
+            );
+        }
+
+        Derived& operator+=(difference_type n)
+        {
+            iterator_core_access::advance(this->derived(), n);
+            return this->derived();
+        }
+
+        Derived& operator-=(difference_type n)
+        {
+            iterator_core_access::advance(this->derived(), -n);
+            return this->derived();
+        }
+
+        Derived operator-(difference_type x) const
+        {
+            Derived result(this->derived());
+            return result -= x;
+        }
+    };
+
+  }
+
+
+
+
+
+  template <
+      class Derived
+    , class Value
+    , class CategoryOrTraversal
+    , class Reference = Value&
+    , class Difference = std::ptrdiff_t
+  >
+  class iterator_facade :
+      public detail::iterator_facade_base<
+          Derived,
+          Value,
+          CategoryOrTraversal,
+          Reference,
+          Difference,
+          detail::is_traversal_at_least< CategoryOrTraversal, bidirectional_traversal_tag >::value,
+          detail::is_traversal_at_least< CategoryOrTraversal, random_access_traversal_tag >::value
+      >
+  {
+  protected:
+
+      typedef iterator_facade<Derived,Value,CategoryOrTraversal,Reference,Difference> iterator_facade_;
+  };
+
+  template <class I, class V, class TC, class R, class D>
+  inline typename boost::iterators::detail::postfix_increment_result<I,V,R,TC>::type
+  operator++(
+      iterator_facade<I,V,TC,R,D>& i
+    , int
+  )
+  {
+      typename boost::iterators::detail::postfix_increment_result<I,V,R,TC>::type
+          tmp(*static_cast<I*>(&i));
+
+      ++i;
+
+      return tmp;
+  }
+# 875 "/usr/include/boost/iterator/iterator_facade.hpp" 3 4
+#define BOOST_ITERATOR_CONVERTIBLE(a,b) is_convertible<a,b>()
+
+
+#define BOOST_ITERATOR_FACADE_INTEROP(op,result_type,return_prefix,base_op) BOOST_ITERATOR_FACADE_INTEROP_HEAD(inline, op, result_type) { BOOST_STATIC_ASSERT(( is_interoperable< Derived1, Derived2 >::value )); return_prefix iterator_core_access::base_op( *static_cast<Derived1 const*>(&lhs) , *static_cast<Derived2 const*>(&rhs) , BOOST_ITERATOR_CONVERTIBLE(Derived2,Derived1) ); }
+# 892 "/usr/include/boost/iterator/iterator_facade.hpp" 3 4
+#define BOOST_ITERATOR_FACADE_RELATION(op,return_prefix,base_op) BOOST_ITERATOR_FACADE_INTEROP( op , boost::iterators::detail::always_bool2 , return_prefix , base_op )
+
+
+
+
+
+
+
+  template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > inline typename boost::iterators::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::iterators::detail::always_bool2,Derived1,Derived2>::type >::type operator ==( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs) { static_assert(( is_interoperable< Derived1, Derived2 >::value ), "( is_interoperable< Derived1, Derived2 >::value )"); return iterator_core_access::equal( *static_cast<Derived1 const*>(&lhs) , *static_cast<Derived2 const*>(&rhs) , is_convertible<Derived2,Derived1>() ); }
+  template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > inline typename boost::iterators::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::iterators::detail::always_bool2,Derived1,Derived2>::type >::type operator !=( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs) { static_assert(( is_interoperable< Derived1, Derived2 >::value ), "( is_interoperable< Derived1, Derived2 >::value )"); return ! iterator_core_access::equal( *static_cast<Derived1 const*>(&lhs) , *static_cast<Derived2 const*>(&rhs) , is_convertible<Derived2,Derived1>() ); }
+
+#undef BOOST_ITERATOR_FACADE_RELATION
+
+
+#define BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS(op,result_type,return_prefix,base_op) BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS_HEAD(inline, op, result_type) { BOOST_STATIC_ASSERT(( is_interoperable< Derived1, Derived2 >::value && boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived1 >::type, random_access_traversal_tag >::value && boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived2 >::type, random_access_traversal_tag >::value )); return_prefix iterator_core_access::base_op( *static_cast<Derived1 const*>(&lhs) , *static_cast<Derived2 const*>(&rhs) , BOOST_ITERATOR_CONVERTIBLE(Derived2,Derived1) ); }
+# 922 "/usr/include/boost/iterator/iterator_facade.hpp" 3 4
+#define BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION(op,return_prefix,base_op) BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS( op , boost::iterators::detail::always_bool2 , return_prefix , base_op )
+
+
+
+
+
+
+
+  template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > inline typename boost::iterators::detail::enable_if_interoperable_and_random_access_traversal< Derived1, Derived2 , typename mpl::apply2<boost::iterators::detail::always_bool2,Derived1,Derived2>::type >::type operator <( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs) { static_assert(( is_interoperable< Derived1, Derived2 >::value && boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived1 >::type, random_access_traversal_tag >::value && boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived2 >::type, random_access_traversal_tag >::value ), "( is_interoperable< Derived1, Derived2 >::value && boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived1 >::type, random_access_traversal_tag >::value && boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived2 >::type, random_access_traversal_tag >::value )"); return 0 > iterator_core_access::distance_from( *static_cast<Derived1 const*>(&lhs) , *static_cast<Derived2 const*>(&rhs) , is_convertible<Derived2,Derived1>() ); }
+  template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > inline typename boost::iterators::detail::enable_if_interoperable_and_random_access_traversal< Derived1, Derived2 , typename mpl::apply2<boost::iterators::detail::always_bool2,Derived1,Derived2>::type >::type operator >( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs) { static_assert(( is_interoperable< Derived1, Derived2 >::value && boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived1 >::type, random_access_traversal_tag >::value && boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived2 >::type, random_access_traversal_tag >::value ), "( is_interoperable< Derived1, Derived2 >::value && boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived1 >::type, random_access_traversal_tag >::value && boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived2 >::type, random_access_traversal_tag >::value )"); return 0 < iterator_core_access::distance_from( *static_cast<Derived1 const*>(&lhs) , *static_cast<Derived2 const*>(&rhs) , is_convertible<Derived2,Derived1>() ); }
+  template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > inline typename boost::iterators::detail::enable_if_interoperable_and_random_access_traversal< Derived1, Derived2 , typename mpl::apply2<boost::iterators::detail::always_bool2,Derived1,Derived2>::type >::type operator <=( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs) { static_assert(( is_interoperable< Derived1, Derived2 >::value && boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived1 >::type, random_access_traversal_tag >::value && boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived2 >::type, random_access_traversal_tag >::value ), "( is_interoperable< Derived1, Derived2 >::value && boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived1 >::type, random_access_traversal_tag >::value && boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived2 >::type, random_access_traversal_tag >::value )"); return 0 >= iterator_core_access::distance_from( *static_cast<Derived1 const*>(&lhs) , *static_cast<Derived2 const*>(&rhs) , is_convertible<Derived2,Derived1>() ); }
+  template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > inline typename boost::iterators::detail::enable_if_interoperable_and_random_access_traversal< Derived1, Derived2 , typename mpl::apply2<boost::iterators::detail::always_bool2,Derived1,Derived2>::type >::type operator >=( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs) { static_assert(( is_interoperable< Derived1, Derived2 >::value && boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived1 >::type, random_access_traversal_tag >::value && boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived2 >::type, random_access_traversal_tag >::value ), "( is_interoperable< Derived1, Derived2 >::value && boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived1 >::type, random_access_traversal_tag >::value && boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived2 >::type, random_access_traversal_tag >::value )"); return 0 <= iterator_core_access::distance_from( *static_cast<Derived1 const*>(&lhs) , *static_cast<Derived2 const*>(&rhs) , is_convertible<Derived2,Derived1>() ); }
+
+#undef BOOST_ITERATOR_FACADE_RANDOM_ACCESS_RELATION
+
+
+  template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > inline typename boost::iterators::detail::enable_if_interoperable_and_random_access_traversal< Derived1, Derived2 , typename mpl::apply2<boost::iterators::detail::choose_difference_type,Derived1,Derived2>::type >::type operator -( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs) { static_assert(( is_interoperable< Derived1, Derived2 >::value && boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived1 >::type, random_access_traversal_tag >::value && boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived2 >::type, random_access_traversal_tag >::value ), "( is_interoperable< Derived1, Derived2 >::value && boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived1 >::type, random_access_traversal_tag >::value && boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived2 >::type, random_access_traversal_tag >::value )"); return iterator_core_access::distance_from( *static_cast<Derived1 const*>(&lhs) , *static_cast<Derived2 const*>(&rhs) , is_convertible<Derived2,Derived1>() ); }
+
+
+
+
+
+
+#undef BOOST_ITERATOR_FACADE_INTEROP
+#undef BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS
+
+#define BOOST_ITERATOR_FACADE_PLUS(args) BOOST_ITERATOR_FACADE_PLUS_HEAD(inline, args) { Derived tmp(static_cast<Derived const&>(i)); return tmp += n; }
+
+
+
+
+
+
+  template <class Derived, class V, class TC, class R, class D> inline typename boost::iterators::enable_if< boost::iterators::detail::is_traversal_at_least< TC, boost::iterators::random_access_traversal_tag >, Derived >::type operator+ ( iterator_facade<Derived, V, TC, R, D> const& i , typename Derived::difference_type n ) { Derived tmp(static_cast<Derived const&>(i)); return tmp += n; }
+
+
+
+
+  template <class Derived, class V, class TC, class R, class D> inline typename boost::iterators::enable_if< boost::iterators::detail::is_traversal_at_least< TC, boost::iterators::random_access_traversal_tag >, Derived >::type operator+ ( typename Derived::difference_type n , iterator_facade<Derived, V, TC, R, D> const& i ) { Derived tmp(static_cast<Derived const&>(i)); return tmp += n; }
+
+
+
+
+#undef BOOST_ITERATOR_FACADE_PLUS
+#undef BOOST_ITERATOR_FACADE_PLUS_HEAD
+
+#undef BOOST_ITERATOR_FACADE_INTEROP_HEAD
+#undef BOOST_ITERATOR_FACADE_INTEROP_RANDOM_ACCESS_HEAD
+#undef BOOST_ITERATOR_FACADE_INTEROP_HEAD_IMPL
+
+}
+
+using iterators::iterator_core_access;
+using iterators::iterator_facade;
+
+}
+
+# 1 "/usr/include/boost/iterator/detail/config_undef.hpp" 1 3 4
+# 14 "/usr/include/boost/iterator/detail/config_undef.hpp" 3 4
+#undef BOOST_NO_IS_CONVERTIBLE
+#undef BOOST_NO_IS_CONVERTIBLE_TEMPLATE
+#undef BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY
+#undef BOOST_NO_LVALUE_RETURN_DETECTION
+#undef BOOST_NO_ONE_WAY_ITERATOR_INTEROP
+
+
+#undef BOOST_ITERATOR_CONFIG_DEF
+# 980 "/usr/include/boost/iterator/iterator_facade.hpp" 2 3 4
+# 17 "/usr/include/boost/test/utils/iterator/input_iterator_facade.hpp" 2 3 4
+
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 19 "/usr/include/boost/test/utils/iterator/input_iterator_facade.hpp" 2 3 4
+
+
+
+namespace boost {
+namespace unit_test {
+namespace utils {
+
+
+
+
+
+class input_iterator_core_access
+{
+
+
+
+    template <class I, class V, class R, class TC> friend class input_iterator_facade;
+
+
+    template <class Facade>
+    static bool get( Facade& f )
+    {
+        return f.get();
+    }
+
+private:
+
+    input_iterator_core_access();
+};
+
+
+
+
+
+template<typename Derived,
+         typename ValueType,
+         typename Reference = ValueType const&,
+         typename Traversal = single_pass_traversal_tag>
+class input_iterator_facade : public iterator_facade<Derived,ValueType,Traversal,Reference>
+{
+public:
+
+    input_iterator_facade() : m_valid( false ), m_value() {}
+
+protected:
+    void init()
+    {
+        m_valid = true;
+        increment();
+    }
+
+
+    mutable bool m_valid;
+    ValueType m_value;
+
+private:
+    friend class boost::iterator_core_access;
+
+
+    void increment()
+    {
+
+        if( m_valid )
+            m_valid = input_iterator_core_access::get( *static_cast<Derived*>(this) );
+    }
+    Reference dereference() const
+    {
+        return m_value;
+    }
+
+
+    bool equal( input_iterator_facade const& rhs ) const
+    {
+
+        return !m_valid && !rhs.m_valid;
+    }
+};
+
+}
+}
+}
+
+
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 104 "/usr/include/boost/test/utils/iterator/input_iterator_facade.hpp" 2 3 4
+# 26 "/usr/include/boost/test/utils/iterator/token_iterator.hpp" 2 3 4
+
+# 1 "/usr/include/boost/test/utils/named_params.hpp" 1 3 4
+# 16 "/usr/include/boost/test/utils/named_params.hpp" 3 4
+#define BOOST_TEST_UTILS_NAMED_PARAM 
+
+
+
+
+
+
+
+# 1 "/usr/include/boost/test/utils/assign_op.hpp" 1 3 4
+# 16 "/usr/include/boost/test/utils/assign_op.hpp" 3 4
+#define BOOST_TEST_UTILS_ASSIGN_OP_HPP 
+
+namespace boost {
+namespace unit_test {
+
+
+
+
+
+
+template<typename T,typename S>
+inline void
+assign_op( T& t, S const& s, long )
+{
+    t = s;
+}
+
+
+
+}
+}
+# 25 "/usr/include/boost/test/utils/named_params.hpp" 2 3 4
+# 36 "/usr/include/boost/test/utils/named_params.hpp" 3 4
+# 1 "/usr/include/boost/utility/enable_if.hpp" 1 3 4
+# 10 "/usr/include/boost/utility/enable_if.hpp" 3 4
+#define BOOST_UTILITY_ENABLE_IF_HPP 
+
+
+
+
+# 1 "/usr/include/boost/core/enable_if.hpp" 1 3 4
+# 15 "/usr/include/boost/core/enable_if.hpp" 3 4
+#define BOOST_CORE_ENABLE_IF_HPP 
+# 24 "/usr/include/boost/core/enable_if.hpp" 3 4
+namespace boost
+{
+  template<typename T, typename R=void>
+  struct enable_if_has_type
+  {
+    typedef R type;
+  };
+
+  template <bool B, class T = void>
+  struct enable_if_c {
+    typedef T type;
+  };
+
+  template <class T>
+  struct enable_if_c<false, T> {};
+
+  template <class Cond, class T = void>
+  struct enable_if : public enable_if_c<Cond::value, T> {};
+
+  template <bool B, class T>
+  struct lazy_enable_if_c {
+    typedef typename T::type type;
+  };
+
+  template <class T>
+  struct lazy_enable_if_c<false, T> {};
+
+  template <class Cond, class T>
+  struct lazy_enable_if : public lazy_enable_if_c<Cond::value, T> {};
+
+
+  template <bool B, class T = void>
+  struct disable_if_c {
+    typedef T type;
+  };
+
+  template <class T>
+  struct disable_if_c<true, T> {};
+
+  template <class Cond, class T = void>
+  struct disable_if : public disable_if_c<Cond::value, T> {};
+
+  template <bool B, class T>
+  struct lazy_disable_if_c {
+    typedef typename T::type type;
+  };
+
+  template <class T>
+  struct lazy_disable_if_c<true, T> {};
+
+  template <class Cond, class T>
+  struct lazy_disable_if : public lazy_disable_if_c<Cond::value, T> {};
+
+}
+# 16 "/usr/include/boost/utility/enable_if.hpp" 2 3 4
+# 37 "/usr/include/boost/test/utils/named_params.hpp" 2 3 4
+
+
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 40 "/usr/include/boost/test/utils/named_params.hpp" 2 3 4
+
+
+
+namespace boost {
+namespace nfp {
+
+
+
+
+
+template<typename unique_id, bool required> struct keyword;
+template<typename T, typename unique_id, bool required = false> struct typed_keyword;
+
+template<typename T, typename unique_id, typename RefType=T&> struct named_parameter;
+template<typename NP1,typename NP2> struct named_parameter_combine;
+
+
+
+
+
+
+
+template<typename T>
+struct is_named_param_pack : public mpl::false_ {};
+
+template<typename T, typename unique_id, typename RefType>
+struct is_named_param_pack<named_parameter<T,unique_id,RefType> > : public mpl::true_ {};
+
+template<typename NP, typename Rest>
+struct is_named_param_pack<named_parameter_combine<NP,Rest> > : public mpl::true_ {};
+# 78 "/usr/include/boost/test/utils/named_params.hpp" 3 4
+template<typename NP, typename Keyword, typename DefaultType=void>
+struct param_type
+: mpl::if_<typename is_same<typename NP::id,typename Keyword::id>::type,
+           typename remove_cv<typename NP::data_type>::type,
+           DefaultType> {};
+
+template<typename NP, typename Rest, typename Keyword, typename DefaultType>
+struct param_type<named_parameter_combine<NP,Rest>,Keyword,DefaultType>
+: mpl::if_<typename is_same<typename NP::id,typename Keyword::id>::type,
+           typename remove_cv<typename NP::data_type>::type,
+           typename param_type<Rest,Keyword,DefaultType>::type> {};
+# 97 "/usr/include/boost/test/utils/named_params.hpp" 3 4
+template<typename NP, typename Keyword>
+struct has_param : is_same<typename NP::id,typename Keyword::id> {};
+
+template<typename NP, typename Rest, typename Keyword>
+struct has_param<named_parameter_combine<NP,Rest>,Keyword>
+: mpl::or_<typename is_same<typename NP::id,typename Keyword::id>::type,
+           typename has_param<Rest,Keyword>::type> {};
+
+
+
+
+
+namespace nfp_detail {
+
+struct access_to_invalid_parameter {};
+
+
+
+inline void
+report_access_to_invalid_parameter( bool v )
+{
+    if( !v ) {} else unit_test::ut_detail::throw_exception( access_to_invalid_parameter() );
+}
+
+}
+
+
+
+
+
+struct nil {
+    template<typename T>
+
+    operator T() const
+
+
+
+    { nfp_detail::report_access_to_invalid_parameter(true); static T* v = 0; return *v; }
+
+    template<typename T>
+    T any_cast() const
+    { nfp_detail::report_access_to_invalid_parameter(true); static typename remove_reference<T>::type* v = 0; return *v; }
+
+    template<typename Arg1>
+    nil operator()( Arg1 const& )
+    { nfp_detail::report_access_to_invalid_parameter(true); return nil(); }
+
+    template<typename Arg1,typename Arg2>
+    nil operator()( Arg1 const&, Arg2 const& )
+    { nfp_detail::report_access_to_invalid_parameter(true); return nil(); }
+
+    template<typename Arg1,typename Arg2,typename Arg3>
+    nil operator()( Arg1 const&, Arg2 const&, Arg3 const& )
+    { nfp_detail::report_access_to_invalid_parameter(true); return nil(); }
+
+
+    template<typename Visitor>
+    void apply_to( Visitor& ) const {}
+
+    static nil& inst() { static nil s_inst; return s_inst; }
+private:
+    nil() {}
+};
+
+
+
+
+
+namespace nfp_detail {
+
+template<typename Derived>
+struct named_parameter_base {
+    template<typename NP>
+    named_parameter_combine<NP,Derived>
+    operator,( NP const& np ) const { return named_parameter_combine<NP,Derived>( np, *static_cast<Derived const*>(this) ); }
+};
+
+}
+
+
+
+
+
+template<typename NP, typename Rest = nil>
+struct named_parameter_combine
+: Rest
+, nfp_detail::named_parameter_base<named_parameter_combine<NP,Rest> > {
+    typedef typename NP::ref_type res_type;
+    typedef named_parameter_combine<NP,Rest> self_type;
+
+
+    named_parameter_combine( NP const& np, Rest const& r )
+    : Rest( r )
+    , m_param( np )
+    {
+    }
+
+
+    res_type operator[]( keyword<typename NP::id,true> kw ) const { return m_param[kw]; }
+    res_type operator[]( keyword<typename NP::id,false> kw ) const { return m_param[kw]; }
+    using Rest::operator[];
+
+    bool has( keyword<typename NP::id,false> kw ) const { return m_param.has( kw ); }
+    using Rest::has;
+
+    void erase( keyword<typename NP::id,false> kw ) const { m_param.erase( kw ); }
+    using Rest::erase;
+
+    using nfp_detail::named_parameter_base<named_parameter_combine<NP,Rest> >::operator,;
+
+
+    template<typename Visitor>
+    void apply_to( Visitor& V ) const
+    {
+        m_param.apply_to( V );
+
+        Rest::apply_to( V );
+    }
+private:
+
+    NP m_param;
+};
+
+
+
+
+
+template<typename T, typename unique_id, typename RefType>
+struct named_parameter
+: nfp_detail::named_parameter_base<named_parameter<T,unique_id,RefType> >
+{
+    typedef T data_type;
+    typedef RefType ref_type;
+    typedef unique_id id;
+
+
+    explicit named_parameter( ref_type v )
+    : m_value( v )
+    , m_erased( false )
+    {}
+    named_parameter( named_parameter const& np )
+    : m_value( np.m_value )
+    , m_erased( np.m_erased )
+    {}
+
+
+    ref_type operator[]( keyword<unique_id,true> ) const { return m_erased ? nil::inst().template any_cast<ref_type>() : m_value; }
+    ref_type operator[]( keyword<unique_id,false> ) const { return m_erased ? nil::inst().template any_cast<ref_type>() : m_value; }
+    template<typename UnknownId>
+    nil operator[]( keyword<UnknownId,false> ) const { return nil::inst(); }
+
+    bool has( keyword<unique_id,false> ) const { return !m_erased; }
+    template<typename UnknownId>
+    bool has( keyword<UnknownId,false> ) const { return false; }
+
+    void erase( keyword<unique_id,false> ) const { m_erased = true; }
+    template<typename UnknownId>
+    void erase( keyword<UnknownId,false> ) const {}
+
+
+    template<typename Visitor>
+    void apply_to( Visitor& V ) const
+    {
+        V.set_parameter( rtti::type_id<unique_id>(), m_value );
+    }
+
+private:
+
+    ref_type m_value;
+    mutable bool m_erased;
+};
+
+
+
+
+
+typedef named_parameter<char, struct no_params_type_t,char> no_params_type;
+
+namespace {
+no_params_type no_params( '\0' );
+}
+
+
+
+
+
+template<typename unique_id, bool required = false>
+struct keyword {
+    typedef unique_id id;
+
+    template<typename T>
+    named_parameter<T const,unique_id>
+    operator=( T const& t ) const { return named_parameter<T const,unique_id>( t ); }
+
+    template<typename T>
+    named_parameter<T,unique_id>
+    operator=( T& t ) const { return named_parameter<T,unique_id>( t ); }
+
+    named_parameter<char const*,unique_id,char const*>
+    operator=( char const* t ) const { return named_parameter<char const*,unique_id,char const*>( t ); }
+};
+
+
+
+
+
+
+
+template<typename T, typename unique_id, bool required>
+struct typed_keyword : keyword<unique_id,required> {
+    named_parameter<T const,unique_id>
+    operator=( T const& t ) const { return named_parameter<T const,unique_id>( t ); }
+
+    named_parameter<T,unique_id>
+    operator=( T& t ) const { return named_parameter<T,unique_id>( t ); }
+};
+
+
+
+template<typename unique_id, bool required>
+struct typed_keyword<bool,unique_id,required>
+: keyword<unique_id,required>
+, named_parameter<bool,unique_id,bool> {
+    typedef unique_id id;
+
+    typed_keyword() : named_parameter<bool,unique_id,bool>( true ) {}
+
+    named_parameter<bool,unique_id,bool>
+    operator!() const { return named_parameter<bool,unique_id,bool>( false ); }
+};
+
+
+
+
+
+template<typename T, typename Params, typename Keyword>
+inline typename enable_if_c<!has_param<Params,Keyword>::value,void>::type
+opt_assign( T& , Params const& , Keyword )
+{
+}
+
+
+
+template<typename T, typename Params, typename Keyword>
+inline typename enable_if_c<has_param<Params,Keyword>::value,void>::type
+opt_assign( T& target, Params const& p, Keyword k )
+{
+    using namespace unit_test;
+
+    assign_op( target, p[k], static_cast<int>(0) );
+}
+
+
+
+
+
+template<typename T, typename Params, typename Keyword>
+inline T
+opt_get( Params const& p, Keyword k, T default_val )
+{
+    opt_assign( default_val, p, k );
+
+    return default_val;
+}
+
+
+
+
+
+template<typename Params, typename NP>
+inline typename enable_if_c<!has_param<Params,keyword<typename NP::id> >::value,
+named_parameter_combine<NP,Params> >::type
+opt_append( Params const& params, NP const& np )
+{
+    return (params,np);
+}
+
+
+
+template<typename Params, typename NP>
+inline typename enable_if_c<has_param<Params,keyword<typename NP::id> >::value,Params>::type
+opt_append( Params const& params, NP const& )
+{
+    return params;
+}
+
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 387 "/usr/include/boost/test/utils/named_params.hpp" 2 3 4
+# 28 "/usr/include/boost/test/utils/iterator/token_iterator.hpp" 2 3 4
+
+
+
+
+# 1 "/usr/include/c++/10.2.0/cctype" 1 3 4
+# 39 "/usr/include/c++/10.2.0/cctype" 3 4
+       
+# 40 "/usr/include/c++/10.2.0/cctype" 3
+# 33 "/usr/include/boost/test/utils/iterator/token_iterator.hpp" 2 3 4
+
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 35 "/usr/include/boost/test/utils/iterator/token_iterator.hpp" 2 3 4
+
+
+
+
+
+
+
+namespace boost {
+namespace unit_test {
+namespace utils {
+
+
+
+
+
+enum ti_delimeter_type {
+    dt_char,
+    dt_ispunct,
+    dt_isspace,
+    dt_none
+};
+
+namespace ut_detail {
+
+
+
+
+
+template<typename CharT>
+class default_char_compare {
+public:
+    bool operator()( CharT c1, CharT c2 )
+    {
+
+
+
+        return std::char_traits<CharT>::eq( c1, c2 );
+
+    }
+};
+
+
+
+
+
+template<typename CharT,typename CharCompare>
+class delim_policy {
+    typedef basic_cstring<CharT const> cstring;
+public:
+
+    explicit delim_policy( ti_delimeter_type type_ = dt_char, cstring delimeters_ = cstring() )
+    : m_type( type_ )
+    {
+        set_delimeters( delimeters_ );
+    }
+
+    void set_delimeters( ti_delimeter_type type_ ) { m_type = type_; }
+    void set_delimeters( cstring delimeters_ )
+    {
+        m_delimeters = delimeters_;
+
+        if( !m_delimeters.is_empty() )
+            m_type = dt_char;
+    }
+    void set_delimeters( nfp::nil ) {}
+    bool operator()( CharT c )
+    {
+        switch( m_type ) {
+        case dt_char: {
+            if( ::boost::unit_test::for_each::static_any_t _fe_cur_104 = ::boost::unit_test::for_each::begin( m_delimeters, ::boost::unit_test::for_each::is_const_coll( m_delimeters ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_104 = ::boost::unit_test::for_each::end( m_delimeters, ::boost::unit_test::for_each::is_const_coll( m_delimeters ) ) ) {} else for( bool _fe_con_104 = true; _fe_con_104 && !::boost::unit_test::for_each::done( _fe_cur_104, _fe_end_104, m_delimeters, ::boost::unit_test::for_each::is_const_coll( m_delimeters ) ); _fe_con_104 ? ::boost::unit_test::for_each::next( _fe_cur_104, m_delimeters, ::boost::unit_test::for_each::is_const_coll( m_delimeters ) ) : ((void)&(m_delimeters))) if( (_fe_con_104 = false, false) ) {} else for( CharT delim = ::boost::unit_test::for_each::deref( _fe_cur_104, m_delimeters, ::boost::type<CharT >(), ::boost::unit_test::for_each::is_const_coll( m_delimeters ) ); !_fe_con_104; _fe_con_104 = true )
+                if( CharCompare()( delim, c ) )
+                    return true;
+
+            return false;
+        }
+        case dt_ispunct:
+            return (std::ispunct)( c ) != 0;
+        case dt_isspace:
+            return (std::isspace)( c ) != 0;
+        case dt_none:
+            return false;
+        }
+
+        return false;
+    }
+
+private:
+
+    cstring m_delimeters;
+    ti_delimeter_type m_type;
+};
+
+
+
+
+
+template<typename TraversalTag>
+struct token_assigner {
+# 141 "/usr/include/boost/test/utils/iterator/token_iterator.hpp" 3 4
+    template<typename Iterator, typename Token>
+    static void assign( Iterator b, Iterator e, Token& t ) { t.assign( b, e ); }
+
+    template<typename Iterator, typename Token>
+    static void append_move( Iterator& b, Token& ) { ++b; }
+};
+
+
+
+template<>
+struct token_assigner<single_pass_traversal_tag> {
+    template<typename Iterator, typename Token>
+    static void assign( Iterator , Iterator , Token& ) {}
+
+    template<typename Iterator, typename Token>
+    static void append_move( Iterator& b, Token& t ) { t += *b; ++b; }
+};
+
+}
+
+
+
+
+
+namespace {
+nfp::keyword<struct dropped_delimeters_t > dropped_delimeters;
+nfp::keyword<struct kept_delimeters_t > kept_delimeters;
+nfp::typed_keyword<bool,struct keep_empty_tokens_t > keep_empty_tokens;
+nfp::typed_keyword<std::size_t,struct max_tokens_t > max_tokens;
+}
+
+
+
+
+
+template<typename Derived,
+         typename CharT,
+         typename CharCompare = ut_detail::default_char_compare<CharT>,
+         typename ValueType = basic_cstring<CharT const>,
+         typename Reference = basic_cstring<CharT const>,
+         typename Traversal = forward_traversal_tag>
+class token_iterator_base
+: public input_iterator_facade<Derived,ValueType,Reference,Traversal> {
+    typedef basic_cstring<CharT const> cstring;
+    typedef ut_detail::delim_policy<CharT,CharCompare> delim_policy;
+    typedef input_iterator_facade<Derived,ValueType,Reference,Traversal> base;
+
+protected:
+
+    explicit token_iterator_base()
+    : m_is_dropped( dt_isspace )
+    , m_is_kept( dt_ispunct )
+    , m_keep_empty_tokens( false )
+    , m_tokens_left( static_cast<std::size_t>(-1) )
+    , m_token_produced( false )
+    {
+    }
+
+    template<typename Modifier>
+    void
+    apply_modifier( Modifier const& m )
+    {
+        if( m.has( dropped_delimeters ) )
+            m_is_dropped.set_delimeters( m[dropped_delimeters] );
+
+        if( m.has( kept_delimeters ) )
+            m_is_kept.set_delimeters( m[kept_delimeters] );
+
+        if( m.has( keep_empty_tokens ) )
+            m_keep_empty_tokens = true;
+
+        nfp::opt_assign( m_tokens_left, m, max_tokens );
+    }
+
+    template<typename Iter>
+    bool get( Iter& begin, Iter end )
+    {
+        typedef ut_detail::token_assigner<typename iterator_traversal<Iter>::type> Assigner;
+        Iter check_point;
+
+        this->m_value.clear();
+
+        if( !m_keep_empty_tokens ) {
+            while( begin != end && m_is_dropped( *begin ) )
+                ++begin;
+
+            if( begin == end )
+                return false;
+
+            check_point = begin;
+
+            if( m_tokens_left == 1 )
+                while( begin != end )
+                    Assigner::append_move( begin, this->m_value );
+            else if( m_is_kept( *begin ) )
+                Assigner::append_move( begin, this->m_value );
+            else
+                while( begin != end && !m_is_dropped( *begin ) && !m_is_kept( *begin ) )
+                    Assigner::append_move( begin, this->m_value );
+
+            --m_tokens_left;
+        }
+        else {
+            check_point = begin;
+
+            if( begin == end ) {
+                if( m_token_produced )
+                    return false;
+
+                m_token_produced = true;
+            }
+            if( m_is_kept( *begin ) ) {
+                if( m_token_produced )
+                    Assigner::append_move( begin, this->m_value );
+
+                m_token_produced = !m_token_produced;
+            }
+            else if( !m_token_produced && m_is_dropped( *begin ) )
+                m_token_produced = true;
+            else {
+                if( m_is_dropped( *begin ) )
+                    check_point = ++begin;
+
+                while( begin != end && !m_is_dropped( *begin ) && !m_is_kept( *begin ) )
+                    Assigner::append_move( begin, this->m_value );
+
+                m_token_produced = true;
+            }
+        }
+
+        Assigner::assign( check_point, begin, this->m_value );
+
+        return true;
+    }
+
+private:
+
+    delim_policy m_is_dropped;
+    delim_policy m_is_kept;
+    bool m_keep_empty_tokens;
+    std::size_t m_tokens_left;
+    bool m_token_produced;
+};
+
+
+
+
+
+template<typename CharT,
+         typename CharCompare = ut_detail::default_char_compare<CharT> >
+class basic_string_token_iterator
+: public token_iterator_base<basic_string_token_iterator<CharT,CharCompare>,CharT,CharCompare> {
+    typedef basic_cstring<CharT const> cstring;
+    typedef token_iterator_base<basic_string_token_iterator<CharT,CharCompare>,CharT,CharCompare> base;
+public:
+    explicit basic_string_token_iterator() {}
+    explicit basic_string_token_iterator( cstring src )
+    : m_src( src )
+    {
+        this->init();
+    }
+
+
+
+
+
+    template<typename Modifier>
+    basic_string_token_iterator( cstring src, Modifier const& m )
+    : m_src( src )
+    {
+        this->apply_modifier( m );
+
+        this->init();
+    }
+
+private:
+    friend class input_iterator_core_access;
+
+
+    bool get()
+    {
+        typename cstring::iterator begin = m_src.begin();
+        bool res = base::get( begin, m_src.end() );
+
+        m_src.assign( begin, m_src.end() );
+
+        return res;
+    }
+
+
+    cstring m_src;
+};
+
+typedef basic_string_token_iterator<char> string_token_iterator;
+typedef basic_string_token_iterator<wchar_t> wstring_token_iterator;
+
+
+
+
+
+template<typename Iter,
+         typename CharCompare = ut_detail::default_char_compare<typename iterator_value<Iter>::type>,
+         typename ValueType = std::basic_string<typename iterator_value<Iter>::type>,
+         typename Reference = ValueType const&>
+class range_token_iterator
+: public token_iterator_base<range_token_iterator<Iter,CharCompare,ValueType,Reference>,
+                             typename iterator_value<Iter>::type,CharCompare,ValueType,Reference> {
+    typedef basic_cstring<typename ValueType::value_type> cstring;
+    typedef token_iterator_base<range_token_iterator<Iter,CharCompare,ValueType,Reference>,
+                                typename iterator_value<Iter>::type,CharCompare,ValueType,Reference> base;
+public:
+    explicit range_token_iterator() {}
+    explicit range_token_iterator( Iter begin, Iter end = Iter() )
+    : m_begin( begin ), m_end( end )
+    {
+        this->init();
+    }
+    range_token_iterator( range_token_iterator const& rhs )
+    : base( rhs )
+    {
+        if( this->m_valid ) {
+            m_begin = rhs.m_begin;
+            m_end = rhs.m_end;
+        }
+    }
+
+    template<typename Modifier>
+    range_token_iterator( Iter begin, Iter end, Modifier const& m )
+    : m_begin( begin ), m_end( end )
+    {
+        this->apply_modifier( m );
+
+        this->init();
+    }
+
+private:
+    friend class input_iterator_core_access;
+
+
+    bool get()
+    {
+        return base::get( m_begin, m_end );
+    }
+
+
+    Iter m_begin;
+    Iter m_end;
+};
+
+
+
+
+
+template<typename Iter>
+inline range_token_iterator<Iter>
+make_range_token_iterator( Iter begin, Iter end = Iter() )
+{
+    return range_token_iterator<Iter>( begin, end );
+}
+
+
+
+template<typename Iter,typename Modifier>
+inline range_token_iterator<Iter>
+make_range_token_iterator( Iter begin, Iter end, Modifier const& m )
+{
+    return range_token_iterator<Iter>( begin, end, m );
+}
+
+
+
+}
+}
+}
+
+
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 419 "/usr/include/boost/test/utils/iterator/token_iterator.hpp" 2 3 4
+# 21 "/usr/include/boost/test/impl/decorator.ipp" 2 3 4
+
+
+
+
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 26 "/usr/include/boost/test/impl/decorator.ipp" 2 3 4
+
+
+
+namespace boost {
+namespace unit_test {
+namespace decorator {
+
+
+
+
+
+
+collector_t& collector_t::instance() { static collector_t the_inst; return the_inst; }
+
+
+collector_t&
+collector_t::operator*( base const& d )
+{
+    m_tu_decorators_stack.begin()->push_back( d.clone() );
+
+    return *this;
+}
+
+
+
+void
+collector_t::store_in( test_unit& tu )
+{
+    tu.p_decorators.value.insert(
+        tu.p_decorators.value.end(),
+        m_tu_decorators_stack.begin()->begin(),
+        m_tu_decorators_stack.begin()->end() );
+}
+
+
+
+void
+collector_t::reset()
+{
+    if(m_tu_decorators_stack.size() > 1) {
+        m_tu_decorators_stack.erase(m_tu_decorators_stack.begin());
+    }
+    else {
+        (static_cast <bool> (m_tu_decorators_stack.size() == 1) ? void (0) : __assert_fail ("m_tu_decorators_stack.size() == 1", "/usr/include/boost/test/impl/decorator.ipp", 69, __extension__ __PRETTY_FUNCTION__));
+        m_tu_decorators_stack.begin()->clear();
+    }
+}
+
+void
+collector_t::stack()
+{
+    (static_cast <bool> (m_tu_decorators_stack.size() >= 1) ? void (0) : __assert_fail ("m_tu_decorators_stack.size() >= 1", "/usr/include/boost/test/impl/decorator.ipp", 77, __extension__ __PRETTY_FUNCTION__));
+    m_tu_decorators_stack.insert(m_tu_decorators_stack.begin(), std::vector<base_ptr>());
+}
+
+
+
+std::vector<base_ptr>
+collector_t::get_lazy_decorators() const
+{
+    return *m_tu_decorators_stack.begin();
+}
+
+
+
+
+
+
+
+collector_t&
+base::operator*() const
+{
+    return collector_t::instance() * *this;
+}
+
+
+
+
+
+collector_t&
+stack_decorator::operator*() const
+{
+    collector_t& instance = collector_t::instance();
+    instance.stack();
+    return instance * *this;
+}
+
+void
+stack_decorator::apply( test_unit& )
+{
+
+}
+
+
+
+
+
+void
+label::apply( test_unit& tu )
+{
+    tu.add_label( m_label );
+}
+
+
+
+
+
+
+
+void
+expected_failures::apply( test_unit& tu )
+{
+    tu.increase_exp_fail( m_exp_fail );
+}
+
+
+
+
+
+
+
+void
+timeout::apply( test_unit& tu )
+{
+    tu.p_timeout.value = m_timeout;
+}
+
+
+
+
+
+
+
+void
+description::apply( test_unit& tu )
+{
+    tu.p_description.value += m_description;
+}
+
+
+
+
+
+
+
+void
+depends_on::apply( test_unit& tu )
+{
+
+
+
+    utils::string_token_iterator tit( m_dependency, (utils::dropped_delimeters = "/", utils::kept_delimeters = utils::dt_none) );
+
+    test_unit* dep = &framework::master_test_suite();
+    while( tit != utils::string_token_iterator() ) {
+        if( dep->p_type == TUT_SUITE ) {} else unit_test::ut_detail::throw_exception( unit_test::framework::setup_error( std::string( "incorrect dependency specification " ) + m_dependency ) );
+
+        test_unit_id next_id = static_cast<test_suite*>(dep)->get( *tit );
+
+        if( next_id != INV_TEST_UNIT_ID ) {} else unit_test::ut_detail::throw_exception( unit_test::framework::setup_error( std::string( "incorrect dependency specification " ) + m_dependency ) )
+                                                                                                      ;
+
+        dep = &framework::get( next_id, TUT_ANY );
+        ++tit;
+    }
+
+    tu.depends_on( dep );
+
+}
+
+
+
+
+
+
+
+void
+enable_if_impl::apply_impl( test_unit& tu, bool condition )
+{
+    if( tu.p_default_status == test_unit::RS_INHERIT ) {} else unit_test::ut_detail::throw_exception( unit_test::framework::setup_error( "Can't apply multiple enabled/disabled decorators " "to the same test unit " + tu.full_name() ) )
+
+                                                                      ;
+
+    tu.p_default_status.value = condition ? test_unit::RS_ENABLED : test_unit::RS_DISABLED;
+}
+
+
+
+
+
+
+
+void
+fixture_t::apply( test_unit& tu )
+{
+    tu.p_fixtures.value.push_back( m_impl );
+}
+
+
+
+
+
+
+
+void
+precondition::apply( test_unit& tu )
+{
+    tu.add_precondition( m_precondition );
+}
+
+
+
+}
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 243 "/usr/include/boost/test/impl/decorator.ipp" 2 3 4
+# 22 "/usr/include/boost/test/included/unit_test.hpp" 2 3 4
+# 1 "/usr/include/boost/test/impl/framework.ipp" 1 3 4
+# 16 "/usr/include/boost/test/impl/framework.ipp" 3 4
+#define BOOST_TEST_FRAMEWORK_IPP_021005GER 
+
+
+
+
+
+
+
+# 1 "/usr/include/boost/test/unit_test_log.hpp" 1 3 4
+# 15 "/usr/include/boost/test/unit_test_log.hpp" 3 4
+#define BOOST_TEST_UNIT_TEST_LOG_HPP_071894GER 
+# 32 "/usr/include/boost/test/unit_test_log.hpp" 3 4
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 33 "/usr/include/boost/test/unit_test_log.hpp" 2 3 4
+
+
+
+namespace boost {
+namespace unit_test {
+
+
+
+
+
+namespace log {
+
+struct __attribute__((__visibility__("default"))) begin {
+    begin( const_string fn, std::size_t ln )
+    : m_file_name( fn )
+    , m_line_num( ln )
+    {}
+
+    const_string m_file_name;
+    std::size_t m_line_num;
+};
+
+struct end {};
+
+}
+
+
+
+
+
+namespace ut_detail {
+
+class __attribute__((__visibility__("default"))) entry_value_collector {
+public:
+
+    entry_value_collector() : m_last( true ) {}
+    entry_value_collector( entry_value_collector const& rhs ) : m_last( true ) { rhs.m_last = false; }
+    ~entry_value_collector();
+
+
+    entry_value_collector const& operator<<( lazy_ostream const& ) const;
+    entry_value_collector const& operator<<( const_string ) const;
+
+private:
+
+    mutable bool m_last;
+};
+
+}
+# 111 "/usr/include/boost/test/unit_test_log.hpp" 3 4
+class __attribute__((__visibility__("default"))) unit_test_log_t : public test_observer {
+public:
+
+    virtual void test_start( counter_t test_cases_amount );
+    virtual void test_finish();
+    virtual void test_aborted();
+
+    virtual void test_unit_start( test_unit const& );
+    virtual void test_unit_finish( test_unit const&, unsigned long elapsed );
+    virtual void test_unit_skipped( test_unit const&, const_string );
+    virtual void test_unit_aborted( test_unit const& );
+    virtual void test_unit_timed_out( test_unit const& );
+
+    virtual void exception_caught( execution_exception const& ex );
+
+    virtual int priority() { return 2; }
+
+
+
+
+
+    void set_stream( std::ostream& );
+
+
+
+
+
+    void set_stream( output_format, std::ostream& );
+
+
+
+
+
+    std::ostream* get_stream( output_format ) const;
+
+
+
+
+
+    void set_threshold_level( log_level );
+
+
+
+
+
+    void set_threshold_level( output_format, log_level );
+
+
+
+
+
+
+    void add_format( output_format );
+
+
+
+
+    void set_format( output_format );
+
+
+
+
+
+    unit_test_log_formatter* get_formatter( output_format );
+# 190 "/usr/include/boost/test/unit_test_log.hpp" 3 4
+    void set_formatter( unit_test_log_formatter* );
+# 204 "/usr/include/boost/test/unit_test_log.hpp" 3 4
+    void add_formatter( unit_test_log_formatter* the_formatter );
+
+
+    void set_checkpoint( const_string file, std::size_t line_num, const_string msg = const_string() );
+
+
+    unit_test_log_t& operator<<( log::begin const& );
+    unit_test_log_t& operator<<( log::end const& );
+    unit_test_log_t& operator<<( log_level );
+    unit_test_log_t& operator<<( const_string );
+    unit_test_log_t& operator<<( lazy_ostream const& );
+
+    ut_detail::entry_value_collector operator()( log_level );
+
+private:
+
+    bool log_entry_start(output_format log_format);
+    void log_entry_context( log_level l );
+    void clear_entry_context();
+
+
+    public: static unit_test_log_t& instance(); private: unit_test_log_t(unit_test_log_t const&) = delete; unit_test_log_t& operator=(unit_test_log_t const&) = delete; ~unit_test_log_t() = default; private: unit_test_log_t() = default;
+};
+
+namespace { unit_test_log_t& unit_test_log __attribute__((__unused__)) = unit_test_log_t::instance(); }
+
+
+#define BOOST_TEST_LOG_ENTRY(ll) (::boost::unit_test::unit_test_log << ::boost::unit_test::log::begin( BOOST_TEST_L(__FILE__), __LINE__ ))(ll)
+
+
+
+
+}
+}
+
+
+
+
+
+
+#define BOOST_TEST_FRAMEWORK_MESSAGE(M) (::boost::unit_test::unit_test_log << ::boost::unit_test::log::begin( "boost.test framework", 0 )) ( ::boost::unit_test::log_messages ) << BOOST_TEST_LAZY_MSG( M )
+# 254 "/usr/include/boost/test/unit_test_log.hpp" 3 4
+#define BOOST_TEST_MESSAGE(M) BOOST_TEST_LOG_ENTRY( ::boost::unit_test::log_messages ) << BOOST_TEST_LAZY_MSG( M )
+
+
+
+
+
+
+#define BOOST_TEST_PASSPOINT() ::boost::unit_test::unit_test_log.set_checkpoint( BOOST_TEST_L(__FILE__), static_cast<std::size_t>(__LINE__) )
+
+
+
+
+
+
+
+#define BOOST_TEST_CHECKPOINT(M) ::boost::unit_test::unit_test_log.set_checkpoint( BOOST_TEST_L(__FILE__), static_cast<std::size_t>(__LINE__), (::boost::wrap_stringstream().ref() << M).str() )
+# 278 "/usr/include/boost/test/unit_test_log.hpp" 3 4
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 279 "/usr/include/boost/test/unit_test_log.hpp" 2 3 4
+# 25 "/usr/include/boost/test/impl/framework.ipp" 2 3 4
+
+# 1 "/usr/include/boost/test/unit_test_monitor.hpp" 1 3 4
+# 15 "/usr/include/boost/test/unit_test_monitor.hpp" 3 4
+#define BOOST_TEST_UNIT_TEST_MONITOR_HPP_020905GER 
+
+
+
+
+
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 22 "/usr/include/boost/test/unit_test_monitor.hpp" 2 3 4
+
+
+
+namespace boost {
+namespace unit_test {
+
+
+
+
+
+class __attribute__((__visibility__("default"))) unit_test_monitor_t :public execution_monitor {
+public:
+    enum error_level {
+        test_ok = 0,
+
+
+        test_setup_failure = -1,
+        unexpected_exception = -2,
+        os_exception = -3,
+        os_timeout = -4,
+        fatal_error = -5
+    };
+
+    static bool is_critical_error( error_level e ) { return e <= fatal_error; }
+
+
+
+    error_level execute_and_translate( boost::function<void ()> const& func, unsigned long int timeout_microseconds = 0 );
+
+
+    public: static unit_test_monitor_t& instance(); private: unit_test_monitor_t(unit_test_monitor_t const&) = delete; unit_test_monitor_t& operator=(unit_test_monitor_t const&) = delete; ~unit_test_monitor_t() = default; private: unit_test_monitor_t() = default;
+};
+
+namespace { unit_test_monitor_t& unit_test_monitor __attribute__((__unused__)) = unit_test_monitor_t::instance(); }
+
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 61 "/usr/include/boost/test/unit_test_monitor.hpp" 2 3 4
+# 27 "/usr/include/boost/test/impl/framework.ipp" 2 3 4
+
+# 1 "/usr/include/boost/test/progress_monitor.hpp" 1 3 4
+# 13 "/usr/include/boost/test/progress_monitor.hpp" 3 4
+#define BOOST_TEST_PROGRESS_MONITOR_HPP_020105GER 
+
+
+
+
+
+
+
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 22 "/usr/include/boost/test/progress_monitor.hpp" 2 3 4
+
+
+
+namespace boost {
+namespace unit_test {
+
+
+
+
+
+
+class __attribute__((__visibility__("default"))) progress_monitor_t : public test_observer {
+public:
+
+
+    virtual void test_start( counter_t test_cases_amount );
+    virtual void test_aborted();
+
+    virtual void test_unit_finish( test_unit const&, unsigned long );
+    virtual void test_unit_skipped( test_unit const&, const_string );
+
+    virtual int priority() { return 4; }
+
+
+
+
+    void set_stream( std::ostream& );
+
+
+
+    public: static progress_monitor_t& instance(); private: progress_monitor_t(progress_monitor_t const&) = delete; progress_monitor_t& operator=(progress_monitor_t const&) = delete; ~progress_monitor_t() = default; private: progress_monitor_t() = default;
+};
+
+namespace { progress_monitor_t& progress_monitor __attribute__((__unused__)) = progress_monitor_t::instance(); }
+
+}
+}
+
+
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 63 "/usr/include/boost/test/progress_monitor.hpp" 2 3 4
+# 29 "/usr/include/boost/test/impl/framework.ipp" 2 3 4
+# 1 "/usr/include/boost/test/results_reporter.hpp" 1 3 4
+# 16 "/usr/include/boost/test/results_reporter.hpp" 3 4
+#define BOOST_TEST_RESULTS_REPORTER_HPP_021205GER 
+# 25 "/usr/include/boost/test/results_reporter.hpp" 3 4
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 26 "/usr/include/boost/test/results_reporter.hpp" 2 3 4
+
+
+
+namespace boost {
+namespace unit_test {
+
+
+namespace results_reporter {
+# 43 "/usr/include/boost/test/results_reporter.hpp" 3 4
+class __attribute__((__visibility__("default"))) format {
+public:
+
+    virtual ~format() {}
+
+    virtual void results_report_start( std::ostream& ostr ) = 0;
+    virtual void results_report_finish( std::ostream& ostr ) = 0;
+
+    virtual void test_unit_report_start( test_unit const&, std::ostream& ostr ) = 0;
+    virtual void test_unit_report_finish( test_unit const&, std::ostream& ostr ) = 0;
+
+    virtual void do_confirmation_report( test_unit const&, std::ostream& ostr ) = 0;
+};
+# 73 "/usr/include/boost/test/results_reporter.hpp" 3 4
+__attribute__((__visibility__("default"))) void set_level( report_level l );
+
+
+
+
+
+__attribute__((__visibility__("default"))) void set_stream( std::ostream& );
+
+
+
+
+
+
+
+__attribute__((__visibility__("default"))) void set_format( output_format of );
+
+
+
+
+
+
+__attribute__((__visibility__("default"))) void set_format( results_reporter::format* f );
+
+
+
+
+__attribute__((__visibility__("default"))) std::ostream& get_stream();
+
+
+
+
+
+
+
+__attribute__((__visibility__("default"))) void make_report( report_level l = INV_REPORT_LEVEL, test_unit_id = INV_TEST_UNIT_ID );
+inline void confirmation_report( test_unit_id id = INV_TEST_UNIT_ID )
+{ make_report( CONFIRMATION_REPORT, id ); }
+inline void short_report( test_unit_id id = INV_TEST_UNIT_ID )
+{ make_report( SHORT_REPORT, id ); }
+inline void detailed_report( test_unit_id id = INV_TEST_UNIT_ID )
+{ make_report( DETAILED_REPORT, id ); }
+
+}
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 120 "/usr/include/boost/test/results_reporter.hpp" 2 3 4
+# 30 "/usr/include/boost/test/impl/framework.ipp" 2 3 4
+# 1 "/usr/include/boost/test/test_framework_init_observer.hpp" 1 3 4
+# 13 "/usr/include/boost/test/test_framework_init_observer.hpp" 3 4
+#define BOOST_TEST_FRAMEWORK_INIT_OBSERVER_HPP_071894GER 
+
+
+
+
+
+
+
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 22 "/usr/include/boost/test/test_framework_init_observer.hpp" 2 3 4
+
+
+
+namespace boost {
+namespace unit_test {
+
+
+
+
+
+
+
+class __attribute__((__visibility__("default"))) framework_init_observer_t : public test_observer {
+public:
+
+    virtual void test_start( counter_t );
+
+    virtual void assertion_result( unit_test::assertion_result );
+    virtual void exception_caught( execution_exception const& );
+    virtual void test_aborted();
+
+    virtual int priority() { return 0; }
+
+    void clear();
+
+
+    bool has_failed( ) const;
+
+
+    public: static framework_init_observer_t& instance(); private: framework_init_observer_t(framework_init_observer_t const&) = delete; framework_init_observer_t& operator=(framework_init_observer_t const&) = delete; ~framework_init_observer_t() = default; private: framework_init_observer_t() = default;
+};
+
+namespace { framework_init_observer_t& framework_init_observer __attribute__((__unused__)) = framework_init_observer_t::instance(); }
+
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 60 "/usr/include/boost/test/test_framework_init_observer.hpp" 2 3 4
+# 31 "/usr/include/boost/test/impl/framework.ipp" 2 3 4
+
+
+
+
+
+# 1 "/usr/include/boost/test/tree/test_case_counter.hpp" 1 3 4
+# 13 "/usr/include/boost/test/tree/test_case_counter.hpp" 3 4
+#define BOOST_TEST_TREE_TEST_CASE_COUNTER_HPP_100211GER 
+# 22 "/usr/include/boost/test/tree/test_case_counter.hpp" 3 4
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 23 "/usr/include/boost/test/tree/test_case_counter.hpp" 2 3 4
+
+
+
+namespace boost {
+namespace unit_test {
+
+
+
+
+
+
+class test_case_counter : public test_tree_visitor {
+public:
+
+
+    test_case_counter(bool ignore_status = false)
+    : p_count( 0 )
+    , m_ignore_status(ignore_status)
+    {}
+
+    class readonly_property43 : public boost::unit_test::readonly_property<counter_t > { typedef boost::unit_test::readonly_property<counter_t > base_prop; friend class test_case_counter; typedef base_prop::write_param_t write_param_t; public: readonly_property43() {} explicit readonly_property43( write_param_t init_v ) : base_prop( init_v ) {} } p_count;
+private:
+
+    virtual void visit( test_case const& tc ) { if( m_ignore_status || tc.is_enabled() ) ++p_count.value; }
+    virtual bool test_suite_start( test_suite const& ts ) { return m_ignore_status || ts.is_enabled(); }
+
+    bool m_ignore_status;
+};
+
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 56 "/usr/include/boost/test/tree/test_case_counter.hpp" 2 3 4
+# 37 "/usr/include/boost/test/impl/framework.ipp" 2 3 4
+# 1 "/usr/include/boost/test/tree/global_fixture.hpp" 1 3 4
+# 13 "/usr/include/boost/test/tree/global_fixture.hpp" 3 4
+#define BOOST_TEST_TREE_GLOBAL_FIXTURE_HPP_091911GER 
+# 22 "/usr/include/boost/test/tree/global_fixture.hpp" 3 4
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 23 "/usr/include/boost/test/tree/global_fixture.hpp" 2 3 4
+
+
+
+
+namespace boost {
+namespace unit_test {
+
+
+
+
+
+class __attribute__((__visibility__("default"))) global_configuration : public test_observer {
+
+public:
+
+    global_configuration();
+
+
+
+
+    void unregister_from_framework();
+
+
+    virtual ~global_configuration();
+
+
+    virtual int priority() { return 1; }
+
+private:
+    bool registered;
+};
+
+
+
+
+
+
+
+class __attribute__((__visibility__("default"))) global_fixture : public test_unit_fixture {
+
+public:
+
+    global_fixture();
+
+
+
+
+    void unregister_from_framework();
+
+
+    virtual ~global_fixture();
+
+private:
+    bool registered;
+};
+
+
+
+namespace ut_detail {
+
+template<typename F>
+struct global_configuration_impl : public global_configuration {
+
+    global_configuration_impl() : m_configuration_observer( 0 ) {
+    }
+
+
+    virtual void test_start( counter_t ) {
+        m_configuration_observer = new F;
+    }
+
+
+    virtual void test_finish() {
+        if(m_configuration_observer) {
+            delete m_configuration_observer;
+            m_configuration_observer = 0;
+        }
+    }
+private:
+
+    F* m_configuration_observer;
+};
+
+template<typename F>
+struct global_fixture_impl : public global_fixture {
+
+    global_fixture_impl() : m_fixture( 0 ) {
+    }
+
+
+    virtual void setup() {
+        m_fixture = new F;
+        setup_conditional(*m_fixture);
+    }
+
+
+    virtual void teardown() {
+        if(m_fixture) {
+            teardown_conditional(*m_fixture);
+        }
+        delete m_fixture;
+        m_fixture = 0;
+    }
+
+private:
+
+    F* m_fixture;
+};
+
+}
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 137 "/usr/include/boost/test/tree/global_fixture.hpp" 2 3 4
+# 38 "/usr/include/boost/test/impl/framework.ipp" 2 3 4
+# 51 "/usr/include/boost/test/impl/framework.ipp" 3 4
+# 1 "/usr/include/boost/test/utils/timer.hpp" 1 3 4
+# 12 "/usr/include/boost/test/utils/timer.hpp" 3 4
+#define BOOST_TEST_UTILS_TIMER_HPP 
+
+
+# 1 "/usr/include/boost/cstdint.hpp" 1 3 4
+# 16 "/usr/include/boost/test/utils/timer.hpp" 2 3 4
+
+# 1 "/usr/include/c++/10.2.0/ctime" 1 3 4
+# 39 "/usr/include/c++/10.2.0/ctime" 3 4
+       
+# 40 "/usr/include/c++/10.2.0/ctime" 3
+
+
+
+
+
+#define _GLIBCXX_CTIME 1
+
+
+#undef clock
+#undef difftime
+#undef mktime
+#undef time
+#undef asctime
+#undef ctime
+#undef gmtime
+#undef localtime
+#undef strftime
+
+namespace std
+{
+  using ::clock_t;
+  using ::time_t;
+  using ::tm;
+
+  using ::clock;
+  using ::difftime;
+  using ::mktime;
+  using ::time;
+  using ::asctime;
+  using ::ctime;
+  using ::gmtime;
+  using ::localtime;
+  using ::strftime;
+}
+
+
+#undef timespec_get
+namespace std
+{
+  using ::timespec;
+  using ::timespec_get;
+}
+# 18 "/usr/include/boost/test/utils/timer.hpp" 2 3 4
+
+
+
+
+
+
+
+#define BOOST_TEST_TIMER_POSIX_API 
+# 44 "/usr/include/boost/test/utils/timer.hpp" 3 4
+namespace boost {
+namespace unit_test {
+namespace timer {
+
+  struct elapsed_time
+  {
+    typedef boost::int_least64_t nanosecond_type;
+
+    nanosecond_type wall;
+    nanosecond_type system;
+    void clear() {
+      wall = 0;
+      system = 0;
+    }
+  };
+
+  inline double
+  microsecond_wall_time( elapsed_time const& elapsed )
+  {
+      return elapsed.wall / 1E3;
+  }
+
+  inline double
+  second_wall_time( elapsed_time const& elapsed )
+  {
+      return elapsed.wall / 1E9;
+  }
+
+  namespace details {
+# 87 "/usr/include/boost/test/utils/timer.hpp" 3 4
+  }
+
+
+
+
+  class timer
+  {
+  public:
+    timer()
+    {
+        restart();
+    }
+    void restart()
+    {
+        _start_time_clock = std::clock();
+
+
+
+
+
+        if( ::clock_gettime( 1, &_start_time_wall ) != 0 )
+        {
+            _start_time_wall.tv_nsec = -1;
+            _start_time_wall.tv_sec = -1;
+        }
+
+    }
+
+
+    elapsed_time elapsed() const
+    {
+      typedef elapsed_time::nanosecond_type nanosecond_type;
+      static const double clock_to_nano_seconds = 1E9 / ((__clock_t) 1000000);
+      elapsed_time return_value;
+
+
+      return_value.system = static_cast<nanosecond_type>(double(std::clock() - _start_time_clock) * clock_to_nano_seconds);
+# 135 "/usr/include/boost/test/utils/timer.hpp" 3 4
+      struct timespec end_time;
+      if( ::clock_gettime( 1, &end_time ) == 0 )
+      {
+          return_value.wall = static_cast<nanosecond_type>((end_time.tv_sec - _start_time_wall.tv_sec) * 1E9 + (end_time.tv_nsec - _start_time_wall.tv_nsec));
+      }
+
+
+      return return_value;
+    }
+
+   private:
+      std::clock_t _start_time_clock;
+
+
+
+
+
+      struct timespec _start_time_wall;
+
+  };
+
+
+
+
+}
+}
+}
+# 52 "/usr/include/boost/test/impl/framework.ipp" 2 3 4
+# 1 "/usr/include/boost/bind.hpp" 1 3 4
+
+#define BOOST_BIND_HPP_INCLUDED 
+# 22 "/usr/include/boost/bind.hpp" 3 4
+# 1 "/usr/include/boost/bind/bind.hpp" 1 3 4
+
+#define BOOST_BIND_BIND_HPP_INCLUDED 
+# 28 "/usr/include/boost/bind/bind.hpp" 3 4
+# 1 "/usr/include/boost/is_placeholder.hpp" 1 3 4
+
+#define BOOST_IS_PLACEHOLDER_HPP_INCLUDED 
+# 21 "/usr/include/boost/is_placeholder.hpp" 3 4
+namespace boost
+{
+
+template< class T > struct is_placeholder
+{
+    enum _vt { value = 0 };
+};
+
+}
+# 29 "/usr/include/boost/bind/bind.hpp" 2 3 4
+# 1 "/usr/include/boost/bind/arg.hpp" 1 3 4
+
+#define BOOST_BIND_ARG_HPP_INCLUDED 
+# 25 "/usr/include/boost/bind/arg.hpp" 3 4
+namespace boost
+{
+
+template<bool Eq> struct _arg_eq
+{
+};
+
+template<> struct _arg_eq<true>
+{
+    typedef void type;
+};
+
+template< int I > struct arg
+{
+    constexpr arg()
+    {
+    }
+
+    template< class T > constexpr arg( T const & , typename _arg_eq< I == is_placeholder<T>::value >::type * = 0 )
+    {
+    }
+};
+
+template< int I > constexpr bool operator==( arg<I> const &, arg<I> const & )
+{
+    return true;
+}
+
+
+
+template< int I > struct is_placeholder< arg<I> >
+{
+    enum _vt { value = I };
+};
+
+template< int I > struct is_placeholder< arg<I> (*) () >
+{
+    enum _vt { value = I };
+};
+
+
+
+}
+# 30 "/usr/include/boost/bind/bind.hpp" 2 3 4
+
+# 1 "/usr/include/boost/visit_each.hpp" 1 3 4
+# 11 "/usr/include/boost/visit_each.hpp" 3 4
+#define BOOST_VISIT_EACH_HPP 
+
+namespace boost {
+  template<typename Visitor, typename T>
+  inline void visit_each(Visitor& visitor, const T& t, long)
+  {
+    visitor(t);
+  }
+
+  template<typename Visitor, typename T>
+  inline void visit_each(Visitor& visitor, const T& t)
+  {
+    visit_each(visitor, t, 0);
+  }
+}
+# 32 "/usr/include/boost/bind/bind.hpp" 2 3 4
+
+# 1 "/usr/include/boost/core/is_same.hpp" 1 3 4
+
+#define BOOST_CORE_IS_SAME_HPP_INCLUDED 
+# 20 "/usr/include/boost/core/is_same.hpp" 3 4
+namespace boost
+{
+
+namespace core
+{
+
+template< class T1, class T2 > struct is_same
+{
+    static const bool value = false;
+};
+
+template< class T > struct is_same< T, T >
+{
+    static const bool value = true;
+};
+
+}
+
+}
+# 34 "/usr/include/boost/bind/bind.hpp" 2 3 4
+# 44 "/usr/include/boost/bind/bind.hpp" 3 4
+#define BOOST_BIND_VISIT_EACH visit_each
+
+
+# 1 "/usr/include/boost/bind/storage.hpp" 1 3 4
+
+#define BOOST_BIND_STORAGE_HPP_INCLUDED 
+# 32 "/usr/include/boost/bind/storage.hpp" 3 4
+namespace boost
+{
+
+namespace _bi
+{
+
+
+
+template<class A1> struct storage1
+{
+    explicit storage1( A1 a1 ): a1_( a1 ) {}
+
+    template<class V> void accept(V & v) const
+    {
+        visit_each(v, a1_, 0);
+    }
+
+    A1 a1_;
+};
+
+
+
+template<int I> struct storage1< boost::arg<I> >
+{
+    explicit storage1( boost::arg<I> ) {}
+
+    template<class V> void accept(V &) const { }
+
+    static boost::arg<I> a1_() { return boost::arg<I>(); }
+};
+
+template<int I> struct storage1< boost::arg<I> (*) () >
+{
+    explicit storage1( boost::arg<I> (*) () ) {}
+
+    template<class V> void accept(V &) const { }
+
+    static boost::arg<I> a1_() { return boost::arg<I>(); }
+};
+
+
+
+
+
+template<class A1, class A2> struct storage2: public storage1<A1>
+{
+    typedef storage1<A1> inherited;
+
+    storage2( A1 a1, A2 a2 ): storage1<A1>( a1 ), a2_( a2 ) {}
+
+    template<class V> void accept(V & v) const
+    {
+        inherited::accept(v);
+        visit_each(v, a2_, 0);
+    }
+
+    A2 a2_;
+};
+
+
+
+template<class A1, int I> struct storage2< A1, boost::arg<I> >: public storage1<A1>
+{
+    typedef storage1<A1> inherited;
+
+    storage2( A1 a1, boost::arg<I> ): storage1<A1>( a1 ) {}
+
+    template<class V> void accept(V & v) const
+    {
+        inherited::accept(v);
+    }
+
+    static boost::arg<I> a2_() { return boost::arg<I>(); }
+};
+
+template<class A1, int I> struct storage2< A1, boost::arg<I> (*) () >: public storage1<A1>
+{
+    typedef storage1<A1> inherited;
+
+    storage2( A1 a1, boost::arg<I> (*) () ): storage1<A1>( a1 ) {}
+
+    template<class V> void accept(V & v) const
+    {
+        inherited::accept(v);
+    }
+
+    static boost::arg<I> a2_() { return boost::arg<I>(); }
+};
+
+
+
+
+
+template<class A1, class A2, class A3> struct storage3: public storage2< A1, A2 >
+{
+    typedef storage2<A1, A2> inherited;
+
+    storage3( A1 a1, A2 a2, A3 a3 ): storage2<A1, A2>( a1, a2 ), a3_( a3 ) {}
+
+    template<class V> void accept(V & v) const
+    {
+        inherited::accept(v);
+        visit_each(v, a3_, 0);
+    }
+
+    A3 a3_;
+};
+
+
+
+template<class A1, class A2, int I> struct storage3< A1, A2, boost::arg<I> >: public storage2< A1, A2 >
+{
+    typedef storage2<A1, A2> inherited;
+
+    storage3( A1 a1, A2 a2, boost::arg<I> ): storage2<A1, A2>( a1, a2 ) {}
+
+    template<class V> void accept(V & v) const
+    {
+        inherited::accept(v);
+    }
+
+    static boost::arg<I> a3_() { return boost::arg<I>(); }
+};
+
+template<class A1, class A2, int I> struct storage3< A1, A2, boost::arg<I> (*) () >: public storage2< A1, A2 >
+{
+    typedef storage2<A1, A2> inherited;
+
+    storage3( A1 a1, A2 a2, boost::arg<I> (*) () ): storage2<A1, A2>( a1, a2 ) {}
+
+    template<class V> void accept(V & v) const
+    {
+        inherited::accept(v);
+    }
+
+    static boost::arg<I> a3_() { return boost::arg<I>(); }
+};
+
+
+
+
+
+template<class A1, class A2, class A3, class A4> struct storage4: public storage3< A1, A2, A3 >
+{
+    typedef storage3<A1, A2, A3> inherited;
+
+    storage4( A1 a1, A2 a2, A3 a3, A4 a4 ): storage3<A1, A2, A3>( a1, a2, a3 ), a4_( a4 ) {}
+
+    template<class V> void accept(V & v) const
+    {
+        inherited::accept(v);
+        visit_each(v, a4_, 0);
+    }
+
+    A4 a4_;
+};
+
+
+
+template<class A1, class A2, class A3, int I> struct storage4< A1, A2, A3, boost::arg<I> >: public storage3< A1, A2, A3 >
+{
+    typedef storage3<A1, A2, A3> inherited;
+
+    storage4( A1 a1, A2 a2, A3 a3, boost::arg<I> ): storage3<A1, A2, A3>( a1, a2, a3 ) {}
+
+    template<class V> void accept(V & v) const
+    {
+        inherited::accept(v);
+    }
+
+    static boost::arg<I> a4_() { return boost::arg<I>(); }
+};
+
+template<class A1, class A2, class A3, int I> struct storage4< A1, A2, A3, boost::arg<I> (*) () >: public storage3< A1, A2, A3 >
+{
+    typedef storage3<A1, A2, A3> inherited;
+
+    storage4( A1 a1, A2 a2, A3 a3, boost::arg<I> (*) () ): storage3<A1, A2, A3>( a1, a2, a3 ) {}
+
+    template<class V> void accept(V & v) const
+    {
+        inherited::accept(v);
+    }
+
+    static boost::arg<I> a4_() { return boost::arg<I>(); }
+};
+
+
+
+
+
+template<class A1, class A2, class A3, class A4, class A5> struct storage5: public storage4< A1, A2, A3, A4 >
+{
+    typedef storage4<A1, A2, A3, A4> inherited;
+
+    storage5( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5 ): storage4<A1, A2, A3, A4>( a1, a2, a3, a4 ), a5_( a5 ) {}
+
+    template<class V> void accept(V & v) const
+    {
+        inherited::accept(v);
+        visit_each(v, a5_, 0);
+    }
+
+    A5 a5_;
+};
+
+
+
+template<class A1, class A2, class A3, class A4, int I> struct storage5< A1, A2, A3, A4, boost::arg<I> >: public storage4< A1, A2, A3, A4 >
+{
+    typedef storage4<A1, A2, A3, A4> inherited;
+
+    storage5( A1 a1, A2 a2, A3 a3, A4 a4, boost::arg<I> ): storage4<A1, A2, A3, A4>( a1, a2, a3, a4 ) {}
+
+    template<class V> void accept(V & v) const
+    {
+        inherited::accept(v);
+    }
+
+    static boost::arg<I> a5_() { return boost::arg<I>(); }
+};
+
+template<class A1, class A2, class A3, class A4, int I> struct storage5< A1, A2, A3, A4, boost::arg<I> (*) () >: public storage4< A1, A2, A3, A4 >
+{
+    typedef storage4<A1, A2, A3, A4> inherited;
+
+    storage5( A1 a1, A2 a2, A3 a3, A4 a4, boost::arg<I> (*) () ): storage4<A1, A2, A3, A4>( a1, a2, a3, a4 ) {}
+
+    template<class V> void accept(V & v) const
+    {
+        inherited::accept(v);
+    }
+
+    static boost::arg<I> a5_() { return boost::arg<I>(); }
+};
+
+
+
+
+
+template<class A1, class A2, class A3, class A4, class A5, class A6> struct storage6: public storage5< A1, A2, A3, A4, A5 >
+{
+    typedef storage5<A1, A2, A3, A4, A5> inherited;
+
+    storage6( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6 ): storage5<A1, A2, A3, A4, A5>( a1, a2, a3, a4, a5 ), a6_( a6 ) {}
+
+    template<class V> void accept(V & v) const
+    {
+        inherited::accept(v);
+        visit_each(v, a6_, 0);
+    }
+
+    A6 a6_;
+};
+
+
+
+template<class A1, class A2, class A3, class A4, class A5, int I> struct storage6< A1, A2, A3, A4, A5, boost::arg<I> >: public storage5< A1, A2, A3, A4, A5 >
+{
+    typedef storage5<A1, A2, A3, A4, A5> inherited;
+
+    storage6( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, boost::arg<I> ): storage5<A1, A2, A3, A4, A5>( a1, a2, a3, a4, a5 ) {}
+
+    template<class V> void accept(V & v) const
+    {
+        inherited::accept(v);
+    }
+
+    static boost::arg<I> a6_() { return boost::arg<I>(); }
+};
+
+template<class A1, class A2, class A3, class A4, class A5, int I> struct storage6< A1, A2, A3, A4, A5, boost::arg<I> (*) () >: public storage5< A1, A2, A3, A4, A5 >
+{
+    typedef storage5<A1, A2, A3, A4, A5> inherited;
+
+    storage6( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, boost::arg<I> (*) () ): storage5<A1, A2, A3, A4, A5>( a1, a2, a3, a4, a5 ) {}
+
+    template<class V> void accept(V & v) const
+    {
+        inherited::accept(v);
+    }
+
+    static boost::arg<I> a6_() { return boost::arg<I>(); }
+};
+
+
+
+
+
+template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> struct storage7: public storage6< A1, A2, A3, A4, A5, A6 >
+{
+    typedef storage6<A1, A2, A3, A4, A5, A6> inherited;
+
+    storage7( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7 ): storage6<A1, A2, A3, A4, A5, A6>( a1, a2, a3, a4, a5, a6 ), a7_( a7 ) {}
+
+    template<class V> void accept(V & v) const
+    {
+        inherited::accept(v);
+        visit_each(v, a7_, 0);
+    }
+
+    A7 a7_;
+};
+
+
+
+template<class A1, class A2, class A3, class A4, class A5, class A6, int I> struct storage7< A1, A2, A3, A4, A5, A6, boost::arg<I> >: public storage6< A1, A2, A3, A4, A5, A6 >
+{
+    typedef storage6<A1, A2, A3, A4, A5, A6> inherited;
+
+    storage7( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, boost::arg<I> ): storage6<A1, A2, A3, A4, A5, A6>( a1, a2, a3, a4, a5, a6 ) {}
+
+    template<class V> void accept(V & v) const
+    {
+        inherited::accept(v);
+    }
+
+    static boost::arg<I> a7_() { return boost::arg<I>(); }
+};
+
+template<class A1, class A2, class A3, class A4, class A5, class A6, int I> struct storage7< A1, A2, A3, A4, A5, A6, boost::arg<I> (*) () >: public storage6< A1, A2, A3, A4, A5, A6 >
+{
+    typedef storage6<A1, A2, A3, A4, A5, A6> inherited;
+
+    storage7( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, boost::arg<I> (*) () ): storage6<A1, A2, A3, A4, A5, A6>( a1, a2, a3, a4, a5, a6 ) {}
+
+    template<class V> void accept(V & v) const
+    {
+        inherited::accept(v);
+    }
+
+    static boost::arg<I> a7_() { return boost::arg<I>(); }
+};
+
+
+
+
+
+template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> struct storage8: public storage7< A1, A2, A3, A4, A5, A6, A7 >
+{
+    typedef storage7<A1, A2, A3, A4, A5, A6, A7> inherited;
+
+    storage8( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8 ): storage7<A1, A2, A3, A4, A5, A6, A7>( a1, a2, a3, a4, a5, a6, a7 ), a8_( a8 ) {}
+
+    template<class V> void accept(V & v) const
+    {
+        inherited::accept(v);
+        visit_each(v, a8_, 0);
+    }
+
+    A8 a8_;
+};
+
+
+
+template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, int I> struct storage8< A1, A2, A3, A4, A5, A6, A7, boost::arg<I> >: public storage7< A1, A2, A3, A4, A5, A6, A7 >
+{
+    typedef storage7<A1, A2, A3, A4, A5, A6, A7> inherited;
+
+    storage8( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, boost::arg<I> ): storage7<A1, A2, A3, A4, A5, A6, A7>( a1, a2, a3, a4, a5, a6, a7 ) {}
+
+    template<class V> void accept(V & v) const
+    {
+        inherited::accept(v);
+    }
+
+    static boost::arg<I> a8_() { return boost::arg<I>(); }
+};
+
+template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, int I> struct storage8< A1, A2, A3, A4, A5, A6, A7, boost::arg<I> (*) () >: public storage7< A1, A2, A3, A4, A5, A6, A7 >
+{
+    typedef storage7<A1, A2, A3, A4, A5, A6, A7> inherited;
+
+    storage8( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, boost::arg<I> (*) () ): storage7<A1, A2, A3, A4, A5, A6, A7>( a1, a2, a3, a4, a5, a6, a7 ) {}
+
+    template<class V> void accept(V & v) const
+    {
+        inherited::accept(v);
+    }
+
+    static boost::arg<I> a8_() { return boost::arg<I>(); }
+};
+
+
+
+
+
+template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> struct storage9: public storage8< A1, A2, A3, A4, A5, A6, A7, A8 >
+{
+    typedef storage8<A1, A2, A3, A4, A5, A6, A7, A8> inherited;
+
+    storage9( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9 ): storage8<A1, A2, A3, A4, A5, A6, A7, A8>( a1, a2, a3, a4, a5, a6, a7, a8 ), a9_( a9 ) {}
+
+    template<class V> void accept(V & v) const
+    {
+        inherited::accept(v);
+        visit_each(v, a9_, 0);
+    }
+
+    A9 a9_;
+};
+
+
+
+template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, int I> struct storage9< A1, A2, A3, A4, A5, A6, A7, A8, boost::arg<I> >: public storage8< A1, A2, A3, A4, A5, A6, A7, A8 >
+{
+    typedef storage8<A1, A2, A3, A4, A5, A6, A7, A8> inherited;
+
+    storage9( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, boost::arg<I> ): storage8<A1, A2, A3, A4, A5, A6, A7, A8>( a1, a2, a3, a4, a5, a6, a7, a8 ) {}
+
+    template<class V> void accept(V & v) const
+    {
+        inherited::accept(v);
+    }
+
+    static boost::arg<I> a9_() { return boost::arg<I>(); }
+};
+
+template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, int I> struct storage9< A1, A2, A3, A4, A5, A6, A7, A8, boost::arg<I> (*) () >: public storage8< A1, A2, A3, A4, A5, A6, A7, A8 >
+{
+    typedef storage8<A1, A2, A3, A4, A5, A6, A7, A8> inherited;
+
+    storage9( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, boost::arg<I> (*) () ): storage8<A1, A2, A3, A4, A5, A6, A7, A8>( a1, a2, a3, a4, a5, a6, a7, a8 ) {}
+
+    template<class V> void accept(V & v) const
+    {
+        inherited::accept(v);
+    }
+
+    static boost::arg<I> a9_() { return boost::arg<I>(); }
+};
+
+
+
+}
+
+}
+# 48 "/usr/include/boost/bind/bind.hpp" 2 3 4
+
+
+
+
+
+
+namespace boost
+{
+
+template<class T> class weak_ptr;
+
+namespace _bi
+{
+
+
+
+template<class R, class F> struct result_traits
+{
+    typedef R type;
+};
+
+
+
+struct unspecified {};
+
+template<class F> struct result_traits<unspecified, F>
+{
+    typedef typename F::result_type type;
+};
+
+template<class F> struct result_traits< unspecified, reference_wrapper<F> >
+{
+    typedef typename F::result_type type;
+};
+
+
+
+
+
+template<class T> bool ref_compare( T const & a, T const & b, long )
+{
+    return a == b;
+}
+
+template<int I> bool ref_compare( arg<I> const &, arg<I> const &, int )
+{
+    return true;
+}
+
+template<int I> bool ref_compare( arg<I> (*) (), arg<I> (*) (), int )
+{
+    return true;
+}
+
+template<class T> bool ref_compare( reference_wrapper<T> const & a, reference_wrapper<T> const & b, int )
+{
+    return a.get_pointer() == b.get_pointer();
+}
+
+
+
+template<class R, class F, class L> class bind_t;
+
+template<class R, class F, class L> bool ref_compare( bind_t<R, F, L> const & a, bind_t<R, F, L> const & b, int )
+{
+    return a.compare( b );
+}
+
+
+
+template<class T> class value
+{
+public:
+
+    value(T const & t): t_(t) {}
+
+    T & get() { return t_; }
+    T const & get() const { return t_; }
+
+    bool operator==(value const & rhs) const
+    {
+        return t_ == rhs.t_;
+    }
+
+private:
+
+    T t_;
+};
+
+
+
+template<class T> bool ref_compare( value< weak_ptr<T> > const & a, value< weak_ptr<T> > const & b, int )
+{
+    return !(a.get() < b.get()) && !(b.get() < a.get());
+}
+
+
+
+template<class T> class type {};
+
+
+
+template<class F> struct unwrapper
+{
+    static inline F & unwrap( F & f, long )
+    {
+        return f;
+    }
+
+    template<class F2> static inline F2 & unwrap( reference_wrapper<F2> rf, int )
+    {
+        return rf.get();
+    }
+
+    template<class R, class T> static inline _mfi::dm<R, T> unwrap( R T::* pm, int )
+    {
+        return _mfi::dm<R, T>( pm );
+    }
+};
+
+
+
+class list0
+{
+public:
+
+    list0() {}
+
+    template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
+
+    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
+
+    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
+
+    template<class R, class F, class A> R operator()(type<R>, F & f, A &, long)
+    {
+        return unwrapper<F>::unwrap(f, 0)();
+    }
+
+    template<class R, class F, class A> R operator()(type<R>, F const & f, A &, long) const
+    {
+        return unwrapper<F const>::unwrap(f, 0)();
+    }
+
+    template<class F, class A> void operator()(type<void>, F & f, A &, int)
+    {
+        unwrapper<F>::unwrap(f, 0)();
+    }
+
+    template<class F, class A> void operator()(type<void>, F const & f, A &, int) const
+    {
+        unwrapper<F const>::unwrap(f, 0)();
+    }
+
+    template<class V> void accept(V &) const
+    {
+    }
+
+    bool operator==(list0 const &) const
+    {
+        return true;
+    }
+};
+# 223 "/usr/include/boost/bind/bind.hpp" 3 4
+template< class A1 > class list1: private storage1< A1 >
+{
+private:
+
+    typedef storage1< A1 > base_type;
+
+public:
+
+    explicit list1( A1 a1 ): base_type( a1 ) {}
+
+    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
+
+    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
+
+    template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); }
+
+    template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); }
+
+    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
+
+    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
+    {
+        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_]);
+    }
+
+    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
+    {
+        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_]);
+    }
+
+    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
+    {
+        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_]);
+    }
+
+    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
+    {
+        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_]);
+    }
+
+    template<class V> void accept(V & v) const
+    {
+        base_type::accept(v);
+    }
+
+    bool operator==(list1 const & rhs) const
+    {
+        return ref_compare(base_type::a1_, rhs.a1_, 0);
+    }
+};
+
+struct logical_and;
+struct logical_or;
+
+template< class A1, class A2 > class list2: private storage2< A1, A2 >
+{
+private:
+
+    typedef storage2< A1, A2 > base_type;
+
+public:
+
+    list2( A1 a1, A2 a2 ): base_type( a1, a2 ) {}
+
+    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
+    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
+
+    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
+    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
+
+    template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
+
+    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
+
+    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
+
+    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
+    {
+        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);
+    }
+
+    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
+    {
+        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);
+    }
+
+    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
+    {
+        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);
+    }
+
+    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
+    {
+        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);
+    }
+
+    template<class A> bool operator()( type<bool>, logical_and & , A & a, int )
+    {
+        return a[ base_type::a1_ ] && a[ base_type::a2_ ];
+    }
+
+    template<class A> bool operator()( type<bool>, logical_and const & , A & a, int ) const
+    {
+        return a[ base_type::a1_ ] && a[ base_type::a2_ ];
+    }
+
+    template<class A> bool operator()( type<bool>, logical_or & , A & a, int )
+    {
+        return a[ base_type::a1_ ] || a[ base_type::a2_ ];
+    }
+
+    template<class A> bool operator()( type<bool>, logical_or const & , A & a, int ) const
+    {
+        return a[ base_type::a1_ ] || a[ base_type::a2_ ];
+    }
+
+    template<class V> void accept(V & v) const
+    {
+        base_type::accept(v);
+    }
+
+    bool operator==(list2 const & rhs) const
+    {
+        return ref_compare(base_type::a1_, rhs.a1_, 0) && ref_compare(base_type::a2_, rhs.a2_, 0);
+    }
+};
+
+template< class A1, class A2, class A3 > class list3: private storage3< A1, A2, A3 >
+{
+private:
+
+    typedef storage3< A1, A2, A3 > base_type;
+
+public:
+
+    list3( A1 a1, A2 a2, A3 a3 ): base_type( a1, a2, a3 ) {}
+
+    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
+    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
+    A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
+
+    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
+    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
+    A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
+
+    template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
+
+    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
+
+    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
+
+    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
+    {
+        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);
+    }
+
+    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
+    {
+        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);
+    }
+
+    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
+    {
+        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);
+    }
+
+    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
+    {
+        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);
+    }
+
+    template<class V> void accept(V & v) const
+    {
+        base_type::accept(v);
+    }
+
+    bool operator==(list3 const & rhs) const
+    {
+        return
+
+            ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
+            ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
+            ref_compare( base_type::a3_, rhs.a3_, 0 );
+    }
+};
+
+template< class A1, class A2, class A3, class A4 > class list4: private storage4< A1, A2, A3, A4 >
+{
+private:
+
+    typedef storage4< A1, A2, A3, A4 > base_type;
+
+public:
+
+    list4( A1 a1, A2 a2, A3 a3, A4 a4 ): base_type( a1, a2, a3, a4 ) {}
+
+    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
+    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
+    A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
+    A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
+
+    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
+    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
+    A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
+    A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
+
+    template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
+
+    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
+
+    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
+
+    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
+    {
+        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]);
+    }
+
+    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
+    {
+        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]);
+    }
+
+    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
+    {
+        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]);
+    }
+
+    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
+    {
+        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]);
+    }
+
+    template<class V> void accept(V & v) const
+    {
+        base_type::accept(v);
+    }
+
+    bool operator==(list4 const & rhs) const
+    {
+        return
+
+            ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
+            ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
+            ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
+            ref_compare( base_type::a4_, rhs.a4_, 0 );
+    }
+};
+
+template< class A1, class A2, class A3, class A4, class A5 > class list5: private storage5< A1, A2, A3, A4, A5 >
+{
+private:
+
+    typedef storage5< A1, A2, A3, A4, A5 > base_type;
+
+public:
+
+    list5( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5 ): base_type( a1, a2, a3, a4, a5 ) {}
+
+    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
+    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
+    A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
+    A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
+    A5 operator[] (boost::arg<5>) const { return base_type::a5_; }
+
+    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
+    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
+    A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
+    A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
+    A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }
+
+    template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
+
+    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
+
+    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
+
+    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
+    {
+        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_]);
+    }
+
+    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
+    {
+        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_]);
+    }
+
+    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
+    {
+        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_]);
+    }
+
+    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
+    {
+        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_]);
+    }
+
+    template<class V> void accept(V & v) const
+    {
+        base_type::accept(v);
+    }
+
+    bool operator==(list5 const & rhs) const
+    {
+        return
+
+            ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
+            ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
+            ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
+            ref_compare( base_type::a4_, rhs.a4_, 0 ) &&
+            ref_compare( base_type::a5_, rhs.a5_, 0 );
+    }
+};
+
+template<class A1, class A2, class A3, class A4, class A5, class A6> class list6: private storage6< A1, A2, A3, A4, A5, A6 >
+{
+private:
+
+    typedef storage6< A1, A2, A3, A4, A5, A6 > base_type;
+
+public:
+
+    list6( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6 ): base_type( a1, a2, a3, a4, a5, a6 ) {}
+
+    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
+    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
+    A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
+    A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
+    A5 operator[] (boost::arg<5>) const { return base_type::a5_; }
+    A6 operator[] (boost::arg<6>) const { return base_type::a6_; }
+
+    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
+    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
+    A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
+    A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
+    A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }
+    A6 operator[] (boost::arg<6> (*) ()) const { return base_type::a6_; }
+
+    template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
+
+    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
+
+    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
+
+    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
+    {
+        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_]);
+    }
+
+    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
+    {
+        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_]);
+    }
+
+    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
+    {
+        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_]);
+    }
+
+    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
+    {
+        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_]);
+    }
+
+    template<class V> void accept(V & v) const
+    {
+        base_type::accept(v);
+    }
+
+    bool operator==(list6 const & rhs) const
+    {
+        return
+
+            ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
+            ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
+            ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
+            ref_compare( base_type::a4_, rhs.a4_, 0 ) &&
+            ref_compare( base_type::a5_, rhs.a5_, 0 ) &&
+            ref_compare( base_type::a6_, rhs.a6_, 0 );
+    }
+};
+
+template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> class list7: private storage7< A1, A2, A3, A4, A5, A6, A7 >
+{
+private:
+
+    typedef storage7< A1, A2, A3, A4, A5, A6, A7 > base_type;
+
+public:
+
+    list7( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7 ): base_type( a1, a2, a3, a4, a5, a6, a7 ) {}
+
+    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
+    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
+    A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
+    A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
+    A5 operator[] (boost::arg<5>) const { return base_type::a5_; }
+    A6 operator[] (boost::arg<6>) const { return base_type::a6_; }
+    A7 operator[] (boost::arg<7>) const { return base_type::a7_; }
+
+    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
+    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
+    A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
+    A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
+    A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }
+    A6 operator[] (boost::arg<6> (*) ()) const { return base_type::a6_; }
+    A7 operator[] (boost::arg<7> (*) ()) const { return base_type::a7_; }
+
+    template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
+
+    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
+
+    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
+
+    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
+    {
+        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_]);
+    }
+
+    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
+    {
+        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_]);
+    }
+
+    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
+    {
+        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_]);
+    }
+
+    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
+    {
+        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_]);
+    }
+
+    template<class V> void accept(V & v) const
+    {
+        base_type::accept(v);
+    }
+
+    bool operator==(list7 const & rhs) const
+    {
+        return
+
+            ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
+            ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
+            ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
+            ref_compare( base_type::a4_, rhs.a4_, 0 ) &&
+            ref_compare( base_type::a5_, rhs.a5_, 0 ) &&
+            ref_compare( base_type::a6_, rhs.a6_, 0 ) &&
+            ref_compare( base_type::a7_, rhs.a7_, 0 );
+    }
+};
+
+template< class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 > class list8: private storage8< A1, A2, A3, A4, A5, A6, A7, A8 >
+{
+private:
+
+    typedef storage8< A1, A2, A3, A4, A5, A6, A7, A8 > base_type;
+
+public:
+
+    list8( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8 ): base_type( a1, a2, a3, a4, a5, a6, a7, a8 ) {}
+
+    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
+    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
+    A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
+    A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
+    A5 operator[] (boost::arg<5>) const { return base_type::a5_; }
+    A6 operator[] (boost::arg<6>) const { return base_type::a6_; }
+    A7 operator[] (boost::arg<7>) const { return base_type::a7_; }
+    A8 operator[] (boost::arg<8>) const { return base_type::a8_; }
+
+    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
+    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
+    A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
+    A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
+    A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }
+    A6 operator[] (boost::arg<6> (*) ()) const { return base_type::a6_; }
+    A7 operator[] (boost::arg<7> (*) ()) const { return base_type::a7_; }
+    A8 operator[] (boost::arg<8> (*) ()) const { return base_type::a8_; }
+
+    template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
+
+    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
+
+    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
+
+    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
+    {
+        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_]);
+    }
+
+    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
+    {
+        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_]);
+    }
+
+    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
+    {
+        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_]);
+    }
+
+    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
+    {
+        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_]);
+    }
+
+    template<class V> void accept(V & v) const
+    {
+        base_type::accept(v);
+    }
+
+    bool operator==(list8 const & rhs) const
+    {
+        return
+
+            ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
+            ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
+            ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
+            ref_compare( base_type::a4_, rhs.a4_, 0 ) &&
+            ref_compare( base_type::a5_, rhs.a5_, 0 ) &&
+            ref_compare( base_type::a6_, rhs.a6_, 0 ) &&
+            ref_compare( base_type::a7_, rhs.a7_, 0 ) &&
+            ref_compare( base_type::a8_, rhs.a8_, 0 );
+    }
+};
+
+template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> class list9: private storage9< A1, A2, A3, A4, A5, A6, A7, A8, A9 >
+{
+private:
+
+    typedef storage9< A1, A2, A3, A4, A5, A6, A7, A8, A9 > base_type;
+
+public:
+
+    list9( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9 ): base_type( a1, a2, a3, a4, a5, a6, a7, a8, a9 ) {}
+
+    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
+    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
+    A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
+    A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
+    A5 operator[] (boost::arg<5>) const { return base_type::a5_; }
+    A6 operator[] (boost::arg<6>) const { return base_type::a6_; }
+    A7 operator[] (boost::arg<7>) const { return base_type::a7_; }
+    A8 operator[] (boost::arg<8>) const { return base_type::a8_; }
+    A9 operator[] (boost::arg<9>) const { return base_type::a9_; }
+
+    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
+    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
+    A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
+    A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
+    A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }
+    A6 operator[] (boost::arg<6> (*) ()) const { return base_type::a6_; }
+    A7 operator[] (boost::arg<7> (*) ()) const { return base_type::a7_; }
+    A8 operator[] (boost::arg<8> (*) ()) const { return base_type::a8_; }
+    A9 operator[] (boost::arg<9> (*) ()) const { return base_type::a9_; }
+
+    template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
+
+    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
+
+    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
+
+    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
+    {
+        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_], a[base_type::a9_]);
+    }
+
+    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
+    {
+        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_], a[base_type::a9_]);
+    }
+
+    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
+    {
+        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_], a[base_type::a9_]);
+    }
+
+    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
+    {
+        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_], a[base_type::a9_]);
+    }
+
+    template<class V> void accept(V & v) const
+    {
+        base_type::accept(v);
+    }
+
+    bool operator==(list9 const & rhs) const
+    {
+        return
+
+            ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
+            ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
+            ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
+            ref_compare( base_type::a4_, rhs.a4_, 0 ) &&
+            ref_compare( base_type::a5_, rhs.a5_, 0 ) &&
+            ref_compare( base_type::a6_, rhs.a6_, 0 ) &&
+            ref_compare( base_type::a7_, rhs.a7_, 0 ) &&
+            ref_compare( base_type::a8_, rhs.a8_, 0 ) &&
+            ref_compare( base_type::a9_, rhs.a9_, 0 );
+    }
+};
+# 870 "/usr/include/boost/bind/bind.hpp" 3 4
+template< class A1 > class rrlist1
+{
+private:
+
+    A1 & a1_;
+
+public:
+
+    explicit rrlist1( A1 & a1 ): a1_( a1 ) {}
+
+    A1 && operator[] (boost::arg<1>) const { return std::forward<A1>( a1_ ); }
+
+    A1 && operator[] (boost::arg<1> (*) ()) const { return std::forward<A1>( a1_ ); }
+
+    template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); }
+
+    template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); }
+
+    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const
+    {
+        rrlist1<A1&> a( a1_ );
+        return b.eval( a );
+    }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const
+    {
+        rrlist1<A1&> a( a1_ );
+        return b.eval( a );
+    }
+};
+
+template< class A1, class A2 > class rrlist2
+{
+private:
+
+    A1 & a1_;
+    A2 & a2_;
+
+public:
+
+    rrlist2( A1 & a1, A2 & a2 ): a1_( a1 ), a2_( a2 ) {}
+
+    A1 && operator[] (boost::arg<1>) const { return std::forward<A1>( a1_ ); }
+    A2 && operator[] (boost::arg<2>) const { return std::forward<A2>( a2_ ); }
+
+    A1 && operator[] (boost::arg<1> (*) ()) const { return std::forward<A1>( a1_ ); }
+    A2 && operator[] (boost::arg<2> (*) ()) const { return std::forward<A2>( a2_ ); }
+
+    template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); }
+
+    template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); }
+
+    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const
+    {
+        rrlist2<A1&, A2&> a( a1_, a2_ );
+        return b.eval( a );
+    }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const
+    {
+        rrlist2<A1&, A2&> a( a1_, a2_ );
+        return b.eval( a );
+    }
+};
+
+template< class A1, class A2, class A3 > class rrlist3
+{
+private:
+
+    A1 & a1_;
+    A2 & a2_;
+    A3 & a3_;
+
+public:
+
+    rrlist3( A1 & a1, A2 & a2, A3 & a3 ): a1_( a1 ), a2_( a2 ), a3_( a3 ) {}
+
+    A1 && operator[] (boost::arg<1>) const { return std::forward<A1>( a1_ ); }
+    A2 && operator[] (boost::arg<2>) const { return std::forward<A2>( a2_ ); }
+    A3 && operator[] (boost::arg<3>) const { return std::forward<A3>( a3_ ); }
+
+    A1 && operator[] (boost::arg<1> (*) ()) const { return std::forward<A1>( a1_ ); }
+    A2 && operator[] (boost::arg<2> (*) ()) const { return std::forward<A2>( a2_ ); }
+    A3 && operator[] (boost::arg<3> (*) ()) const { return std::forward<A3>( a3_ ); }
+
+    template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); }
+
+    template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); }
+
+    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const
+    {
+        rrlist3<A1&, A2&, A3&> a( a1_, a2_, a3_ );
+        return b.eval( a );
+    }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const
+    {
+        rrlist3<A1&, A2&, A3&> a( a1_, a2_, a3_ );
+        return b.eval( a );
+    }
+};
+
+template< class A1, class A2, class A3, class A4 > class rrlist4
+{
+private:
+
+    A1 & a1_;
+    A2 & a2_;
+    A3 & a3_;
+    A4 & a4_;
+
+public:
+
+    rrlist4( A1 & a1, A2 & a2, A3 & a3, A4 & a4 ): a1_( a1 ), a2_( a2 ), a3_( a3 ), a4_( a4 ) {}
+
+    A1 && operator[] (boost::arg<1>) const { return std::forward<A1>( a1_ ); }
+    A2 && operator[] (boost::arg<2>) const { return std::forward<A2>( a2_ ); }
+    A3 && operator[] (boost::arg<3>) const { return std::forward<A3>( a3_ ); }
+    A4 && operator[] (boost::arg<4>) const { return std::forward<A4>( a4_ ); }
+
+    A1 && operator[] (boost::arg<1> (*) ()) const { return std::forward<A1>( a1_ ); }
+    A2 && operator[] (boost::arg<2> (*) ()) const { return std::forward<A2>( a2_ ); }
+    A3 && operator[] (boost::arg<3> (*) ()) const { return std::forward<A3>( a3_ ); }
+    A4 && operator[] (boost::arg<4> (*) ()) const { return std::forward<A4>( a4_ ); }
+
+    template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); }
+
+    template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); }
+
+    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const
+    {
+        rrlist4<A1&, A2&, A3&, A4&> a( a1_, a2_, a3_, a4_ );
+        return b.eval( a );
+    }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const
+    {
+        rrlist4<A1&, A2&, A3&, A4&> a( a1_, a2_, a3_, a4_ );
+        return b.eval( a );
+    }
+};
+
+template< class A1, class A2, class A3, class A4, class A5 > class rrlist5
+{
+private:
+
+    A1 & a1_;
+    A2 & a2_;
+    A3 & a3_;
+    A4 & a4_;
+    A5 & a5_;
+
+public:
+
+    rrlist5( A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5 ): a1_( a1 ), a2_( a2 ), a3_( a3 ), a4_( a4 ), a5_( a5 ) {}
+
+    A1 && operator[] (boost::arg<1>) const { return std::forward<A1>( a1_ ); }
+    A2 && operator[] (boost::arg<2>) const { return std::forward<A2>( a2_ ); }
+    A3 && operator[] (boost::arg<3>) const { return std::forward<A3>( a3_ ); }
+    A4 && operator[] (boost::arg<4>) const { return std::forward<A4>( a4_ ); }
+    A5 && operator[] (boost::arg<5>) const { return std::forward<A5>( a5_ ); }
+
+    A1 && operator[] (boost::arg<1> (*) ()) const { return std::forward<A1>( a1_ ); }
+    A2 && operator[] (boost::arg<2> (*) ()) const { return std::forward<A2>( a2_ ); }
+    A3 && operator[] (boost::arg<3> (*) ()) const { return std::forward<A3>( a3_ ); }
+    A4 && operator[] (boost::arg<4> (*) ()) const { return std::forward<A4>( a4_ ); }
+    A5 && operator[] (boost::arg<5> (*) ()) const { return std::forward<A5>( a5_ ); }
+
+    template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); }
+
+    template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); }
+
+    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const
+    {
+        rrlist5<A1&, A2&, A3&, A4&, A5&> a( a1_, a2_, a3_, a4_, a5_ );
+        return b.eval( a );
+    }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const
+    {
+        rrlist5<A1&, A2&, A3&, A4&, A5&> a( a1_, a2_, a3_, a4_, a5_ );
+        return b.eval( a );
+    }
+};
+
+template< class A1, class A2, class A3, class A4, class A5, class A6 > class rrlist6
+{
+private:
+
+    A1 & a1_;
+    A2 & a2_;
+    A3 & a3_;
+    A4 & a4_;
+    A5 & a5_;
+    A6 & a6_;
+
+public:
+
+    rrlist6( A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6 ): a1_( a1 ), a2_( a2 ), a3_( a3 ), a4_( a4 ), a5_( a5 ), a6_( a6 ) {}
+
+    A1 && operator[] (boost::arg<1>) const { return std::forward<A1>( a1_ ); }
+    A2 && operator[] (boost::arg<2>) const { return std::forward<A2>( a2_ ); }
+    A3 && operator[] (boost::arg<3>) const { return std::forward<A3>( a3_ ); }
+    A4 && operator[] (boost::arg<4>) const { return std::forward<A4>( a4_ ); }
+    A5 && operator[] (boost::arg<5>) const { return std::forward<A5>( a5_ ); }
+    A6 && operator[] (boost::arg<6>) const { return std::forward<A6>( a6_ ); }
+
+    A1 && operator[] (boost::arg<1> (*) ()) const { return std::forward<A1>( a1_ ); }
+    A2 && operator[] (boost::arg<2> (*) ()) const { return std::forward<A2>( a2_ ); }
+    A3 && operator[] (boost::arg<3> (*) ()) const { return std::forward<A3>( a3_ ); }
+    A4 && operator[] (boost::arg<4> (*) ()) const { return std::forward<A4>( a4_ ); }
+    A5 && operator[] (boost::arg<5> (*) ()) const { return std::forward<A5>( a5_ ); }
+    A6 && operator[] (boost::arg<6> (*) ()) const { return std::forward<A6>( a6_ ); }
+
+    template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); }
+
+    template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); }
+
+    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const
+    {
+        rrlist6<A1&, A2&, A3&, A4&, A5&, A6&> a( a1_, a2_, a3_, a4_, a5_, a6_ );
+        return b.eval( a );
+    }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const
+    {
+        rrlist6<A1&, A2&, A3&, A4&, A5&, A6&> a( a1_, a2_, a3_, a4_, a5_, a6_ );
+        return b.eval( a );
+    }
+};
+
+template< class A1, class A2, class A3, class A4, class A5, class A6, class A7 > class rrlist7
+{
+private:
+
+    A1 & a1_;
+    A2 & a2_;
+    A3 & a3_;
+    A4 & a4_;
+    A5 & a5_;
+    A6 & a6_;
+    A7 & a7_;
+
+public:
+
+    rrlist7( A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7 ): a1_( a1 ), a2_( a2 ), a3_( a3 ), a4_( a4 ), a5_( a5 ), a6_( a6 ), a7_( a7 ) {}
+
+    A1 && operator[] (boost::arg<1>) const { return std::forward<A1>( a1_ ); }
+    A2 && operator[] (boost::arg<2>) const { return std::forward<A2>( a2_ ); }
+    A3 && operator[] (boost::arg<3>) const { return std::forward<A3>( a3_ ); }
+    A4 && operator[] (boost::arg<4>) const { return std::forward<A4>( a4_ ); }
+    A5 && operator[] (boost::arg<5>) const { return std::forward<A5>( a5_ ); }
+    A6 && operator[] (boost::arg<6>) const { return std::forward<A6>( a6_ ); }
+    A7 && operator[] (boost::arg<7>) const { return std::forward<A7>( a7_ ); }
+
+    A1 && operator[] (boost::arg<1> (*) ()) const { return std::forward<A1>( a1_ ); }
+    A2 && operator[] (boost::arg<2> (*) ()) const { return std::forward<A2>( a2_ ); }
+    A3 && operator[] (boost::arg<3> (*) ()) const { return std::forward<A3>( a3_ ); }
+    A4 && operator[] (boost::arg<4> (*) ()) const { return std::forward<A4>( a4_ ); }
+    A5 && operator[] (boost::arg<5> (*) ()) const { return std::forward<A5>( a5_ ); }
+    A6 && operator[] (boost::arg<6> (*) ()) const { return std::forward<A6>( a6_ ); }
+    A7 && operator[] (boost::arg<7> (*) ()) const { return std::forward<A7>( a7_ ); }
+
+    template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); }
+
+    template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); }
+
+    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const
+    {
+        rrlist7<A1&, A2&, A3&, A4&, A5&, A6&, A7&> a( a1_, a2_, a3_, a4_, a5_, a6_, a7_ );
+        return b.eval( a );
+    }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const
+    {
+        rrlist7<A1&, A2&, A3&, A4&, A5&, A6&, A7&> a( a1_, a2_, a3_, a4_, a5_, a6_, a7_ );
+        return b.eval( a );
+    }
+};
+
+template< class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 > class rrlist8
+{
+private:
+
+    A1 & a1_;
+    A2 & a2_;
+    A3 & a3_;
+    A4 & a4_;
+    A5 & a5_;
+    A6 & a6_;
+    A7 & a7_;
+    A8 & a8_;
+
+public:
+
+    rrlist8( A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8 ): a1_( a1 ), a2_( a2 ), a3_( a3 ), a4_( a4 ), a5_( a5 ), a6_( a6 ), a7_( a7 ), a8_( a8 ) {}
+
+    A1 && operator[] (boost::arg<1>) const { return std::forward<A1>( a1_ ); }
+    A2 && operator[] (boost::arg<2>) const { return std::forward<A2>( a2_ ); }
+    A3 && operator[] (boost::arg<3>) const { return std::forward<A3>( a3_ ); }
+    A4 && operator[] (boost::arg<4>) const { return std::forward<A4>( a4_ ); }
+    A5 && operator[] (boost::arg<5>) const { return std::forward<A5>( a5_ ); }
+    A6 && operator[] (boost::arg<6>) const { return std::forward<A6>( a6_ ); }
+    A7 && operator[] (boost::arg<7>) const { return std::forward<A7>( a7_ ); }
+    A8 && operator[] (boost::arg<8>) const { return std::forward<A8>( a8_ ); }
+
+    A1 && operator[] (boost::arg<1> (*) ()) const { return std::forward<A1>( a1_ ); }
+    A2 && operator[] (boost::arg<2> (*) ()) const { return std::forward<A2>( a2_ ); }
+    A3 && operator[] (boost::arg<3> (*) ()) const { return std::forward<A3>( a3_ ); }
+    A4 && operator[] (boost::arg<4> (*) ()) const { return std::forward<A4>( a4_ ); }
+    A5 && operator[] (boost::arg<5> (*) ()) const { return std::forward<A5>( a5_ ); }
+    A6 && operator[] (boost::arg<6> (*) ()) const { return std::forward<A6>( a6_ ); }
+    A7 && operator[] (boost::arg<7> (*) ()) const { return std::forward<A7>( a7_ ); }
+    A8 && operator[] (boost::arg<8> (*) ()) const { return std::forward<A8>( a8_ ); }
+
+    template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); }
+
+    template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); }
+
+    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const
+    {
+        rrlist8<A1&, A2&, A3&, A4&, A5&, A6&, A7&, A8&> a( a1_, a2_, a3_, a4_, a5_, a6_, a7_, a8_ );
+        return b.eval( a );
+    }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const
+    {
+        rrlist8<A1&, A2&, A3&, A4&, A5&, A6&, A7&, A8&> a( a1_, a2_, a3_, a4_, a5_, a6_, a7_, a8_ );
+        return b.eval( a );
+    }
+};
+
+template< class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9 > class rrlist9
+{
+private:
+
+    A1 & a1_;
+    A2 & a2_;
+    A3 & a3_;
+    A4 & a4_;
+    A5 & a5_;
+    A6 & a6_;
+    A7 & a7_;
+    A8 & a8_;
+    A9 & a9_;
+
+public:
+
+    rrlist9( A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9 ): a1_( a1 ), a2_( a2 ), a3_( a3 ), a4_( a4 ), a5_( a5 ), a6_( a6 ), a7_( a7 ), a8_( a8 ), a9_( a9 ) {}
+
+    A1 && operator[] (boost::arg<1>) const { return std::forward<A1>( a1_ ); }
+    A2 && operator[] (boost::arg<2>) const { return std::forward<A2>( a2_ ); }
+    A3 && operator[] (boost::arg<3>) const { return std::forward<A3>( a3_ ); }
+    A4 && operator[] (boost::arg<4>) const { return std::forward<A4>( a4_ ); }
+    A5 && operator[] (boost::arg<5>) const { return std::forward<A5>( a5_ ); }
+    A6 && operator[] (boost::arg<6>) const { return std::forward<A6>( a6_ ); }
+    A7 && operator[] (boost::arg<7>) const { return std::forward<A7>( a7_ ); }
+    A8 && operator[] (boost::arg<8>) const { return std::forward<A8>( a8_ ); }
+    A9 && operator[] (boost::arg<9>) const { return std::forward<A9>( a9_ ); }
+
+    A1 && operator[] (boost::arg<1> (*) ()) const { return std::forward<A1>( a1_ ); }
+    A2 && operator[] (boost::arg<2> (*) ()) const { return std::forward<A2>( a2_ ); }
+    A3 && operator[] (boost::arg<3> (*) ()) const { return std::forward<A3>( a3_ ); }
+    A4 && operator[] (boost::arg<4> (*) ()) const { return std::forward<A4>( a4_ ); }
+    A5 && operator[] (boost::arg<5> (*) ()) const { return std::forward<A5>( a5_ ); }
+    A6 && operator[] (boost::arg<6> (*) ()) const { return std::forward<A6>( a6_ ); }
+    A7 && operator[] (boost::arg<7> (*) ()) const { return std::forward<A7>( a7_ ); }
+    A8 && operator[] (boost::arg<8> (*) ()) const { return std::forward<A8>( a8_ ); }
+    A9 && operator[] (boost::arg<9> (*) ()) const { return std::forward<A9>( a9_ ); }
+
+    template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); }
+
+    template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); }
+
+    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const
+    {
+        rrlist9<A1&, A2&, A3&, A4&, A5&, A6&, A7&, A8&, A9&> a( a1_, a2_, a3_, a4_, a5_, a6_, a7_, a8_, a9_ );
+        return b.eval( a );
+    }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const
+    {
+        rrlist9<A1&, A2&, A3&, A4&, A5&, A6&, A7&, A8&, A9&> a( a1_, a2_, a3_, a4_, a5_, a6_, a7_, a8_, a9_ );
+        return b.eval( a );
+    }
+};
+
+template<class R, class F, class L> class bind_t
+{
+private:
+
+    F f_;
+    L l_;
+
+public:
+
+    typedef typename result_traits<R, F>::type result_type;
+    typedef bind_t this_type;
+
+    bind_t( F f, L const & l ): f_( f ), l_( l ) {}
+
+
+
+    result_type operator()()
+    {
+        list0 a;
+        return l_( type<result_type>(), f_, a, 0 );
+    }
+
+    result_type operator()() const
+    {
+        list0 a;
+        return l_( type<result_type>(), f_, a, 0 );
+    }
+
+    template<class A1> result_type operator()( A1 && a1 )
+    {
+        rrlist1< A1 > a( a1 );
+        return l_( type<result_type>(), f_, a, 0 );
+    }
+
+    template<class A1> result_type operator()( A1 && a1 ) const
+    {
+        rrlist1< A1 > a( a1 );
+        return l_(type<result_type>(), f_, a, 0);
+    }
+
+    template<class A1, class A2> result_type operator()( A1 && a1, A2 && a2 )
+    {
+        rrlist2< A1, A2 > a( a1, a2 );
+        return l_( type<result_type>(), f_, a, 0 );
+    }
+
+    template<class A1, class A2> result_type operator()( A1 && a1, A2 && a2 ) const
+    {
+        rrlist2< A1, A2 > a( a1, a2 );
+        return l_( type<result_type>(), f_, a, 0 );
+    }
+
+    template<class A1, class A2, class A3> result_type operator()( A1 && a1, A2 && a2, A3 && a3 )
+    {
+        rrlist3< A1, A2, A3 > a( a1, a2, a3 );
+        return l_( type<result_type>(), f_, a, 0 );
+    }
+
+    template<class A1, class A2, class A3> result_type operator()( A1 && a1, A2 && a2, A3 && a3 ) const
+    {
+        rrlist3< A1, A2, A3 > a( a1, a2, a3 );
+        return l_( type<result_type>(), f_, a, 0 );
+    }
+
+    template<class A1, class A2, class A3, class A4> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4 )
+    {
+        rrlist4< A1, A2, A3, A4 > a( a1, a2, a3, a4 );
+        return l_( type<result_type>(), f_, a, 0 );
+    }
+
+    template<class A1, class A2, class A3, class A4> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4 ) const
+    {
+        rrlist4< A1, A2, A3, A4 > a( a1, a2, a3, a4 );
+        return l_( type<result_type>(), f_, a, 0 );
+    }
+
+    template<class A1, class A2, class A3, class A4, class A5> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5 )
+    {
+        rrlist5< A1, A2, A3, A4, A5 > a( a1, a2, a3, a4, a5 );
+        return l_( type<result_type>(), f_, a, 0 );
+    }
+
+    template<class A1, class A2, class A3, class A4, class A5> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5 ) const
+    {
+        rrlist5< A1, A2, A3, A4, A5 > a( a1, a2, a3, a4, a5 );
+        return l_( type<result_type>(), f_, a, 0 );
+    }
+
+    template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6 )
+    {
+        rrlist6< A1, A2, A3, A4, A5, A6 > a( a1, a2, a3, a4, a5, a6 );
+        return l_( type<result_type>(), f_, a, 0 );
+    }
+
+    template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6 ) const
+    {
+        rrlist6< A1, A2, A3, A4, A5, A6 > a( a1, a2, a3, a4, a5, a6 );
+        return l_( type<result_type>(), f_, a, 0 );
+    }
+
+    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7 )
+    {
+        rrlist7< A1, A2, A3, A4, A5, A6, A7 > a( a1, a2, a3, a4, a5, a6, a7 );
+        return l_( type<result_type>(), f_, a, 0 );
+    }
+
+    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7 ) const
+    {
+        rrlist7< A1, A2, A3, A4, A5, A6, A7 > a( a1, a2, a3, a4, a5, a6, a7 );
+        return l_( type<result_type>(), f_, a, 0 );
+    }
+
+    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7, A8 && a8 )
+    {
+        rrlist8< A1, A2, A3, A4, A5, A6, A7, A8 > a( a1, a2, a3, a4, a5, a6, a7, a8 );
+        return l_( type<result_type>(), f_, a, 0 );
+    }
+
+    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7, A8 && a8 ) const
+    {
+        rrlist8< A1, A2, A3, A4, A5, A6, A7, A8 > a( a1, a2, a3, a4, a5, a6, a7, a8 );
+        return l_( type<result_type>(), f_, a, 0 );
+    }
+
+    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7, A8 && a8, A9 && a9 )
+    {
+        rrlist9< A1, A2, A3, A4, A5, A6, A7, A8, A9 > a( a1, a2, a3, a4, a5, a6, a7, a8, a9 );
+        return l_( type<result_type>(), f_, a, 0 );
+    }
+
+    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7, A8 && a8, A9 && a9 ) const
+    {
+        rrlist9< A1, A2, A3, A4, A5, A6, A7, A8, A9 > a( a1, a2, a3, a4, a5, a6, a7, a8, a9 );
+        return l_( type<result_type>(), f_, a, 0 );
+    }
+
+
+
+    template<class A> result_type eval( A & a )
+    {
+        return l_( type<result_type>(), f_, a, 0 );
+    }
+
+    template<class A> result_type eval( A & a ) const
+    {
+        return l_( type<result_type>(), f_, a, 0 );
+    }
+
+    template<class V> void accept( V & v ) const
+    {
+
+        using boost::visit_each;
+
+
+        visit_each( v, f_, 0 );
+        l_.accept( v );
+    }
+
+    bool compare( this_type const & rhs ) const
+    {
+        return ref_compare( f_, rhs.f_, 0 ) && l_ == rhs.l_;
+    }
+};
+# 1517 "/usr/include/boost/bind/bind.hpp" 3 4
+template<class R, class F, class L> bool function_equal( bind_t<R, F, L> const & a, bind_t<R, F, L> const & b )
+{
+    return a.compare(b);
+}
+# 1571 "/usr/include/boost/bind/bind.hpp" 3 4
+template< class T, int I > struct add_value_2
+{
+    typedef boost::arg<I> type;
+};
+
+template< class T > struct add_value_2< T, 0 >
+{
+    typedef _bi::value< T > type;
+};
+
+template<class T> struct add_value
+{
+    typedef typename add_value_2< T, boost::is_placeholder< T >::value >::type type;
+};
+
+
+
+template<class T> struct add_value< value<T> >
+{
+    typedef _bi::value<T> type;
+};
+
+template<class T> struct add_value< reference_wrapper<T> >
+{
+    typedef reference_wrapper<T> type;
+};
+
+template<int I> struct add_value< arg<I> >
+{
+    typedef boost::arg<I> type;
+};
+
+template<int I> struct add_value< arg<I> (*) () >
+{
+    typedef boost::arg<I> (*type) ();
+};
+
+template<class R, class F, class L> struct add_value< bind_t<R, F, L> >
+{
+    typedef bind_t<R, F, L> type;
+};
+# 1654 "/usr/include/boost/bind/bind.hpp" 3 4
+template<class A1> struct list_av_1
+{
+    typedef typename add_value<A1>::type B1;
+    typedef list1<B1> type;
+};
+
+template<class A1, class A2> struct list_av_2
+{
+    typedef typename add_value<A1>::type B1;
+    typedef typename add_value<A2>::type B2;
+    typedef list2<B1, B2> type;
+};
+
+template<class A1, class A2, class A3> struct list_av_3
+{
+    typedef typename add_value<A1>::type B1;
+    typedef typename add_value<A2>::type B2;
+    typedef typename add_value<A3>::type B3;
+    typedef list3<B1, B2, B3> type;
+};
+
+template<class A1, class A2, class A3, class A4> struct list_av_4
+{
+    typedef typename add_value<A1>::type B1;
+    typedef typename add_value<A2>::type B2;
+    typedef typename add_value<A3>::type B3;
+    typedef typename add_value<A4>::type B4;
+    typedef list4<B1, B2, B3, B4> type;
+};
+
+template<class A1, class A2, class A3, class A4, class A5> struct list_av_5
+{
+    typedef typename add_value<A1>::type B1;
+    typedef typename add_value<A2>::type B2;
+    typedef typename add_value<A3>::type B3;
+    typedef typename add_value<A4>::type B4;
+    typedef typename add_value<A5>::type B5;
+    typedef list5<B1, B2, B3, B4, B5> type;
+};
+
+template<class A1, class A2, class A3, class A4, class A5, class A6> struct list_av_6
+{
+    typedef typename add_value<A1>::type B1;
+    typedef typename add_value<A2>::type B2;
+    typedef typename add_value<A3>::type B3;
+    typedef typename add_value<A4>::type B4;
+    typedef typename add_value<A5>::type B5;
+    typedef typename add_value<A6>::type B6;
+    typedef list6<B1, B2, B3, B4, B5, B6> type;
+};
+
+template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> struct list_av_7
+{
+    typedef typename add_value<A1>::type B1;
+    typedef typename add_value<A2>::type B2;
+    typedef typename add_value<A3>::type B3;
+    typedef typename add_value<A4>::type B4;
+    typedef typename add_value<A5>::type B5;
+    typedef typename add_value<A6>::type B6;
+    typedef typename add_value<A7>::type B7;
+    typedef list7<B1, B2, B3, B4, B5, B6, B7> type;
+};
+
+template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> struct list_av_8
+{
+    typedef typename add_value<A1>::type B1;
+    typedef typename add_value<A2>::type B2;
+    typedef typename add_value<A3>::type B3;
+    typedef typename add_value<A4>::type B4;
+    typedef typename add_value<A5>::type B5;
+    typedef typename add_value<A6>::type B6;
+    typedef typename add_value<A7>::type B7;
+    typedef typename add_value<A8>::type B8;
+    typedef list8<B1, B2, B3, B4, B5, B6, B7, B8> type;
+};
+
+template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> struct list_av_9
+{
+    typedef typename add_value<A1>::type B1;
+    typedef typename add_value<A2>::type B2;
+    typedef typename add_value<A3>::type B3;
+    typedef typename add_value<A4>::type B4;
+    typedef typename add_value<A5>::type B5;
+    typedef typename add_value<A6>::type B6;
+    typedef typename add_value<A7>::type B7;
+    typedef typename add_value<A8>::type B8;
+    typedef typename add_value<A9>::type B9;
+    typedef list9<B1, B2, B3, B4, B5, B6, B7, B8, B9> type;
+};
+
+
+
+struct logical_not
+{
+    template<class V> bool operator()(V const & v) const { return !v; }
+};
+
+template<class R, class F, class L>
+    bind_t< bool, logical_not, list1< bind_t<R, F, L> > >
+    operator! (bind_t<R, F, L> const & f)
+{
+    typedef list1< bind_t<R, F, L> > list_type;
+    return bind_t<bool, logical_not, list_type> ( logical_not(), list_type(f) );
+}
+
+
+
+#define BOOST_BIND_OPERATOR(op,name) struct name { template<class V, class W> bool operator()(V const & v, W const & w) const { return v op w; } }; template<class R, class F, class L, class A2> bind_t< bool, name, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator op (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, name, list_type> ( name(), list_type(f, a2) ); }
+# 1777 "/usr/include/boost/bind/bind.hpp" 3 4
+struct equal { template<class V, class W> bool operator()(V const & v, W const & w) const { return v == w; } }; template<class R, class F, class L, class A2> bind_t< bool, equal, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator == (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, equal, list_type> ( equal(), list_type(f, a2) ); }
+struct not_equal { template<class V, class W> bool operator()(V const & v, W const & w) const { return v != w; } }; template<class R, class F, class L, class A2> bind_t< bool, not_equal, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator != (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, not_equal, list_type> ( not_equal(), list_type(f, a2) ); }
+
+struct less { template<class V, class W> bool operator()(V const & v, W const & w) const { return v < w; } }; template<class R, class F, class L, class A2> bind_t< bool, less, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator < (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, less, list_type> ( less(), list_type(f, a2) ); }
+struct less_equal { template<class V, class W> bool operator()(V const & v, W const & w) const { return v <= w; } }; template<class R, class F, class L, class A2> bind_t< bool, less_equal, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator <= (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, less_equal, list_type> ( less_equal(), list_type(f, a2) ); }
+
+struct greater { template<class V, class W> bool operator()(V const & v, W const & w) const { return v > w; } }; template<class R, class F, class L, class A2> bind_t< bool, greater, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator > (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, greater, list_type> ( greater(), list_type(f, a2) ); }
+struct greater_equal { template<class V, class W> bool operator()(V const & v, W const & w) const { return v >= w; } }; template<class R, class F, class L, class A2> bind_t< bool, greater_equal, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator >= (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, greater_equal, list_type> ( greater_equal(), list_type(f, a2) ); }
+
+struct logical_and { template<class V, class W> bool operator()(V const & v, W const & w) const { return v && w; } }; template<class R, class F, class L, class A2> bind_t< bool, logical_and, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator && (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, logical_and, list_type> ( logical_and(), list_type(f, a2) ); }
+struct logical_or { template<class V, class W> bool operator()(V const & v, W const & w) const { return v || w; } }; template<class R, class F, class L, class A2> bind_t< bool, logical_or, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator || (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, logical_or, list_type> ( logical_or(), list_type(f, a2) ); }
+
+#undef BOOST_BIND_OPERATOR
+# 1817 "/usr/include/boost/bind/bind.hpp" 3 4
+template<class V, class T> void visit_each( V & v, value<T> const & t, int )
+{
+    using boost::visit_each;
+    visit_each( v, t.get(), 0 );
+}
+
+template<class V, class R, class F, class L> void visit_each( V & v, bind_t<R, F, L> const & t, int )
+{
+    t.accept( v );
+}
+
+
+
+}
+# 1851 "/usr/include/boost/bind/bind.hpp" 3 4
+template< class T > struct is_bind_expression
+{
+    enum _vt { value = 0 };
+};
+
+
+
+template< class R, class F, class L > struct is_bind_expression< _bi::bind_t< R, F, L > >
+{
+    enum _vt { value = 1 };
+};
+
+
+
+
+
+
+#define BOOST_BIND bind
+
+
+
+
+template<class R, class F>
+    _bi::bind_t<R, F, _bi::list0>
+    bind(F f)
+{
+    typedef _bi::list0 list_type;
+    return _bi::bind_t<R, F, list_type> (f, list_type());
+}
+
+template<class R, class F, class A1>
+    _bi::bind_t<R, F, typename _bi::list_av_1<A1>::type>
+    bind(F f, A1 a1)
+{
+    typedef typename _bi::list_av_1<A1>::type list_type;
+    return _bi::bind_t<R, F, list_type> (f, list_type(a1));
+}
+
+template<class R, class F, class A1, class A2>
+    _bi::bind_t<R, F, typename _bi::list_av_2<A1, A2>::type>
+    bind(F f, A1 a1, A2 a2)
+{
+    typedef typename _bi::list_av_2<A1, A2>::type list_type;
+    return _bi::bind_t<R, F, list_type> (f, list_type(a1, a2));
+}
+
+template<class R, class F, class A1, class A2, class A3>
+    _bi::bind_t<R, F, typename _bi::list_av_3<A1, A2, A3>::type>
+    bind(F f, A1 a1, A2 a2, A3 a3)
+{
+    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
+    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3));
+}
+
+template<class R, class F, class A1, class A2, class A3, class A4>
+    _bi::bind_t<R, F, typename _bi::list_av_4<A1, A2, A3, A4>::type>
+    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4)
+{
+    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
+    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4));
+}
+
+template<class R, class F, class A1, class A2, class A3, class A4, class A5>
+    _bi::bind_t<R, F, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
+    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
+{
+    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
+    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5));
+}
+
+template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6>
+    _bi::bind_t<R, F, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
+    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
+{
+    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
+    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6));
+}
+
+template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
+    _bi::bind_t<R, F, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
+    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
+{
+    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
+    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7));
+}
+
+template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
+    _bi::bind_t<R, F, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
+    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
+{
+    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
+    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8));
+}
+
+template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
+    _bi::bind_t<R, F, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
+    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
+{
+    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
+    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
+}
+
+
+
+template<class R, class F>
+    _bi::bind_t<R, F, _bi::list0>
+    bind(boost::type<R>, F f)
+{
+    typedef _bi::list0 list_type;
+    return _bi::bind_t<R, F, list_type> (f, list_type());
+}
+
+template<class R, class F, class A1>
+    _bi::bind_t<R, F, typename _bi::list_av_1<A1>::type>
+    bind(boost::type<R>, F f, A1 a1)
+{
+    typedef typename _bi::list_av_1<A1>::type list_type;
+    return _bi::bind_t<R, F, list_type> (f, list_type(a1));
+}
+
+template<class R, class F, class A1, class A2>
+    _bi::bind_t<R, F, typename _bi::list_av_2<A1, A2>::type>
+    bind(boost::type<R>, F f, A1 a1, A2 a2)
+{
+    typedef typename _bi::list_av_2<A1, A2>::type list_type;
+    return _bi::bind_t<R, F, list_type> (f, list_type(a1, a2));
+}
+
+template<class R, class F, class A1, class A2, class A3>
+    _bi::bind_t<R, F, typename _bi::list_av_3<A1, A2, A3>::type>
+    bind(boost::type<R>, F f, A1 a1, A2 a2, A3 a3)
+{
+    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
+    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3));
+}
+
+template<class R, class F, class A1, class A2, class A3, class A4>
+    _bi::bind_t<R, F, typename _bi::list_av_4<A1, A2, A3, A4>::type>
+    bind(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4)
+{
+    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
+    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4));
+}
+
+template<class R, class F, class A1, class A2, class A3, class A4, class A5>
+    _bi::bind_t<R, F, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
+    bind(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
+{
+    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
+    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5));
+}
+
+template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6>
+    _bi::bind_t<R, F, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
+    bind(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
+{
+    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
+    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6));
+}
+
+template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
+    _bi::bind_t<R, F, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
+    bind(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
+{
+    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
+    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7));
+}
+
+template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
+    _bi::bind_t<R, F, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
+    bind(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
+{
+    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
+    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8));
+}
+
+template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
+    _bi::bind_t<R, F, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
+    bind(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
+{
+    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
+    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
+}
+
+
+
+
+
+template<class F>
+    _bi::bind_t<_bi::unspecified, F, _bi::list0>
+    bind(F f)
+{
+    typedef _bi::list0 list_type;
+    return _bi::bind_t<_bi::unspecified, F, list_type> (f, list_type());
+}
+
+template<class F, class A1>
+    _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_1<A1>::type>
+    bind(F f, A1 a1)
+{
+    typedef typename _bi::list_av_1<A1>::type list_type;
+    return _bi::bind_t<_bi::unspecified, F, list_type> (f, list_type(a1));
+}
+
+template<class F, class A1, class A2>
+    _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_2<A1, A2>::type>
+    bind(F f, A1 a1, A2 a2)
+{
+    typedef typename _bi::list_av_2<A1, A2>::type list_type;
+    return _bi::bind_t<_bi::unspecified, F, list_type> (f, list_type(a1, a2));
+}
+
+template<class F, class A1, class A2, class A3>
+    _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_3<A1, A2, A3>::type>
+    bind(F f, A1 a1, A2 a2, A3 a3)
+{
+    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
+    return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3));
+}
+
+template<class F, class A1, class A2, class A3, class A4>
+    _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_4<A1, A2, A3, A4>::type>
+    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4)
+{
+    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
+    return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4));
+}
+
+template<class F, class A1, class A2, class A3, class A4, class A5>
+    _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
+    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
+{
+    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
+    return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5));
+}
+
+template<class F, class A1, class A2, class A3, class A4, class A5, class A6>
+    _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
+    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
+{
+    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
+    return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6));
+}
+
+template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
+    _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
+    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
+{
+    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
+    return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7));
+}
+
+template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
+    _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
+    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
+{
+    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
+    return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8));
+}
+
+template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
+    _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
+    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
+{
+    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
+    return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
+}
+
+
+
+
+
+#define BOOST_BIND_CC 
+#define BOOST_BIND_ST 
+#define BOOST_BIND_NOEXCEPT 
+
+# 1 "/usr/include/boost/bind/bind_cc.hpp" 1 3 4
+# 15 "/usr/include/boost/bind/bind_cc.hpp" 3 4
+template<class R>
+    _bi::bind_t<R, R ( *) () , _bi::list0>
+    bind( R ( *f) () )
+{
+    typedef R ( *F) () ;
+    typedef _bi::list0 list_type;
+    return _bi::bind_t<R, F, list_type> (f, list_type());
+}
+
+template<class R, class B1, class A1>
+    _bi::bind_t<R, R ( *) (B1) , typename _bi::list_av_1<A1>::type>
+    bind( R ( *f) (B1) , A1 a1)
+{
+    typedef R ( *F) (B1) ;
+    typedef typename _bi::list_av_1<A1>::type list_type;
+    return _bi::bind_t<R, F, list_type> (f, list_type(a1));
+}
+
+template<class R, class B1, class B2, class A1, class A2>
+    _bi::bind_t<R, R ( *) (B1, B2) , typename _bi::list_av_2<A1, A2>::type>
+    bind( R ( *f) (B1, B2) , A1 a1, A2 a2)
+{
+    typedef R ( *F) (B1, B2) ;
+    typedef typename _bi::list_av_2<A1, A2>::type list_type;
+    return _bi::bind_t<R, F, list_type> (f, list_type(a1, a2));
+}
+
+template<class R,
+    class B1, class B2, class B3,
+    class A1, class A2, class A3>
+    _bi::bind_t<R, R ( *) (B1, B2, B3) , typename _bi::list_av_3<A1, A2, A3>::type>
+    bind( R ( *f) (B1, B2, B3) , A1 a1, A2 a2, A3 a3)
+{
+    typedef R ( *F) (B1, B2, B3) ;
+    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
+    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3));
+}
+
+template<class R,
+    class B1, class B2, class B3, class B4,
+    class A1, class A2, class A3, class A4>
+    _bi::bind_t<R, R ( *) (B1, B2, B3, B4) , typename _bi::list_av_4<A1, A2, A3, A4>::type>
+    bind( R ( *f) (B1, B2, B3, B4) , A1 a1, A2 a2, A3 a3, A4 a4)
+{
+    typedef R ( *F) (B1, B2, B3, B4) ;
+    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
+    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4));
+}
+
+template<class R,
+    class B1, class B2, class B3, class B4, class B5,
+    class A1, class A2, class A3, class A4, class A5>
+    _bi::bind_t<R, R ( *) (B1, B2, B3, B4, B5) , typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
+    bind( R ( *f) (B1, B2, B3, B4, B5) , A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
+{
+    typedef R ( *F) (B1, B2, B3, B4, B5) ;
+    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
+    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5));
+}
+
+template<class R,
+    class B1, class B2, class B3, class B4, class B5, class B6,
+    class A1, class A2, class A3, class A4, class A5, class A6>
+    _bi::bind_t<R, R ( *) (B1, B2, B3, B4, B5, B6) , typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
+    bind( R ( *f) (B1, B2, B3, B4, B5, B6) , A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
+{
+    typedef R ( *F) (B1, B2, B3, B4, B5, B6) ;
+    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
+    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6));
+}
+
+template<class R,
+    class B1, class B2, class B3, class B4, class B5, class B6, class B7,
+    class A1, class A2, class A3, class A4, class A5, class A6, class A7>
+    _bi::bind_t<R, R ( *) (B1, B2, B3, B4, B5, B6, B7) , typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
+    bind( R ( *f) (B1, B2, B3, B4, B5, B6, B7) , A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
+{
+    typedef R ( *F) (B1, B2, B3, B4, B5, B6, B7) ;
+    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
+    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7));
+}
+
+template<class R,
+    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
+    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
+    _bi::bind_t<R, R ( *) (B1, B2, B3, B4, B5, B6, B7, B8) , typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
+    bind( R ( *f) (B1, B2, B3, B4, B5, B6, B7, B8) , A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
+{
+    typedef R ( *F) (B1, B2, B3, B4, B5, B6, B7, B8) ;
+    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
+    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8));
+}
+
+template<class R,
+    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8, class B9,
+    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
+    _bi::bind_t<R, R ( *) (B1, B2, B3, B4, B5, B6, B7, B8, B9) , typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
+    bind( R ( *f) (B1, B2, B3, B4, B5, B6, B7, B8, B9) , A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
+{
+    typedef R ( *F) (B1, B2, B3, B4, B5, B6, B7, B8, B9) ;
+    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
+    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
+}
+# 2128 "/usr/include/boost/bind/bind.hpp" 2 3 4
+
+
+#undef BOOST_BIND_NOEXCEPT
+#define BOOST_BIND_NOEXCEPT noexcept
+# 1 "/usr/include/boost/bind/bind_cc.hpp" 1 3 4
+# 15 "/usr/include/boost/bind/bind_cc.hpp" 3 4
+template<class R>
+    _bi::bind_t<R, R ( *) () noexcept, _bi::list0>
+    bind( R ( *f) () noexcept)
+{
+    typedef R ( *F) () noexcept;
+    typedef _bi::list0 list_type;
+    return _bi::bind_t<R, F, list_type> (f, list_type());
+}
+
+template<class R, class B1, class A1>
+    _bi::bind_t<R, R ( *) (B1) noexcept, typename _bi::list_av_1<A1>::type>
+    bind( R ( *f) (B1) noexcept, A1 a1)
+{
+    typedef R ( *F) (B1) noexcept;
+    typedef typename _bi::list_av_1<A1>::type list_type;
+    return _bi::bind_t<R, F, list_type> (f, list_type(a1));
+}
+
+template<class R, class B1, class B2, class A1, class A2>
+    _bi::bind_t<R, R ( *) (B1, B2) noexcept, typename _bi::list_av_2<A1, A2>::type>
+    bind( R ( *f) (B1, B2) noexcept, A1 a1, A2 a2)
+{
+    typedef R ( *F) (B1, B2) noexcept;
+    typedef typename _bi::list_av_2<A1, A2>::type list_type;
+    return _bi::bind_t<R, F, list_type> (f, list_type(a1, a2));
+}
+
+template<class R,
+    class B1, class B2, class B3,
+    class A1, class A2, class A3>
+    _bi::bind_t<R, R ( *) (B1, B2, B3) noexcept, typename _bi::list_av_3<A1, A2, A3>::type>
+    bind( R ( *f) (B1, B2, B3) noexcept, A1 a1, A2 a2, A3 a3)
+{
+    typedef R ( *F) (B1, B2, B3) noexcept;
+    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
+    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3));
+}
+
+template<class R,
+    class B1, class B2, class B3, class B4,
+    class A1, class A2, class A3, class A4>
+    _bi::bind_t<R, R ( *) (B1, B2, B3, B4) noexcept, typename _bi::list_av_4<A1, A2, A3, A4>::type>
+    bind( R ( *f) (B1, B2, B3, B4) noexcept, A1 a1, A2 a2, A3 a3, A4 a4)
+{
+    typedef R ( *F) (B1, B2, B3, B4) noexcept;
+    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
+    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4));
+}
+
+template<class R,
+    class B1, class B2, class B3, class B4, class B5,
+    class A1, class A2, class A3, class A4, class A5>
+    _bi::bind_t<R, R ( *) (B1, B2, B3, B4, B5) noexcept, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
+    bind( R ( *f) (B1, B2, B3, B4, B5) noexcept, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
+{
+    typedef R ( *F) (B1, B2, B3, B4, B5) noexcept;
+    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
+    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5));
+}
+
+template<class R,
+    class B1, class B2, class B3, class B4, class B5, class B6,
+    class A1, class A2, class A3, class A4, class A5, class A6>
+    _bi::bind_t<R, R ( *) (B1, B2, B3, B4, B5, B6) noexcept, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
+    bind( R ( *f) (B1, B2, B3, B4, B5, B6) noexcept, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
+{
+    typedef R ( *F) (B1, B2, B3, B4, B5, B6) noexcept;
+    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
+    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6));
+}
+
+template<class R,
+    class B1, class B2, class B3, class B4, class B5, class B6, class B7,
+    class A1, class A2, class A3, class A4, class A5, class A6, class A7>
+    _bi::bind_t<R, R ( *) (B1, B2, B3, B4, B5, B6, B7) noexcept, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
+    bind( R ( *f) (B1, B2, B3, B4, B5, B6, B7) noexcept, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
+{
+    typedef R ( *F) (B1, B2, B3, B4, B5, B6, B7) noexcept;
+    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
+    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7));
+}
+
+template<class R,
+    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
+    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
+    _bi::bind_t<R, R ( *) (B1, B2, B3, B4, B5, B6, B7, B8) noexcept, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
+    bind( R ( *f) (B1, B2, B3, B4, B5, B6, B7, B8) noexcept, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
+{
+    typedef R ( *F) (B1, B2, B3, B4, B5, B6, B7, B8) noexcept;
+    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
+    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8));
+}
+
+template<class R,
+    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8, class B9,
+    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
+    _bi::bind_t<R, R ( *) (B1, B2, B3, B4, B5, B6, B7, B8, B9) noexcept, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
+    bind( R ( *f) (B1, B2, B3, B4, B5, B6, B7, B8, B9) noexcept, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
+{
+    typedef R ( *F) (B1, B2, B3, B4, B5, B6, B7, B8, B9) noexcept;
+    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
+    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
+}
+# 2133 "/usr/include/boost/bind/bind.hpp" 2 3 4
+
+
+#undef BOOST_BIND_CC
+#undef BOOST_BIND_ST
+#undef BOOST_BIND_NOEXCEPT
+# 2183 "/usr/include/boost/bind/bind.hpp" 3 4
+#define BOOST_BIND_MF_NAME(X) X
+#define BOOST_BIND_MF_CC 
+#define BOOST_BIND_MF_NOEXCEPT 
+
+# 1 "/usr/include/boost/bind/bind_mf_cc.hpp" 1 3 4
+# 17 "/usr/include/boost/bind/bind_mf_cc.hpp" 3 4
+template<class R, class T,
+    class A1>
+    _bi::bind_t<R, _mfi::mf0<R, T>, typename _bi::list_av_1<A1>::type>
+    bind(R ( T::*f) () , A1 a1)
+{
+    typedef _mfi::mf0<R, T> F;
+    typedef typename _bi::list_av_1<A1>::type list_type;
+    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1));
+}
+
+template<class R, class T,
+    class A1>
+    _bi::bind_t<R, _mfi::cmf0<R, T>, typename _bi::list_av_1<A1>::type>
+    bind(R ( T::*f) () const , A1 a1)
+{
+    typedef _mfi::cmf0<R, T> F;
+    typedef typename _bi::list_av_1<A1>::type list_type;
+    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1));
+}
+
+template<class Rt2, class R, class T,
+    class A1>
+    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
+    _bi::bind_t<Rt2, _mfi::mf0<R, T>, typename _bi::list_av_1<A1>::type>
+    >::type bind(R ( T::*f) () , A1 a1)
+{
+    typedef _mfi::mf0<R, T> F;
+    typedef typename _bi::list_av_1<A1>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1));
+}
+
+template<class Rt2, class R, class T,
+    class A1>
+    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
+    _bi::bind_t<Rt2, _mfi::cmf0<R, T>, typename _bi::list_av_1<A1>::type>
+    >::type bind(R ( T::*f) () const , A1 a1)
+{
+    typedef _mfi::cmf0<R, T> F;
+    typedef typename _bi::list_av_1<A1>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1));
+}
+
+
+
+template<class R, class T,
+    class B1,
+    class A1, class A2>
+    _bi::bind_t<R, _mfi::mf1<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
+    bind(R ( T::*f) (B1) , A1 a1, A2 a2)
+{
+    typedef _mfi::mf1<R, T, B1> F;
+    typedef typename _bi::list_av_2<A1, A2>::type list_type;
+    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2));
+}
+
+template<class R, class T,
+    class B1,
+    class A1, class A2>
+    _bi::bind_t<R, _mfi::cmf1<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
+    bind(R ( T::*f) (B1) const , A1 a1, A2 a2)
+{
+    typedef _mfi::cmf1<R, T, B1> F;
+    typedef typename _bi::list_av_2<A1, A2>::type list_type;
+    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2));
+}
+
+template<class Rt2, class R, class T,
+    class B1,
+    class A1, class A2>
+    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
+    _bi::bind_t<Rt2, _mfi::mf1<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
+    >::type bind(R ( T::*f) (B1) , A1 a1, A2 a2)
+{
+    typedef _mfi::mf1<R, T, B1> F;
+    typedef typename _bi::list_av_2<A1, A2>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2));
+}
+
+template<class Rt2, class R, class T,
+    class B1,
+    class A1, class A2>
+    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
+    _bi::bind_t<Rt2, _mfi::cmf1<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
+    >::type bind(R ( T::*f) (B1) const , A1 a1, A2 a2)
+{
+    typedef _mfi::cmf1<R, T, B1> F;
+    typedef typename _bi::list_av_2<A1, A2>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2));
+}
+
+
+
+template<class R, class T,
+    class B1, class B2,
+    class A1, class A2, class A3>
+    _bi::bind_t<R, _mfi::mf2<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
+    bind(R ( T::*f) (B1, B2) , A1 a1, A2 a2, A3 a3)
+{
+    typedef _mfi::mf2<R, T, B1, B2> F;
+    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
+    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3));
+}
+
+template<class R, class T,
+    class B1, class B2,
+    class A1, class A2, class A3>
+    _bi::bind_t<R, _mfi::cmf2<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
+    bind(R ( T::*f) (B1, B2) const , A1 a1, A2 a2, A3 a3)
+{
+    typedef _mfi::cmf2<R, T, B1, B2> F;
+    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
+    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3));
+}
+
+template<class Rt2, class R, class T,
+    class B1, class B2,
+    class A1, class A2, class A3>
+    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
+    _bi::bind_t<Rt2, _mfi::mf2<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
+    >::type bind(R ( T::*f) (B1, B2) , A1 a1, A2 a2, A3 a3)
+{
+    typedef _mfi::mf2<R, T, B1, B2> F;
+    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3));
+}
+
+template<class Rt2, class R, class T,
+    class B1, class B2,
+    class A1, class A2, class A3>
+    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
+    _bi::bind_t<Rt2, _mfi::cmf2<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
+    >::type bind(R ( T::*f) (B1, B2) const , A1 a1, A2 a2, A3 a3)
+{
+    typedef _mfi::cmf2<R, T, B1, B2> F;
+    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3));
+}
+
+
+
+template<class R, class T,
+    class B1, class B2, class B3,
+    class A1, class A2, class A3, class A4>
+    _bi::bind_t<R, _mfi::mf3<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
+    bind(R ( T::*f) (B1, B2, B3) , A1 a1, A2 a2, A3 a3, A4 a4)
+{
+    typedef _mfi::mf3<R, T, B1, B2, B3> F;
+    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
+    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4));
+}
+
+template<class R, class T,
+    class B1, class B2, class B3,
+    class A1, class A2, class A3, class A4>
+    _bi::bind_t<R, _mfi::cmf3<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
+    bind(R ( T::*f) (B1, B2, B3) const , A1 a1, A2 a2, A3 a3, A4 a4)
+{
+    typedef _mfi::cmf3<R, T, B1, B2, B3> F;
+    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
+    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4));
+}
+
+template<class Rt2, class R, class T,
+    class B1, class B2, class B3,
+    class A1, class A2, class A3, class A4>
+    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
+    _bi::bind_t<Rt2, _mfi::mf3<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
+    >::type bind(R ( T::*f) (B1, B2, B3) , A1 a1, A2 a2, A3 a3, A4 a4)
+{
+    typedef _mfi::mf3<R, T, B1, B2, B3> F;
+    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4));
+}
+
+template<class Rt2, class R, class T,
+    class B1, class B2, class B3,
+    class A1, class A2, class A3, class A4>
+    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
+    _bi::bind_t<Rt2, _mfi::cmf3<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
+    >::type bind(R ( T::*f) (B1, B2, B3) const , A1 a1, A2 a2, A3 a3, A4 a4)
+{
+    typedef _mfi::cmf3<R, T, B1, B2, B3> F;
+    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4));
+}
+
+
+
+template<class R, class T,
+    class B1, class B2, class B3, class B4,
+    class A1, class A2, class A3, class A4, class A5>
+    _bi::bind_t<R, _mfi::mf4<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
+    bind(R ( T::*f) (B1, B2, B3, B4) , A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
+{
+    typedef _mfi::mf4<R, T, B1, B2, B3, B4> F;
+    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
+    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
+}
+
+template<class R, class T,
+    class B1, class B2, class B3, class B4,
+    class A1, class A2, class A3, class A4, class A5>
+    _bi::bind_t<R, _mfi::cmf4<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
+    bind(R ( T::*f) (B1, B2, B3, B4) const , A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
+{
+    typedef _mfi::cmf4<R, T, B1, B2, B3, B4> F;
+    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
+    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
+}
+
+template<class Rt2, class R, class T,
+    class B1, class B2, class B3, class B4,
+    class A1, class A2, class A3, class A4, class A5>
+    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
+    _bi::bind_t<Rt2, _mfi::mf4<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
+    >::type bind(R ( T::*f) (B1, B2, B3, B4) , A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
+{
+    typedef _mfi::mf4<R, T, B1, B2, B3, B4> F;
+    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
+}
+
+template<class Rt2, class R, class T,
+    class B1, class B2, class B3, class B4,
+    class A1, class A2, class A3, class A4, class A5>
+    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
+    _bi::bind_t<Rt2, _mfi::cmf4<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
+    >::type bind(R ( T::*f) (B1, B2, B3, B4) const , A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
+{
+    typedef _mfi::cmf4<R, T, B1, B2, B3, B4> F;
+    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
+}
+
+
+
+template<class R, class T,
+    class B1, class B2, class B3, class B4, class B5,
+    class A1, class A2, class A3, class A4, class A5, class A6>
+    _bi::bind_t<R, _mfi::mf5<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
+    bind(R ( T::*f) (B1, B2, B3, B4, B5) , A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
+{
+    typedef _mfi::mf5<R, T, B1, B2, B3, B4, B5> F;
+    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
+    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
+}
+
+template<class R, class T,
+    class B1, class B2, class B3, class B4, class B5,
+    class A1, class A2, class A3, class A4, class A5, class A6>
+    _bi::bind_t<R, _mfi::cmf5<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
+    bind(R ( T::*f) (B1, B2, B3, B4, B5) const , A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
+{
+    typedef _mfi::cmf5<R, T, B1, B2, B3, B4, B5> F;
+    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
+    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
+}
+
+template<class Rt2, class R, class T,
+    class B1, class B2, class B3, class B4, class B5,
+    class A1, class A2, class A3, class A4, class A5, class A6>
+    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
+    _bi::bind_t<Rt2, _mfi::mf5<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
+    >::type bind(R ( T::*f) (B1, B2, B3, B4, B5) , A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
+{
+    typedef _mfi::mf5<R, T, B1, B2, B3, B4, B5> F;
+    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
+}
+
+template<class Rt2, class R, class T,
+    class B1, class B2, class B3, class B4, class B5,
+    class A1, class A2, class A3, class A4, class A5, class A6>
+    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
+    _bi::bind_t<Rt2, _mfi::cmf5<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
+    >::type bind(R ( T::*f) (B1, B2, B3, B4, B5) const , A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
+{
+    typedef _mfi::cmf5<R, T, B1, B2, B3, B4, B5> F;
+    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
+}
+
+
+
+template<class R, class T,
+    class B1, class B2, class B3, class B4, class B5, class B6,
+    class A1, class A2, class A3, class A4, class A5, class A6, class A7>
+    _bi::bind_t<R, _mfi::mf6<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
+    bind(R ( T::*f) (B1, B2, B3, B4, B5, B6) , A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
+{
+    typedef _mfi::mf6<R, T, B1, B2, B3, B4, B5, B6> F;
+    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
+    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
+}
+
+template<class R, class T,
+    class B1, class B2, class B3, class B4, class B5, class B6,
+    class A1, class A2, class A3, class A4, class A5, class A6, class A7>
+    _bi::bind_t<R, _mfi::cmf6<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
+    bind(R ( T::*f) (B1, B2, B3, B4, B5, B6) const , A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
+{
+    typedef _mfi::cmf6<R, T, B1, B2, B3, B4, B5, B6> F;
+    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
+    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
+}
+
+template<class Rt2, class R, class T,
+    class B1, class B2, class B3, class B4, class B5, class B6,
+    class A1, class A2, class A3, class A4, class A5, class A6, class A7>
+    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
+    _bi::bind_t<Rt2, _mfi::mf6<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
+    >::type bind(R ( T::*f) (B1, B2, B3, B4, B5, B6) , A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
+{
+    typedef _mfi::mf6<R, T, B1, B2, B3, B4, B5, B6> F;
+    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
+}
+
+template<class Rt2, class R, class T,
+    class B1, class B2, class B3, class B4, class B5, class B6,
+    class A1, class A2, class A3, class A4, class A5, class A6, class A7>
+    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
+    _bi::bind_t<Rt2, _mfi::cmf6<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
+    >::type bind(R ( T::*f) (B1, B2, B3, B4, B5, B6) const , A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
+{
+    typedef _mfi::cmf6<R, T, B1, B2, B3, B4, B5, B6> F;
+    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
+}
+
+
+
+template<class R, class T,
+    class B1, class B2, class B3, class B4, class B5, class B6, class B7,
+    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
+    _bi::bind_t<R, _mfi::mf7<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
+    bind(R ( T::*f) (B1, B2, B3, B4, B5, B6, B7) , A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
+{
+    typedef _mfi::mf7<R, T, B1, B2, B3, B4, B5, B6, B7> F;
+    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
+    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
+}
+
+template<class R, class T,
+    class B1, class B2, class B3, class B4, class B5, class B6, class B7,
+    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
+    _bi::bind_t<R, _mfi::cmf7<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
+    bind(R ( T::*f) (B1, B2, B3, B4, B5, B6, B7) const , A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
+{
+    typedef _mfi::cmf7<R, T, B1, B2, B3, B4, B5, B6, B7> F;
+    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
+    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
+}
+
+template<class Rt2, class R, class T,
+    class B1, class B2, class B3, class B4, class B5, class B6, class B7,
+    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
+    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
+    _bi::bind_t<Rt2, _mfi::mf7<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
+    >::type bind(R ( T::*f) (B1, B2, B3, B4, B5, B6, B7) , A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
+{
+    typedef _mfi::mf7<R, T, B1, B2, B3, B4, B5, B6, B7> F;
+    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
+}
+
+template<class Rt2, class R, class T,
+    class B1, class B2, class B3, class B4, class B5, class B6, class B7,
+    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
+    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
+    _bi::bind_t<Rt2, _mfi::cmf7<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
+    >::type bind(R ( T::*f) (B1, B2, B3, B4, B5, B6, B7) const , A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
+{
+    typedef _mfi::cmf7<R, T, B1, B2, B3, B4, B5, B6, B7> F;
+    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
+}
+
+
+
+template<class R, class T,
+    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
+    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
+    _bi::bind_t<R, _mfi::mf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
+    bind(R ( T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) , A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
+{
+    typedef _mfi::mf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
+    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
+    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
+}
+
+template<class R, class T,
+    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
+    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
+    _bi::bind_t<R, _mfi::cmf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
+    bind(R ( T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) const , A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
+{
+    typedef _mfi::cmf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
+    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
+    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
+}
+
+template<class Rt2, class R, class T,
+    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
+    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
+    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
+    _bi::bind_t<Rt2, _mfi::mf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
+    >::type bind(R ( T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) , A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
+{
+    typedef _mfi::mf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
+    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
+}
+
+template<class Rt2, class R, class T,
+    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
+    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
+    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
+    _bi::bind_t<Rt2, _mfi::cmf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
+    >::type bind(R ( T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) const , A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
+{
+    typedef _mfi::cmf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
+    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
+}
+# 2188 "/usr/include/boost/bind/bind.hpp" 2 3 4
+# 1 "/usr/include/boost/bind/bind_mf2_cc.hpp" 1 3 4
+# 18 "/usr/include/boost/bind/bind_mf2_cc.hpp" 3 4
+template<class Rt2, class R, class T,
+    class A1>
+    _bi::bind_t<Rt2, _mfi::mf0<R, T>, typename _bi::list_av_1<A1>::type>
+    bind(boost::type<Rt2>, R ( T::*f) (), A1 a1)
+{
+    typedef _mfi::mf0<R, T> F;
+    typedef typename _bi::list_av_1<A1>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1));
+}
+
+template<class Rt2, class R, class T,
+    class A1>
+    _bi::bind_t<Rt2, _mfi::cmf0<R, T>, typename _bi::list_av_1<A1>::type>
+    bind(boost::type<Rt2>, R ( T::*f) () const, A1 a1)
+{
+    typedef _mfi::cmf0<R, T> F;
+    typedef typename _bi::list_av_1<A1>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1));
+}
+
+
+
+template<class Rt2, class R, class T,
+    class B1,
+    class A1, class A2>
+    _bi::bind_t<Rt2, _mfi::mf1<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
+    bind(boost::type<Rt2>, R ( T::*f) (B1), A1 a1, A2 a2)
+{
+    typedef _mfi::mf1<R, T, B1> F;
+    typedef typename _bi::list_av_2<A1, A2>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2));
+}
+
+template<class Rt2, class R, class T,
+    class B1,
+    class A1, class A2>
+    _bi::bind_t<Rt2, _mfi::cmf1<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
+    bind(boost::type<Rt2>, R ( T::*f) (B1) const, A1 a1, A2 a2)
+{
+    typedef _mfi::cmf1<R, T, B1> F;
+    typedef typename _bi::list_av_2<A1, A2>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2));
+}
+
+
+
+template<class Rt2, class R, class T,
+    class B1, class B2,
+    class A1, class A2, class A3>
+    _bi::bind_t<Rt2, _mfi::mf2<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
+    bind(boost::type<Rt2>, R ( T::*f) (B1, B2), A1 a1, A2 a2, A3 a3)
+{
+    typedef _mfi::mf2<R, T, B1, B2> F;
+    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3));
+}
+
+template<class Rt2, class R, class T,
+    class B1, class B2,
+    class A1, class A2, class A3>
+    _bi::bind_t<Rt2, _mfi::cmf2<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
+    bind(boost::type<Rt2>, R ( T::*f) (B1, B2) const, A1 a1, A2 a2, A3 a3)
+{
+    typedef _mfi::cmf2<R, T, B1, B2> F;
+    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3));
+}
+
+
+
+template<class Rt2, class R, class T,
+    class B1, class B2, class B3,
+    class A1, class A2, class A3, class A4>
+    _bi::bind_t<Rt2, _mfi::mf3<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
+    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3), A1 a1, A2 a2, A3 a3, A4 a4)
+{
+    typedef _mfi::mf3<R, T, B1, B2, B3> F;
+    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4));
+}
+
+template<class Rt2, class R, class T,
+    class B1, class B2, class B3,
+    class A1, class A2, class A3, class A4>
+    _bi::bind_t<Rt2, _mfi::cmf3<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
+    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3) const, A1 a1, A2 a2, A3 a3, A4 a4)
+{
+    typedef _mfi::cmf3<R, T, B1, B2, B3> F;
+    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4));
+}
+
+
+
+template<class Rt2, class R, class T,
+    class B1, class B2, class B3, class B4,
+    class A1, class A2, class A3, class A4, class A5>
+    _bi::bind_t<Rt2, _mfi::mf4<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
+    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
+{
+    typedef _mfi::mf4<R, T, B1, B2, B3, B4> F;
+    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
+}
+
+template<class Rt2, class R, class T,
+    class B1, class B2, class B3, class B4,
+    class A1, class A2, class A3, class A4, class A5>
+    _bi::bind_t<Rt2, _mfi::cmf4<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
+    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
+{
+    typedef _mfi::cmf4<R, T, B1, B2, B3, B4> F;
+    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
+}
+
+
+
+template<class Rt2, class R, class T,
+    class B1, class B2, class B3, class B4, class B5,
+    class A1, class A2, class A3, class A4, class A5, class A6>
+    _bi::bind_t<Rt2, _mfi::mf5<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
+    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4, B5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
+{
+    typedef _mfi::mf5<R, T, B1, B2, B3, B4, B5> F;
+    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
+}
+
+template<class Rt2, class R, class T,
+    class B1, class B2, class B3, class B4, class B5,
+    class A1, class A2, class A3, class A4, class A5, class A6>
+    _bi::bind_t<Rt2, _mfi::cmf5<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
+    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4, B5) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
+{
+    typedef _mfi::cmf5<R, T, B1, B2, B3, B4, B5> F;
+    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
+}
+
+
+
+template<class Rt2, class R, class T,
+    class B1, class B2, class B3, class B4, class B5, class B6,
+    class A1, class A2, class A3, class A4, class A5, class A6, class A7>
+    _bi::bind_t<Rt2, _mfi::mf6<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
+    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4, B5, B6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
+{
+    typedef _mfi::mf6<R, T, B1, B2, B3, B4, B5, B6> F;
+    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
+}
+
+template<class Rt2, class R, class T,
+    class B1, class B2, class B3, class B4, class B5, class B6,
+    class A1, class A2, class A3, class A4, class A5, class A6, class A7>
+    _bi::bind_t<Rt2, _mfi::cmf6<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
+    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4, B5, B6) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
+{
+    typedef _mfi::cmf6<R, T, B1, B2, B3, B4, B5, B6> F;
+    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
+}
+
+
+
+template<class Rt2, class R, class T,
+    class B1, class B2, class B3, class B4, class B5, class B6, class B7,
+    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
+    _bi::bind_t<Rt2, _mfi::mf7<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
+    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4, B5, B6, B7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
+{
+    typedef _mfi::mf7<R, T, B1, B2, B3, B4, B5, B6, B7> F;
+    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
+}
+
+template<class Rt2, class R, class T,
+    class B1, class B2, class B3, class B4, class B5, class B6, class B7,
+    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
+    _bi::bind_t<Rt2, _mfi::cmf7<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
+    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4, B5, B6, B7) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
+{
+    typedef _mfi::cmf7<R, T, B1, B2, B3, B4, B5, B6, B7> F;
+    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
+}
+
+
+
+template<class Rt2, class R, class T,
+    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
+    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
+    _bi::bind_t<Rt2, _mfi::mf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
+    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4, B5, B6, B7, B8), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
+{
+    typedef _mfi::mf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
+    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
+}
+
+template<class Rt2, class R, class T,
+    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
+    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
+    _bi::bind_t<Rt2, _mfi::cmf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
+    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
+{
+    typedef _mfi::cmf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
+    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
+}
+# 2189 "/usr/include/boost/bind/bind.hpp" 2 3 4
+
+
+#undef BOOST_BIND_MF_NOEXCEPT
+#define BOOST_BIND_MF_NOEXCEPT noexcept
+# 1 "/usr/include/boost/bind/bind_mf_cc.hpp" 1 3 4
+# 17 "/usr/include/boost/bind/bind_mf_cc.hpp" 3 4
+template<class R, class T,
+    class A1>
+    _bi::bind_t<R, _mfi::mf0<R, T>, typename _bi::list_av_1<A1>::type>
+    bind(R ( T::*f) () noexcept, A1 a1)
+{
+    typedef _mfi::mf0<R, T> F;
+    typedef typename _bi::list_av_1<A1>::type list_type;
+    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1));
+}
+
+template<class R, class T,
+    class A1>
+    _bi::bind_t<R, _mfi::cmf0<R, T>, typename _bi::list_av_1<A1>::type>
+    bind(R ( T::*f) () const noexcept, A1 a1)
+{
+    typedef _mfi::cmf0<R, T> F;
+    typedef typename _bi::list_av_1<A1>::type list_type;
+    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1));
+}
+
+template<class Rt2, class R, class T,
+    class A1>
+    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
+    _bi::bind_t<Rt2, _mfi::mf0<R, T>, typename _bi::list_av_1<A1>::type>
+    >::type bind(R ( T::*f) () noexcept, A1 a1)
+{
+    typedef _mfi::mf0<R, T> F;
+    typedef typename _bi::list_av_1<A1>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1));
+}
+
+template<class Rt2, class R, class T,
+    class A1>
+    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
+    _bi::bind_t<Rt2, _mfi::cmf0<R, T>, typename _bi::list_av_1<A1>::type>
+    >::type bind(R ( T::*f) () const noexcept, A1 a1)
+{
+    typedef _mfi::cmf0<R, T> F;
+    typedef typename _bi::list_av_1<A1>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1));
+}
+
+
+
+template<class R, class T,
+    class B1,
+    class A1, class A2>
+    _bi::bind_t<R, _mfi::mf1<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
+    bind(R ( T::*f) (B1) noexcept, A1 a1, A2 a2)
+{
+    typedef _mfi::mf1<R, T, B1> F;
+    typedef typename _bi::list_av_2<A1, A2>::type list_type;
+    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2));
+}
+
+template<class R, class T,
+    class B1,
+    class A1, class A2>
+    _bi::bind_t<R, _mfi::cmf1<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
+    bind(R ( T::*f) (B1) const noexcept, A1 a1, A2 a2)
+{
+    typedef _mfi::cmf1<R, T, B1> F;
+    typedef typename _bi::list_av_2<A1, A2>::type list_type;
+    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2));
+}
+
+template<class Rt2, class R, class T,
+    class B1,
+    class A1, class A2>
+    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
+    _bi::bind_t<Rt2, _mfi::mf1<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
+    >::type bind(R ( T::*f) (B1) noexcept, A1 a1, A2 a2)
+{
+    typedef _mfi::mf1<R, T, B1> F;
+    typedef typename _bi::list_av_2<A1, A2>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2));
+}
+
+template<class Rt2, class R, class T,
+    class B1,
+    class A1, class A2>
+    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
+    _bi::bind_t<Rt2, _mfi::cmf1<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
+    >::type bind(R ( T::*f) (B1) const noexcept, A1 a1, A2 a2)
+{
+    typedef _mfi::cmf1<R, T, B1> F;
+    typedef typename _bi::list_av_2<A1, A2>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2));
+}
+
+
+
+template<class R, class T,
+    class B1, class B2,
+    class A1, class A2, class A3>
+    _bi::bind_t<R, _mfi::mf2<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
+    bind(R ( T::*f) (B1, B2) noexcept, A1 a1, A2 a2, A3 a3)
+{
+    typedef _mfi::mf2<R, T, B1, B2> F;
+    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
+    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3));
+}
+
+template<class R, class T,
+    class B1, class B2,
+    class A1, class A2, class A3>
+    _bi::bind_t<R, _mfi::cmf2<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
+    bind(R ( T::*f) (B1, B2) const noexcept, A1 a1, A2 a2, A3 a3)
+{
+    typedef _mfi::cmf2<R, T, B1, B2> F;
+    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
+    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3));
+}
+
+template<class Rt2, class R, class T,
+    class B1, class B2,
+    class A1, class A2, class A3>
+    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
+    _bi::bind_t<Rt2, _mfi::mf2<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
+    >::type bind(R ( T::*f) (B1, B2) noexcept, A1 a1, A2 a2, A3 a3)
+{
+    typedef _mfi::mf2<R, T, B1, B2> F;
+    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3));
+}
+
+template<class Rt2, class R, class T,
+    class B1, class B2,
+    class A1, class A2, class A3>
+    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
+    _bi::bind_t<Rt2, _mfi::cmf2<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
+    >::type bind(R ( T::*f) (B1, B2) const noexcept, A1 a1, A2 a2, A3 a3)
+{
+    typedef _mfi::cmf2<R, T, B1, B2> F;
+    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3));
+}
+
+
+
+template<class R, class T,
+    class B1, class B2, class B3,
+    class A1, class A2, class A3, class A4>
+    _bi::bind_t<R, _mfi::mf3<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
+    bind(R ( T::*f) (B1, B2, B3) noexcept, A1 a1, A2 a2, A3 a3, A4 a4)
+{
+    typedef _mfi::mf3<R, T, B1, B2, B3> F;
+    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
+    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4));
+}
+
+template<class R, class T,
+    class B1, class B2, class B3,
+    class A1, class A2, class A3, class A4>
+    _bi::bind_t<R, _mfi::cmf3<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
+    bind(R ( T::*f) (B1, B2, B3) const noexcept, A1 a1, A2 a2, A3 a3, A4 a4)
+{
+    typedef _mfi::cmf3<R, T, B1, B2, B3> F;
+    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
+    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4));
+}
+
+template<class Rt2, class R, class T,
+    class B1, class B2, class B3,
+    class A1, class A2, class A3, class A4>
+    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
+    _bi::bind_t<Rt2, _mfi::mf3<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
+    >::type bind(R ( T::*f) (B1, B2, B3) noexcept, A1 a1, A2 a2, A3 a3, A4 a4)
+{
+    typedef _mfi::mf3<R, T, B1, B2, B3> F;
+    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4));
+}
+
+template<class Rt2, class R, class T,
+    class B1, class B2, class B3,
+    class A1, class A2, class A3, class A4>
+    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
+    _bi::bind_t<Rt2, _mfi::cmf3<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
+    >::type bind(R ( T::*f) (B1, B2, B3) const noexcept, A1 a1, A2 a2, A3 a3, A4 a4)
+{
+    typedef _mfi::cmf3<R, T, B1, B2, B3> F;
+    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4));
+}
+
+
+
+template<class R, class T,
+    class B1, class B2, class B3, class B4,
+    class A1, class A2, class A3, class A4, class A5>
+    _bi::bind_t<R, _mfi::mf4<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
+    bind(R ( T::*f) (B1, B2, B3, B4) noexcept, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
+{
+    typedef _mfi::mf4<R, T, B1, B2, B3, B4> F;
+    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
+    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
+}
+
+template<class R, class T,
+    class B1, class B2, class B3, class B4,
+    class A1, class A2, class A3, class A4, class A5>
+    _bi::bind_t<R, _mfi::cmf4<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
+    bind(R ( T::*f) (B1, B2, B3, B4) const noexcept, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
+{
+    typedef _mfi::cmf4<R, T, B1, B2, B3, B4> F;
+    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
+    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
+}
+
+template<class Rt2, class R, class T,
+    class B1, class B2, class B3, class B4,
+    class A1, class A2, class A3, class A4, class A5>
+    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
+    _bi::bind_t<Rt2, _mfi::mf4<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
+    >::type bind(R ( T::*f) (B1, B2, B3, B4) noexcept, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
+{
+    typedef _mfi::mf4<R, T, B1, B2, B3, B4> F;
+    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
+}
+
+template<class Rt2, class R, class T,
+    class B1, class B2, class B3, class B4,
+    class A1, class A2, class A3, class A4, class A5>
+    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
+    _bi::bind_t<Rt2, _mfi::cmf4<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
+    >::type bind(R ( T::*f) (B1, B2, B3, B4) const noexcept, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
+{
+    typedef _mfi::cmf4<R, T, B1, B2, B3, B4> F;
+    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
+}
+
+
+
+template<class R, class T,
+    class B1, class B2, class B3, class B4, class B5,
+    class A1, class A2, class A3, class A4, class A5, class A6>
+    _bi::bind_t<R, _mfi::mf5<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
+    bind(R ( T::*f) (B1, B2, B3, B4, B5) noexcept, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
+{
+    typedef _mfi::mf5<R, T, B1, B2, B3, B4, B5> F;
+    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
+    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
+}
+
+template<class R, class T,
+    class B1, class B2, class B3, class B4, class B5,
+    class A1, class A2, class A3, class A4, class A5, class A6>
+    _bi::bind_t<R, _mfi::cmf5<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
+    bind(R ( T::*f) (B1, B2, B3, B4, B5) const noexcept, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
+{
+    typedef _mfi::cmf5<R, T, B1, B2, B3, B4, B5> F;
+    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
+    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
+}
+
+template<class Rt2, class R, class T,
+    class B1, class B2, class B3, class B4, class B5,
+    class A1, class A2, class A3, class A4, class A5, class A6>
+    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
+    _bi::bind_t<Rt2, _mfi::mf5<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
+    >::type bind(R ( T::*f) (B1, B2, B3, B4, B5) noexcept, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
+{
+    typedef _mfi::mf5<R, T, B1, B2, B3, B4, B5> F;
+    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
+}
+
+template<class Rt2, class R, class T,
+    class B1, class B2, class B3, class B4, class B5,
+    class A1, class A2, class A3, class A4, class A5, class A6>
+    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
+    _bi::bind_t<Rt2, _mfi::cmf5<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
+    >::type bind(R ( T::*f) (B1, B2, B3, B4, B5) const noexcept, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
+{
+    typedef _mfi::cmf5<R, T, B1, B2, B3, B4, B5> F;
+    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
+}
+
+
+
+template<class R, class T,
+    class B1, class B2, class B3, class B4, class B5, class B6,
+    class A1, class A2, class A3, class A4, class A5, class A6, class A7>
+    _bi::bind_t<R, _mfi::mf6<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
+    bind(R ( T::*f) (B1, B2, B3, B4, B5, B6) noexcept, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
+{
+    typedef _mfi::mf6<R, T, B1, B2, B3, B4, B5, B6> F;
+    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
+    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
+}
+
+template<class R, class T,
+    class B1, class B2, class B3, class B4, class B5, class B6,
+    class A1, class A2, class A3, class A4, class A5, class A6, class A7>
+    _bi::bind_t<R, _mfi::cmf6<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
+    bind(R ( T::*f) (B1, B2, B3, B4, B5, B6) const noexcept, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
+{
+    typedef _mfi::cmf6<R, T, B1, B2, B3, B4, B5, B6> F;
+    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
+    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
+}
+
+template<class Rt2, class R, class T,
+    class B1, class B2, class B3, class B4, class B5, class B6,
+    class A1, class A2, class A3, class A4, class A5, class A6, class A7>
+    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
+    _bi::bind_t<Rt2, _mfi::mf6<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
+    >::type bind(R ( T::*f) (B1, B2, B3, B4, B5, B6) noexcept, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
+{
+    typedef _mfi::mf6<R, T, B1, B2, B3, B4, B5, B6> F;
+    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
+}
+
+template<class Rt2, class R, class T,
+    class B1, class B2, class B3, class B4, class B5, class B6,
+    class A1, class A2, class A3, class A4, class A5, class A6, class A7>
+    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
+    _bi::bind_t<Rt2, _mfi::cmf6<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
+    >::type bind(R ( T::*f) (B1, B2, B3, B4, B5, B6) const noexcept, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
+{
+    typedef _mfi::cmf6<R, T, B1, B2, B3, B4, B5, B6> F;
+    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
+}
+
+
+
+template<class R, class T,
+    class B1, class B2, class B3, class B4, class B5, class B6, class B7,
+    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
+    _bi::bind_t<R, _mfi::mf7<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
+    bind(R ( T::*f) (B1, B2, B3, B4, B5, B6, B7) noexcept, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
+{
+    typedef _mfi::mf7<R, T, B1, B2, B3, B4, B5, B6, B7> F;
+    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
+    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
+}
+
+template<class R, class T,
+    class B1, class B2, class B3, class B4, class B5, class B6, class B7,
+    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
+    _bi::bind_t<R, _mfi::cmf7<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
+    bind(R ( T::*f) (B1, B2, B3, B4, B5, B6, B7) const noexcept, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
+{
+    typedef _mfi::cmf7<R, T, B1, B2, B3, B4, B5, B6, B7> F;
+    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
+    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
+}
+
+template<class Rt2, class R, class T,
+    class B1, class B2, class B3, class B4, class B5, class B6, class B7,
+    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
+    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
+    _bi::bind_t<Rt2, _mfi::mf7<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
+    >::type bind(R ( T::*f) (B1, B2, B3, B4, B5, B6, B7) noexcept, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
+{
+    typedef _mfi::mf7<R, T, B1, B2, B3, B4, B5, B6, B7> F;
+    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
+}
+
+template<class Rt2, class R, class T,
+    class B1, class B2, class B3, class B4, class B5, class B6, class B7,
+    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
+    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
+    _bi::bind_t<Rt2, _mfi::cmf7<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
+    >::type bind(R ( T::*f) (B1, B2, B3, B4, B5, B6, B7) const noexcept, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
+{
+    typedef _mfi::cmf7<R, T, B1, B2, B3, B4, B5, B6, B7> F;
+    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
+}
+
+
+
+template<class R, class T,
+    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
+    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
+    _bi::bind_t<R, _mfi::mf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
+    bind(R ( T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) noexcept, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
+{
+    typedef _mfi::mf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
+    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
+    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
+}
+
+template<class R, class T,
+    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
+    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
+    _bi::bind_t<R, _mfi::cmf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
+    bind(R ( T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) const noexcept, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
+{
+    typedef _mfi::cmf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
+    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
+    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
+}
+
+template<class Rt2, class R, class T,
+    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
+    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
+    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
+    _bi::bind_t<Rt2, _mfi::mf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
+    >::type bind(R ( T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) noexcept, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
+{
+    typedef _mfi::mf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
+    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
+}
+
+template<class Rt2, class R, class T,
+    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
+    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
+    typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
+    _bi::bind_t<Rt2, _mfi::cmf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
+    >::type bind(R ( T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) const noexcept, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
+{
+    typedef _mfi::cmf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
+    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
+}
+# 2194 "/usr/include/boost/bind/bind.hpp" 2 3 4
+
+
+#undef BOOST_BIND_MF_NAME
+#undef BOOST_BIND_MF_CC
+#undef BOOST_BIND_MF_NOEXCEPT
+# 2261 "/usr/include/boost/bind/bind.hpp" 3 4
+namespace _bi
+{
+
+template< class Pm, int I > struct add_cref;
+
+template< class M, class T > struct add_cref< M T::*, 0 >
+{
+    typedef M type;
+};
+
+template< class M, class T > struct add_cref< M T::*, 1 >
+{
+
+
+
+
+    typedef M const & type;
+
+
+
+};
+
+template< class R, class T > struct add_cref< R (T::*) (), 1 >
+{
+    typedef void type;
+};
+
+
+
+template< class R, class T > struct add_cref< R (T::*) () const, 1 >
+{
+    typedef void type;
+};
+
+
+
+template< class R, class T > struct add_cref< R (T::*) () const noexcept, 1 >
+{
+    typedef void type;
+};
+
+
+
+
+
+template<class R> struct isref
+{
+    enum value_type { value = 0 };
+};
+
+template<class R> struct isref< R& >
+{
+    enum value_type { value = 1 };
+};
+
+template<class R> struct isref< R* >
+{
+    enum value_type { value = 1 };
+};
+
+template<class Pm, class A1> struct dm_result
+{
+    typedef typename add_cref< Pm, 1 >::type type;
+};
+
+template<class Pm, class R, class F, class L> struct dm_result< Pm, bind_t<R, F, L> >
+{
+    typedef typename bind_t<R, F, L>::result_type result_type;
+    typedef typename add_cref< Pm, isref< result_type >::value >::type type;
+};
+
+}
+
+template< class A1, class M, class T >
+
+_bi::bind_t<
+    typename _bi::dm_result< M T::*, A1 >::type,
+    _mfi::dm<M, T>,
+    typename _bi::list_av_1<A1>::type
+>
+
+bind( M T::*f, A1 a1 )
+{
+    typedef typename _bi::dm_result< M T::*, A1 >::type result_type;
+    typedef _mfi::dm<M, T> F;
+    typedef typename _bi::list_av_1<A1>::type list_type;
+    return _bi::bind_t< result_type, F, list_type >( F( f ), list_type( a1 ) );
+}
+
+
+
+}
+
+
+
+# 1 "/usr/include/boost/bind/placeholders.hpp" 1 3 4
+
+#define BOOST_BIND_PLACEHOLDERS_HPP_INCLUDED 
+# 26 "/usr/include/boost/bind/placeholders.hpp" 3 4
+namespace boost
+{
+
+namespace placeholders
+{
+# 46 "/usr/include/boost/bind/placeholders.hpp" 3 4
+static constexpr boost::arg<1> _1;
+static constexpr boost::arg<2> _2;
+static constexpr boost::arg<3> _3;
+static constexpr boost::arg<4> _4;
+static constexpr boost::arg<5> _5;
+static constexpr boost::arg<6> _6;
+static constexpr boost::arg<7> _7;
+static constexpr boost::arg<8> _8;
+static constexpr boost::arg<9> _9;
+
+
+
+}
+
+}
+# 2357 "/usr/include/boost/bind/bind.hpp" 2 3 4
+# 23 "/usr/include/boost/bind.hpp" 2 3 4
+# 33 "/usr/include/boost/bind.hpp" 3 4
+using namespace boost::placeholders;
+# 53 "/usr/include/boost/test/impl/framework.ipp" 2 3 4
+
+
+
+
+
+# 1 "/usr/include/c++/10.2.0/cstdlib" 1 3 4
+# 39 "/usr/include/c++/10.2.0/cstdlib" 3 4
+       
+# 40 "/usr/include/c++/10.2.0/cstdlib" 3
+# 59 "/usr/include/boost/test/impl/framework.ipp" 2 3 4
+# 1 "/usr/include/c++/10.2.0/ctime" 1 3 4
+# 39 "/usr/include/c++/10.2.0/ctime" 3 4
+       
+# 40 "/usr/include/c++/10.2.0/ctime" 3
+# 60 "/usr/include/boost/test/impl/framework.ipp" 2 3 4
+# 1 "/usr/include/c++/10.2.0/numeric" 1 3 4
+# 56 "/usr/include/c++/10.2.0/numeric" 3 4
+#define _GLIBCXX_NUMERIC 1
+
+       
+# 59 "/usr/include/c++/10.2.0/numeric" 3
+
+
+
+# 1 "/usr/include/c++/10.2.0/bits/stl_numeric.h" 1 3
+# 57 "/usr/include/c++/10.2.0/bits/stl_numeric.h" 3
+#define _STL_NUMERIC_H 1
+
+
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 85 "/usr/include/c++/10.2.0/bits/stl_numeric.h" 3
+  template<typename _ForwardIterator, typename _Tp>
+   
+    void
+    iota(_ForwardIterator __first, _ForwardIterator __last, _Tp __value)
+    {
+
+     
+
+     
+
+      ;
+
+      for (; __first != __last; ++__first)
+ {
+   *__first = __value;
+   ++__value;
+ }
+    }
+
+
+
+
+
+
+
+
+
+
+
+#define _GLIBCXX_MOVE_IF_20(_E) _E
+# 131 "/usr/include/c++/10.2.0/bits/stl_numeric.h" 3
+  template<typename _InputIterator, typename _Tp>
+   
+    inline _Tp
+    accumulate(_InputIterator __first, _InputIterator __last, _Tp __init)
+    {
+
+     
+      ;
+
+      for (; __first != __last; ++__first)
+ __init = __init + *__first;
+      return __init;
+    }
+# 158 "/usr/include/c++/10.2.0/bits/stl_numeric.h" 3
+  template<typename _InputIterator, typename _Tp, typename _BinaryOperation>
+   
+    inline _Tp
+    accumulate(_InputIterator __first, _InputIterator __last, _Tp __init,
+        _BinaryOperation __binary_op)
+    {
+
+     
+      ;
+
+      for (; __first != __last; ++__first)
+ __init = __binary_op(__init, *__first);
+      return __init;
+    }
+# 187 "/usr/include/c++/10.2.0/bits/stl_numeric.h" 3
+  template<typename _InputIterator1, typename _InputIterator2, typename _Tp>
+   
+    inline _Tp
+    inner_product(_InputIterator1 __first1, _InputIterator1 __last1,
+    _InputIterator2 __first2, _Tp __init)
+    {
+
+     
+     
+      ;
+
+      for (; __first1 != __last1; ++__first1, (void)++__first2)
+ __init = __init + (*__first1 * *__first2);
+      return __init;
+    }
+# 219 "/usr/include/c++/10.2.0/bits/stl_numeric.h" 3
+  template<typename _InputIterator1, typename _InputIterator2, typename _Tp,
+    typename _BinaryOperation1, typename _BinaryOperation2>
+   
+    inline _Tp
+    inner_product(_InputIterator1 __first1, _InputIterator1 __last1,
+    _InputIterator2 __first2, _Tp __init,
+    _BinaryOperation1 __binary_op1,
+    _BinaryOperation2 __binary_op2)
+    {
+
+     
+     
+      ;
+
+      for (; __first1 != __last1; ++__first1, (void)++__first2)
+ __init = __binary_op1(__init,
+         __binary_op2(*__first1, *__first2));
+      return __init;
+    }
+# 253 "/usr/include/c++/10.2.0/bits/stl_numeric.h" 3
+  template<typename _InputIterator, typename _OutputIterator>
+   
+    _OutputIterator
+    partial_sum(_InputIterator __first, _InputIterator __last,
+  _OutputIterator __result)
+    {
+      typedef typename iterator_traits<_InputIterator>::value_type _ValueType;
+
+
+     
+     
+
+      ;
+
+      if (__first == __last)
+ return __result;
+      _ValueType __value = *__first;
+      *__result = __value;
+      while (++__first != __last)
+ {
+   __value = __value + *__first;
+   *++__result = __value;
+ }
+      return ++__result;
+    }
+# 294 "/usr/include/c++/10.2.0/bits/stl_numeric.h" 3
+  template<typename _InputIterator, typename _OutputIterator,
+    typename _BinaryOperation>
+   
+    _OutputIterator
+    partial_sum(_InputIterator __first, _InputIterator __last,
+  _OutputIterator __result, _BinaryOperation __binary_op)
+    {
+      typedef typename iterator_traits<_InputIterator>::value_type _ValueType;
+
+
+     
+     
+
+      ;
+
+      if (__first == __last)
+ return __result;
+      _ValueType __value = *__first;
+      *__result = __value;
+      while (++__first != __last)
+ {
+   __value = __binary_op(__value, *__first);
+   *++__result = __value;
+ }
+      return ++__result;
+    }
+# 335 "/usr/include/c++/10.2.0/bits/stl_numeric.h" 3
+  template<typename _InputIterator, typename _OutputIterator>
+   
+    _OutputIterator
+    adjacent_difference(_InputIterator __first,
+   _InputIterator __last, _OutputIterator __result)
+    {
+      typedef typename iterator_traits<_InputIterator>::value_type _ValueType;
+
+
+     
+     
+
+      ;
+
+      if (__first == __last)
+ return __result;
+      _ValueType __value = *__first;
+      *__result = __value;
+      while (++__first != __last)
+ {
+   _ValueType __tmp = *__first;
+   *++__result = __tmp - __value;
+   __value = std::move(__tmp);
+ }
+      return ++__result;
+    }
+# 378 "/usr/include/c++/10.2.0/bits/stl_numeric.h" 3
+  template<typename _InputIterator, typename _OutputIterator,
+    typename _BinaryOperation>
+   
+    _OutputIterator
+    adjacent_difference(_InputIterator __first, _InputIterator __last,
+   _OutputIterator __result, _BinaryOperation __binary_op)
+    {
+      typedef typename iterator_traits<_InputIterator>::value_type _ValueType;
+
+
+     
+     
+
+      ;
+
+      if (__first == __last)
+ return __result;
+      _ValueType __value = *__first;
+      *__result = __value;
+      while (++__first != __last)
+ {
+   _ValueType __tmp = *__first;
+   *++__result = __binary_op(__tmp, __value);
+   __value = std::move(__tmp);
+ }
+      return ++__result;
+    }
+
+
+
+#undef _GLIBCXX_MOVE_IF_20
+
+
+}
+# 63 "/usr/include/c++/10.2.0/numeric" 2 3
+# 79 "/usr/include/c++/10.2.0/numeric" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+namespace __detail
+{
+
+  template<typename _Tp>
+    constexpr
+    enable_if_t<__and_<is_integral<_Tp>, is_signed<_Tp>>::value, _Tp>
+    __abs_integral(_Tp __val)
+    { return __val < 0 ? -__val : __val; }
+
+  template<typename _Tp>
+    constexpr
+    enable_if_t<__and_<is_integral<_Tp>, is_unsigned<_Tp>>::value, _Tp>
+    __abs_integral(_Tp __val)
+    { return __val; }
+
+  void __abs_integral(bool) = delete;
+
+  template<typename _Mn, typename _Nn>
+    constexpr common_type_t<_Mn, _Nn>
+    __gcd(_Mn __m, _Nn __n)
+    {
+      return __m == 0 ? __detail::__abs_integral(__n)
+ : __n == 0 ? __detail::__abs_integral(__m)
+ : __detail::__gcd(__n, __m % __n);
+    }
+
+
+  template<typename _Mn, typename _Nn>
+    constexpr common_type_t<_Mn, _Nn>
+    __lcm(_Mn __m, _Nn __n)
+    {
+      return (__m != 0 && __n != 0)
+ ? (__detail::__abs_integral(__m) / __detail::__gcd(__m, __n))
+   * __detail::__abs_integral(__n)
+ : 0;
+    }
+}
+
+
+
+#define __cpp_lib_gcd_lcm 201606
+
+#define __cpp_lib_gcd 201606
+#define __cpp_lib_lcm 201606
+
+
+  template<typename _Mn, typename _Nn>
+    constexpr common_type_t<_Mn, _Nn>
+    gcd(_Mn __m, _Nn __n)
+    {
+      static_assert(is_integral_v<_Mn>, "gcd arguments are integers");
+      static_assert(is_integral_v<_Nn>, "gcd arguments are integers");
+      static_assert(!is_same_v<remove_cv_t<_Mn>, bool>,
+      "gcd arguments are not bools");
+      static_assert(!is_same_v<remove_cv_t<_Nn>, bool>,
+      "gcd arguments are not bools");
+      return __detail::__gcd(__m, __n);
+    }
+
+
+  template<typename _Mn, typename _Nn>
+    constexpr common_type_t<_Mn, _Nn>
+    lcm(_Mn __m, _Nn __n)
+    {
+      static_assert(is_integral_v<_Mn>, "lcm arguments are integers");
+      static_assert(is_integral_v<_Nn>, "lcm arguments are integers");
+      static_assert(!is_same_v<remove_cv_t<_Mn>, bool>,
+      "lcm arguments are not bools");
+      static_assert(!is_same_v<remove_cv_t<_Nn>, bool>,
+      "lcm arguments are not bools");
+      return __detail::__lcm(__m, __n);
+    }
+
+
+
+
+}
+# 225 "/usr/include/c++/10.2.0/numeric" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 255 "/usr/include/c++/10.2.0/numeric" 3
+  template<typename _InputIterator, typename _Tp, typename _BinaryOperation>
+   
+    _Tp
+    reduce(_InputIterator __first, _InputIterator __last, _Tp __init,
+    _BinaryOperation __binary_op)
+    {
+      using value_type = typename iterator_traits<_InputIterator>::value_type;
+      static_assert(is_invocable_r_v<_Tp, _BinaryOperation&, _Tp&, _Tp&>);
+      static_assert(is_convertible_v<value_type, _Tp>);
+      if constexpr (__is_random_access_iter<_InputIterator>::value)
+ {
+   while ((__last - __first) >= 4)
+     {
+       _Tp __v1 = __binary_op(__first[0], __first[1]);
+       _Tp __v2 = __binary_op(__first[2], __first[3]);
+       _Tp __v3 = __binary_op(__v1, __v2);
+       __init = __binary_op(__init, __v3);
+       __first += 4;
+     }
+ }
+      for (; __first != __last; ++__first)
+ __init = __binary_op(__init, *__first);
+      return __init;
+    }
+# 291 "/usr/include/c++/10.2.0/numeric" 3
+  template<typename _InputIterator, typename _Tp>
+   
+    inline _Tp
+    reduce(_InputIterator __first, _InputIterator __last, _Tp __init)
+    { return std::reduce(__first, __last, std::move(__init), plus<>()); }
+# 308 "/usr/include/c++/10.2.0/numeric" 3
+  template<typename _InputIterator>
+   
+    inline typename iterator_traits<_InputIterator>::value_type
+    reduce(_InputIterator __first, _InputIterator __last)
+    {
+      using value_type = typename iterator_traits<_InputIterator>::value_type;
+      return std::reduce(__first, __last, value_type{}, plus<>());
+    }
+# 335 "/usr/include/c++/10.2.0/numeric" 3
+  template<typename _InputIterator1, typename _InputIterator2, typename _Tp,
+    typename _BinaryOperation1, typename _BinaryOperation2>
+   
+    _Tp
+    transform_reduce(_InputIterator1 __first1, _InputIterator1 __last1,
+       _InputIterator2 __first2, _Tp __init,
+       _BinaryOperation1 __binary_op1,
+       _BinaryOperation2 __binary_op2)
+    {
+      if constexpr (__and_v<__is_random_access_iter<_InputIterator1>,
+       __is_random_access_iter<_InputIterator2>>)
+ {
+   while ((__last1 - __first1) >= 4)
+     {
+       _Tp __v1 = __binary_op1(__binary_op2(__first1[0], __first2[0]),
+          __binary_op2(__first1[1], __first2[1]));
+       _Tp __v2 = __binary_op1(__binary_op2(__first1[2], __first2[2]),
+          __binary_op2(__first1[3], __first2[3]));
+       _Tp __v3 = __binary_op1(__v1, __v2);
+       __init = __binary_op1(__init, __v3);
+       __first1 += 4;
+       __first2 += 4;
+     }
+ }
+      for (; __first1 != __last1; ++__first1, (void) ++__first2)
+ __init = __binary_op1(__init, __binary_op2(*__first1, *__first2));
+      return __init;
+    }
+# 379 "/usr/include/c++/10.2.0/numeric" 3
+  template<typename _InputIterator1, typename _InputIterator2, typename _Tp>
+   
+    inline _Tp
+    transform_reduce(_InputIterator1 __first1, _InputIterator1 __last1,
+       _InputIterator2 __first2, _Tp __init)
+    {
+      return std::transform_reduce(__first1, __last1, __first2,
+       std::move(__init),
+       plus<>(), multiplies<>());
+    }
+# 404 "/usr/include/c++/10.2.0/numeric" 3
+  template<typename _InputIterator, typename _Tp,
+    typename _BinaryOperation, typename _UnaryOperation>
+   
+    _Tp
+    transform_reduce(_InputIterator __first, _InputIterator __last, _Tp __init,
+       _BinaryOperation __binary_op, _UnaryOperation __unary_op)
+    {
+      if constexpr (__is_random_access_iter<_InputIterator>::value)
+ {
+   while ((__last - __first) >= 4)
+     {
+       _Tp __v1 = __binary_op(__unary_op(__first[0]),
+         __unary_op(__first[1]));
+       _Tp __v2 = __binary_op(__unary_op(__first[2]),
+         __unary_op(__first[3]));
+       _Tp __v3 = __binary_op(__v1, __v2);
+       __init = __binary_op(__init, __v3);
+       __first += 4;
+     }
+ }
+      for (; __first != __last; ++__first)
+ __init = __binary_op(__init, __unary_op(*__first));
+      return __init;
+    }
+# 447 "/usr/include/c++/10.2.0/numeric" 3
+  template<typename _InputIterator, typename _OutputIterator, typename _Tp,
+    typename _BinaryOperation>
+   
+    _OutputIterator
+    exclusive_scan(_InputIterator __first, _InputIterator __last,
+     _OutputIterator __result, _Tp __init,
+     _BinaryOperation __binary_op)
+    {
+      while (__first != __last)
+ {
+   auto __v = __init;
+   __init = __binary_op(__init, *__first);
+   ++__first;
+   *__result++ = std::move(__v);
+ }
+      return __result;
+    }
+# 482 "/usr/include/c++/10.2.0/numeric" 3
+  template<typename _InputIterator, typename _OutputIterator, typename _Tp>
+   
+    inline _OutputIterator
+    exclusive_scan(_InputIterator __first, _InputIterator __last,
+     _OutputIterator __result, _Tp __init)
+    {
+      return std::exclusive_scan(__first, __last, __result, std::move(__init),
+     plus<>());
+    }
+# 510 "/usr/include/c++/10.2.0/numeric" 3
+  template<typename _InputIterator, typename _OutputIterator,
+    typename _BinaryOperation, typename _Tp>
+   
+    _OutputIterator
+    inclusive_scan(_InputIterator __first, _InputIterator __last,
+     _OutputIterator __result, _BinaryOperation __binary_op,
+     _Tp __init)
+    {
+      for (; __first != __last; ++__first)
+ *__result++ = __init = __binary_op(__init, *__first);
+      return __result;
+    }
+# 539 "/usr/include/c++/10.2.0/numeric" 3
+  template<typename _InputIterator, typename _OutputIterator,
+    typename _BinaryOperation>
+   
+    _OutputIterator
+    inclusive_scan(_InputIterator __first, _InputIterator __last,
+     _OutputIterator __result, _BinaryOperation __binary_op)
+    {
+      if (__first != __last)
+ {
+   auto __init = *__first;
+   *__result++ = __init;
+   ++__first;
+   if (__first != __last)
+     __result = std::inclusive_scan(__first, __last, __result,
+        __binary_op, std::move(__init));
+ }
+      return __result;
+    }
+# 573 "/usr/include/c++/10.2.0/numeric" 3
+  template<typename _InputIterator, typename _OutputIterator>
+   
+    inline _OutputIterator
+    inclusive_scan(_InputIterator __first, _InputIterator __last,
+     _OutputIterator __result)
+    { return std::inclusive_scan(__first, __last, __result, plus<>()); }
+# 600 "/usr/include/c++/10.2.0/numeric" 3
+  template<typename _InputIterator, typename _OutputIterator, typename _Tp,
+    typename _BinaryOperation, typename _UnaryOperation>
+   
+    _OutputIterator
+    transform_exclusive_scan(_InputIterator __first, _InputIterator __last,
+        _OutputIterator __result, _Tp __init,
+        _BinaryOperation __binary_op,
+        _UnaryOperation __unary_op)
+    {
+      while (__first != __last)
+ {
+   auto __v = __init;
+   __init = __binary_op(__init, __unary_op(*__first));
+   ++__first;
+   *__result++ = std::move(__v);
+ }
+      return __result;
+    }
+# 639 "/usr/include/c++/10.2.0/numeric" 3
+  template<typename _InputIterator, typename _OutputIterator,
+    typename _BinaryOperation, typename _UnaryOperation, typename _Tp>
+   
+    _OutputIterator
+    transform_inclusive_scan(_InputIterator __first, _InputIterator __last,
+        _OutputIterator __result,
+        _BinaryOperation __binary_op,
+        _UnaryOperation __unary_op,
+        _Tp __init)
+    {
+      for (; __first != __last; ++__first)
+ *__result++ = __init = __binary_op(__init, __unary_op(*__first));
+      return __result;
+    }
+# 673 "/usr/include/c++/10.2.0/numeric" 3
+  template<typename _InputIterator, typename _OutputIterator,
+   typename _BinaryOperation, typename _UnaryOperation>
+   
+    _OutputIterator
+    transform_inclusive_scan(_InputIterator __first, _InputIterator __last,
+        _OutputIterator __result,
+        _BinaryOperation __binary_op,
+        _UnaryOperation __unary_op)
+    {
+      if (__first != __last)
+ {
+   auto __init = __unary_op(*__first);
+   *__result++ = __init;
+   ++__first;
+   if (__first != __last)
+     __result = std::transform_inclusive_scan(__first, __last, __result,
+           __binary_op, __unary_op,
+           std::move(__init));
+ }
+      return __result;
+    }
+
+
+
+
+}
+
+
+
+
+
+
+
+# 1 "/usr/include/c++/10.2.0/pstl/glue_numeric_defs.h" 1 3
+# 11 "/usr/include/c++/10.2.0/pstl/glue_numeric_defs.h" 3
+#define _PSTL_GLUE_NUMERIC_DEFS_H 
+
+
+
+namespace std
+{
+
+
+template <class _ExecutionPolicy, class _ForwardIterator, class _Tp, class _BinaryOperation>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _Tp>
+reduce(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Tp __init,
+       _BinaryOperation __binary_op);
+
+template <class _ExecutionPolicy, class _ForwardIterator, class _Tp>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _Tp>
+reduce(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Tp __init);
+
+template <class _ExecutionPolicy, class _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy,
+                                                 typename iterator_traits<_ForwardIterator>::value_type>
+reduce(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last);
+
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Tp>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _Tp>
+transform_reduce(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
+                 _ForwardIterator2 __first2, _Tp __init);
+
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Tp, class _BinaryOperation1,
+          class _BinaryOperation2>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _Tp>
+transform_reduce(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
+                 _ForwardIterator2 __first2, _Tp __init, _BinaryOperation1 __binary_op1,
+                 _BinaryOperation2 __binary_op2);
+
+template <class _ExecutionPolicy, class _ForwardIterator, class _Tp, class _BinaryOperation, class _UnaryOperation>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _Tp>
+transform_reduce(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Tp __init,
+                 _BinaryOperation __binary_op, _UnaryOperation __unary_op);
+
+
+
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Tp>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+exclusive_scan(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
+               _ForwardIterator2 __result, _Tp __init);
+
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Tp, class _BinaryOperation>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+exclusive_scan(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
+               _ForwardIterator2 __result, _Tp __init, _BinaryOperation __binary_op);
+
+
+
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+inclusive_scan(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
+               _ForwardIterator2 __result);
+
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryOperation>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+inclusive_scan(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
+               _ForwardIterator2 __result, _BinaryOperation __binary_op);
+
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Tp, class _BinaryOperation>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+inclusive_scan(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
+               _ForwardIterator2 __result, _BinaryOperation __binary_op, _Tp __init);
+
+
+
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Tp, class _BinaryOperation,
+          class _UnaryOperation>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+transform_exclusive_scan(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
+                         _ForwardIterator2 __result, _Tp __init, _BinaryOperation __binary_op,
+                         _UnaryOperation __unary_op);
+
+
+
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryOperation,
+          class _UnaryOperation, class _Tp>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+transform_inclusive_scan(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
+                         _ForwardIterator2 __result, _BinaryOperation __binary_op, _UnaryOperation __unary_op,
+                         _Tp __init);
+
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _UnaryOperation,
+          class _BinaryOperation>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+transform_inclusive_scan(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
+                         _ForwardIterator2 __result, _BinaryOperation __binary_op, _UnaryOperation __unary_op);
+
+
+
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryOperation>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+adjacent_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
+                    _ForwardIterator2 __d_first, _BinaryOperation op);
+
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+adjacent_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
+                    _ForwardIterator2 __d_first);
+
+}
+# 707 "/usr/include/c++/10.2.0/numeric" 2 3
+#define _PSTL_NUMERIC_FORWARD_DECLARED 1
+
+
+
+#define __cpp_lib_parallel_algorithm 201603L
+# 61 "/usr/include/boost/test/impl/framework.ipp" 2 3 4
+# 1 "/usr/include/c++/10.2.0/cmath" 1 3 4
+# 39 "/usr/include/c++/10.2.0/cmath" 3 4
+       
+# 40 "/usr/include/c++/10.2.0/cmath" 3
+
+
+
+
+#define _GLIBCXX_INCLUDE_NEXT_C_HEADERS 
+# 1 "/usr/include/math.h" 1 3 4
+# 24 "/usr/include/math.h" 3 4
+#define _MATH_H 1
+
+#define __GLIBC_INTERNAL_STARTING_HEADER_IMPLEMENTATION 
+# 1 "/usr/include/bits/libc-header-start.h" 1 3 4
+# 31 "/usr/include/bits/libc-header-start.h" 3 4
+#undef __GLIBC_INTERNAL_STARTING_HEADER_IMPLEMENTATION
+
+
+
+
+
+#undef __GLIBC_USE_LIB_EXT2
+
+
+#define __GLIBC_USE_LIB_EXT2 1
+# 49 "/usr/include/bits/libc-header-start.h" 3 4
+#undef __GLIBC_USE_IEC_60559_BFP_EXT
+
+#define __GLIBC_USE_IEC_60559_BFP_EXT 1
+
+
+
+#undef __GLIBC_USE_IEC_60559_BFP_EXT_C2X
+
+#define __GLIBC_USE_IEC_60559_BFP_EXT_C2X 1
+# 66 "/usr/include/bits/libc-header-start.h" 3 4
+#undef __GLIBC_USE_IEC_60559_FUNCS_EXT
+
+#define __GLIBC_USE_IEC_60559_FUNCS_EXT 1
+
+
+
+#undef __GLIBC_USE_IEC_60559_FUNCS_EXT_C2X
+
+#define __GLIBC_USE_IEC_60559_FUNCS_EXT_C2X 1
+
+
+
+
+
+
+#undef __GLIBC_USE_IEC_60559_TYPES_EXT
+
+#define __GLIBC_USE_IEC_60559_TYPES_EXT 1
+# 28 "/usr/include/math.h" 2 3 4
+
+
+
+
+
+
+extern "C" {
+
+
+
+
+
+# 1 "/usr/include/bits/math-vector.h" 1 3 4
+# 25 "/usr/include/bits/math-vector.h" 3 4
+# 1 "/usr/include/bits/libm-simd-decl-stubs.h" 1 3 4
+# 34 "/usr/include/bits/libm-simd-decl-stubs.h" 3 4
+#define _BITS_LIBM_SIMD_DECL_STUBS_H 1
+
+#define __DECL_SIMD_cos 
+#define __DECL_SIMD_cosf 
+#define __DECL_SIMD_cosl 
+#define __DECL_SIMD_cosf16 
+#define __DECL_SIMD_cosf32 
+#define __DECL_SIMD_cosf64 
+#define __DECL_SIMD_cosf128 
+#define __DECL_SIMD_cosf32x 
+#define __DECL_SIMD_cosf64x 
+#define __DECL_SIMD_cosf128x 
+
+#define __DECL_SIMD_sin 
+#define __DECL_SIMD_sinf 
+#define __DECL_SIMD_sinl 
+#define __DECL_SIMD_sinf16 
+#define __DECL_SIMD_sinf32 
+#define __DECL_SIMD_sinf64 
+#define __DECL_SIMD_sinf128 
+#define __DECL_SIMD_sinf32x 
+#define __DECL_SIMD_sinf64x 
+#define __DECL_SIMD_sinf128x 
+
+#define __DECL_SIMD_sincos 
+#define __DECL_SIMD_sincosf 
+#define __DECL_SIMD_sincosl 
+#define __DECL_SIMD_sincosf16 
+#define __DECL_SIMD_sincosf32 
+#define __DECL_SIMD_sincosf64 
+#define __DECL_SIMD_sincosf128 
+#define __DECL_SIMD_sincosf32x 
+#define __DECL_SIMD_sincosf64x 
+#define __DECL_SIMD_sincosf128x 
+
+#define __DECL_SIMD_log 
+#define __DECL_SIMD_logf 
+#define __DECL_SIMD_logl 
+#define __DECL_SIMD_logf16 
+#define __DECL_SIMD_logf32 
+#define __DECL_SIMD_logf64 
+#define __DECL_SIMD_logf128 
+#define __DECL_SIMD_logf32x 
+#define __DECL_SIMD_logf64x 
+#define __DECL_SIMD_logf128x 
+
+#define __DECL_SIMD_exp 
+#define __DECL_SIMD_expf 
+#define __DECL_SIMD_expl 
+#define __DECL_SIMD_expf16 
+#define __DECL_SIMD_expf32 
+#define __DECL_SIMD_expf64 
+#define __DECL_SIMD_expf128 
+#define __DECL_SIMD_expf32x 
+#define __DECL_SIMD_expf64x 
+#define __DECL_SIMD_expf128x 
+
+#define __DECL_SIMD_pow 
+#define __DECL_SIMD_powf 
+#define __DECL_SIMD_powl 
+#define __DECL_SIMD_powf16 
+#define __DECL_SIMD_powf32 
+#define __DECL_SIMD_powf64 
+#define __DECL_SIMD_powf128 
+#define __DECL_SIMD_powf32x 
+#define __DECL_SIMD_powf64x 
+#define __DECL_SIMD_powf128x 
+# 26 "/usr/include/bits/math-vector.h" 2 3 4
+# 41 "/usr/include/math.h" 2 3 4
+
+
+
+
+
+
+
+#define HUGE_VAL (__builtin_huge_val ())
+# 59 "/usr/include/math.h" 3 4
+#define HUGE_VALF (__builtin_huge_valf ())
+#define HUGE_VALL (__builtin_huge_vall ())
+# 70 "/usr/include/math.h" 3 4
+#define HUGE_VAL_F32 (__builtin_huge_valf32 ())
+
+
+#define HUGE_VAL_F64 (__builtin_huge_valf64 ())
+
+
+#define HUGE_VAL_F128 (__builtin_huge_valf128 ())
+
+
+#define HUGE_VAL_F32X (__builtin_huge_valf32x ())
+
+
+#define HUGE_VAL_F64X (__builtin_huge_valf64x ())
+# 91 "/usr/include/math.h" 3 4
+#define INFINITY (__builtin_inff ())
+
+
+
+
+
+
+#define NAN (__builtin_nanf (""))
+# 110 "/usr/include/math.h" 3 4
+#define SNANF (__builtin_nansf (""))
+#define SNAN (__builtin_nans (""))
+#define SNANL (__builtin_nansl (""))
+
+
+
+
+
+
+#define SNANF32 (__builtin_nansf32 (""))
+
+
+#define SNANF64 (__builtin_nansf64 (""))
+
+
+#define SNANF128 (__builtin_nansf128 (""))
+
+
+#define SNANF32X (__builtin_nansf32x (""))
+
+
+#define SNANF64X (__builtin_nansf64x (""))
+
+
+
+
+
+
+# 1 "/usr/include/bits/flt-eval-method.h" 1 3 4
+# 27 "/usr/include/bits/flt-eval-method.h" 3 4
+#define __GLIBC_FLT_EVAL_METHOD __FLT_EVAL_METHOD__
+# 139 "/usr/include/math.h" 2 3 4
+# 149 "/usr/include/math.h" 3 4
+typedef float float_t;
+typedef double double_t;
+# 190 "/usr/include/math.h" 3 4
+# 1 "/usr/include/bits/fp-logb.h" 1 3 4
+# 23 "/usr/include/bits/fp-logb.h" 3 4
+#define __FP_LOGB0_IS_MIN 1
+#define __FP_LOGBNAN_IS_MIN 1
+# 191 "/usr/include/math.h" 2 3 4
+
+
+#define FP_ILOGB0 (-2147483647 - 1)
+
+
+
+
+#define FP_ILOGBNAN (-2147483647 - 1)
+# 207 "/usr/include/math.h" 3 4
+#define __FP_LONG_MAX 0x7fffffffffffffffL
+
+
+#define FP_LLOGB0 (-__FP_LONG_MAX - 1)
+
+
+
+
+#define FP_LLOGBNAN (-__FP_LONG_MAX - 1)
+# 233 "/usr/include/math.h" 3 4
+# 1 "/usr/include/bits/fp-fast.h" 1 3 4
+# 234 "/usr/include/math.h" 2 3 4
+
+
+
+enum
+  {
+    FP_INT_UPWARD =
+#define FP_INT_UPWARD 0
+      0,
+    FP_INT_DOWNWARD =
+#define FP_INT_DOWNWARD 1
+      1,
+    FP_INT_TOWARDZERO =
+#define FP_INT_TOWARDZERO 2
+      2,
+    FP_INT_TONEARESTFROMZERO =
+#define FP_INT_TONEARESTFROMZERO 3
+      3,
+    FP_INT_TONEAREST =
+#define FP_INT_TONEAREST 4
+      4,
+  };
+
+
+
+
+
+
+
+#define __SIMD_DECL(function) __CONCAT (__DECL_SIMD_, function)
+
+#define __MATHCALL_VEC(function,suffix,args) __SIMD_DECL (__MATH_PRECNAME (function, suffix)) __MATHCALL (function, suffix, args)
+
+
+
+#define __MATHDECL_VEC(type,function,suffix,args) __SIMD_DECL (__MATH_PRECNAME (function, suffix)) __MATHDECL(type, function,suffix, args)
+
+
+
+#define __MATHCALL(function,suffix,args) __MATHDECL (_Mdouble_,function,suffix, args)
+
+#define __MATHDECL(type,function,suffix,args) __MATHDECL_1(type, function,suffix, args); __MATHDECL_1(type, __CONCAT(__,function),suffix, args)
+
+
+#define __MATHCALLX(function,suffix,args,attrib) __MATHDECLX (_Mdouble_,function,suffix, args, attrib)
+
+#define __MATHDECLX(type,function,suffix,args,attrib) __MATHDECL_1(type, function,suffix, args) __attribute__ (attrib); __MATHDECL_1(type, __CONCAT(__,function),suffix, args) __attribute__ (attrib)
+
+
+#define __MATHDECL_1_IMPL(type,function,suffix,args) extern type __MATH_PRECNAME(function,suffix) args __THROW
+
+#define __MATHDECL_1(type,function,suffix,args) __MATHDECL_1_IMPL(type, function, suffix, args)
+
+
+
+#define __MATHDECL_ALIAS(type,function,suffix,args,alias) __MATHDECL_1(type, function, suffix, args)
+
+
+#define __MATHREDIR(type,function,suffix,args,to) extern type __REDIRECT_NTH (__MATH_PRECNAME (function, suffix), args, to)
+
+
+#define _Mdouble_ double
+#define __MATH_PRECNAME(name,r) __CONCAT(name,r)
+#define __MATH_DECLARING_DOUBLE 1
+#define __MATH_DECLARING_FLOATN 0
+# 1 "/usr/include/bits/mathcalls-helper-functions.h" 1 3 4
+# 20 "/usr/include/bits/mathcalls-helper-functions.h" 3 4
+extern int __fpclassify (double __value) throw ()
+     __attribute__ ((__const__));
+
+
+extern int __signbit (double __value) throw ()
+     __attribute__ ((__const__));
+
+
+
+extern int __isinf (double __value) throw ()
+  __attribute__ ((__const__));
+
+
+extern int __finite (double __value) throw ()
+  __attribute__ ((__const__));
+
+
+extern int __isnan (double __value) throw ()
+  __attribute__ ((__const__));
+
+
+extern int __iseqsig (double __x, double __y) throw ();
+
+
+extern int __issignaling (double __value) throw ()
+     __attribute__ ((__const__));
+# 299 "/usr/include/math.h" 2 3 4
+# 1 "/usr/include/bits/mathcalls.h" 1 3 4
+# 53 "/usr/include/bits/mathcalls.h" 3 4
+extern double acos (double __x) throw (); extern double __acos (double __x) throw ();
+
+extern double asin (double __x) throw (); extern double __asin (double __x) throw ();
+
+extern double atan (double __x) throw (); extern double __atan (double __x) throw ();
+
+extern double atan2 (double __y, double __x) throw (); extern double __atan2 (double __y, double __x) throw ();
+
+
+ extern double cos (double __x) throw (); extern double __cos (double __x) throw ();
+
+ extern double sin (double __x) throw (); extern double __sin (double __x) throw ();
+
+extern double tan (double __x) throw (); extern double __tan (double __x) throw ();
+
+
+
+
+extern double cosh (double __x) throw (); extern double __cosh (double __x) throw ();
+
+extern double sinh (double __x) throw (); extern double __sinh (double __x) throw ();
+
+extern double tanh (double __x) throw (); extern double __tanh (double __x) throw ();
+
+
+
+ extern void sincos (double __x, double *__sinx, double *__cosx) throw (); extern void __sincos (double __x, double *__sinx, double *__cosx) throw ()
+                                                        ;
+
+
+
+
+extern double acosh (double __x) throw (); extern double __acosh (double __x) throw ();
+
+extern double asinh (double __x) throw (); extern double __asinh (double __x) throw ();
+
+extern double atanh (double __x) throw (); extern double __atanh (double __x) throw ();
+
+
+
+
+
+ extern double exp (double __x) throw (); extern double __exp (double __x) throw ();
+
+
+extern double frexp (double __x, int *__exponent) throw (); extern double __frexp (double __x, int *__exponent) throw ();
+
+
+extern double ldexp (double __x, int __exponent) throw (); extern double __ldexp (double __x, int __exponent) throw ();
+
+
+ extern double log (double __x) throw (); extern double __log (double __x) throw ();
+
+
+extern double log10 (double __x) throw (); extern double __log10 (double __x) throw ();
+
+
+extern double modf (double __x, double *__iptr) throw (); extern double __modf (double __x, double *__iptr) throw () __attribute__ ((__nonnull__ (2)));
+
+
+
+extern double exp10 (double __x) throw (); extern double __exp10 (double __x) throw ();
+
+
+
+
+extern double expm1 (double __x) throw (); extern double __expm1 (double __x) throw ();
+
+
+extern double log1p (double __x) throw (); extern double __log1p (double __x) throw ();
+
+
+extern double logb (double __x) throw (); extern double __logb (double __x) throw ();
+
+
+
+
+extern double exp2 (double __x) throw (); extern double __exp2 (double __x) throw ();
+
+
+extern double log2 (double __x) throw (); extern double __log2 (double __x) throw ();
+
+
+
+
+
+
+ extern double pow (double __x, double __y) throw (); extern double __pow (double __x, double __y) throw ();
+
+
+extern double sqrt (double __x) throw (); extern double __sqrt (double __x) throw ();
+
+
+
+extern double hypot (double __x, double __y) throw (); extern double __hypot (double __x, double __y) throw ();
+
+
+
+
+extern double cbrt (double __x) throw (); extern double __cbrt (double __x) throw ();
+
+
+
+
+
+
+extern double ceil (double __x) throw () __attribute__ ((__const__)); extern double __ceil (double __x) throw () __attribute__ ((__const__));
+
+
+extern double fabs (double __x) throw () __attribute__ ((__const__)); extern double __fabs (double __x) throw () __attribute__ ((__const__));
+
+
+extern double floor (double __x) throw () __attribute__ ((__const__)); extern double __floor (double __x) throw () __attribute__ ((__const__));
+
+
+extern double fmod (double __x, double __y) throw (); extern double __fmod (double __x, double __y) throw ();
+# 183 "/usr/include/bits/mathcalls.h" 3 4
+extern int finite (double __value) throw ()
+  __attribute__ ((__const__));
+
+
+extern double drem (double __x, double __y) throw (); extern double __drem (double __x, double __y) throw ();
+
+
+
+extern double significand (double __x) throw (); extern double __significand (double __x) throw ();
+
+
+
+
+
+
+extern double copysign (double __x, double __y) throw () __attribute__ ((__const__)); extern double __copysign (double __x, double __y) throw () __attribute__ ((__const__));
+
+
+
+
+extern double nan (const char *__tagb) throw (); extern double __nan (const char *__tagb) throw ();
+# 220 "/usr/include/bits/mathcalls.h" 3 4
+extern double j0 (double) throw (); extern double __j0 (double) throw ();
+extern double j1 (double) throw (); extern double __j1 (double) throw ();
+extern double jn (int, double) throw (); extern double __jn (int, double) throw ();
+extern double y0 (double) throw (); extern double __y0 (double) throw ();
+extern double y1 (double) throw (); extern double __y1 (double) throw ();
+extern double yn (int, double) throw (); extern double __yn (int, double) throw ();
+
+
+
+
+
+extern double erf (double) throw (); extern double __erf (double) throw ();
+extern double erfc (double) throw (); extern double __erfc (double) throw ();
+extern double lgamma (double) throw (); extern double __lgamma (double) throw ();
+
+
+
+
+extern double tgamma (double) throw (); extern double __tgamma (double) throw ();
+
+
+
+
+
+extern double gamma (double) throw (); extern double __gamma (double) throw ();
+
+
+
+
+
+
+
+extern double lgamma_r (double, int *__signgamp) throw (); extern double __lgamma_r (double, int *__signgamp) throw ();
+
+
+
+
+
+
+extern double rint (double __x) throw (); extern double __rint (double __x) throw ();
+
+
+extern double nextafter (double __x, double __y) throw (); extern double __nextafter (double __x, double __y) throw ();
+
+extern double nexttoward (double __x, long double __y) throw (); extern double __nexttoward (double __x, long double __y) throw ();
+
+
+
+
+extern double nextdown (double __x) throw (); extern double __nextdown (double __x) throw ();
+
+extern double nextup (double __x) throw (); extern double __nextup (double __x) throw ();
+
+
+
+extern double remainder (double __x, double __y) throw (); extern double __remainder (double __x, double __y) throw ();
+
+
+
+extern double scalbn (double __x, int __n) throw (); extern double __scalbn (double __x, int __n) throw ();
+
+
+
+extern int ilogb (double __x) throw (); extern int __ilogb (double __x) throw ();
+
+
+
+
+extern long int llogb (double __x) throw (); extern long int __llogb (double __x) throw ();
+
+
+
+
+extern double scalbln (double __x, long int __n) throw (); extern double __scalbln (double __x, long int __n) throw ();
+
+
+
+extern double nearbyint (double __x) throw (); extern double __nearbyint (double __x) throw ();
+
+
+
+extern double round (double __x) throw () __attribute__ ((__const__)); extern double __round (double __x) throw () __attribute__ ((__const__));
+
+
+
+extern double trunc (double __x) throw () __attribute__ ((__const__)); extern double __trunc (double __x) throw () __attribute__ ((__const__));
+
+
+
+
+extern double remquo (double __x, double __y, int *__quo) throw (); extern double __remquo (double __x, double __y, int *__quo) throw ();
+
+
+
+
+
+
+extern long int lrint (double __x) throw (); extern long int __lrint (double __x) throw ();
+__extension__
+extern long long int llrint (double __x) throw (); extern long long int __llrint (double __x) throw ();
+
+
+
+extern long int lround (double __x) throw (); extern long int __lround (double __x) throw ();
+__extension__
+extern long long int llround (double __x) throw (); extern long long int __llround (double __x) throw ();
+
+
+
+extern double fdim (double __x, double __y) throw (); extern double __fdim (double __x, double __y) throw ();
+
+
+extern double fmax (double __x, double __y) throw () __attribute__ ((__const__)); extern double __fmax (double __x, double __y) throw () __attribute__ ((__const__));
+
+
+extern double fmin (double __x, double __y) throw () __attribute__ ((__const__)); extern double __fmin (double __x, double __y) throw () __attribute__ ((__const__));
+
+
+extern double fma (double __x, double __y, double __z) throw (); extern double __fma (double __x, double __y, double __z) throw ();
+
+
+
+
+extern double roundeven (double __x) throw () __attribute__ ((__const__)); extern double __roundeven (double __x) throw () __attribute__ ((__const__));
+
+
+
+extern __intmax_t fromfp (double __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfp (double __x, int __round, unsigned int __width) throw ()
+                            ;
+
+
+
+extern __uintmax_t ufromfp (double __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfp (double __x, int __round, unsigned int __width) throw ()
+                              ;
+
+
+
+
+extern __intmax_t fromfpx (double __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpx (double __x, int __round, unsigned int __width) throw ()
+                             ;
+
+
+
+
+extern __uintmax_t ufromfpx (double __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpx (double __x, int __round, unsigned int __width) throw ()
+                               ;
+
+
+extern double fmaxmag (double __x, double __y) throw () __attribute__ ((__const__)); extern double __fmaxmag (double __x, double __y) throw () __attribute__ ((__const__));
+
+
+extern double fminmag (double __x, double __y) throw () __attribute__ ((__const__)); extern double __fminmag (double __x, double __y) throw () __attribute__ ((__const__));
+
+
+extern int canonicalize (double *__cx, const double *__x) throw ();
+
+
+
+
+extern int totalorder (const double *__x, const double *__y) throw ()
+
+     __attribute__ ((__pure__));
+
+
+extern int totalordermag (const double *__x, const double *__y) throw ()
+
+     __attribute__ ((__pure__));
+
+
+extern double getpayload (const double *__x) throw (); extern double __getpayload (const double *__x) throw ();
+
+
+extern int setpayload (double *__x, double __payload) throw ();
+
+
+extern int setpayloadsig (double *__x, double __payload) throw ();
+
+
+
+
+
+
+
+extern double scalb (double __x, double __n) throw (); extern double __scalb (double __x, double __n) throw ();
+# 300 "/usr/include/math.h" 2 3 4
+#undef _Mdouble_
+#undef __MATH_PRECNAME
+#undef __MATH_DECLARING_DOUBLE
+#undef __MATH_DECLARING_FLOATN
+
+
+
+
+
+
+
+#define _Mdouble_ float
+#define __MATH_PRECNAME(name,r) name ##f ##r
+#define __MATH_DECLARING_DOUBLE 0
+#define __MATH_DECLARING_FLOATN 0
+# 1 "/usr/include/bits/mathcalls-helper-functions.h" 1 3 4
+# 20 "/usr/include/bits/mathcalls-helper-functions.h" 3 4
+extern int __fpclassifyf (float __value) throw ()
+     __attribute__ ((__const__));
+
+
+extern int __signbitf (float __value) throw ()
+     __attribute__ ((__const__));
+
+
+
+extern int __isinff (float __value) throw ()
+  __attribute__ ((__const__));
+
+
+extern int __finitef (float __value) throw ()
+  __attribute__ ((__const__));
+
+
+extern int __isnanf (float __value) throw ()
+  __attribute__ ((__const__));
+
+
+extern int __iseqsigf (float __x, float __y) throw ();
+
+
+extern int __issignalingf (float __value) throw ()
+     __attribute__ ((__const__));
+# 316 "/usr/include/math.h" 2 3 4
+# 1 "/usr/include/bits/mathcalls.h" 1 3 4
+# 53 "/usr/include/bits/mathcalls.h" 3 4
+extern float acosf (float __x) throw (); extern float __acosf (float __x) throw ();
+
+extern float asinf (float __x) throw (); extern float __asinf (float __x) throw ();
+
+extern float atanf (float __x) throw (); extern float __atanf (float __x) throw ();
+
+extern float atan2f (float __y, float __x) throw (); extern float __atan2f (float __y, float __x) throw ();
+
+
+ extern float cosf (float __x) throw (); extern float __cosf (float __x) throw ();
+
+ extern float sinf (float __x) throw (); extern float __sinf (float __x) throw ();
+
+extern float tanf (float __x) throw (); extern float __tanf (float __x) throw ();
+
+
+
+
+extern float coshf (float __x) throw (); extern float __coshf (float __x) throw ();
+
+extern float sinhf (float __x) throw (); extern float __sinhf (float __x) throw ();
+
+extern float tanhf (float __x) throw (); extern float __tanhf (float __x) throw ();
+
+
+
+ extern void sincosf (float __x, float *__sinx, float *__cosx) throw (); extern void __sincosf (float __x, float *__sinx, float *__cosx) throw ()
+                                                        ;
+
+
+
+
+extern float acoshf (float __x) throw (); extern float __acoshf (float __x) throw ();
+
+extern float asinhf (float __x) throw (); extern float __asinhf (float __x) throw ();
+
+extern float atanhf (float __x) throw (); extern float __atanhf (float __x) throw ();
+
+
+
+
+
+ extern float expf (float __x) throw (); extern float __expf (float __x) throw ();
+
+
+extern float frexpf (float __x, int *__exponent) throw (); extern float __frexpf (float __x, int *__exponent) throw ();
+
+
+extern float ldexpf (float __x, int __exponent) throw (); extern float __ldexpf (float __x, int __exponent) throw ();
+
+
+ extern float logf (float __x) throw (); extern float __logf (float __x) throw ();
+
+
+extern float log10f (float __x) throw (); extern float __log10f (float __x) throw ();
+
+
+extern float modff (float __x, float *__iptr) throw (); extern float __modff (float __x, float *__iptr) throw () __attribute__ ((__nonnull__ (2)));
+
+
+
+extern float exp10f (float __x) throw (); extern float __exp10f (float __x) throw ();
+
+
+
+
+extern float expm1f (float __x) throw (); extern float __expm1f (float __x) throw ();
+
+
+extern float log1pf (float __x) throw (); extern float __log1pf (float __x) throw ();
+
+
+extern float logbf (float __x) throw (); extern float __logbf (float __x) throw ();
+
+
+
+
+extern float exp2f (float __x) throw (); extern float __exp2f (float __x) throw ();
+
+
+extern float log2f (float __x) throw (); extern float __log2f (float __x) throw ();
+
+
+
+
+
+
+ extern float powf (float __x, float __y) throw (); extern float __powf (float __x, float __y) throw ();
+
+
+extern float sqrtf (float __x) throw (); extern float __sqrtf (float __x) throw ();
+
+
+
+extern float hypotf (float __x, float __y) throw (); extern float __hypotf (float __x, float __y) throw ();
+
+
+
+
+extern float cbrtf (float __x) throw (); extern float __cbrtf (float __x) throw ();
+
+
+
+
+
+
+extern float ceilf (float __x) throw () __attribute__ ((__const__)); extern float __ceilf (float __x) throw () __attribute__ ((__const__));
+
+
+extern float fabsf (float __x) throw () __attribute__ ((__const__)); extern float __fabsf (float __x) throw () __attribute__ ((__const__));
+
+
+extern float floorf (float __x) throw () __attribute__ ((__const__)); extern float __floorf (float __x) throw () __attribute__ ((__const__));
+
+
+extern float fmodf (float __x, float __y) throw (); extern float __fmodf (float __x, float __y) throw ();
+# 177 "/usr/include/bits/mathcalls.h" 3 4
+extern int isinff (float __value) throw ()
+  __attribute__ ((__const__));
+
+
+
+
+extern int finitef (float __value) throw ()
+  __attribute__ ((__const__));
+
+
+extern float dremf (float __x, float __y) throw (); extern float __dremf (float __x, float __y) throw ();
+
+
+
+extern float significandf (float __x) throw (); extern float __significandf (float __x) throw ();
+
+
+
+
+
+
+extern float copysignf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __copysignf (float __x, float __y) throw () __attribute__ ((__const__));
+
+
+
+
+extern float nanf (const char *__tagb) throw (); extern float __nanf (const char *__tagb) throw ();
+# 213 "/usr/include/bits/mathcalls.h" 3 4
+extern int isnanf (float __value) throw ()
+  __attribute__ ((__const__));
+
+
+
+
+
+extern float j0f (float) throw (); extern float __j0f (float) throw ();
+extern float j1f (float) throw (); extern float __j1f (float) throw ();
+extern float jnf (int, float) throw (); extern float __jnf (int, float) throw ();
+extern float y0f (float) throw (); extern float __y0f (float) throw ();
+extern float y1f (float) throw (); extern float __y1f (float) throw ();
+extern float ynf (int, float) throw (); extern float __ynf (int, float) throw ();
+
+
+
+
+
+extern float erff (float) throw (); extern float __erff (float) throw ();
+extern float erfcf (float) throw (); extern float __erfcf (float) throw ();
+extern float lgammaf (float) throw (); extern float __lgammaf (float) throw ();
+
+
+
+
+extern float tgammaf (float) throw (); extern float __tgammaf (float) throw ();
+
+
+
+
+
+extern float gammaf (float) throw (); extern float __gammaf (float) throw ();
+
+
+
+
+
+
+
+extern float lgammaf_r (float, int *__signgamp) throw (); extern float __lgammaf_r (float, int *__signgamp) throw ();
+
+
+
+
+
+
+extern float rintf (float __x) throw (); extern float __rintf (float __x) throw ();
+
+
+extern float nextafterf (float __x, float __y) throw (); extern float __nextafterf (float __x, float __y) throw ();
+
+extern float nexttowardf (float __x, long double __y) throw (); extern float __nexttowardf (float __x, long double __y) throw ();
+
+
+
+
+extern float nextdownf (float __x) throw (); extern float __nextdownf (float __x) throw ();
+
+extern float nextupf (float __x) throw (); extern float __nextupf (float __x) throw ();
+
+
+
+extern float remainderf (float __x, float __y) throw (); extern float __remainderf (float __x, float __y) throw ();
+
+
+
+extern float scalbnf (float __x, int __n) throw (); extern float __scalbnf (float __x, int __n) throw ();
+
+
+
+extern int ilogbf (float __x) throw (); extern int __ilogbf (float __x) throw ();
+
+
+
+
+extern long int llogbf (float __x) throw (); extern long int __llogbf (float __x) throw ();
+
+
+
+
+extern float scalblnf (float __x, long int __n) throw (); extern float __scalblnf (float __x, long int __n) throw ();
+
+
+
+extern float nearbyintf (float __x) throw (); extern float __nearbyintf (float __x) throw ();
+
+
+
+extern float roundf (float __x) throw () __attribute__ ((__const__)); extern float __roundf (float __x) throw () __attribute__ ((__const__));
+
+
+
+extern float truncf (float __x) throw () __attribute__ ((__const__)); extern float __truncf (float __x) throw () __attribute__ ((__const__));
+
+
+
+
+extern float remquof (float __x, float __y, int *__quo) throw (); extern float __remquof (float __x, float __y, int *__quo) throw ();
+
+
+
+
+
+
+extern long int lrintf (float __x) throw (); extern long int __lrintf (float __x) throw ();
+__extension__
+extern long long int llrintf (float __x) throw (); extern long long int __llrintf (float __x) throw ();
+
+
+
+extern long int lroundf (float __x) throw (); extern long int __lroundf (float __x) throw ();
+__extension__
+extern long long int llroundf (float __x) throw (); extern long long int __llroundf (float __x) throw ();
+
+
+
+extern float fdimf (float __x, float __y) throw (); extern float __fdimf (float __x, float __y) throw ();
+
+
+extern float fmaxf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __fmaxf (float __x, float __y) throw () __attribute__ ((__const__));
+
+
+extern float fminf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __fminf (float __x, float __y) throw () __attribute__ ((__const__));
+
+
+extern float fmaf (float __x, float __y, float __z) throw (); extern float __fmaf (float __x, float __y, float __z) throw ();
+
+
+
+
+extern float roundevenf (float __x) throw () __attribute__ ((__const__)); extern float __roundevenf (float __x) throw () __attribute__ ((__const__));
+
+
+
+extern __intmax_t fromfpf (float __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpf (float __x, int __round, unsigned int __width) throw ()
+                            ;
+
+
+
+extern __uintmax_t ufromfpf (float __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpf (float __x, int __round, unsigned int __width) throw ()
+                              ;
+
+
+
+
+extern __intmax_t fromfpxf (float __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpxf (float __x, int __round, unsigned int __width) throw ()
+                             ;
+
+
+
+
+extern __uintmax_t ufromfpxf (float __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpxf (float __x, int __round, unsigned int __width) throw ()
+                               ;
+
+
+extern float fmaxmagf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __fmaxmagf (float __x, float __y) throw () __attribute__ ((__const__));
+
+
+extern float fminmagf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __fminmagf (float __x, float __y) throw () __attribute__ ((__const__));
+
+
+extern int canonicalizef (float *__cx, const float *__x) throw ();
+
+
+
+
+extern int totalorderf (const float *__x, const float *__y) throw ()
+
+     __attribute__ ((__pure__));
+
+
+extern int totalordermagf (const float *__x, const float *__y) throw ()
+
+     __attribute__ ((__pure__));
+
+
+extern float getpayloadf (const float *__x) throw (); extern float __getpayloadf (const float *__x) throw ();
+
+
+extern int setpayloadf (float *__x, float __payload) throw ();
+
+
+extern int setpayloadsigf (float *__x, float __payload) throw ();
+
+
+
+
+
+
+
+extern float scalbf (float __x, float __n) throw (); extern float __scalbf (float __x, float __n) throw ();
+# 317 "/usr/include/math.h" 2 3 4
+#undef _Mdouble_
+#undef __MATH_PRECNAME
+#undef __MATH_DECLARING_DOUBLE
+#undef __MATH_DECLARING_FLOATN
+# 379 "/usr/include/math.h" 3 4
+#define _Mdouble_ long double
+#define __MATH_PRECNAME(name,r) name ##l ##r
+#define __MATH_DECLARING_DOUBLE 0
+#define __MATH_DECLARING_FLOATN 0
+#define __MATH_DECLARE_LDOUBLE 1
+# 1 "/usr/include/bits/mathcalls-helper-functions.h" 1 3 4
+# 20 "/usr/include/bits/mathcalls-helper-functions.h" 3 4
+extern int __fpclassifyl (long double __value) throw ()
+     __attribute__ ((__const__));
+
+
+extern int __signbitl (long double __value) throw ()
+     __attribute__ ((__const__));
+
+
+
+extern int __isinfl (long double __value) throw ()
+  __attribute__ ((__const__));
+
+
+extern int __finitel (long double __value) throw ()
+  __attribute__ ((__const__));
+
+
+extern int __isnanl (long double __value) throw ()
+  __attribute__ ((__const__));
+
+
+extern int __iseqsigl (long double __x, long double __y) throw ();
+
+
+extern int __issignalingl (long double __value) throw ()
+     __attribute__ ((__const__));
+# 385 "/usr/include/math.h" 2 3 4
+# 1 "/usr/include/bits/mathcalls.h" 1 3 4
+# 53 "/usr/include/bits/mathcalls.h" 3 4
+extern long double acosl (long double __x) throw (); extern long double __acosl (long double __x) throw ();
+
+extern long double asinl (long double __x) throw (); extern long double __asinl (long double __x) throw ();
+
+extern long double atanl (long double __x) throw (); extern long double __atanl (long double __x) throw ();
+
+extern long double atan2l (long double __y, long double __x) throw (); extern long double __atan2l (long double __y, long double __x) throw ();
+
+
+ extern long double cosl (long double __x) throw (); extern long double __cosl (long double __x) throw ();
+
+ extern long double sinl (long double __x) throw (); extern long double __sinl (long double __x) throw ();
+
+extern long double tanl (long double __x) throw (); extern long double __tanl (long double __x) throw ();
+
+
+
+
+extern long double coshl (long double __x) throw (); extern long double __coshl (long double __x) throw ();
+
+extern long double sinhl (long double __x) throw (); extern long double __sinhl (long double __x) throw ();
+
+extern long double tanhl (long double __x) throw (); extern long double __tanhl (long double __x) throw ();
+
+
+
+ extern void sincosl (long double __x, long double *__sinx, long double *__cosx) throw (); extern void __sincosl (long double __x, long double *__sinx, long double *__cosx) throw ()
+                                                        ;
+
+
+
+
+extern long double acoshl (long double __x) throw (); extern long double __acoshl (long double __x) throw ();
+
+extern long double asinhl (long double __x) throw (); extern long double __asinhl (long double __x) throw ();
+
+extern long double atanhl (long double __x) throw (); extern long double __atanhl (long double __x) throw ();
+
+
+
+
+
+ extern long double expl (long double __x) throw (); extern long double __expl (long double __x) throw ();
+
+
+extern long double frexpl (long double __x, int *__exponent) throw (); extern long double __frexpl (long double __x, int *__exponent) throw ();
+
+
+extern long double ldexpl (long double __x, int __exponent) throw (); extern long double __ldexpl (long double __x, int __exponent) throw ();
+
+
+ extern long double logl (long double __x) throw (); extern long double __logl (long double __x) throw ();
+
+
+extern long double log10l (long double __x) throw (); extern long double __log10l (long double __x) throw ();
+
+
+extern long double modfl (long double __x, long double *__iptr) throw (); extern long double __modfl (long double __x, long double *__iptr) throw () __attribute__ ((__nonnull__ (2)));
+
+
+
+extern long double exp10l (long double __x) throw (); extern long double __exp10l (long double __x) throw ();
+
+
+
+
+extern long double expm1l (long double __x) throw (); extern long double __expm1l (long double __x) throw ();
+
+
+extern long double log1pl (long double __x) throw (); extern long double __log1pl (long double __x) throw ();
+
+
+extern long double logbl (long double __x) throw (); extern long double __logbl (long double __x) throw ();
+
+
+
+
+extern long double exp2l (long double __x) throw (); extern long double __exp2l (long double __x) throw ();
+
+
+extern long double log2l (long double __x) throw (); extern long double __log2l (long double __x) throw ();
+
+
+
+
+
+
+ extern long double powl (long double __x, long double __y) throw (); extern long double __powl (long double __x, long double __y) throw ();
+
+
+extern long double sqrtl (long double __x) throw (); extern long double __sqrtl (long double __x) throw ();
+
+
+
+extern long double hypotl (long double __x, long double __y) throw (); extern long double __hypotl (long double __x, long double __y) throw ();
+
+
+
+
+extern long double cbrtl (long double __x) throw (); extern long double __cbrtl (long double __x) throw ();
+
+
+
+
+
+
+extern long double ceill (long double __x) throw () __attribute__ ((__const__)); extern long double __ceill (long double __x) throw () __attribute__ ((__const__));
+
+
+extern long double fabsl (long double __x) throw () __attribute__ ((__const__)); extern long double __fabsl (long double __x) throw () __attribute__ ((__const__));
+
+
+extern long double floorl (long double __x) throw () __attribute__ ((__const__)); extern long double __floorl (long double __x) throw () __attribute__ ((__const__));
+
+
+extern long double fmodl (long double __x, long double __y) throw (); extern long double __fmodl (long double __x, long double __y) throw ();
+# 177 "/usr/include/bits/mathcalls.h" 3 4
+extern int isinfl (long double __value) throw ()
+  __attribute__ ((__const__));
+
+
+
+
+extern int finitel (long double __value) throw ()
+  __attribute__ ((__const__));
+
+
+extern long double dreml (long double __x, long double __y) throw (); extern long double __dreml (long double __x, long double __y) throw ();
+
+
+
+extern long double significandl (long double __x) throw (); extern long double __significandl (long double __x) throw ();
+
+
+
+
+
+
+extern long double copysignl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __copysignl (long double __x, long double __y) throw () __attribute__ ((__const__));
+
+
+
+
+extern long double nanl (const char *__tagb) throw (); extern long double __nanl (const char *__tagb) throw ();
+# 213 "/usr/include/bits/mathcalls.h" 3 4
+extern int isnanl (long double __value) throw ()
+  __attribute__ ((__const__));
+
+
+
+
+
+extern long double j0l (long double) throw (); extern long double __j0l (long double) throw ();
+extern long double j1l (long double) throw (); extern long double __j1l (long double) throw ();
+extern long double jnl (int, long double) throw (); extern long double __jnl (int, long double) throw ();
+extern long double y0l (long double) throw (); extern long double __y0l (long double) throw ();
+extern long double y1l (long double) throw (); extern long double __y1l (long double) throw ();
+extern long double ynl (int, long double) throw (); extern long double __ynl (int, long double) throw ();
+
+
+
+
+
+extern long double erfl (long double) throw (); extern long double __erfl (long double) throw ();
+extern long double erfcl (long double) throw (); extern long double __erfcl (long double) throw ();
+extern long double lgammal (long double) throw (); extern long double __lgammal (long double) throw ();
+
+
+
+
+extern long double tgammal (long double) throw (); extern long double __tgammal (long double) throw ();
+
+
+
+
+
+extern long double gammal (long double) throw (); extern long double __gammal (long double) throw ();
+
+
+
+
+
+
+
+extern long double lgammal_r (long double, int *__signgamp) throw (); extern long double __lgammal_r (long double, int *__signgamp) throw ();
+
+
+
+
+
+
+extern long double rintl (long double __x) throw (); extern long double __rintl (long double __x) throw ();
+
+
+extern long double nextafterl (long double __x, long double __y) throw (); extern long double __nextafterl (long double __x, long double __y) throw ();
+
+extern long double nexttowardl (long double __x, long double __y) throw (); extern long double __nexttowardl (long double __x, long double __y) throw ();
+
+
+
+
+extern long double nextdownl (long double __x) throw (); extern long double __nextdownl (long double __x) throw ();
+
+extern long double nextupl (long double __x) throw (); extern long double __nextupl (long double __x) throw ();
+
+
+
+extern long double remainderl (long double __x, long double __y) throw (); extern long double __remainderl (long double __x, long double __y) throw ();
+
+
+
+extern long double scalbnl (long double __x, int __n) throw (); extern long double __scalbnl (long double __x, int __n) throw ();
+
+
+
+extern int ilogbl (long double __x) throw (); extern int __ilogbl (long double __x) throw ();
+
+
+
+
+extern long int llogbl (long double __x) throw (); extern long int __llogbl (long double __x) throw ();
+
+
+
+
+extern long double scalblnl (long double __x, long int __n) throw (); extern long double __scalblnl (long double __x, long int __n) throw ();
+
+
+
+extern long double nearbyintl (long double __x) throw (); extern long double __nearbyintl (long double __x) throw ();
+
+
+
+extern long double roundl (long double __x) throw () __attribute__ ((__const__)); extern long double __roundl (long double __x) throw () __attribute__ ((__const__));
+
+
+
+extern long double truncl (long double __x) throw () __attribute__ ((__const__)); extern long double __truncl (long double __x) throw () __attribute__ ((__const__));
+
+
+
+
+extern long double remquol (long double __x, long double __y, int *__quo) throw (); extern long double __remquol (long double __x, long double __y, int *__quo) throw ();
+
+
+
+
+
+
+extern long int lrintl (long double __x) throw (); extern long int __lrintl (long double __x) throw ();
+__extension__
+extern long long int llrintl (long double __x) throw (); extern long long int __llrintl (long double __x) throw ();
+
+
+
+extern long int lroundl (long double __x) throw (); extern long int __lroundl (long double __x) throw ();
+__extension__
+extern long long int llroundl (long double __x) throw (); extern long long int __llroundl (long double __x) throw ();
+
+
+
+extern long double fdiml (long double __x, long double __y) throw (); extern long double __fdiml (long double __x, long double __y) throw ();
+
+
+extern long double fmaxl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __fmaxl (long double __x, long double __y) throw () __attribute__ ((__const__));
+
+
+extern long double fminl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __fminl (long double __x, long double __y) throw () __attribute__ ((__const__));
+
+
+extern long double fmal (long double __x, long double __y, long double __z) throw (); extern long double __fmal (long double __x, long double __y, long double __z) throw ();
+
+
+
+
+extern long double roundevenl (long double __x) throw () __attribute__ ((__const__)); extern long double __roundevenl (long double __x) throw () __attribute__ ((__const__));
+
+
+
+extern __intmax_t fromfpl (long double __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpl (long double __x, int __round, unsigned int __width) throw ()
+                            ;
+
+
+
+extern __uintmax_t ufromfpl (long double __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpl (long double __x, int __round, unsigned int __width) throw ()
+                              ;
+
+
+
+
+extern __intmax_t fromfpxl (long double __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpxl (long double __x, int __round, unsigned int __width) throw ()
+                             ;
+
+
+
+
+extern __uintmax_t ufromfpxl (long double __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpxl (long double __x, int __round, unsigned int __width) throw ()
+                               ;
+
+
+extern long double fmaxmagl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __fmaxmagl (long double __x, long double __y) throw () __attribute__ ((__const__));
+
+
+extern long double fminmagl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __fminmagl (long double __x, long double __y) throw () __attribute__ ((__const__));
+
+
+extern int canonicalizel (long double *__cx, const long double *__x) throw ();
+
+
+
+
+extern int totalorderl (const long double *__x, const long double *__y) throw ()
+
+     __attribute__ ((__pure__));
+
+
+extern int totalordermagl (const long double *__x, const long double *__y) throw ()
+
+     __attribute__ ((__pure__));
+
+
+extern long double getpayloadl (const long double *__x) throw (); extern long double __getpayloadl (const long double *__x) throw ();
+
+
+extern int setpayloadl (long double *__x, long double __payload) throw ();
+
+
+extern int setpayloadsigl (long double *__x, long double __payload) throw ();
+
+
+
+
+
+
+
+extern long double scalbl (long double __x, long double __n) throw (); extern long double __scalbl (long double __x, long double __n) throw ();
+# 386 "/usr/include/math.h" 2 3 4
+
+#undef _Mdouble_
+#undef __MATH_PRECNAME
+#undef __MATH_DECLARING_DOUBLE
+#undef __MATH_DECLARING_FLOATN
+# 428 "/usr/include/math.h" 3 4
+#define _Mdouble_ _Float32
+#define __MATH_PRECNAME(name,r) name ##f32 ##r
+#define __MATH_DECLARING_DOUBLE 0
+#define __MATH_DECLARING_FLOATN 1
+
+
+
+
+# 1 "/usr/include/bits/mathcalls.h" 1 3 4
+# 53 "/usr/include/bits/mathcalls.h" 3 4
+extern _Float32 acosf32 (_Float32 __x) throw (); extern _Float32 __acosf32 (_Float32 __x) throw ();
+
+extern _Float32 asinf32 (_Float32 __x) throw (); extern _Float32 __asinf32 (_Float32 __x) throw ();
+
+extern _Float32 atanf32 (_Float32 __x) throw (); extern _Float32 __atanf32 (_Float32 __x) throw ();
+
+extern _Float32 atan2f32 (_Float32 __y, _Float32 __x) throw (); extern _Float32 __atan2f32 (_Float32 __y, _Float32 __x) throw ();
+
+
+ extern _Float32 cosf32 (_Float32 __x) throw (); extern _Float32 __cosf32 (_Float32 __x) throw ();
+
+ extern _Float32 sinf32 (_Float32 __x) throw (); extern _Float32 __sinf32 (_Float32 __x) throw ();
+
+extern _Float32 tanf32 (_Float32 __x) throw (); extern _Float32 __tanf32 (_Float32 __x) throw ();
+
+
+
+
+extern _Float32 coshf32 (_Float32 __x) throw (); extern _Float32 __coshf32 (_Float32 __x) throw ();
+
+extern _Float32 sinhf32 (_Float32 __x) throw (); extern _Float32 __sinhf32 (_Float32 __x) throw ();
+
+extern _Float32 tanhf32 (_Float32 __x) throw (); extern _Float32 __tanhf32 (_Float32 __x) throw ();
+
+
+
+ extern void sincosf32 (_Float32 __x, _Float32 *__sinx, _Float32 *__cosx) throw (); extern void __sincosf32 (_Float32 __x, _Float32 *__sinx, _Float32 *__cosx) throw ()
+                                                        ;
+
+
+
+
+extern _Float32 acoshf32 (_Float32 __x) throw (); extern _Float32 __acoshf32 (_Float32 __x) throw ();
+
+extern _Float32 asinhf32 (_Float32 __x) throw (); extern _Float32 __asinhf32 (_Float32 __x) throw ();
+
+extern _Float32 atanhf32 (_Float32 __x) throw (); extern _Float32 __atanhf32 (_Float32 __x) throw ();
+
+
+
+
+
+ extern _Float32 expf32 (_Float32 __x) throw (); extern _Float32 __expf32 (_Float32 __x) throw ();
+
+
+extern _Float32 frexpf32 (_Float32 __x, int *__exponent) throw (); extern _Float32 __frexpf32 (_Float32 __x, int *__exponent) throw ();
+
+
+extern _Float32 ldexpf32 (_Float32 __x, int __exponent) throw (); extern _Float32 __ldexpf32 (_Float32 __x, int __exponent) throw ();
+
+
+ extern _Float32 logf32 (_Float32 __x) throw (); extern _Float32 __logf32 (_Float32 __x) throw ();
+
+
+extern _Float32 log10f32 (_Float32 __x) throw (); extern _Float32 __log10f32 (_Float32 __x) throw ();
+
+
+extern _Float32 modff32 (_Float32 __x, _Float32 *__iptr) throw (); extern _Float32 __modff32 (_Float32 __x, _Float32 *__iptr) throw () __attribute__ ((__nonnull__ (2)));
+
+
+
+extern _Float32 exp10f32 (_Float32 __x) throw (); extern _Float32 __exp10f32 (_Float32 __x) throw ();
+
+
+
+
+extern _Float32 expm1f32 (_Float32 __x) throw (); extern _Float32 __expm1f32 (_Float32 __x) throw ();
+
+
+extern _Float32 log1pf32 (_Float32 __x) throw (); extern _Float32 __log1pf32 (_Float32 __x) throw ();
+
+
+extern _Float32 logbf32 (_Float32 __x) throw (); extern _Float32 __logbf32 (_Float32 __x) throw ();
+
+
+
+
+extern _Float32 exp2f32 (_Float32 __x) throw (); extern _Float32 __exp2f32 (_Float32 __x) throw ();
+
+
+extern _Float32 log2f32 (_Float32 __x) throw (); extern _Float32 __log2f32 (_Float32 __x) throw ();
+
+
+
+
+
+
+ extern _Float32 powf32 (_Float32 __x, _Float32 __y) throw (); extern _Float32 __powf32 (_Float32 __x, _Float32 __y) throw ();
+
+
+extern _Float32 sqrtf32 (_Float32 __x) throw (); extern _Float32 __sqrtf32 (_Float32 __x) throw ();
+
+
+
+extern _Float32 hypotf32 (_Float32 __x, _Float32 __y) throw (); extern _Float32 __hypotf32 (_Float32 __x, _Float32 __y) throw ();
+
+
+
+
+extern _Float32 cbrtf32 (_Float32 __x) throw (); extern _Float32 __cbrtf32 (_Float32 __x) throw ();
+
+
+
+
+
+
+extern _Float32 ceilf32 (_Float32 __x) throw () __attribute__ ((__const__)); extern _Float32 __ceilf32 (_Float32 __x) throw () __attribute__ ((__const__));
+
+
+extern _Float32 fabsf32 (_Float32 __x) throw () __attribute__ ((__const__)); extern _Float32 __fabsf32 (_Float32 __x) throw () __attribute__ ((__const__));
+
+
+extern _Float32 floorf32 (_Float32 __x) throw () __attribute__ ((__const__)); extern _Float32 __floorf32 (_Float32 __x) throw () __attribute__ ((__const__));
+
+
+extern _Float32 fmodf32 (_Float32 __x, _Float32 __y) throw (); extern _Float32 __fmodf32 (_Float32 __x, _Float32 __y) throw ();
+# 198 "/usr/include/bits/mathcalls.h" 3 4
+extern _Float32 copysignf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__)); extern _Float32 __copysignf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__));
+
+
+
+
+extern _Float32 nanf32 (const char *__tagb) throw (); extern _Float32 __nanf32 (const char *__tagb) throw ();
+# 220 "/usr/include/bits/mathcalls.h" 3 4
+extern _Float32 j0f32 (_Float32) throw (); extern _Float32 __j0f32 (_Float32) throw ();
+extern _Float32 j1f32 (_Float32) throw (); extern _Float32 __j1f32 (_Float32) throw ();
+extern _Float32 jnf32 (int, _Float32) throw (); extern _Float32 __jnf32 (int, _Float32) throw ();
+extern _Float32 y0f32 (_Float32) throw (); extern _Float32 __y0f32 (_Float32) throw ();
+extern _Float32 y1f32 (_Float32) throw (); extern _Float32 __y1f32 (_Float32) throw ();
+extern _Float32 ynf32 (int, _Float32) throw (); extern _Float32 __ynf32 (int, _Float32) throw ();
+
+
+
+
+
+extern _Float32 erff32 (_Float32) throw (); extern _Float32 __erff32 (_Float32) throw ();
+extern _Float32 erfcf32 (_Float32) throw (); extern _Float32 __erfcf32 (_Float32) throw ();
+extern _Float32 lgammaf32 (_Float32) throw (); extern _Float32 __lgammaf32 (_Float32) throw ();
+
+
+
+
+extern _Float32 tgammaf32 (_Float32) throw (); extern _Float32 __tgammaf32 (_Float32) throw ();
+# 252 "/usr/include/bits/mathcalls.h" 3 4
+extern _Float32 lgammaf32_r (_Float32, int *__signgamp) throw (); extern _Float32 __lgammaf32_r (_Float32, int *__signgamp) throw ();
+
+
+
+
+
+
+extern _Float32 rintf32 (_Float32 __x) throw (); extern _Float32 __rintf32 (_Float32 __x) throw ();
+
+
+extern _Float32 nextafterf32 (_Float32 __x, _Float32 __y) throw (); extern _Float32 __nextafterf32 (_Float32 __x, _Float32 __y) throw ();
+
+
+
+
+
+
+extern _Float32 nextdownf32 (_Float32 __x) throw (); extern _Float32 __nextdownf32 (_Float32 __x) throw ();
+
+extern _Float32 nextupf32 (_Float32 __x) throw (); extern _Float32 __nextupf32 (_Float32 __x) throw ();
+
+
+
+extern _Float32 remainderf32 (_Float32 __x, _Float32 __y) throw (); extern _Float32 __remainderf32 (_Float32 __x, _Float32 __y) throw ();
+
+
+
+extern _Float32 scalbnf32 (_Float32 __x, int __n) throw (); extern _Float32 __scalbnf32 (_Float32 __x, int __n) throw ();
+
+
+
+extern int ilogbf32 (_Float32 __x) throw (); extern int __ilogbf32 (_Float32 __x) throw ();
+
+
+
+
+extern long int llogbf32 (_Float32 __x) throw (); extern long int __llogbf32 (_Float32 __x) throw ();
+
+
+
+
+extern _Float32 scalblnf32 (_Float32 __x, long int __n) throw (); extern _Float32 __scalblnf32 (_Float32 __x, long int __n) throw ();
+
+
+
+extern _Float32 nearbyintf32 (_Float32 __x) throw (); extern _Float32 __nearbyintf32 (_Float32 __x) throw ();
+
+
+
+extern _Float32 roundf32 (_Float32 __x) throw () __attribute__ ((__const__)); extern _Float32 __roundf32 (_Float32 __x) throw () __attribute__ ((__const__));
+
+
+
+extern _Float32 truncf32 (_Float32 __x) throw () __attribute__ ((__const__)); extern _Float32 __truncf32 (_Float32 __x) throw () __attribute__ ((__const__));
+
+
+
+
+extern _Float32 remquof32 (_Float32 __x, _Float32 __y, int *__quo) throw (); extern _Float32 __remquof32 (_Float32 __x, _Float32 __y, int *__quo) throw ();
+
+
+
+
+
+
+extern long int lrintf32 (_Float32 __x) throw (); extern long int __lrintf32 (_Float32 __x) throw ();
+__extension__
+extern long long int llrintf32 (_Float32 __x) throw (); extern long long int __llrintf32 (_Float32 __x) throw ();
+
+
+
+extern long int lroundf32 (_Float32 __x) throw (); extern long int __lroundf32 (_Float32 __x) throw ();
+__extension__
+extern long long int llroundf32 (_Float32 __x) throw (); extern long long int __llroundf32 (_Float32 __x) throw ();
+
+
+
+extern _Float32 fdimf32 (_Float32 __x, _Float32 __y) throw (); extern _Float32 __fdimf32 (_Float32 __x, _Float32 __y) throw ();
+
+
+extern _Float32 fmaxf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__)); extern _Float32 __fmaxf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__));
+
+
+extern _Float32 fminf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__)); extern _Float32 __fminf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__));
+
+
+extern _Float32 fmaf32 (_Float32 __x, _Float32 __y, _Float32 __z) throw (); extern _Float32 __fmaf32 (_Float32 __x, _Float32 __y, _Float32 __z) throw ();
+
+
+
+
+extern _Float32 roundevenf32 (_Float32 __x) throw () __attribute__ ((__const__)); extern _Float32 __roundevenf32 (_Float32 __x) throw () __attribute__ ((__const__));
+
+
+
+extern __intmax_t fromfpf32 (_Float32 __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpf32 (_Float32 __x, int __round, unsigned int __width) throw ()
+                            ;
+
+
+
+extern __uintmax_t ufromfpf32 (_Float32 __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpf32 (_Float32 __x, int __round, unsigned int __width) throw ()
+                              ;
+
+
+
+
+extern __intmax_t fromfpxf32 (_Float32 __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpxf32 (_Float32 __x, int __round, unsigned int __width) throw ()
+                             ;
+
+
+
+
+extern __uintmax_t ufromfpxf32 (_Float32 __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpxf32 (_Float32 __x, int __round, unsigned int __width) throw ()
+                               ;
+
+
+extern _Float32 fmaxmagf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__)); extern _Float32 __fmaxmagf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__));
+
+
+extern _Float32 fminmagf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__)); extern _Float32 __fminmagf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__));
+
+
+extern int canonicalizef32 (_Float32 *__cx, const _Float32 *__x) throw ();
+
+
+
+
+extern int totalorderf32 (const _Float32 *__x, const _Float32 *__y) throw ()
+
+     __attribute__ ((__pure__));
+
+
+extern int totalordermagf32 (const _Float32 *__x, const _Float32 *__y) throw ()
+
+     __attribute__ ((__pure__));
+
+
+extern _Float32 getpayloadf32 (const _Float32 *__x) throw (); extern _Float32 __getpayloadf32 (const _Float32 *__x) throw ();
+
+
+extern int setpayloadf32 (_Float32 *__x, _Float32 __payload) throw ();
+
+
+extern int setpayloadsigf32 (_Float32 *__x, _Float32 __payload) throw ();
+# 437 "/usr/include/math.h" 2 3 4
+
+#undef _Mdouble_
+#undef __MATH_PRECNAME
+#undef __MATH_DECLARING_DOUBLE
+#undef __MATH_DECLARING_FLOATN
+
+
+
+#define _Mdouble_ _Float64
+#define __MATH_PRECNAME(name,r) name ##f64 ##r
+#define __MATH_DECLARING_DOUBLE 0
+#define __MATH_DECLARING_FLOATN 1
+
+
+
+
+# 1 "/usr/include/bits/mathcalls.h" 1 3 4
+# 53 "/usr/include/bits/mathcalls.h" 3 4
+extern _Float64 acosf64 (_Float64 __x) throw (); extern _Float64 __acosf64 (_Float64 __x) throw ();
+
+extern _Float64 asinf64 (_Float64 __x) throw (); extern _Float64 __asinf64 (_Float64 __x) throw ();
+
+extern _Float64 atanf64 (_Float64 __x) throw (); extern _Float64 __atanf64 (_Float64 __x) throw ();
+
+extern _Float64 atan2f64 (_Float64 __y, _Float64 __x) throw (); extern _Float64 __atan2f64 (_Float64 __y, _Float64 __x) throw ();
+
+
+ extern _Float64 cosf64 (_Float64 __x) throw (); extern _Float64 __cosf64 (_Float64 __x) throw ();
+
+ extern _Float64 sinf64 (_Float64 __x) throw (); extern _Float64 __sinf64 (_Float64 __x) throw ();
+
+extern _Float64 tanf64 (_Float64 __x) throw (); extern _Float64 __tanf64 (_Float64 __x) throw ();
+
+
+
+
+extern _Float64 coshf64 (_Float64 __x) throw (); extern _Float64 __coshf64 (_Float64 __x) throw ();
+
+extern _Float64 sinhf64 (_Float64 __x) throw (); extern _Float64 __sinhf64 (_Float64 __x) throw ();
+
+extern _Float64 tanhf64 (_Float64 __x) throw (); extern _Float64 __tanhf64 (_Float64 __x) throw ();
+
+
+
+ extern void sincosf64 (_Float64 __x, _Float64 *__sinx, _Float64 *__cosx) throw (); extern void __sincosf64 (_Float64 __x, _Float64 *__sinx, _Float64 *__cosx) throw ()
+                                                        ;
+
+
+
+
+extern _Float64 acoshf64 (_Float64 __x) throw (); extern _Float64 __acoshf64 (_Float64 __x) throw ();
+
+extern _Float64 asinhf64 (_Float64 __x) throw (); extern _Float64 __asinhf64 (_Float64 __x) throw ();
+
+extern _Float64 atanhf64 (_Float64 __x) throw (); extern _Float64 __atanhf64 (_Float64 __x) throw ();
+
+
+
+
+
+ extern _Float64 expf64 (_Float64 __x) throw (); extern _Float64 __expf64 (_Float64 __x) throw ();
+
+
+extern _Float64 frexpf64 (_Float64 __x, int *__exponent) throw (); extern _Float64 __frexpf64 (_Float64 __x, int *__exponent) throw ();
+
+
+extern _Float64 ldexpf64 (_Float64 __x, int __exponent) throw (); extern _Float64 __ldexpf64 (_Float64 __x, int __exponent) throw ();
+
+
+ extern _Float64 logf64 (_Float64 __x) throw (); extern _Float64 __logf64 (_Float64 __x) throw ();
+
+
+extern _Float64 log10f64 (_Float64 __x) throw (); extern _Float64 __log10f64 (_Float64 __x) throw ();
+
+
+extern _Float64 modff64 (_Float64 __x, _Float64 *__iptr) throw (); extern _Float64 __modff64 (_Float64 __x, _Float64 *__iptr) throw () __attribute__ ((__nonnull__ (2)));
+
+
+
+extern _Float64 exp10f64 (_Float64 __x) throw (); extern _Float64 __exp10f64 (_Float64 __x) throw ();
+
+
+
+
+extern _Float64 expm1f64 (_Float64 __x) throw (); extern _Float64 __expm1f64 (_Float64 __x) throw ();
+
+
+extern _Float64 log1pf64 (_Float64 __x) throw (); extern _Float64 __log1pf64 (_Float64 __x) throw ();
+
+
+extern _Float64 logbf64 (_Float64 __x) throw (); extern _Float64 __logbf64 (_Float64 __x) throw ();
+
+
+
+
+extern _Float64 exp2f64 (_Float64 __x) throw (); extern _Float64 __exp2f64 (_Float64 __x) throw ();
+
+
+extern _Float64 log2f64 (_Float64 __x) throw (); extern _Float64 __log2f64 (_Float64 __x) throw ();
+
+
+
+
+
+
+ extern _Float64 powf64 (_Float64 __x, _Float64 __y) throw (); extern _Float64 __powf64 (_Float64 __x, _Float64 __y) throw ();
+
+
+extern _Float64 sqrtf64 (_Float64 __x) throw (); extern _Float64 __sqrtf64 (_Float64 __x) throw ();
+
+
+
+extern _Float64 hypotf64 (_Float64 __x, _Float64 __y) throw (); extern _Float64 __hypotf64 (_Float64 __x, _Float64 __y) throw ();
+
+
+
+
+extern _Float64 cbrtf64 (_Float64 __x) throw (); extern _Float64 __cbrtf64 (_Float64 __x) throw ();
+
+
+
+
+
+
+extern _Float64 ceilf64 (_Float64 __x) throw () __attribute__ ((__const__)); extern _Float64 __ceilf64 (_Float64 __x) throw () __attribute__ ((__const__));
+
+
+extern _Float64 fabsf64 (_Float64 __x) throw () __attribute__ ((__const__)); extern _Float64 __fabsf64 (_Float64 __x) throw () __attribute__ ((__const__));
+
+
+extern _Float64 floorf64 (_Float64 __x) throw () __attribute__ ((__const__)); extern _Float64 __floorf64 (_Float64 __x) throw () __attribute__ ((__const__));
+
+
+extern _Float64 fmodf64 (_Float64 __x, _Float64 __y) throw (); extern _Float64 __fmodf64 (_Float64 __x, _Float64 __y) throw ();
+# 198 "/usr/include/bits/mathcalls.h" 3 4
+extern _Float64 copysignf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__)); extern _Float64 __copysignf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__));
+
+
+
+
+extern _Float64 nanf64 (const char *__tagb) throw (); extern _Float64 __nanf64 (const char *__tagb) throw ();
+# 220 "/usr/include/bits/mathcalls.h" 3 4
+extern _Float64 j0f64 (_Float64) throw (); extern _Float64 __j0f64 (_Float64) throw ();
+extern _Float64 j1f64 (_Float64) throw (); extern _Float64 __j1f64 (_Float64) throw ();
+extern _Float64 jnf64 (int, _Float64) throw (); extern _Float64 __jnf64 (int, _Float64) throw ();
+extern _Float64 y0f64 (_Float64) throw (); extern _Float64 __y0f64 (_Float64) throw ();
+extern _Float64 y1f64 (_Float64) throw (); extern _Float64 __y1f64 (_Float64) throw ();
+extern _Float64 ynf64 (int, _Float64) throw (); extern _Float64 __ynf64 (int, _Float64) throw ();
+
+
+
+
+
+extern _Float64 erff64 (_Float64) throw (); extern _Float64 __erff64 (_Float64) throw ();
+extern _Float64 erfcf64 (_Float64) throw (); extern _Float64 __erfcf64 (_Float64) throw ();
+extern _Float64 lgammaf64 (_Float64) throw (); extern _Float64 __lgammaf64 (_Float64) throw ();
+
+
+
+
+extern _Float64 tgammaf64 (_Float64) throw (); extern _Float64 __tgammaf64 (_Float64) throw ();
+# 252 "/usr/include/bits/mathcalls.h" 3 4
+extern _Float64 lgammaf64_r (_Float64, int *__signgamp) throw (); extern _Float64 __lgammaf64_r (_Float64, int *__signgamp) throw ();
+
+
+
+
+
+
+extern _Float64 rintf64 (_Float64 __x) throw (); extern _Float64 __rintf64 (_Float64 __x) throw ();
+
+
+extern _Float64 nextafterf64 (_Float64 __x, _Float64 __y) throw (); extern _Float64 __nextafterf64 (_Float64 __x, _Float64 __y) throw ();
+
+
+
+
+
+
+extern _Float64 nextdownf64 (_Float64 __x) throw (); extern _Float64 __nextdownf64 (_Float64 __x) throw ();
+
+extern _Float64 nextupf64 (_Float64 __x) throw (); extern _Float64 __nextupf64 (_Float64 __x) throw ();
+
+
+
+extern _Float64 remainderf64 (_Float64 __x, _Float64 __y) throw (); extern _Float64 __remainderf64 (_Float64 __x, _Float64 __y) throw ();
+
+
+
+extern _Float64 scalbnf64 (_Float64 __x, int __n) throw (); extern _Float64 __scalbnf64 (_Float64 __x, int __n) throw ();
+
+
+
+extern int ilogbf64 (_Float64 __x) throw (); extern int __ilogbf64 (_Float64 __x) throw ();
+
+
+
+
+extern long int llogbf64 (_Float64 __x) throw (); extern long int __llogbf64 (_Float64 __x) throw ();
+
+
+
+
+extern _Float64 scalblnf64 (_Float64 __x, long int __n) throw (); extern _Float64 __scalblnf64 (_Float64 __x, long int __n) throw ();
+
+
+
+extern _Float64 nearbyintf64 (_Float64 __x) throw (); extern _Float64 __nearbyintf64 (_Float64 __x) throw ();
+
+
+
+extern _Float64 roundf64 (_Float64 __x) throw () __attribute__ ((__const__)); extern _Float64 __roundf64 (_Float64 __x) throw () __attribute__ ((__const__));
+
+
+
+extern _Float64 truncf64 (_Float64 __x) throw () __attribute__ ((__const__)); extern _Float64 __truncf64 (_Float64 __x) throw () __attribute__ ((__const__));
+
+
+
+
+extern _Float64 remquof64 (_Float64 __x, _Float64 __y, int *__quo) throw (); extern _Float64 __remquof64 (_Float64 __x, _Float64 __y, int *__quo) throw ();
+
+
+
+
+
+
+extern long int lrintf64 (_Float64 __x) throw (); extern long int __lrintf64 (_Float64 __x) throw ();
+__extension__
+extern long long int llrintf64 (_Float64 __x) throw (); extern long long int __llrintf64 (_Float64 __x) throw ();
+
+
+
+extern long int lroundf64 (_Float64 __x) throw (); extern long int __lroundf64 (_Float64 __x) throw ();
+__extension__
+extern long long int llroundf64 (_Float64 __x) throw (); extern long long int __llroundf64 (_Float64 __x) throw ();
+
+
+
+extern _Float64 fdimf64 (_Float64 __x, _Float64 __y) throw (); extern _Float64 __fdimf64 (_Float64 __x, _Float64 __y) throw ();
+
+
+extern _Float64 fmaxf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__)); extern _Float64 __fmaxf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__));
+
+
+extern _Float64 fminf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__)); extern _Float64 __fminf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__));
+
+
+extern _Float64 fmaf64 (_Float64 __x, _Float64 __y, _Float64 __z) throw (); extern _Float64 __fmaf64 (_Float64 __x, _Float64 __y, _Float64 __z) throw ();
+
+
+
+
+extern _Float64 roundevenf64 (_Float64 __x) throw () __attribute__ ((__const__)); extern _Float64 __roundevenf64 (_Float64 __x) throw () __attribute__ ((__const__));
+
+
+
+extern __intmax_t fromfpf64 (_Float64 __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpf64 (_Float64 __x, int __round, unsigned int __width) throw ()
+                            ;
+
+
+
+extern __uintmax_t ufromfpf64 (_Float64 __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpf64 (_Float64 __x, int __round, unsigned int __width) throw ()
+                              ;
+
+
+
+
+extern __intmax_t fromfpxf64 (_Float64 __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpxf64 (_Float64 __x, int __round, unsigned int __width) throw ()
+                             ;
+
+
+
+
+extern __uintmax_t ufromfpxf64 (_Float64 __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpxf64 (_Float64 __x, int __round, unsigned int __width) throw ()
+                               ;
+
+
+extern _Float64 fmaxmagf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__)); extern _Float64 __fmaxmagf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__));
+
+
+extern _Float64 fminmagf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__)); extern _Float64 __fminmagf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__));
+
+
+extern int canonicalizef64 (_Float64 *__cx, const _Float64 *__x) throw ();
+
+
+
+
+extern int totalorderf64 (const _Float64 *__x, const _Float64 *__y) throw ()
+
+     __attribute__ ((__pure__));
+
+
+extern int totalordermagf64 (const _Float64 *__x, const _Float64 *__y) throw ()
+
+     __attribute__ ((__pure__));
+
+
+extern _Float64 getpayloadf64 (const _Float64 *__x) throw (); extern _Float64 __getpayloadf64 (const _Float64 *__x) throw ();
+
+
+extern int setpayloadf64 (_Float64 *__x, _Float64 __payload) throw ();
+
+
+extern int setpayloadsigf64 (_Float64 *__x, _Float64 __payload) throw ();
+# 454 "/usr/include/math.h" 2 3 4
+
+#undef _Mdouble_
+#undef __MATH_PRECNAME
+#undef __MATH_DECLARING_DOUBLE
+#undef __MATH_DECLARING_FLOATN
+
+
+
+#define _Mdouble_ _Float128
+#define __MATH_PRECNAME(name,r) name ##f128 ##r
+#define __MATH_DECLARING_DOUBLE 0
+#define __MATH_DECLARING_FLOATN 1
+
+# 1 "/usr/include/bits/mathcalls-helper-functions.h" 1 3 4
+# 20 "/usr/include/bits/mathcalls-helper-functions.h" 3 4
+extern int __fpclassifyf128 (_Float128 __value) throw ()
+     __attribute__ ((__const__));
+
+
+extern int __signbitf128 (_Float128 __value) throw ()
+     __attribute__ ((__const__));
+
+
+
+extern int __isinff128 (_Float128 __value) throw ()
+  __attribute__ ((__const__));
+
+
+extern int __finitef128 (_Float128 __value) throw ()
+  __attribute__ ((__const__));
+
+
+extern int __isnanf128 (_Float128 __value) throw ()
+  __attribute__ ((__const__));
+
+
+extern int __iseqsigf128 (_Float128 __x, _Float128 __y) throw ();
+
+
+extern int __issignalingf128 (_Float128 __value) throw ()
+     __attribute__ ((__const__));
+# 468 "/usr/include/math.h" 2 3 4
+
+
+# 1 "/usr/include/bits/mathcalls.h" 1 3 4
+# 53 "/usr/include/bits/mathcalls.h" 3 4
+extern _Float128 acosf128 (_Float128 __x) throw (); extern _Float128 __acosf128 (_Float128 __x) throw ();
+
+extern _Float128 asinf128 (_Float128 __x) throw (); extern _Float128 __asinf128 (_Float128 __x) throw ();
+
+extern _Float128 atanf128 (_Float128 __x) throw (); extern _Float128 __atanf128 (_Float128 __x) throw ();
+
+extern _Float128 atan2f128 (_Float128 __y, _Float128 __x) throw (); extern _Float128 __atan2f128 (_Float128 __y, _Float128 __x) throw ();
+
+
+ extern _Float128 cosf128 (_Float128 __x) throw (); extern _Float128 __cosf128 (_Float128 __x) throw ();
+
+ extern _Float128 sinf128 (_Float128 __x) throw (); extern _Float128 __sinf128 (_Float128 __x) throw ();
+
+extern _Float128 tanf128 (_Float128 __x) throw (); extern _Float128 __tanf128 (_Float128 __x) throw ();
+
+
+
+
+extern _Float128 coshf128 (_Float128 __x) throw (); extern _Float128 __coshf128 (_Float128 __x) throw ();
+
+extern _Float128 sinhf128 (_Float128 __x) throw (); extern _Float128 __sinhf128 (_Float128 __x) throw ();
+
+extern _Float128 tanhf128 (_Float128 __x) throw (); extern _Float128 __tanhf128 (_Float128 __x) throw ();
+
+
+
+ extern void sincosf128 (_Float128 __x, _Float128 *__sinx, _Float128 *__cosx) throw (); extern void __sincosf128 (_Float128 __x, _Float128 *__sinx, _Float128 *__cosx) throw ()
+                                                        ;
+
+
+
+
+extern _Float128 acoshf128 (_Float128 __x) throw (); extern _Float128 __acoshf128 (_Float128 __x) throw ();
+
+extern _Float128 asinhf128 (_Float128 __x) throw (); extern _Float128 __asinhf128 (_Float128 __x) throw ();
+
+extern _Float128 atanhf128 (_Float128 __x) throw (); extern _Float128 __atanhf128 (_Float128 __x) throw ();
+
+
+
+
+
+ extern _Float128 expf128 (_Float128 __x) throw (); extern _Float128 __expf128 (_Float128 __x) throw ();
+
+
+extern _Float128 frexpf128 (_Float128 __x, int *__exponent) throw (); extern _Float128 __frexpf128 (_Float128 __x, int *__exponent) throw ();
+
+
+extern _Float128 ldexpf128 (_Float128 __x, int __exponent) throw (); extern _Float128 __ldexpf128 (_Float128 __x, int __exponent) throw ();
+
+
+ extern _Float128 logf128 (_Float128 __x) throw (); extern _Float128 __logf128 (_Float128 __x) throw ();
+
+
+extern _Float128 log10f128 (_Float128 __x) throw (); extern _Float128 __log10f128 (_Float128 __x) throw ();
+
+
+extern _Float128 modff128 (_Float128 __x, _Float128 *__iptr) throw (); extern _Float128 __modff128 (_Float128 __x, _Float128 *__iptr) throw () __attribute__ ((__nonnull__ (2)));
+
+
+
+extern _Float128 exp10f128 (_Float128 __x) throw (); extern _Float128 __exp10f128 (_Float128 __x) throw ();
+
+
+
+
+extern _Float128 expm1f128 (_Float128 __x) throw (); extern _Float128 __expm1f128 (_Float128 __x) throw ();
+
+
+extern _Float128 log1pf128 (_Float128 __x) throw (); extern _Float128 __log1pf128 (_Float128 __x) throw ();
+
+
+extern _Float128 logbf128 (_Float128 __x) throw (); extern _Float128 __logbf128 (_Float128 __x) throw ();
+
+
+
+
+extern _Float128 exp2f128 (_Float128 __x) throw (); extern _Float128 __exp2f128 (_Float128 __x) throw ();
+
+
+extern _Float128 log2f128 (_Float128 __x) throw (); extern _Float128 __log2f128 (_Float128 __x) throw ();
+
+
+
+
+
+
+ extern _Float128 powf128 (_Float128 __x, _Float128 __y) throw (); extern _Float128 __powf128 (_Float128 __x, _Float128 __y) throw ();
+
+
+extern _Float128 sqrtf128 (_Float128 __x) throw (); extern _Float128 __sqrtf128 (_Float128 __x) throw ();
+
+
+
+extern _Float128 hypotf128 (_Float128 __x, _Float128 __y) throw (); extern _Float128 __hypotf128 (_Float128 __x, _Float128 __y) throw ();
+
+
+
+
+extern _Float128 cbrtf128 (_Float128 __x) throw (); extern _Float128 __cbrtf128 (_Float128 __x) throw ();
+
+
+
+
+
+
+extern _Float128 ceilf128 (_Float128 __x) throw () __attribute__ ((__const__)); extern _Float128 __ceilf128 (_Float128 __x) throw () __attribute__ ((__const__));
+
+
+extern _Float128 fabsf128 (_Float128 __x) throw () __attribute__ ((__const__)); extern _Float128 __fabsf128 (_Float128 __x) throw () __attribute__ ((__const__));
+
+
+extern _Float128 floorf128 (_Float128 __x) throw () __attribute__ ((__const__)); extern _Float128 __floorf128 (_Float128 __x) throw () __attribute__ ((__const__));
+
+
+extern _Float128 fmodf128 (_Float128 __x, _Float128 __y) throw (); extern _Float128 __fmodf128 (_Float128 __x, _Float128 __y) throw ();
+# 198 "/usr/include/bits/mathcalls.h" 3 4
+extern _Float128 copysignf128 (_Float128 __x, _Float128 __y) throw () __attribute__ ((__const__)); extern _Float128 __copysignf128 (_Float128 __x, _Float128 __y) throw () __attribute__ ((__const__));
+
+
+
+
+extern _Float128 nanf128 (const char *__tagb) throw (); extern _Float128 __nanf128 (const char *__tagb) throw ();
+# 220 "/usr/include/bits/mathcalls.h" 3 4
+extern _Float128 j0f128 (_Float128) throw (); extern _Float128 __j0f128 (_Float128) throw ();
+extern _Float128 j1f128 (_Float128) throw (); extern _Float128 __j1f128 (_Float128) throw ();
+extern _Float128 jnf128 (int, _Float128) throw (); extern _Float128 __jnf128 (int, _Float128) throw ();
+extern _Float128 y0f128 (_Float128) throw (); extern _Float128 __y0f128 (_Float128) throw ();
+extern _Float128 y1f128 (_Float128) throw (); extern _Float128 __y1f128 (_Float128) throw ();
+extern _Float128 ynf128 (int, _Float128) throw (); extern _Float128 __ynf128 (int, _Float128) throw ();
+
+
+
+
+
+extern _Float128 erff128 (_Float128) throw (); extern _Float128 __erff128 (_Float128) throw ();
+extern _Float128 erfcf128 (_Float128) throw (); extern _Float128 __erfcf128 (_Float128) throw ();
+extern _Float128 lgammaf128 (_Float128) throw (); extern _Float128 __lgammaf128 (_Float128) throw ();
+
+
+
+
+extern _Float128 tgammaf128 (_Float128) throw (); extern _Float128 __tgammaf128 (_Float128) throw ();
+# 252 "/usr/include/bits/mathcalls.h" 3 4
+extern _Float128 lgammaf128_r (_Float128, int *__signgamp) throw (); extern _Float128 __lgammaf128_r (_Float128, int *__signgamp) throw ();
+
+
+
+
+
+
+extern _Float128 rintf128 (_Float128 __x) throw (); extern _Float128 __rintf128 (_Float128 __x) throw ();
+
+
+extern _Float128 nextafterf128 (_Float128 __x, _Float128 __y) throw (); extern _Float128 __nextafterf128 (_Float128 __x, _Float128 __y) throw ();
+
+
+
+
+
+
+extern _Float128 nextdownf128 (_Float128 __x) throw (); extern _Float128 __nextdownf128 (_Float128 __x) throw ();
+
+extern _Float128 nextupf128 (_Float128 __x) throw (); extern _Float128 __nextupf128 (_Float128 __x) throw ();
+
+
+
+extern _Float128 remainderf128 (_Float128 __x, _Float128 __y) throw (); extern _Float128 __remainderf128 (_Float128 __x, _Float128 __y) throw ();
+
+
+
+extern _Float128 scalbnf128 (_Float128 __x, int __n) throw (); extern _Float128 __scalbnf128 (_Float128 __x, int __n) throw ();
+
+
+
+extern int ilogbf128 (_Float128 __x) throw (); extern int __ilogbf128 (_Float128 __x) throw ();
+
+
+
+
+extern long int llogbf128 (_Float128 __x) throw (); extern long int __llogbf128 (_Float128 __x) throw ();
+
+
+
+
+extern _Float128 scalblnf128 (_Float128 __x, long int __n) throw (); extern _Float128 __scalblnf128 (_Float128 __x, long int __n) throw ();
+
+
+
+extern _Float128 nearbyintf128 (_Float128 __x) throw (); extern _Float128 __nearbyintf128 (_Float128 __x) throw ();
+
+
+
+extern _Float128 roundf128 (_Float128 __x) throw () __attribute__ ((__const__)); extern _Float128 __roundf128 (_Float128 __x) throw () __attribute__ ((__const__));
+
+
+
+extern _Float128 truncf128 (_Float128 __x) throw () __attribute__ ((__const__)); extern _Float128 __truncf128 (_Float128 __x) throw () __attribute__ ((__const__));
+
+
+
+
+extern _Float128 remquof128 (_Float128 __x, _Float128 __y, int *__quo) throw (); extern _Float128 __remquof128 (_Float128 __x, _Float128 __y, int *__quo) throw ();
+
+
+
+
+
+
+extern long int lrintf128 (_Float128 __x) throw (); extern long int __lrintf128 (_Float128 __x) throw ();
+__extension__
+extern long long int llrintf128 (_Float128 __x) throw (); extern long long int __llrintf128 (_Float128 __x) throw ();
+
+
+
+extern long int lroundf128 (_Float128 __x) throw (); extern long int __lroundf128 (_Float128 __x) throw ();
+__extension__
+extern long long int llroundf128 (_Float128 __x) throw (); extern long long int __llroundf128 (_Float128 __x) throw ();
+
+
+
+extern _Float128 fdimf128 (_Float128 __x, _Float128 __y) throw (); extern _Float128 __fdimf128 (_Float128 __x, _Float128 __y) throw ();
+
+
+extern _Float128 fmaxf128 (_Float128 __x, _Float128 __y) throw () __attribute__ ((__const__)); extern _Float128 __fmaxf128 (_Float128 __x, _Float128 __y) throw () __attribute__ ((__const__));
+
+
+extern _Float128 fminf128 (_Float128 __x, _Float128 __y) throw () __attribute__ ((__const__)); extern _Float128 __fminf128 (_Float128 __x, _Float128 __y) throw () __attribute__ ((__const__));
+
+
+extern _Float128 fmaf128 (_Float128 __x, _Float128 __y, _Float128 __z) throw (); extern _Float128 __fmaf128 (_Float128 __x, _Float128 __y, _Float128 __z) throw ();
+
+
+
+
+extern _Float128 roundevenf128 (_Float128 __x) throw () __attribute__ ((__const__)); extern _Float128 __roundevenf128 (_Float128 __x) throw () __attribute__ ((__const__));
+
+
+
+extern __intmax_t fromfpf128 (_Float128 __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpf128 (_Float128 __x, int __round, unsigned int __width) throw ()
+                            ;
+
+
+
+extern __uintmax_t ufromfpf128 (_Float128 __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpf128 (_Float128 __x, int __round, unsigned int __width) throw ()
+                              ;
+
+
+
+
+extern __intmax_t fromfpxf128 (_Float128 __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpxf128 (_Float128 __x, int __round, unsigned int __width) throw ()
+                             ;
+
+
+
+
+extern __uintmax_t ufromfpxf128 (_Float128 __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpxf128 (_Float128 __x, int __round, unsigned int __width) throw ()
+                               ;
+
+
+extern _Float128 fmaxmagf128 (_Float128 __x, _Float128 __y) throw () __attribute__ ((__const__)); extern _Float128 __fmaxmagf128 (_Float128 __x, _Float128 __y) throw () __attribute__ ((__const__));
+
+
+extern _Float128 fminmagf128 (_Float128 __x, _Float128 __y) throw () __attribute__ ((__const__)); extern _Float128 __fminmagf128 (_Float128 __x, _Float128 __y) throw () __attribute__ ((__const__));
+
+
+extern int canonicalizef128 (_Float128 *__cx, const _Float128 *__x) throw ();
+
+
+
+
+extern int totalorderf128 (const _Float128 *__x, const _Float128 *__y) throw ()
+
+     __attribute__ ((__pure__));
+
+
+extern int totalordermagf128 (const _Float128 *__x, const _Float128 *__y) throw ()
+
+     __attribute__ ((__pure__));
+
+
+extern _Float128 getpayloadf128 (const _Float128 *__x) throw (); extern _Float128 __getpayloadf128 (const _Float128 *__x) throw ();
+
+
+extern int setpayloadf128 (_Float128 *__x, _Float128 __payload) throw ();
+
+
+extern int setpayloadsigf128 (_Float128 *__x, _Float128 __payload) throw ();
+# 471 "/usr/include/math.h" 2 3 4
+
+#undef _Mdouble_
+#undef __MATH_PRECNAME
+#undef __MATH_DECLARING_DOUBLE
+#undef __MATH_DECLARING_FLOATN
+
+
+
+#define _Mdouble_ _Float32x
+#define __MATH_PRECNAME(name,r) name ##f32x ##r
+#define __MATH_DECLARING_DOUBLE 0
+#define __MATH_DECLARING_FLOATN 1
+
+
+
+
+# 1 "/usr/include/bits/mathcalls.h" 1 3 4
+# 53 "/usr/include/bits/mathcalls.h" 3 4
+extern _Float32x acosf32x (_Float32x __x) throw (); extern _Float32x __acosf32x (_Float32x __x) throw ();
+
+extern _Float32x asinf32x (_Float32x __x) throw (); extern _Float32x __asinf32x (_Float32x __x) throw ();
+
+extern _Float32x atanf32x (_Float32x __x) throw (); extern _Float32x __atanf32x (_Float32x __x) throw ();
+
+extern _Float32x atan2f32x (_Float32x __y, _Float32x __x) throw (); extern _Float32x __atan2f32x (_Float32x __y, _Float32x __x) throw ();
+
+
+ extern _Float32x cosf32x (_Float32x __x) throw (); extern _Float32x __cosf32x (_Float32x __x) throw ();
+
+ extern _Float32x sinf32x (_Float32x __x) throw (); extern _Float32x __sinf32x (_Float32x __x) throw ();
+
+extern _Float32x tanf32x (_Float32x __x) throw (); extern _Float32x __tanf32x (_Float32x __x) throw ();
+
+
+
+
+extern _Float32x coshf32x (_Float32x __x) throw (); extern _Float32x __coshf32x (_Float32x __x) throw ();
+
+extern _Float32x sinhf32x (_Float32x __x) throw (); extern _Float32x __sinhf32x (_Float32x __x) throw ();
+
+extern _Float32x tanhf32x (_Float32x __x) throw (); extern _Float32x __tanhf32x (_Float32x __x) throw ();
+
+
+
+ extern void sincosf32x (_Float32x __x, _Float32x *__sinx, _Float32x *__cosx) throw (); extern void __sincosf32x (_Float32x __x, _Float32x *__sinx, _Float32x *__cosx) throw ()
+                                                        ;
+
+
+
+
+extern _Float32x acoshf32x (_Float32x __x) throw (); extern _Float32x __acoshf32x (_Float32x __x) throw ();
+
+extern _Float32x asinhf32x (_Float32x __x) throw (); extern _Float32x __asinhf32x (_Float32x __x) throw ();
+
+extern _Float32x atanhf32x (_Float32x __x) throw (); extern _Float32x __atanhf32x (_Float32x __x) throw ();
+
+
+
+
+
+ extern _Float32x expf32x (_Float32x __x) throw (); extern _Float32x __expf32x (_Float32x __x) throw ();
+
+
+extern _Float32x frexpf32x (_Float32x __x, int *__exponent) throw (); extern _Float32x __frexpf32x (_Float32x __x, int *__exponent) throw ();
+
+
+extern _Float32x ldexpf32x (_Float32x __x, int __exponent) throw (); extern _Float32x __ldexpf32x (_Float32x __x, int __exponent) throw ();
+
+
+ extern _Float32x logf32x (_Float32x __x) throw (); extern _Float32x __logf32x (_Float32x __x) throw ();
+
+
+extern _Float32x log10f32x (_Float32x __x) throw (); extern _Float32x __log10f32x (_Float32x __x) throw ();
+
+
+extern _Float32x modff32x (_Float32x __x, _Float32x *__iptr) throw (); extern _Float32x __modff32x (_Float32x __x, _Float32x *__iptr) throw () __attribute__ ((__nonnull__ (2)));
+
+
+
+extern _Float32x exp10f32x (_Float32x __x) throw (); extern _Float32x __exp10f32x (_Float32x __x) throw ();
+
+
+
+
+extern _Float32x expm1f32x (_Float32x __x) throw (); extern _Float32x __expm1f32x (_Float32x __x) throw ();
+
+
+extern _Float32x log1pf32x (_Float32x __x) throw (); extern _Float32x __log1pf32x (_Float32x __x) throw ();
+
+
+extern _Float32x logbf32x (_Float32x __x) throw (); extern _Float32x __logbf32x (_Float32x __x) throw ();
+
+
+
+
+extern _Float32x exp2f32x (_Float32x __x) throw (); extern _Float32x __exp2f32x (_Float32x __x) throw ();
+
+
+extern _Float32x log2f32x (_Float32x __x) throw (); extern _Float32x __log2f32x (_Float32x __x) throw ();
+
+
+
+
+
+
+ extern _Float32x powf32x (_Float32x __x, _Float32x __y) throw (); extern _Float32x __powf32x (_Float32x __x, _Float32x __y) throw ();
+
+
+extern _Float32x sqrtf32x (_Float32x __x) throw (); extern _Float32x __sqrtf32x (_Float32x __x) throw ();
+
+
+
+extern _Float32x hypotf32x (_Float32x __x, _Float32x __y) throw (); extern _Float32x __hypotf32x (_Float32x __x, _Float32x __y) throw ();
+
+
+
+
+extern _Float32x cbrtf32x (_Float32x __x) throw (); extern _Float32x __cbrtf32x (_Float32x __x) throw ();
+
+
+
+
+
+
+extern _Float32x ceilf32x (_Float32x __x) throw () __attribute__ ((__const__)); extern _Float32x __ceilf32x (_Float32x __x) throw () __attribute__ ((__const__));
+
+
+extern _Float32x fabsf32x (_Float32x __x) throw () __attribute__ ((__const__)); extern _Float32x __fabsf32x (_Float32x __x) throw () __attribute__ ((__const__));
+
+
+extern _Float32x floorf32x (_Float32x __x) throw () __attribute__ ((__const__)); extern _Float32x __floorf32x (_Float32x __x) throw () __attribute__ ((__const__));
+
+
+extern _Float32x fmodf32x (_Float32x __x, _Float32x __y) throw (); extern _Float32x __fmodf32x (_Float32x __x, _Float32x __y) throw ();
+# 198 "/usr/include/bits/mathcalls.h" 3 4
+extern _Float32x copysignf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__)); extern _Float32x __copysignf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__));
+
+
+
+
+extern _Float32x nanf32x (const char *__tagb) throw (); extern _Float32x __nanf32x (const char *__tagb) throw ();
+# 220 "/usr/include/bits/mathcalls.h" 3 4
+extern _Float32x j0f32x (_Float32x) throw (); extern _Float32x __j0f32x (_Float32x) throw ();
+extern _Float32x j1f32x (_Float32x) throw (); extern _Float32x __j1f32x (_Float32x) throw ();
+extern _Float32x jnf32x (int, _Float32x) throw (); extern _Float32x __jnf32x (int, _Float32x) throw ();
+extern _Float32x y0f32x (_Float32x) throw (); extern _Float32x __y0f32x (_Float32x) throw ();
+extern _Float32x y1f32x (_Float32x) throw (); extern _Float32x __y1f32x (_Float32x) throw ();
+extern _Float32x ynf32x (int, _Float32x) throw (); extern _Float32x __ynf32x (int, _Float32x) throw ();
+
+
+
+
+
+extern _Float32x erff32x (_Float32x) throw (); extern _Float32x __erff32x (_Float32x) throw ();
+extern _Float32x erfcf32x (_Float32x) throw (); extern _Float32x __erfcf32x (_Float32x) throw ();
+extern _Float32x lgammaf32x (_Float32x) throw (); extern _Float32x __lgammaf32x (_Float32x) throw ();
+
+
+
+
+extern _Float32x tgammaf32x (_Float32x) throw (); extern _Float32x __tgammaf32x (_Float32x) throw ();
+# 252 "/usr/include/bits/mathcalls.h" 3 4
+extern _Float32x lgammaf32x_r (_Float32x, int *__signgamp) throw (); extern _Float32x __lgammaf32x_r (_Float32x, int *__signgamp) throw ();
+
+
+
+
+
+
+extern _Float32x rintf32x (_Float32x __x) throw (); extern _Float32x __rintf32x (_Float32x __x) throw ();
+
+
+extern _Float32x nextafterf32x (_Float32x __x, _Float32x __y) throw (); extern _Float32x __nextafterf32x (_Float32x __x, _Float32x __y) throw ();
+
+
+
+
+
+
+extern _Float32x nextdownf32x (_Float32x __x) throw (); extern _Float32x __nextdownf32x (_Float32x __x) throw ();
+
+extern _Float32x nextupf32x (_Float32x __x) throw (); extern _Float32x __nextupf32x (_Float32x __x) throw ();
+
+
+
+extern _Float32x remainderf32x (_Float32x __x, _Float32x __y) throw (); extern _Float32x __remainderf32x (_Float32x __x, _Float32x __y) throw ();
+
+
+
+extern _Float32x scalbnf32x (_Float32x __x, int __n) throw (); extern _Float32x __scalbnf32x (_Float32x __x, int __n) throw ();
+
+
+
+extern int ilogbf32x (_Float32x __x) throw (); extern int __ilogbf32x (_Float32x __x) throw ();
+
+
+
+
+extern long int llogbf32x (_Float32x __x) throw (); extern long int __llogbf32x (_Float32x __x) throw ();
+
+
+
+
+extern _Float32x scalblnf32x (_Float32x __x, long int __n) throw (); extern _Float32x __scalblnf32x (_Float32x __x, long int __n) throw ();
+
+
+
+extern _Float32x nearbyintf32x (_Float32x __x) throw (); extern _Float32x __nearbyintf32x (_Float32x __x) throw ();
+
+
+
+extern _Float32x roundf32x (_Float32x __x) throw () __attribute__ ((__const__)); extern _Float32x __roundf32x (_Float32x __x) throw () __attribute__ ((__const__));
+
+
+
+extern _Float32x truncf32x (_Float32x __x) throw () __attribute__ ((__const__)); extern _Float32x __truncf32x (_Float32x __x) throw () __attribute__ ((__const__));
+
+
+
+
+extern _Float32x remquof32x (_Float32x __x, _Float32x __y, int *__quo) throw (); extern _Float32x __remquof32x (_Float32x __x, _Float32x __y, int *__quo) throw ();
+
+
+
+
+
+
+extern long int lrintf32x (_Float32x __x) throw (); extern long int __lrintf32x (_Float32x __x) throw ();
+__extension__
+extern long long int llrintf32x (_Float32x __x) throw (); extern long long int __llrintf32x (_Float32x __x) throw ();
+
+
+
+extern long int lroundf32x (_Float32x __x) throw (); extern long int __lroundf32x (_Float32x __x) throw ();
+__extension__
+extern long long int llroundf32x (_Float32x __x) throw (); extern long long int __llroundf32x (_Float32x __x) throw ();
+
+
+
+extern _Float32x fdimf32x (_Float32x __x, _Float32x __y) throw (); extern _Float32x __fdimf32x (_Float32x __x, _Float32x __y) throw ();
+
+
+extern _Float32x fmaxf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__)); extern _Float32x __fmaxf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__));
+
+
+extern _Float32x fminf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__)); extern _Float32x __fminf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__));
+
+
+extern _Float32x fmaf32x (_Float32x __x, _Float32x __y, _Float32x __z) throw (); extern _Float32x __fmaf32x (_Float32x __x, _Float32x __y, _Float32x __z) throw ();
+
+
+
+
+extern _Float32x roundevenf32x (_Float32x __x) throw () __attribute__ ((__const__)); extern _Float32x __roundevenf32x (_Float32x __x) throw () __attribute__ ((__const__));
+
+
+
+extern __intmax_t fromfpf32x (_Float32x __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpf32x (_Float32x __x, int __round, unsigned int __width) throw ()
+                            ;
+
+
+
+extern __uintmax_t ufromfpf32x (_Float32x __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpf32x (_Float32x __x, int __round, unsigned int __width) throw ()
+                              ;
+
+
+
+
+extern __intmax_t fromfpxf32x (_Float32x __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpxf32x (_Float32x __x, int __round, unsigned int __width) throw ()
+                             ;
+
+
+
+
+extern __uintmax_t ufromfpxf32x (_Float32x __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpxf32x (_Float32x __x, int __round, unsigned int __width) throw ()
+                               ;
+
+
+extern _Float32x fmaxmagf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__)); extern _Float32x __fmaxmagf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__));
+
+
+extern _Float32x fminmagf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__)); extern _Float32x __fminmagf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__));
+
+
+extern int canonicalizef32x (_Float32x *__cx, const _Float32x *__x) throw ();
+
+
+
+
+extern int totalorderf32x (const _Float32x *__x, const _Float32x *__y) throw ()
+
+     __attribute__ ((__pure__));
+
+
+extern int totalordermagf32x (const _Float32x *__x, const _Float32x *__y) throw ()
+
+     __attribute__ ((__pure__));
+
+
+extern _Float32x getpayloadf32x (const _Float32x *__x) throw (); extern _Float32x __getpayloadf32x (const _Float32x *__x) throw ();
+
+
+extern int setpayloadf32x (_Float32x *__x, _Float32x __payload) throw ();
+
+
+extern int setpayloadsigf32x (_Float32x *__x, _Float32x __payload) throw ();
+# 488 "/usr/include/math.h" 2 3 4
+
+#undef _Mdouble_
+#undef __MATH_PRECNAME
+#undef __MATH_DECLARING_DOUBLE
+#undef __MATH_DECLARING_FLOATN
+
+
+
+#define _Mdouble_ _Float64x
+#define __MATH_PRECNAME(name,r) name ##f64x ##r
+#define __MATH_DECLARING_DOUBLE 0
+#define __MATH_DECLARING_FLOATN 1
+
+
+
+
+# 1 "/usr/include/bits/mathcalls.h" 1 3 4
+# 53 "/usr/include/bits/mathcalls.h" 3 4
+extern _Float64x acosf64x (_Float64x __x) throw (); extern _Float64x __acosf64x (_Float64x __x) throw ();
+
+extern _Float64x asinf64x (_Float64x __x) throw (); extern _Float64x __asinf64x (_Float64x __x) throw ();
+
+extern _Float64x atanf64x (_Float64x __x) throw (); extern _Float64x __atanf64x (_Float64x __x) throw ();
+
+extern _Float64x atan2f64x (_Float64x __y, _Float64x __x) throw (); extern _Float64x __atan2f64x (_Float64x __y, _Float64x __x) throw ();
+
+
+ extern _Float64x cosf64x (_Float64x __x) throw (); extern _Float64x __cosf64x (_Float64x __x) throw ();
+
+ extern _Float64x sinf64x (_Float64x __x) throw (); extern _Float64x __sinf64x (_Float64x __x) throw ();
+
+extern _Float64x tanf64x (_Float64x __x) throw (); extern _Float64x __tanf64x (_Float64x __x) throw ();
+
+
+
+
+extern _Float64x coshf64x (_Float64x __x) throw (); extern _Float64x __coshf64x (_Float64x __x) throw ();
+
+extern _Float64x sinhf64x (_Float64x __x) throw (); extern _Float64x __sinhf64x (_Float64x __x) throw ();
+
+extern _Float64x tanhf64x (_Float64x __x) throw (); extern _Float64x __tanhf64x (_Float64x __x) throw ();
+
+
+
+ extern void sincosf64x (_Float64x __x, _Float64x *__sinx, _Float64x *__cosx) throw (); extern void __sincosf64x (_Float64x __x, _Float64x *__sinx, _Float64x *__cosx) throw ()
+                                                        ;
+
+
+
+
+extern _Float64x acoshf64x (_Float64x __x) throw (); extern _Float64x __acoshf64x (_Float64x __x) throw ();
+
+extern _Float64x asinhf64x (_Float64x __x) throw (); extern _Float64x __asinhf64x (_Float64x __x) throw ();
+
+extern _Float64x atanhf64x (_Float64x __x) throw (); extern _Float64x __atanhf64x (_Float64x __x) throw ();
+
+
+
+
+
+ extern _Float64x expf64x (_Float64x __x) throw (); extern _Float64x __expf64x (_Float64x __x) throw ();
+
+
+extern _Float64x frexpf64x (_Float64x __x, int *__exponent) throw (); extern _Float64x __frexpf64x (_Float64x __x, int *__exponent) throw ();
+
+
+extern _Float64x ldexpf64x (_Float64x __x, int __exponent) throw (); extern _Float64x __ldexpf64x (_Float64x __x, int __exponent) throw ();
+
+
+ extern _Float64x logf64x (_Float64x __x) throw (); extern _Float64x __logf64x (_Float64x __x) throw ();
+
+
+extern _Float64x log10f64x (_Float64x __x) throw (); extern _Float64x __log10f64x (_Float64x __x) throw ();
+
+
+extern _Float64x modff64x (_Float64x __x, _Float64x *__iptr) throw (); extern _Float64x __modff64x (_Float64x __x, _Float64x *__iptr) throw () __attribute__ ((__nonnull__ (2)));
+
+
+
+extern _Float64x exp10f64x (_Float64x __x) throw (); extern _Float64x __exp10f64x (_Float64x __x) throw ();
+
+
+
+
+extern _Float64x expm1f64x (_Float64x __x) throw (); extern _Float64x __expm1f64x (_Float64x __x) throw ();
+
+
+extern _Float64x log1pf64x (_Float64x __x) throw (); extern _Float64x __log1pf64x (_Float64x __x) throw ();
+
+
+extern _Float64x logbf64x (_Float64x __x) throw (); extern _Float64x __logbf64x (_Float64x __x) throw ();
+
+
+
+
+extern _Float64x exp2f64x (_Float64x __x) throw (); extern _Float64x __exp2f64x (_Float64x __x) throw ();
+
+
+extern _Float64x log2f64x (_Float64x __x) throw (); extern _Float64x __log2f64x (_Float64x __x) throw ();
+
+
+
+
+
+
+ extern _Float64x powf64x (_Float64x __x, _Float64x __y) throw (); extern _Float64x __powf64x (_Float64x __x, _Float64x __y) throw ();
+
+
+extern _Float64x sqrtf64x (_Float64x __x) throw (); extern _Float64x __sqrtf64x (_Float64x __x) throw ();
+
+
+
+extern _Float64x hypotf64x (_Float64x __x, _Float64x __y) throw (); extern _Float64x __hypotf64x (_Float64x __x, _Float64x __y) throw ();
+
+
+
+
+extern _Float64x cbrtf64x (_Float64x __x) throw (); extern _Float64x __cbrtf64x (_Float64x __x) throw ();
+
+
+
+
+
+
+extern _Float64x ceilf64x (_Float64x __x) throw () __attribute__ ((__const__)); extern _Float64x __ceilf64x (_Float64x __x) throw () __attribute__ ((__const__));
+
+
+extern _Float64x fabsf64x (_Float64x __x) throw () __attribute__ ((__const__)); extern _Float64x __fabsf64x (_Float64x __x) throw () __attribute__ ((__const__));
+
+
+extern _Float64x floorf64x (_Float64x __x) throw () __attribute__ ((__const__)); extern _Float64x __floorf64x (_Float64x __x) throw () __attribute__ ((__const__));
+
+
+extern _Float64x fmodf64x (_Float64x __x, _Float64x __y) throw (); extern _Float64x __fmodf64x (_Float64x __x, _Float64x __y) throw ();
+# 198 "/usr/include/bits/mathcalls.h" 3 4
+extern _Float64x copysignf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__)); extern _Float64x __copysignf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__));
+
+
+
+
+extern _Float64x nanf64x (const char *__tagb) throw (); extern _Float64x __nanf64x (const char *__tagb) throw ();
+# 220 "/usr/include/bits/mathcalls.h" 3 4
+extern _Float64x j0f64x (_Float64x) throw (); extern _Float64x __j0f64x (_Float64x) throw ();
+extern _Float64x j1f64x (_Float64x) throw (); extern _Float64x __j1f64x (_Float64x) throw ();
+extern _Float64x jnf64x (int, _Float64x) throw (); extern _Float64x __jnf64x (int, _Float64x) throw ();
+extern _Float64x y0f64x (_Float64x) throw (); extern _Float64x __y0f64x (_Float64x) throw ();
+extern _Float64x y1f64x (_Float64x) throw (); extern _Float64x __y1f64x (_Float64x) throw ();
+extern _Float64x ynf64x (int, _Float64x) throw (); extern _Float64x __ynf64x (int, _Float64x) throw ();
+
+
+
+
+
+extern _Float64x erff64x (_Float64x) throw (); extern _Float64x __erff64x (_Float64x) throw ();
+extern _Float64x erfcf64x (_Float64x) throw (); extern _Float64x __erfcf64x (_Float64x) throw ();
+extern _Float64x lgammaf64x (_Float64x) throw (); extern _Float64x __lgammaf64x (_Float64x) throw ();
+
+
+
+
+extern _Float64x tgammaf64x (_Float64x) throw (); extern _Float64x __tgammaf64x (_Float64x) throw ();
+# 252 "/usr/include/bits/mathcalls.h" 3 4
+extern _Float64x lgammaf64x_r (_Float64x, int *__signgamp) throw (); extern _Float64x __lgammaf64x_r (_Float64x, int *__signgamp) throw ();
+
+
+
+
+
+
+extern _Float64x rintf64x (_Float64x __x) throw (); extern _Float64x __rintf64x (_Float64x __x) throw ();
+
+
+extern _Float64x nextafterf64x (_Float64x __x, _Float64x __y) throw (); extern _Float64x __nextafterf64x (_Float64x __x, _Float64x __y) throw ();
+
+
+
+
+
+
+extern _Float64x nextdownf64x (_Float64x __x) throw (); extern _Float64x __nextdownf64x (_Float64x __x) throw ();
+
+extern _Float64x nextupf64x (_Float64x __x) throw (); extern _Float64x __nextupf64x (_Float64x __x) throw ();
+
+
+
+extern _Float64x remainderf64x (_Float64x __x, _Float64x __y) throw (); extern _Float64x __remainderf64x (_Float64x __x, _Float64x __y) throw ();
+
+
+
+extern _Float64x scalbnf64x (_Float64x __x, int __n) throw (); extern _Float64x __scalbnf64x (_Float64x __x, int __n) throw ();
+
+
+
+extern int ilogbf64x (_Float64x __x) throw (); extern int __ilogbf64x (_Float64x __x) throw ();
+
+
+
+
+extern long int llogbf64x (_Float64x __x) throw (); extern long int __llogbf64x (_Float64x __x) throw ();
+
+
+
+
+extern _Float64x scalblnf64x (_Float64x __x, long int __n) throw (); extern _Float64x __scalblnf64x (_Float64x __x, long int __n) throw ();
+
+
+
+extern _Float64x nearbyintf64x (_Float64x __x) throw (); extern _Float64x __nearbyintf64x (_Float64x __x) throw ();
+
+
+
+extern _Float64x roundf64x (_Float64x __x) throw () __attribute__ ((__const__)); extern _Float64x __roundf64x (_Float64x __x) throw () __attribute__ ((__const__));
+
+
+
+extern _Float64x truncf64x (_Float64x __x) throw () __attribute__ ((__const__)); extern _Float64x __truncf64x (_Float64x __x) throw () __attribute__ ((__const__));
+
+
+
+
+extern _Float64x remquof64x (_Float64x __x, _Float64x __y, int *__quo) throw (); extern _Float64x __remquof64x (_Float64x __x, _Float64x __y, int *__quo) throw ();
+
+
+
+
+
+
+extern long int lrintf64x (_Float64x __x) throw (); extern long int __lrintf64x (_Float64x __x) throw ();
+__extension__
+extern long long int llrintf64x (_Float64x __x) throw (); extern long long int __llrintf64x (_Float64x __x) throw ();
+
+
+
+extern long int lroundf64x (_Float64x __x) throw (); extern long int __lroundf64x (_Float64x __x) throw ();
+__extension__
+extern long long int llroundf64x (_Float64x __x) throw (); extern long long int __llroundf64x (_Float64x __x) throw ();
+
+
+
+extern _Float64x fdimf64x (_Float64x __x, _Float64x __y) throw (); extern _Float64x __fdimf64x (_Float64x __x, _Float64x __y) throw ();
+
+
+extern _Float64x fmaxf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__)); extern _Float64x __fmaxf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__));
+
+
+extern _Float64x fminf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__)); extern _Float64x __fminf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__));
+
+
+extern _Float64x fmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) throw (); extern _Float64x __fmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) throw ();
+
+
+
+
+extern _Float64x roundevenf64x (_Float64x __x) throw () __attribute__ ((__const__)); extern _Float64x __roundevenf64x (_Float64x __x) throw () __attribute__ ((__const__));
+
+
+
+extern __intmax_t fromfpf64x (_Float64x __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpf64x (_Float64x __x, int __round, unsigned int __width) throw ()
+                            ;
+
+
+
+extern __uintmax_t ufromfpf64x (_Float64x __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpf64x (_Float64x __x, int __round, unsigned int __width) throw ()
+                              ;
+
+
+
+
+extern __intmax_t fromfpxf64x (_Float64x __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpxf64x (_Float64x __x, int __round, unsigned int __width) throw ()
+                             ;
+
+
+
+
+extern __uintmax_t ufromfpxf64x (_Float64x __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpxf64x (_Float64x __x, int __round, unsigned int __width) throw ()
+                               ;
+
+
+extern _Float64x fmaxmagf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__)); extern _Float64x __fmaxmagf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__));
+
+
+extern _Float64x fminmagf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__)); extern _Float64x __fminmagf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__));
+
+
+extern int canonicalizef64x (_Float64x *__cx, const _Float64x *__x) throw ();
+
+
+
+
+extern int totalorderf64x (const _Float64x *__x, const _Float64x *__y) throw ()
+
+     __attribute__ ((__pure__));
+
+
+extern int totalordermagf64x (const _Float64x *__x, const _Float64x *__y) throw ()
+
+     __attribute__ ((__pure__));
+
+
+extern _Float64x getpayloadf64x (const _Float64x *__x) throw (); extern _Float64x __getpayloadf64x (const _Float64x *__x) throw ();
+
+
+extern int setpayloadf64x (_Float64x *__x, _Float64x __payload) throw ();
+
+
+extern int setpayloadsigf64x (_Float64x *__x, _Float64x __payload) throw ();
+# 505 "/usr/include/math.h" 2 3 4
+
+#undef _Mdouble_
+#undef __MATH_PRECNAME
+#undef __MATH_DECLARING_DOUBLE
+#undef __MATH_DECLARING_FLOATN
+# 529 "/usr/include/math.h" 3 4
+#undef __MATHDECL_1_IMPL
+#undef __MATHDECL_1
+#undef __MATHDECL_ALIAS
+#undef __MATHDECL
+#undef __MATHCALL
+
+
+#define __MATHCALL_NARROW_ARGS_1 (_Marg_ __x)
+#define __MATHCALL_NARROW_ARGS_2 (_Marg_ __x, _Marg_ __y)
+#define __MATHCALL_NARROW_ARGS_3 (_Marg_ __x, _Marg_ __y, _Marg_ __z)
+#define __MATHCALL_NARROW_NORMAL(func,nargs) extern _Mret_ func __MATHCALL_NARROW_ARGS_ ## nargs __THROW
+
+#define __MATHCALL_NARROW_REDIR(func,redir,nargs) extern _Mret_ __REDIRECT_NTH (func, __MATHCALL_NARROW_ARGS_ ## nargs, redir)
+
+
+#define __MATHCALL_NARROW(func,redir,nargs) __MATHCALL_NARROW_NORMAL (func, nargs)
+
+
+
+
+#define _Mret_ float
+#define _Marg_ double
+#define __MATHCALL_NAME(name) f ## name
+# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4
+# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4
+extern float fadd (double __x, double __y) throw ();
+
+
+extern float fdiv (double __x, double __y) throw ();
+
+
+extern float fmul (double __x, double __y) throw ();
+
+
+extern float fsub (double __x, double __y) throw ();
+# 553 "/usr/include/math.h" 2 3 4
+#undef _Mret_
+#undef _Marg_
+#undef __MATHCALL_NAME
+
+#define _Mret_ float
+#define _Marg_ long double
+#define __MATHCALL_NAME(name) f ## name ## l
+# 571 "/usr/include/math.h" 3 4
+# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4
+# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4
+extern float faddl (long double __x, long double __y) throw ();
+
+
+extern float fdivl (long double __x, long double __y) throw ();
+
+
+extern float fmull (long double __x, long double __y) throw ();
+
+
+extern float fsubl (long double __x, long double __y) throw ();
+# 572 "/usr/include/math.h" 2 3 4
+#undef _Mret_
+#undef _Marg_
+#undef __MATHCALL_NAME
+# 583 "/usr/include/math.h" 3 4
+#define _Mret_ double
+#define _Marg_ long double
+#define __MATHCALL_NAME(name) d ## name ## l
+# 597 "/usr/include/math.h" 3 4
+# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4
+# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4
+extern double daddl (long double __x, long double __y) throw ();
+
+
+extern double ddivl (long double __x, long double __y) throw ();
+
+
+extern double dmull (long double __x, long double __y) throw ();
+
+
+extern double dsubl (long double __x, long double __y) throw ();
+# 598 "/usr/include/math.h" 2 3 4
+#undef _Mret_
+#undef _Marg_
+#undef __MATHCALL_NAME
+# 674 "/usr/include/math.h" 3 4
+#define _Mret_ _Float32
+#define _Marg_ _Float32x
+#define __MATHCALL_NAME(name) f32 ## name ## f32x
+# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4
+# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4
+extern _Float32 f32addf32x (_Float32x __x, _Float32x __y) throw ();
+
+
+extern _Float32 f32divf32x (_Float32x __x, _Float32x __y) throw ();
+
+
+extern _Float32 f32mulf32x (_Float32x __x, _Float32x __y) throw ();
+
+
+extern _Float32 f32subf32x (_Float32x __x, _Float32x __y) throw ();
+# 678 "/usr/include/math.h" 2 3 4
+#undef _Mret_
+#undef _Marg_
+#undef __MATHCALL_NAME
+
+
+
+#define _Mret_ _Float32
+#define _Marg_ _Float64
+#define __MATHCALL_NAME(name) f32 ## name ## f64
+# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4
+# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4
+extern _Float32 f32addf64 (_Float64 __x, _Float64 __y) throw ();
+
+
+extern _Float32 f32divf64 (_Float64 __x, _Float64 __y) throw ();
+
+
+extern _Float32 f32mulf64 (_Float64 __x, _Float64 __y) throw ();
+
+
+extern _Float32 f32subf64 (_Float64 __x, _Float64 __y) throw ();
+# 688 "/usr/include/math.h" 2 3 4
+#undef _Mret_
+#undef _Marg_
+#undef __MATHCALL_NAME
+
+
+
+#define _Mret_ _Float32
+#define _Marg_ _Float64x
+#define __MATHCALL_NAME(name) f32 ## name ## f64x
+# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4
+# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4
+extern _Float32 f32addf64x (_Float64x __x, _Float64x __y) throw ();
+
+
+extern _Float32 f32divf64x (_Float64x __x, _Float64x __y) throw ();
+
+
+extern _Float32 f32mulf64x (_Float64x __x, _Float64x __y) throw ();
+
+
+extern _Float32 f32subf64x (_Float64x __x, _Float64x __y) throw ();
+# 698 "/usr/include/math.h" 2 3 4
+#undef _Mret_
+#undef _Marg_
+#undef __MATHCALL_NAME
+
+
+
+#define _Mret_ _Float32
+#define _Marg_ _Float128
+#define __MATHCALL_NAME(name) f32 ## name ## f128
+# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4
+# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4
+extern _Float32 f32addf128 (_Float128 __x, _Float128 __y) throw ();
+
+
+extern _Float32 f32divf128 (_Float128 __x, _Float128 __y) throw ();
+
+
+extern _Float32 f32mulf128 (_Float128 __x, _Float128 __y) throw ();
+
+
+extern _Float32 f32subf128 (_Float128 __x, _Float128 __y) throw ();
+# 708 "/usr/include/math.h" 2 3 4
+#undef _Mret_
+#undef _Marg_
+#undef __MATHCALL_NAME
+# 724 "/usr/include/math.h" 3 4
+#define _Mret_ _Float32x
+#define _Marg_ _Float64
+#define __MATHCALL_NAME(name) f32x ## name ## f64
+# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4
+# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4
+extern _Float32x f32xaddf64 (_Float64 __x, _Float64 __y) throw ();
+
+
+extern _Float32x f32xdivf64 (_Float64 __x, _Float64 __y) throw ();
+
+
+extern _Float32x f32xmulf64 (_Float64 __x, _Float64 __y) throw ();
+
+
+extern _Float32x f32xsubf64 (_Float64 __x, _Float64 __y) throw ();
+# 728 "/usr/include/math.h" 2 3 4
+#undef _Mret_
+#undef _Marg_
+#undef __MATHCALL_NAME
+
+
+
+#define _Mret_ _Float32x
+#define _Marg_ _Float64x
+#define __MATHCALL_NAME(name) f32x ## name ## f64x
+# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4
+# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4
+extern _Float32x f32xaddf64x (_Float64x __x, _Float64x __y) throw ();
+
+
+extern _Float32x f32xdivf64x (_Float64x __x, _Float64x __y) throw ();
+
+
+extern _Float32x f32xmulf64x (_Float64x __x, _Float64x __y) throw ();
+
+
+extern _Float32x f32xsubf64x (_Float64x __x, _Float64x __y) throw ();
+# 738 "/usr/include/math.h" 2 3 4
+#undef _Mret_
+#undef _Marg_
+#undef __MATHCALL_NAME
+
+
+
+#define _Mret_ _Float32x
+#define _Marg_ _Float128
+#define __MATHCALL_NAME(name) f32x ## name ## f128
+# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4
+# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4
+extern _Float32x f32xaddf128 (_Float128 __x, _Float128 __y) throw ();
+
+
+extern _Float32x f32xdivf128 (_Float128 __x, _Float128 __y) throw ();
+
+
+extern _Float32x f32xmulf128 (_Float128 __x, _Float128 __y) throw ();
+
+
+extern _Float32x f32xsubf128 (_Float128 __x, _Float128 __y) throw ();
+# 748 "/usr/include/math.h" 2 3 4
+#undef _Mret_
+#undef _Marg_
+#undef __MATHCALL_NAME
+# 764 "/usr/include/math.h" 3 4
+#define _Mret_ _Float64
+#define _Marg_ _Float64x
+#define __MATHCALL_NAME(name) f64 ## name ## f64x
+# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4
+# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4
+extern _Float64 f64addf64x (_Float64x __x, _Float64x __y) throw ();
+
+
+extern _Float64 f64divf64x (_Float64x __x, _Float64x __y) throw ();
+
+
+extern _Float64 f64mulf64x (_Float64x __x, _Float64x __y) throw ();
+
+
+extern _Float64 f64subf64x (_Float64x __x, _Float64x __y) throw ();
+# 768 "/usr/include/math.h" 2 3 4
+#undef _Mret_
+#undef _Marg_
+#undef __MATHCALL_NAME
+
+
+
+#define _Mret_ _Float64
+#define _Marg_ _Float128
+#define __MATHCALL_NAME(name) f64 ## name ## f128
+# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4
+# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4
+extern _Float64 f64addf128 (_Float128 __x, _Float128 __y) throw ();
+
+
+extern _Float64 f64divf128 (_Float128 __x, _Float128 __y) throw ();
+
+
+extern _Float64 f64mulf128 (_Float128 __x, _Float128 __y) throw ();
+
+
+extern _Float64 f64subf128 (_Float128 __x, _Float128 __y) throw ();
+# 778 "/usr/include/math.h" 2 3 4
+#undef _Mret_
+#undef _Marg_
+#undef __MATHCALL_NAME
+# 794 "/usr/include/math.h" 3 4
+#define _Mret_ _Float64x
+#define _Marg_ _Float128
+#define __MATHCALL_NAME(name) f64x ## name ## f128
+# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4
+# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4
+extern _Float64x f64xaddf128 (_Float128 __x, _Float128 __y) throw ();
+
+
+extern _Float64x f64xdivf128 (_Float128 __x, _Float128 __y) throw ();
+
+
+extern _Float64x f64xmulf128 (_Float128 __x, _Float128 __y) throw ();
+
+
+extern _Float64x f64xsubf128 (_Float128 __x, _Float128 __y) throw ();
+# 798 "/usr/include/math.h" 2 3 4
+#undef _Mret_
+#undef _Marg_
+#undef __MATHCALL_NAME
+# 825 "/usr/include/math.h" 3 4
+#undef __MATHCALL_NARROW_ARGS_1
+#undef __MATHCALL_NARROW_ARGS_2
+#undef __MATHCALL_NARROW_ARGS_3
+#undef __MATHCALL_NARROW_NORMAL
+#undef __MATHCALL_NARROW_REDIR
+#undef __MATHCALL_NARROW
+
+
+
+extern int signgam;
+# 889 "/usr/include/math.h" 3 4
+#define __MATH_TG(TG_ARG,FUNC,ARGS) __builtin_choose_expr (__builtin_types_compatible_p (__typeof (TG_ARG), float), FUNC ## f ARGS, __builtin_choose_expr (__builtin_types_compatible_p (__typeof (TG_ARG), double), FUNC ARGS, __builtin_choose_expr (__builtin_types_compatible_p (__typeof (TG_ARG), long double), FUNC ## l ARGS, FUNC ## f128 ARGS)))
+# 914 "/usr/include/math.h" 3 4
+enum
+  {
+    FP_NAN =
+#define FP_NAN 0
+      0,
+    FP_INFINITE =
+#define FP_INFINITE 1
+      1,
+    FP_ZERO =
+#define FP_ZERO 2
+      2,
+    FP_SUBNORMAL =
+#define FP_SUBNORMAL 3
+      3,
+    FP_NORMAL =
+#define FP_NORMAL 4
+      4
+  };
+# 947 "/usr/include/math.h" 3 4
+#define fpclassify(x) __builtin_fpclassify (FP_NAN, FP_INFINITE, FP_NORMAL, FP_SUBNORMAL, FP_ZERO, x)
+
+
+
+
+
+
+
+#define signbit(x) __builtin_signbit (x)
+# 974 "/usr/include/math.h" 3 4
+#define isfinite(x) __builtin_isfinite (x)
+
+
+
+
+
+
+
+#define isnormal(x) __builtin_isnormal (x)
+# 991 "/usr/include/math.h" 3 4
+#define isnan(x) __builtin_isnan (x)
+# 1009 "/usr/include/math.h" 3 4
+#define isinf(x) __builtin_isinf_sign (x)
+
+
+
+
+
+#define MATH_ERRNO 1
+#define MATH_ERREXCEPT 2
+# 1028 "/usr/include/math.h" 3 4
+#define math_errhandling (MATH_ERRNO | MATH_ERREXCEPT)
+
+
+
+
+
+# 1 "/usr/include/bits/iscanonical.h" 1 3 4
+# 23 "/usr/include/bits/iscanonical.h" 3 4
+extern int __iscanonicall (long double __x)
+     throw () __attribute__ ((__const__));
+#define __iscanonicalf(x) ((void) (__typeof (x)) (x), 1)
+#define __iscanonical(x) ((void) (__typeof (x)) (x), 1)
+
+#define __iscanonicalf128(x) ((void) (__typeof (x)) (x), 1)
+# 46 "/usr/include/bits/iscanonical.h" 3 4
+extern "C++" {
+inline int iscanonical (float __val) { return ((void) (__typeof (__val)) (__val), 1); }
+inline int iscanonical (double __val) { return ((void) (__typeof (__val)) (__val), 1); }
+inline int iscanonical (long double __val) { return __iscanonicall (__val); }
+
+inline int iscanonical (_Float128 __val) { return ((void) (__typeof (__val)) (__val), 1); }
+
+}
+# 1035 "/usr/include/math.h" 2 3 4
+# 1046 "/usr/include/math.h" 3 4
+extern "C++" {
+inline int issignaling (float __val) { return __issignalingf (__val); }
+inline int issignaling (double __val) { return __issignaling (__val); }
+inline int
+issignaling (long double __val)
+{
+
+
+
+  return __issignalingl (__val);
+
+}
+
+
+
+inline int issignaling (_Float128 __val) { return __issignalingf128 (__val); }
+
+}
+
+
+
+#define issubnormal(x) (fpclassify (x) == FP_SUBNORMAL)
+# 1077 "/usr/include/math.h" 3 4
+extern "C++" {
+# 1108 "/usr/include/math.h" 3 4
+template <class __T> inline bool
+iszero (__T __val)
+{
+  return __val == 0;
+}
+
+}
+
+
+
+
+
+#define MAXFLOAT 3.40282347e+38F
+
+
+
+
+
+#define M_E 2.7182818284590452354
+#define M_LOG2E 1.4426950408889634074
+#define M_LOG10E 0.43429448190325182765
+#define M_LN2 0.69314718055994530942
+#define M_LN10 2.30258509299404568402
+#define M_PI 3.14159265358979323846
+#define M_PI_2 1.57079632679489661923
+#define M_PI_4 0.78539816339744830962
+#define M_1_PI 0.31830988618379067154
+#define M_2_PI 0.63661977236758134308
+#define M_2_SQRTPI 1.12837916709551257390
+#define M_SQRT2 1.41421356237309504880
+#define M_SQRT1_2 0.70710678118654752440
+
+
+
+
+
+
+#define M_El 2.718281828459045235360287471352662498L
+#define M_LOG2El 1.442695040888963407359924681001892137L
+#define M_LOG10El 0.434294481903251827651128918916605082L
+#define M_LN2l 0.693147180559945309417232121458176568L
+#define M_LN10l 2.302585092994045684017991454684364208L
+#define M_PIl 3.141592653589793238462643383279502884L
+#define M_PI_2l 1.570796326794896619231321691639751442L
+#define M_PI_4l 0.785398163397448309615660845819875721L
+#define M_1_PIl 0.318309886183790671537767526745028724L
+#define M_2_PIl 0.636619772367581343075535053490057448L
+#define M_2_SQRTPIl 1.128379167095512573896158903121545172L
+#define M_SQRT2l 1.414213562373095048801688724209698079L
+#define M_SQRT1_2l 0.707106781186547524400844362104849039L
+# 1177 "/usr/include/math.h" 3 4
+#define M_Ef32 __f32 (2.718281828459045235360287471352662498)
+#define M_LOG2Ef32 __f32 (1.442695040888963407359924681001892137)
+#define M_LOG10Ef32 __f32 (0.434294481903251827651128918916605082)
+#define M_LN2f32 __f32 (0.693147180559945309417232121458176568)
+#define M_LN10f32 __f32 (2.302585092994045684017991454684364208)
+#define M_PIf32 __f32 (3.141592653589793238462643383279502884)
+#define M_PI_2f32 __f32 (1.570796326794896619231321691639751442)
+#define M_PI_4f32 __f32 (0.785398163397448309615660845819875721)
+#define M_1_PIf32 __f32 (0.318309886183790671537767526745028724)
+#define M_2_PIf32 __f32 (0.636619772367581343075535053490057448)
+#define M_2_SQRTPIf32 __f32 (1.128379167095512573896158903121545172)
+#define M_SQRT2f32 __f32 (1.414213562373095048801688724209698079)
+#define M_SQRT1_2f32 __f32 (0.707106781186547524400844362104849039)
+
+
+
+#define M_Ef64 __f64 (2.718281828459045235360287471352662498)
+#define M_LOG2Ef64 __f64 (1.442695040888963407359924681001892137)
+#define M_LOG10Ef64 __f64 (0.434294481903251827651128918916605082)
+#define M_LN2f64 __f64 (0.693147180559945309417232121458176568)
+#define M_LN10f64 __f64 (2.302585092994045684017991454684364208)
+#define M_PIf64 __f64 (3.141592653589793238462643383279502884)
+#define M_PI_2f64 __f64 (1.570796326794896619231321691639751442)
+#define M_PI_4f64 __f64 (0.785398163397448309615660845819875721)
+#define M_1_PIf64 __f64 (0.318309886183790671537767526745028724)
+#define M_2_PIf64 __f64 (0.636619772367581343075535053490057448)
+#define M_2_SQRTPIf64 __f64 (1.128379167095512573896158903121545172)
+#define M_SQRT2f64 __f64 (1.414213562373095048801688724209698079)
+#define M_SQRT1_2f64 __f64 (0.707106781186547524400844362104849039)
+
+
+
+#define M_Ef128 __f128 (2.718281828459045235360287471352662498)
+#define M_LOG2Ef128 __f128 (1.442695040888963407359924681001892137)
+#define M_LOG10Ef128 __f128 (0.434294481903251827651128918916605082)
+#define M_LN2f128 __f128 (0.693147180559945309417232121458176568)
+#define M_LN10f128 __f128 (2.302585092994045684017991454684364208)
+#define M_PIf128 __f128 (3.141592653589793238462643383279502884)
+#define M_PI_2f128 __f128 (1.570796326794896619231321691639751442)
+#define M_PI_4f128 __f128 (0.785398163397448309615660845819875721)
+#define M_1_PIf128 __f128 (0.318309886183790671537767526745028724)
+#define M_2_PIf128 __f128 (0.636619772367581343075535053490057448)
+#define M_2_SQRTPIf128 __f128 (1.128379167095512573896158903121545172)
+#define M_SQRT2f128 __f128 (1.414213562373095048801688724209698079)
+#define M_SQRT1_2f128 __f128 (0.707106781186547524400844362104849039)
+
+
+
+#define M_Ef32x __f32x (2.718281828459045235360287471352662498)
+#define M_LOG2Ef32x __f32x (1.442695040888963407359924681001892137)
+#define M_LOG10Ef32x __f32x (0.434294481903251827651128918916605082)
+#define M_LN2f32x __f32x (0.693147180559945309417232121458176568)
+#define M_LN10f32x __f32x (2.302585092994045684017991454684364208)
+#define M_PIf32x __f32x (3.141592653589793238462643383279502884)
+#define M_PI_2f32x __f32x (1.570796326794896619231321691639751442)
+#define M_PI_4f32x __f32x (0.785398163397448309615660845819875721)
+#define M_1_PIf32x __f32x (0.318309886183790671537767526745028724)
+#define M_2_PIf32x __f32x (0.636619772367581343075535053490057448)
+#define M_2_SQRTPIf32x __f32x (1.128379167095512573896158903121545172)
+#define M_SQRT2f32x __f32x (1.414213562373095048801688724209698079)
+#define M_SQRT1_2f32x __f32x (0.707106781186547524400844362104849039)
+
+
+
+#define M_Ef64x __f64x (2.718281828459045235360287471352662498)
+#define M_LOG2Ef64x __f64x (1.442695040888963407359924681001892137)
+#define M_LOG10Ef64x __f64x (0.434294481903251827651128918916605082)
+#define M_LN2f64x __f64x (0.693147180559945309417232121458176568)
+#define M_LN10f64x __f64x (2.302585092994045684017991454684364208)
+#define M_PIf64x __f64x (3.141592653589793238462643383279502884)
+#define M_PI_2f64x __f64x (1.570796326794896619231321691639751442)
+#define M_PI_4f64x __f64x (0.785398163397448309615660845819875721)
+#define M_1_PIf64x __f64x (0.318309886183790671537767526745028724)
+#define M_2_PIf64x __f64x (0.636619772367581343075535053490057448)
+#define M_2_SQRTPIf64x __f64x (1.128379167095512573896158903121545172)
+#define M_SQRT2f64x __f64x (1.414213562373095048801688724209698079)
+#define M_SQRT1_2f64x __f64x (0.707106781186547524400844362104849039)
+# 1268 "/usr/include/math.h" 3 4
+#define isgreater(x,y) __builtin_isgreater(x, y)
+#define isgreaterequal(x,y) __builtin_isgreaterequal(x, y)
+#define isless(x,y) __builtin_isless(x, y)
+#define islessequal(x,y) __builtin_islessequal(x, y)
+#define islessgreater(x,y) __builtin_islessgreater(x, y)
+#define isunordered(x,y) __builtin_isunordered(x, y)
+# 1305 "/usr/include/math.h" 3 4
+#define __MATH_EVAL_FMT2(x,y) ((x) + (y) + 0.0f)
+# 1326 "/usr/include/math.h" 3 4
+extern "C++" {
+template<typename> struct __iseqsig_type;
+
+template<> struct __iseqsig_type<float>
+{
+  static int __call (float __x, float __y) throw ()
+  {
+    return __iseqsigf (__x, __y);
+  }
+};
+
+template<> struct __iseqsig_type<double>
+{
+  static int __call (double __x, double __y) throw ()
+  {
+    return __iseqsig (__x, __y);
+  }
+};
+
+template<> struct __iseqsig_type<long double>
+{
+  static int __call (long double __x, long double __y) throw ()
+  {
+
+    return __iseqsigl (__x, __y);
+
+
+
+  }
+};
+
+
+
+
+template<> struct __iseqsig_type<_Float128>
+{
+  static int __call (_Float128 __x, _Float128 __y) throw ()
+  {
+    return __iseqsigf128 (__x, __y);
+  }
+};
+
+
+template<typename _T1, typename _T2>
+inline int
+iseqsig (_T1 __x, _T2 __y) throw ()
+{
+
+  typedef decltype (((__x) + (__y) + 0.0f)) _T3;
+
+
+
+  return __iseqsig_type<_T3>::__call (__x, __y);
+}
+
+}
+
+
+
+
+}
+# 46 "/usr/include/c++/10.2.0/cmath" 2 3
+#undef _GLIBCXX_INCLUDE_NEXT_C_HEADERS
+
+
+
+#define _GLIBCXX_CMATH 1
+
+
+#undef div
+#undef acos
+#undef asin
+#undef atan
+#undef atan2
+#undef ceil
+#undef cos
+#undef cosh
+#undef exp
+#undef fabs
+#undef floor
+#undef fmod
+#undef frexp
+#undef ldexp
+#undef log
+#undef log10
+#undef modf
+#undef pow
+#undef sin
+#undef sinh
+#undef sqrt
+#undef tan
+#undef tanh
+
+extern "C++"
+{
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  using ::acos;
+
+
+  inline constexpr float
+  acos(float __x)
+  { return __builtin_acosf(__x); }
+
+  inline constexpr long double
+  acos(long double __x)
+  { return __builtin_acosl(__x); }
+
+
+  template<typename _Tp>
+    inline constexpr
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    acos(_Tp __x)
+    { return __builtin_acos(__x); }
+
+  using ::asin;
+
+
+  inline constexpr float
+  asin(float __x)
+  { return __builtin_asinf(__x); }
+
+  inline constexpr long double
+  asin(long double __x)
+  { return __builtin_asinl(__x); }
+
+
+  template<typename _Tp>
+    inline constexpr
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    asin(_Tp __x)
+    { return __builtin_asin(__x); }
+
+  using ::atan;
+
+
+  inline constexpr float
+  atan(float __x)
+  { return __builtin_atanf(__x); }
+
+  inline constexpr long double
+  atan(long double __x)
+  { return __builtin_atanl(__x); }
+
+
+  template<typename _Tp>
+    inline constexpr
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    atan(_Tp __x)
+    { return __builtin_atan(__x); }
+
+  using ::atan2;
+
+
+  inline constexpr float
+  atan2(float __y, float __x)
+  { return __builtin_atan2f(__y, __x); }
+
+  inline constexpr long double
+  atan2(long double __y, long double __x)
+  { return __builtin_atan2l(__y, __x); }
+
+
+  template<typename _Tp, typename _Up>
+    inline constexpr
+    typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    atan2(_Tp __y, _Up __x)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return atan2(__type(__y), __type(__x));
+    }
+
+  using ::ceil;
+
+
+  inline constexpr float
+  ceil(float __x)
+  { return __builtin_ceilf(__x); }
+
+  inline constexpr long double
+  ceil(long double __x)
+  { return __builtin_ceill(__x); }
+
+
+  template<typename _Tp>
+    inline constexpr
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    ceil(_Tp __x)
+    { return __builtin_ceil(__x); }
+
+  using ::cos;
+
+
+  inline constexpr float
+  cos(float __x)
+  { return __builtin_cosf(__x); }
+
+  inline constexpr long double
+  cos(long double __x)
+  { return __builtin_cosl(__x); }
+
+
+  template<typename _Tp>
+    inline constexpr
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    cos(_Tp __x)
+    { return __builtin_cos(__x); }
+
+  using ::cosh;
+
+
+  inline constexpr float
+  cosh(float __x)
+  { return __builtin_coshf(__x); }
+
+  inline constexpr long double
+  cosh(long double __x)
+  { return __builtin_coshl(__x); }
+
+
+  template<typename _Tp>
+    inline constexpr
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    cosh(_Tp __x)
+    { return __builtin_cosh(__x); }
+
+  using ::exp;
+
+
+  inline constexpr float
+  exp(float __x)
+  { return __builtin_expf(__x); }
+
+  inline constexpr long double
+  exp(long double __x)
+  { return __builtin_expl(__x); }
+
+
+  template<typename _Tp>
+    inline constexpr
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    exp(_Tp __x)
+    { return __builtin_exp(__x); }
+
+  using ::fabs;
+
+
+  inline constexpr float
+  fabs(float __x)
+  { return __builtin_fabsf(__x); }
+
+  inline constexpr long double
+  fabs(long double __x)
+  { return __builtin_fabsl(__x); }
+
+
+  template<typename _Tp>
+    inline constexpr
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    fabs(_Tp __x)
+    { return __builtin_fabs(__x); }
+
+  using ::floor;
+
+
+  inline constexpr float
+  floor(float __x)
+  { return __builtin_floorf(__x); }
+
+  inline constexpr long double
+  floor(long double __x)
+  { return __builtin_floorl(__x); }
+
+
+  template<typename _Tp>
+    inline constexpr
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    floor(_Tp __x)
+    { return __builtin_floor(__x); }
+
+  using ::fmod;
+
+
+  inline constexpr float
+  fmod(float __x, float __y)
+  { return __builtin_fmodf(__x, __y); }
+
+  inline constexpr long double
+  fmod(long double __x, long double __y)
+  { return __builtin_fmodl(__x, __y); }
+
+
+  template<typename _Tp, typename _Up>
+    inline constexpr
+    typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    fmod(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return fmod(__type(__x), __type(__y));
+    }
+
+  using ::frexp;
+
+
+  inline float
+  frexp(float __x, int* __exp)
+  { return __builtin_frexpf(__x, __exp); }
+
+  inline long double
+  frexp(long double __x, int* __exp)
+  { return __builtin_frexpl(__x, __exp); }
+
+
+  template<typename _Tp>
+    inline constexpr
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    frexp(_Tp __x, int* __exp)
+    { return __builtin_frexp(__x, __exp); }
+
+  using ::ldexp;
+
+
+  inline constexpr float
+  ldexp(float __x, int __exp)
+  { return __builtin_ldexpf(__x, __exp); }
+
+  inline constexpr long double
+  ldexp(long double __x, int __exp)
+  { return __builtin_ldexpl(__x, __exp); }
+
+
+  template<typename _Tp>
+    inline constexpr
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    ldexp(_Tp __x, int __exp)
+    { return __builtin_ldexp(__x, __exp); }
+
+  using ::log;
+
+
+  inline constexpr float
+  log(float __x)
+  { return __builtin_logf(__x); }
+
+  inline constexpr long double
+  log(long double __x)
+  { return __builtin_logl(__x); }
+
+
+  template<typename _Tp>
+    inline constexpr
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    log(_Tp __x)
+    { return __builtin_log(__x); }
+
+  using ::log10;
+
+
+  inline constexpr float
+  log10(float __x)
+  { return __builtin_log10f(__x); }
+
+  inline constexpr long double
+  log10(long double __x)
+  { return __builtin_log10l(__x); }
+
+
+  template<typename _Tp>
+    inline constexpr
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    log10(_Tp __x)
+    { return __builtin_log10(__x); }
+
+  using ::modf;
+
+
+  inline float
+  modf(float __x, float* __iptr)
+  { return __builtin_modff(__x, __iptr); }
+
+  inline long double
+  modf(long double __x, long double* __iptr)
+  { return __builtin_modfl(__x, __iptr); }
+
+
+  using ::pow;
+
+
+  inline constexpr float
+  pow(float __x, float __y)
+  { return __builtin_powf(__x, __y); }
+
+  inline constexpr long double
+  pow(long double __x, long double __y)
+  { return __builtin_powl(__x, __y); }
+# 412 "/usr/include/c++/10.2.0/cmath" 3
+  template<typename _Tp, typename _Up>
+    inline constexpr
+    typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    pow(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return pow(__type(__x), __type(__y));
+    }
+
+  using ::sin;
+
+
+  inline constexpr float
+  sin(float __x)
+  { return __builtin_sinf(__x); }
+
+  inline constexpr long double
+  sin(long double __x)
+  { return __builtin_sinl(__x); }
+
+
+  template<typename _Tp>
+    inline constexpr
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    sin(_Tp __x)
+    { return __builtin_sin(__x); }
+
+  using ::sinh;
+
+
+  inline constexpr float
+  sinh(float __x)
+  { return __builtin_sinhf(__x); }
+
+  inline constexpr long double
+  sinh(long double __x)
+  { return __builtin_sinhl(__x); }
+
+
+  template<typename _Tp>
+    inline constexpr
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    sinh(_Tp __x)
+    { return __builtin_sinh(__x); }
+
+  using ::sqrt;
+
+
+  inline constexpr float
+  sqrt(float __x)
+  { return __builtin_sqrtf(__x); }
+
+  inline constexpr long double
+  sqrt(long double __x)
+  { return __builtin_sqrtl(__x); }
+
+
+  template<typename _Tp>
+    inline constexpr
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    sqrt(_Tp __x)
+    { return __builtin_sqrt(__x); }
+
+  using ::tan;
+
+
+  inline constexpr float
+  tan(float __x)
+  { return __builtin_tanf(__x); }
+
+  inline constexpr long double
+  tan(long double __x)
+  { return __builtin_tanl(__x); }
+
+
+  template<typename _Tp>
+    inline constexpr
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    tan(_Tp __x)
+    { return __builtin_tan(__x); }
+
+  using ::tanh;
+
+
+  inline constexpr float
+  tanh(float __x)
+  { return __builtin_tanhf(__x); }
+
+  inline constexpr long double
+  tanh(long double __x)
+  { return __builtin_tanhl(__x); }
+
+
+  template<typename _Tp>
+    inline constexpr
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    tanh(_Tp __x)
+    { return __builtin_tanh(__x); }
+
+
+
+
+
+#undef fpclassify
+#undef isfinite
+#undef isinf
+#undef isnan
+#undef isnormal
+#undef signbit
+#undef isgreater
+#undef isgreaterequal
+#undef isless
+#undef islessequal
+#undef islessgreater
+#undef isunordered
+
+
+
+
+  constexpr int
+  fpclassify(float __x)
+  { return __builtin_fpclassify(0, 1, 4,
+    3, 2, __x); }
+
+  constexpr int
+  fpclassify(double __x)
+  { return __builtin_fpclassify(0, 1, 4,
+    3, 2, __x); }
+
+  constexpr int
+  fpclassify(long double __x)
+  { return __builtin_fpclassify(0, 1, 4,
+    3, 2, __x); }
+
+
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              int>::__type
+    fpclassify(_Tp __x)
+    { return __x != 0 ? 4 : 2; }
+
+
+
+  constexpr bool
+  isfinite(float __x)
+  { return __builtin_isfinite(__x); }
+
+  constexpr bool
+  isfinite(double __x)
+  { return __builtin_isfinite(__x); }
+
+  constexpr bool
+  isfinite(long double __x)
+  { return __builtin_isfinite(__x); }
+
+
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              bool>::__type
+    isfinite(_Tp __x)
+    { return true; }
+
+
+
+  constexpr bool
+  isinf(float __x)
+  { return __builtin_isinf(__x); }
+
+
+
+
+
+  constexpr bool
+  isinf(double __x)
+  { return __builtin_isinf(__x); }
+
+
+  constexpr bool
+  isinf(long double __x)
+  { return __builtin_isinf(__x); }
+
+
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              bool>::__type
+    isinf(_Tp __x)
+    { return false; }
+
+
+
+  constexpr bool
+  isnan(float __x)
+  { return __builtin_isnan(__x); }
+
+
+
+
+
+  constexpr bool
+  isnan(double __x)
+  { return __builtin_isnan(__x); }
+
+
+  constexpr bool
+  isnan(long double __x)
+  { return __builtin_isnan(__x); }
+
+
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              bool>::__type
+    isnan(_Tp __x)
+    { return false; }
+
+
+
+  constexpr bool
+  isnormal(float __x)
+  { return __builtin_isnormal(__x); }
+
+  constexpr bool
+  isnormal(double __x)
+  { return __builtin_isnormal(__x); }
+
+  constexpr bool
+  isnormal(long double __x)
+  { return __builtin_isnormal(__x); }
+
+
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              bool>::__type
+    isnormal(_Tp __x)
+    { return __x != 0 ? true : false; }
+
+
+
+
+  constexpr bool
+  signbit(float __x)
+  { return __builtin_signbit(__x); }
+
+  constexpr bool
+  signbit(double __x)
+  { return __builtin_signbit(__x); }
+
+  constexpr bool
+  signbit(long double __x)
+  { return __builtin_signbit(__x); }
+
+
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              bool>::__type
+    signbit(_Tp __x)
+    { return __x < 0 ? true : false; }
+
+
+
+  constexpr bool
+  isgreater(float __x, float __y)
+  { return __builtin_isgreater(__x, __y); }
+
+  constexpr bool
+  isgreater(double __x, double __y)
+  { return __builtin_isgreater(__x, __y); }
+
+  constexpr bool
+  isgreater(long double __x, long double __y)
+  { return __builtin_isgreater(__x, __y); }
+
+
+
+  template<typename _Tp, typename _Up>
+    constexpr typename
+    __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
+       && __is_arithmetic<_Up>::__value), bool>::__type
+    isgreater(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return __builtin_isgreater(__type(__x), __type(__y));
+    }
+
+
+
+  constexpr bool
+  isgreaterequal(float __x, float __y)
+  { return __builtin_isgreaterequal(__x, __y); }
+
+  constexpr bool
+  isgreaterequal(double __x, double __y)
+  { return __builtin_isgreaterequal(__x, __y); }
+
+  constexpr bool
+  isgreaterequal(long double __x, long double __y)
+  { return __builtin_isgreaterequal(__x, __y); }
+
+
+
+  template<typename _Tp, typename _Up>
+    constexpr typename
+    __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
+       && __is_arithmetic<_Up>::__value), bool>::__type
+    isgreaterequal(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return __builtin_isgreaterequal(__type(__x), __type(__y));
+    }
+
+
+
+  constexpr bool
+  isless(float __x, float __y)
+  { return __builtin_isless(__x, __y); }
+
+  constexpr bool
+  isless(double __x, double __y)
+  { return __builtin_isless(__x, __y); }
+
+  constexpr bool
+  isless(long double __x, long double __y)
+  { return __builtin_isless(__x, __y); }
+
+
+
+  template<typename _Tp, typename _Up>
+    constexpr typename
+    __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
+       && __is_arithmetic<_Up>::__value), bool>::__type
+    isless(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return __builtin_isless(__type(__x), __type(__y));
+    }
+
+
+
+  constexpr bool
+  islessequal(float __x, float __y)
+  { return __builtin_islessequal(__x, __y); }
+
+  constexpr bool
+  islessequal(double __x, double __y)
+  { return __builtin_islessequal(__x, __y); }
+
+  constexpr bool
+  islessequal(long double __x, long double __y)
+  { return __builtin_islessequal(__x, __y); }
+
+
+
+  template<typename _Tp, typename _Up>
+    constexpr typename
+    __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
+       && __is_arithmetic<_Up>::__value), bool>::__type
+    islessequal(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return __builtin_islessequal(__type(__x), __type(__y));
+    }
+
+
+
+  constexpr bool
+  islessgreater(float __x, float __y)
+  { return __builtin_islessgreater(__x, __y); }
+
+  constexpr bool
+  islessgreater(double __x, double __y)
+  { return __builtin_islessgreater(__x, __y); }
+
+  constexpr bool
+  islessgreater(long double __x, long double __y)
+  { return __builtin_islessgreater(__x, __y); }
+
+
+
+  template<typename _Tp, typename _Up>
+    constexpr typename
+    __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
+       && __is_arithmetic<_Up>::__value), bool>::__type
+    islessgreater(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return __builtin_islessgreater(__type(__x), __type(__y));
+    }
+
+
+
+  constexpr bool
+  isunordered(float __x, float __y)
+  { return __builtin_isunordered(__x, __y); }
+
+  constexpr bool
+  isunordered(double __x, double __y)
+  { return __builtin_isunordered(__x, __y); }
+
+  constexpr bool
+  isunordered(long double __x, long double __y)
+  { return __builtin_isunordered(__x, __y); }
+
+
+
+  template<typename _Tp, typename _Up>
+    constexpr typename
+    __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
+       && __is_arithmetic<_Up>::__value), bool>::__type
+    isunordered(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return __builtin_isunordered(__type(__x), __type(__y));
+    }
+# 956 "/usr/include/c++/10.2.0/cmath" 3
+#undef acosh
+#undef acoshf
+#undef acoshl
+#undef asinh
+#undef asinhf
+#undef asinhl
+#undef atanh
+#undef atanhf
+#undef atanhl
+#undef cbrt
+#undef cbrtf
+#undef cbrtl
+#undef copysign
+#undef copysignf
+#undef copysignl
+#undef erf
+#undef erff
+#undef erfl
+#undef erfc
+#undef erfcf
+#undef erfcl
+#undef exp2
+#undef exp2f
+#undef exp2l
+#undef expm1
+#undef expm1f
+#undef expm1l
+#undef fdim
+#undef fdimf
+#undef fdiml
+#undef fma
+#undef fmaf
+#undef fmal
+#undef fmax
+#undef fmaxf
+#undef fmaxl
+#undef fmin
+#undef fminf
+#undef fminl
+#undef hypot
+#undef hypotf
+#undef hypotl
+#undef ilogb
+#undef ilogbf
+#undef ilogbl
+#undef lgamma
+#undef lgammaf
+#undef lgammal
+
+#undef llrint
+#undef llrintf
+#undef llrintl
+#undef llround
+#undef llroundf
+#undef llroundl
+
+#undef log1p
+#undef log1pf
+#undef log1pl
+#undef log2
+#undef log2f
+#undef log2l
+#undef logb
+#undef logbf
+#undef logbl
+#undef lrint
+#undef lrintf
+#undef lrintl
+#undef lround
+#undef lroundf
+#undef lroundl
+#undef nan
+#undef nanf
+#undef nanl
+#undef nearbyint
+#undef nearbyintf
+#undef nearbyintl
+#undef nextafter
+#undef nextafterf
+#undef nextafterl
+#undef nexttoward
+#undef nexttowardf
+#undef nexttowardl
+#undef remainder
+#undef remainderf
+#undef remainderl
+#undef remquo
+#undef remquof
+#undef remquol
+#undef rint
+#undef rintf
+#undef rintl
+#undef round
+#undef roundf
+#undef roundl
+#undef scalbln
+#undef scalblnf
+#undef scalblnl
+#undef scalbn
+#undef scalbnf
+#undef scalbnl
+#undef tgamma
+#undef tgammaf
+#undef tgammal
+#undef trunc
+#undef truncf
+#undef truncl
+
+
+  using ::double_t;
+  using ::float_t;
+
+
+  using ::acosh;
+  using ::acoshf;
+  using ::acoshl;
+
+  using ::asinh;
+  using ::asinhf;
+  using ::asinhl;
+
+  using ::atanh;
+  using ::atanhf;
+  using ::atanhl;
+
+  using ::cbrt;
+  using ::cbrtf;
+  using ::cbrtl;
+
+  using ::copysign;
+  using ::copysignf;
+  using ::copysignl;
+
+  using ::erf;
+  using ::erff;
+  using ::erfl;
+
+  using ::erfc;
+  using ::erfcf;
+  using ::erfcl;
+
+  using ::exp2;
+  using ::exp2f;
+  using ::exp2l;
+
+  using ::expm1;
+  using ::expm1f;
+  using ::expm1l;
+
+  using ::fdim;
+  using ::fdimf;
+  using ::fdiml;
+
+  using ::fma;
+  using ::fmaf;
+  using ::fmal;
+
+  using ::fmax;
+  using ::fmaxf;
+  using ::fmaxl;
+
+  using ::fmin;
+  using ::fminf;
+  using ::fminl;
+
+  using ::hypot;
+  using ::hypotf;
+  using ::hypotl;
+
+  using ::ilogb;
+  using ::ilogbf;
+  using ::ilogbl;
+
+  using ::lgamma;
+  using ::lgammaf;
+  using ::lgammal;
+
+
+  using ::llrint;
+  using ::llrintf;
+  using ::llrintl;
+
+  using ::llround;
+  using ::llroundf;
+  using ::llroundl;
+
+
+  using ::log1p;
+  using ::log1pf;
+  using ::log1pl;
+
+  using ::log2;
+  using ::log2f;
+  using ::log2l;
+
+  using ::logb;
+  using ::logbf;
+  using ::logbl;
+
+  using ::lrint;
+  using ::lrintf;
+  using ::lrintl;
+
+  using ::lround;
+  using ::lroundf;
+  using ::lroundl;
+
+  using ::nan;
+  using ::nanf;
+  using ::nanl;
+
+  using ::nearbyint;
+  using ::nearbyintf;
+  using ::nearbyintl;
+
+  using ::nextafter;
+  using ::nextafterf;
+  using ::nextafterl;
+
+  using ::nexttoward;
+  using ::nexttowardf;
+  using ::nexttowardl;
+
+  using ::remainder;
+  using ::remainderf;
+  using ::remainderl;
+
+  using ::remquo;
+  using ::remquof;
+  using ::remquol;
+
+  using ::rint;
+  using ::rintf;
+  using ::rintl;
+
+  using ::round;
+  using ::roundf;
+  using ::roundl;
+
+  using ::scalbln;
+  using ::scalblnf;
+  using ::scalblnl;
+
+  using ::scalbn;
+  using ::scalbnf;
+  using ::scalbnl;
+
+  using ::tgamma;
+  using ::tgammaf;
+  using ::tgammal;
+
+  using ::trunc;
+  using ::truncf;
+  using ::truncl;
+
+
+
+  constexpr float
+  acosh(float __x)
+  { return __builtin_acoshf(__x); }
+
+  constexpr long double
+  acosh(long double __x)
+  { return __builtin_acoshl(__x); }
+
+
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              double>::__type
+    acosh(_Tp __x)
+    { return __builtin_acosh(__x); }
+
+
+
+  constexpr float
+  asinh(float __x)
+  { return __builtin_asinhf(__x); }
+
+  constexpr long double
+  asinh(long double __x)
+  { return __builtin_asinhl(__x); }
+
+
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              double>::__type
+    asinh(_Tp __x)
+    { return __builtin_asinh(__x); }
+
+
+
+  constexpr float
+  atanh(float __x)
+  { return __builtin_atanhf(__x); }
+
+  constexpr long double
+  atanh(long double __x)
+  { return __builtin_atanhl(__x); }
+
+
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              double>::__type
+    atanh(_Tp __x)
+    { return __builtin_atanh(__x); }
+
+
+
+  constexpr float
+  cbrt(float __x)
+  { return __builtin_cbrtf(__x); }
+
+  constexpr long double
+  cbrt(long double __x)
+  { return __builtin_cbrtl(__x); }
+
+
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              double>::__type
+    cbrt(_Tp __x)
+    { return __builtin_cbrt(__x); }
+
+
+
+  constexpr float
+  copysign(float __x, float __y)
+  { return __builtin_copysignf(__x, __y); }
+
+  constexpr long double
+  copysign(long double __x, long double __y)
+  { return __builtin_copysignl(__x, __y); }
+
+
+
+  template<typename _Tp, typename _Up>
+    constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    copysign(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return copysign(__type(__x), __type(__y));
+    }
+
+
+
+  constexpr float
+  erf(float __x)
+  { return __builtin_erff(__x); }
+
+  constexpr long double
+  erf(long double __x)
+  { return __builtin_erfl(__x); }
+
+
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              double>::__type
+    erf(_Tp __x)
+    { return __builtin_erf(__x); }
+
+
+
+  constexpr float
+  erfc(float __x)
+  { return __builtin_erfcf(__x); }
+
+  constexpr long double
+  erfc(long double __x)
+  { return __builtin_erfcl(__x); }
+
+
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              double>::__type
+    erfc(_Tp __x)
+    { return __builtin_erfc(__x); }
+
+
+
+  constexpr float
+  exp2(float __x)
+  { return __builtin_exp2f(__x); }
+
+  constexpr long double
+  exp2(long double __x)
+  { return __builtin_exp2l(__x); }
+
+
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              double>::__type
+    exp2(_Tp __x)
+    { return __builtin_exp2(__x); }
+
+
+
+  constexpr float
+  expm1(float __x)
+  { return __builtin_expm1f(__x); }
+
+  constexpr long double
+  expm1(long double __x)
+  { return __builtin_expm1l(__x); }
+
+
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              double>::__type
+    expm1(_Tp __x)
+    { return __builtin_expm1(__x); }
+
+
+
+  constexpr float
+  fdim(float __x, float __y)
+  { return __builtin_fdimf(__x, __y); }
+
+  constexpr long double
+  fdim(long double __x, long double __y)
+  { return __builtin_fdiml(__x, __y); }
+
+
+
+  template<typename _Tp, typename _Up>
+    constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    fdim(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return fdim(__type(__x), __type(__y));
+    }
+
+
+
+  constexpr float
+  fma(float __x, float __y, float __z)
+  { return __builtin_fmaf(__x, __y, __z); }
+
+  constexpr long double
+  fma(long double __x, long double __y, long double __z)
+  { return __builtin_fmal(__x, __y, __z); }
+
+
+
+  template<typename _Tp, typename _Up, typename _Vp>
+    constexpr typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type
+    fma(_Tp __x, _Up __y, _Vp __z)
+    {
+      typedef typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type __type;
+      return fma(__type(__x), __type(__y), __type(__z));
+    }
+
+
+
+  constexpr float
+  fmax(float __x, float __y)
+  { return __builtin_fmaxf(__x, __y); }
+
+  constexpr long double
+  fmax(long double __x, long double __y)
+  { return __builtin_fmaxl(__x, __y); }
+
+
+
+  template<typename _Tp, typename _Up>
+    constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    fmax(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return fmax(__type(__x), __type(__y));
+    }
+
+
+
+  constexpr float
+  fmin(float __x, float __y)
+  { return __builtin_fminf(__x, __y); }
+
+  constexpr long double
+  fmin(long double __x, long double __y)
+  { return __builtin_fminl(__x, __y); }
+
+
+
+  template<typename _Tp, typename _Up>
+    constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    fmin(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return fmin(__type(__x), __type(__y));
+    }
+
+
+
+  constexpr float
+  hypot(float __x, float __y)
+  { return __builtin_hypotf(__x, __y); }
+
+  constexpr long double
+  hypot(long double __x, long double __y)
+  { return __builtin_hypotl(__x, __y); }
+
+
+
+  template<typename _Tp, typename _Up>
+    constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    hypot(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return hypot(__type(__x), __type(__y));
+    }
+
+
+
+  constexpr int
+  ilogb(float __x)
+  { return __builtin_ilogbf(__x); }
+
+  constexpr int
+  ilogb(long double __x)
+  { return __builtin_ilogbl(__x); }
+
+
+
+  template<typename _Tp>
+    constexpr
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    int>::__type
+    ilogb(_Tp __x)
+    { return __builtin_ilogb(__x); }
+
+
+
+  constexpr float
+  lgamma(float __x)
+  { return __builtin_lgammaf(__x); }
+
+  constexpr long double
+  lgamma(long double __x)
+  { return __builtin_lgammal(__x); }
+
+
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              double>::__type
+    lgamma(_Tp __x)
+    { return __builtin_lgamma(__x); }
+
+
+
+  constexpr long long
+  llrint(float __x)
+  { return __builtin_llrintf(__x); }
+
+  constexpr long long
+  llrint(long double __x)
+  { return __builtin_llrintl(__x); }
+
+
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              long long>::__type
+    llrint(_Tp __x)
+    { return __builtin_llrint(__x); }
+
+
+
+  constexpr long long
+  llround(float __x)
+  { return __builtin_llroundf(__x); }
+
+  constexpr long long
+  llround(long double __x)
+  { return __builtin_llroundl(__x); }
+
+
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              long long>::__type
+    llround(_Tp __x)
+    { return __builtin_llround(__x); }
+
+
+
+  constexpr float
+  log1p(float __x)
+  { return __builtin_log1pf(__x); }
+
+  constexpr long double
+  log1p(long double __x)
+  { return __builtin_log1pl(__x); }
+
+
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              double>::__type
+    log1p(_Tp __x)
+    { return __builtin_log1p(__x); }
+
+
+
+
+  constexpr float
+  log2(float __x)
+  { return __builtin_log2f(__x); }
+
+  constexpr long double
+  log2(long double __x)
+  { return __builtin_log2l(__x); }
+
+
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              double>::__type
+    log2(_Tp __x)
+    { return __builtin_log2(__x); }
+
+
+
+  constexpr float
+  logb(float __x)
+  { return __builtin_logbf(__x); }
+
+  constexpr long double
+  logb(long double __x)
+  { return __builtin_logbl(__x); }
+
+
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              double>::__type
+    logb(_Tp __x)
+    { return __builtin_logb(__x); }
+
+
+
+  constexpr long
+  lrint(float __x)
+  { return __builtin_lrintf(__x); }
+
+  constexpr long
+  lrint(long double __x)
+  { return __builtin_lrintl(__x); }
+
+
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              long>::__type
+    lrint(_Tp __x)
+    { return __builtin_lrint(__x); }
+
+
+
+  constexpr long
+  lround(float __x)
+  { return __builtin_lroundf(__x); }
+
+  constexpr long
+  lround(long double __x)
+  { return __builtin_lroundl(__x); }
+
+
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              long>::__type
+    lround(_Tp __x)
+    { return __builtin_lround(__x); }
+
+
+
+  constexpr float
+  nearbyint(float __x)
+  { return __builtin_nearbyintf(__x); }
+
+  constexpr long double
+  nearbyint(long double __x)
+  { return __builtin_nearbyintl(__x); }
+
+
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              double>::__type
+    nearbyint(_Tp __x)
+    { return __builtin_nearbyint(__x); }
+
+
+
+  constexpr float
+  nextafter(float __x, float __y)
+  { return __builtin_nextafterf(__x, __y); }
+
+  constexpr long double
+  nextafter(long double __x, long double __y)
+  { return __builtin_nextafterl(__x, __y); }
+
+
+
+  template<typename _Tp, typename _Up>
+    constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    nextafter(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return nextafter(__type(__x), __type(__y));
+    }
+
+
+
+  constexpr float
+  nexttoward(float __x, long double __y)
+  { return __builtin_nexttowardf(__x, __y); }
+
+  constexpr long double
+  nexttoward(long double __x, long double __y)
+  { return __builtin_nexttowardl(__x, __y); }
+
+
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              double>::__type
+    nexttoward(_Tp __x, long double __y)
+    { return __builtin_nexttoward(__x, __y); }
+
+
+
+  constexpr float
+  remainder(float __x, float __y)
+  { return __builtin_remainderf(__x, __y); }
+
+  constexpr long double
+  remainder(long double __x, long double __y)
+  { return __builtin_remainderl(__x, __y); }
+
+
+
+  template<typename _Tp, typename _Up>
+    constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    remainder(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return remainder(__type(__x), __type(__y));
+    }
+
+
+
+  inline float
+  remquo(float __x, float __y, int* __pquo)
+  { return __builtin_remquof(__x, __y, __pquo); }
+
+  inline long double
+  remquo(long double __x, long double __y, int* __pquo)
+  { return __builtin_remquol(__x, __y, __pquo); }
+
+
+
+  template<typename _Tp, typename _Up>
+    inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    remquo(_Tp __x, _Up __y, int* __pquo)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return remquo(__type(__x), __type(__y), __pquo);
+    }
+
+
+
+  constexpr float
+  rint(float __x)
+  { return __builtin_rintf(__x); }
+
+  constexpr long double
+  rint(long double __x)
+  { return __builtin_rintl(__x); }
+
+
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              double>::__type
+    rint(_Tp __x)
+    { return __builtin_rint(__x); }
+
+
+
+  constexpr float
+  round(float __x)
+  { return __builtin_roundf(__x); }
+
+  constexpr long double
+  round(long double __x)
+  { return __builtin_roundl(__x); }
+
+
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              double>::__type
+    round(_Tp __x)
+    { return __builtin_round(__x); }
+
+
+
+  constexpr float
+  scalbln(float __x, long __ex)
+  { return __builtin_scalblnf(__x, __ex); }
+
+  constexpr long double
+  scalbln(long double __x, long __ex)
+  { return __builtin_scalblnl(__x, __ex); }
+
+
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              double>::__type
+    scalbln(_Tp __x, long __ex)
+    { return __builtin_scalbln(__x, __ex); }
+
+
+
+  constexpr float
+  scalbn(float __x, int __ex)
+  { return __builtin_scalbnf(__x, __ex); }
+
+  constexpr long double
+  scalbn(long double __x, int __ex)
+  { return __builtin_scalbnl(__x, __ex); }
+
+
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              double>::__type
+    scalbn(_Tp __x, int __ex)
+    { return __builtin_scalbn(__x, __ex); }
+
+
+
+  constexpr float
+  tgamma(float __x)
+  { return __builtin_tgammaf(__x); }
+
+  constexpr long double
+  tgamma(long double __x)
+  { return __builtin_tgammal(__x); }
+
+
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              double>::__type
+    tgamma(_Tp __x)
+    { return __builtin_tgamma(__x); }
+
+
+
+  constexpr float
+  trunc(float __x)
+  { return __builtin_truncf(__x); }
+
+  constexpr long double
+  trunc(long double __x)
+  { return __builtin_truncl(__x); }
+
+
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              double>::__type
+    trunc(_Tp __x)
+    { return __builtin_trunc(__x); }
+# 1850 "/usr/include/c++/10.2.0/cmath" 3
+#define __cpp_lib_hypot 201603
+
+  template<typename _Tp>
+    inline _Tp
+    __hypot3(_Tp __x, _Tp __y, _Tp __z)
+    {
+      __x = std::abs(__x);
+      __y = std::abs(__y);
+      __z = std::abs(__z);
+      if (_Tp __a = __x < __y ? __y < __z ? __z : __y : __x < __z ? __z : __x)
+ return __a * std::sqrt((__x / __a) * (__x / __a)
+          + (__y / __a) * (__y / __a)
+          + (__z / __a) * (__z / __a));
+      else
+ return {};
+    }
+
+  inline float
+  hypot(float __x, float __y, float __z)
+  { return std::__hypot3<float>(__x, __y, __z); }
+
+  inline double
+  hypot(double __x, double __y, double __z)
+  { return std::__hypot3<double>(__x, __y, __z); }
+
+  inline long double
+  hypot(long double __x, long double __y, long double __z)
+  { return std::__hypot3<long double>(__x, __y, __z); }
+
+  template<typename _Tp, typename _Up, typename _Vp>
+    typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type
+    hypot(_Tp __x, _Up __y, _Vp __z)
+    {
+      using __type = typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type;
+      return std::__hypot3<__type>(__x, __y, __z);
+    }
+# 1923 "/usr/include/c++/10.2.0/cmath" 3
+
+}
+
+
+# 1 "/usr/include/c++/10.2.0/bits/specfun.h" 1 3
+# 31 "/usr/include/c++/10.2.0/bits/specfun.h" 3
+#define _GLIBCXX_BITS_SPECFUN_H 1
+
+#pragma GCC visibility push(default)
+
+
+
+#define __STDCPP_MATH_SPEC_FUNCS__ 201003L
+
+#define __cpp_lib_math_special_functions 201603L
+# 49 "/usr/include/c++/10.2.0/bits/specfun.h" 3
+# 1 "/usr/include/c++/10.2.0/tr1/gamma.tcc" 1 3
+# 47 "/usr/include/c++/10.2.0/tr1/gamma.tcc" 3
+#define _GLIBCXX_TR1_GAMMA_TCC 1
+
+# 1 "/usr/include/c++/10.2.0/tr1/special_function_util.h" 1 3
+# 37 "/usr/include/c++/10.2.0/tr1/special_function_util.h" 3
+#define _GLIBCXX_TR1_SPECIAL_FUNCTION_UTIL_H 1
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 50 "/usr/include/c++/10.2.0/tr1/special_function_util.h" 3
+  namespace __detail
+  {
+
+
+
+    template<typename _Tp>
+    struct __floating_point_constant
+    {
+      static const _Tp __value;
+    };
+
+
+
+    template<typename _Tp>
+      struct __numeric_constants
+      {
+
+        static _Tp __pi() throw()
+        { return static_cast<_Tp>(3.1415926535897932384626433832795029L); }
+
+        static _Tp __pi_2() throw()
+        { return static_cast<_Tp>(1.5707963267948966192313216916397514L); }
+
+        static _Tp __pi_3() throw()
+        { return static_cast<_Tp>(1.0471975511965977461542144610931676L); }
+
+        static _Tp __pi_4() throw()
+        { return static_cast<_Tp>(0.7853981633974483096156608458198757L); }
+
+        static _Tp __1_pi() throw()
+        { return static_cast<_Tp>(0.3183098861837906715377675267450287L); }
+
+        static _Tp __2_sqrtpi() throw()
+        { return static_cast<_Tp>(1.1283791670955125738961589031215452L); }
+
+        static _Tp __sqrt2() throw()
+        { return static_cast<_Tp>(1.4142135623730950488016887242096981L); }
+
+        static _Tp __sqrt3() throw()
+        { return static_cast<_Tp>(1.7320508075688772935274463415058723L); }
+
+        static _Tp __sqrtpio2() throw()
+        { return static_cast<_Tp>(1.2533141373155002512078826424055226L); }
+
+        static _Tp __sqrt1_2() throw()
+        { return static_cast<_Tp>(0.7071067811865475244008443621048490L); }
+
+        static _Tp __lnpi() throw()
+        { return static_cast<_Tp>(1.1447298858494001741434273513530587L); }
+
+        static _Tp __gamma_e() throw()
+        { return static_cast<_Tp>(0.5772156649015328606065120900824024L); }
+
+        static _Tp __euler() throw()
+        { return static_cast<_Tp>(2.7182818284590452353602874713526625L); }
+      };
+# 114 "/usr/include/c++/10.2.0/tr1/special_function_util.h" 3
+    template<typename _Tp>
+    inline bool __isnan(_Tp __x)
+    { return std::isnan(__x); }
+# 133 "/usr/include/c++/10.2.0/tr1/special_function_util.h" 3
+  }
+
+
+
+
+
+}
+# 50 "/usr/include/c++/10.2.0/tr1/gamma.tcc" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+#define _GLIBCXX_MATH_NS ::std
+# 65 "/usr/include/c++/10.2.0/tr1/gamma.tcc" 3
+  namespace __detail
+  {
+# 76 "/usr/include/c++/10.2.0/tr1/gamma.tcc" 3
+    template <typename _Tp>
+    _Tp
+    __bernoulli_series(unsigned int __n)
+    {
+
+      static const _Tp __num[28] = {
+        _Tp(1UL), -_Tp(1UL) / _Tp(2UL),
+        _Tp(1UL) / _Tp(6UL), _Tp(0UL),
+        -_Tp(1UL) / _Tp(30UL), _Tp(0UL),
+        _Tp(1UL) / _Tp(42UL), _Tp(0UL),
+        -_Tp(1UL) / _Tp(30UL), _Tp(0UL),
+        _Tp(5UL) / _Tp(66UL), _Tp(0UL),
+        -_Tp(691UL) / _Tp(2730UL), _Tp(0UL),
+        _Tp(7UL) / _Tp(6UL), _Tp(0UL),
+        -_Tp(3617UL) / _Tp(510UL), _Tp(0UL),
+        _Tp(43867UL) / _Tp(798UL), _Tp(0UL),
+        -_Tp(174611) / _Tp(330UL), _Tp(0UL),
+        _Tp(854513UL) / _Tp(138UL), _Tp(0UL),
+        -_Tp(236364091UL) / _Tp(2730UL), _Tp(0UL),
+        _Tp(8553103UL) / _Tp(6UL), _Tp(0UL)
+      };
+
+      if (__n == 0)
+        return _Tp(1);
+
+      if (__n == 1)
+        return -_Tp(1) / _Tp(2);
+
+
+      if (__n % 2 == 1)
+        return _Tp(0);
+
+
+      if (__n < 28)
+        return __num[__n];
+
+
+      _Tp __fact = _Tp(1);
+      if ((__n / 2) % 2 == 0)
+        __fact *= _Tp(-1);
+      for (unsigned int __k = 1; __k <= __n; ++__k)
+        __fact *= __k / (_Tp(2) * __numeric_constants<_Tp>::__pi());
+      __fact *= _Tp(2);
+
+      _Tp __sum = _Tp(0);
+      for (unsigned int __i = 1; __i < 1000; ++__i)
+        {
+          _Tp __term = std::pow(_Tp(__i), -_Tp(__n));
+          if (__term < std::numeric_limits<_Tp>::epsilon())
+            break;
+          __sum += __term;
+        }
+
+      return __fact * __sum;
+    }
+# 139 "/usr/include/c++/10.2.0/tr1/gamma.tcc" 3
+    template<typename _Tp>
+    inline _Tp
+    __bernoulli(int __n)
+    { return __bernoulli_series<_Tp>(__n); }
+# 153 "/usr/include/c++/10.2.0/tr1/gamma.tcc" 3
+    template<typename _Tp>
+    _Tp
+    __log_gamma_bernoulli(_Tp __x)
+    {
+      _Tp __lg = (__x - _Tp(0.5L)) * std::log(__x) - __x
+               + _Tp(0.5L) * std::log(_Tp(2)
+               * __numeric_constants<_Tp>::__pi());
+
+      const _Tp __xx = __x * __x;
+      _Tp __help = _Tp(1) / __x;
+      for ( unsigned int __i = 1; __i < 20; ++__i )
+        {
+          const _Tp __2i = _Tp(2 * __i);
+          __help /= __2i * (__2i - _Tp(1)) * __xx;
+          __lg += __bernoulli<_Tp>(2 * __i) * __help;
+        }
+
+      return __lg;
+    }
+# 181 "/usr/include/c++/10.2.0/tr1/gamma.tcc" 3
+    template<typename _Tp>
+    _Tp
+    __log_gamma_lanczos(_Tp __x)
+    {
+      const _Tp __xm1 = __x - _Tp(1);
+
+      static const _Tp __lanczos_cheb_7[9] = {
+       _Tp( 0.99999999999980993227684700473478L),
+       _Tp( 676.520368121885098567009190444019L),
+       _Tp(-1259.13921672240287047156078755283L),
+       _Tp( 771.3234287776530788486528258894L),
+       _Tp(-176.61502916214059906584551354L),
+       _Tp( 12.507343278686904814458936853L),
+       _Tp(-0.13857109526572011689554707L),
+       _Tp( 9.984369578019570859563e-6L),
+       _Tp( 1.50563273514931155834e-7L)
+      };
+
+      static const _Tp __LOGROOT2PI
+          = _Tp(0.9189385332046727417803297364056176L);
+
+      _Tp __sum = __lanczos_cheb_7[0];
+      for(unsigned int __k = 1; __k < 9; ++__k)
+        __sum += __lanczos_cheb_7[__k] / (__xm1 + __k);
+
+      const _Tp __term1 = (__xm1 + _Tp(0.5L))
+                        * std::log((__xm1 + _Tp(7.5L))
+                       / __numeric_constants<_Tp>::__euler());
+      const _Tp __term2 = __LOGROOT2PI + std::log(__sum);
+      const _Tp __result = __term1 + (__term2 - _Tp(7));
+
+      return __result;
+    }
+# 225 "/usr/include/c++/10.2.0/tr1/gamma.tcc" 3
+    template<typename _Tp>
+    _Tp
+    __log_gamma(_Tp __x)
+    {
+      if (__x > _Tp(0.5L))
+        return __log_gamma_lanczos(__x);
+      else
+        {
+          const _Tp __sin_fact
+                 = std::abs(std::sin(__numeric_constants<_Tp>::__pi() * __x));
+          if (__sin_fact == _Tp(0))
+            std::__throw_domain_error(("Argument is nonpositive integer " "in __log_gamma")
+                                                           );
+          return __numeric_constants<_Tp>::__lnpi()
+                     - std::log(__sin_fact)
+                     - __log_gamma_lanczos(_Tp(1) - __x);
+        }
+    }
+# 252 "/usr/include/c++/10.2.0/tr1/gamma.tcc" 3
+    template<typename _Tp>
+    _Tp
+    __log_gamma_sign(_Tp __x)
+    {
+      if (__x > _Tp(0))
+        return _Tp(1);
+      else
+        {
+          const _Tp __sin_fact
+                  = std::sin(__numeric_constants<_Tp>::__pi() * __x);
+          if (__sin_fact > _Tp(0))
+            return (1);
+          else if (__sin_fact < _Tp(0))
+            return -_Tp(1);
+          else
+            return _Tp(0);
+        }
+    }
+# 283 "/usr/include/c++/10.2.0/tr1/gamma.tcc" 3
+    template<typename _Tp>
+    _Tp
+    __log_bincoef(unsigned int __n, unsigned int __k)
+    {
+
+      static const _Tp __max_bincoeff
+                      = std::numeric_limits<_Tp>::max_exponent10
+                      * std::log(_Tp(10)) - _Tp(1);
+
+      _Tp __coeff = ::std::lgamma(_Tp(1 + __n))
+                  - ::std::lgamma(_Tp(1 + __k))
+                  - ::std::lgamma(_Tp(1 + __n - __k));
+
+
+
+
+
+    }
+# 314 "/usr/include/c++/10.2.0/tr1/gamma.tcc" 3
+    template<typename _Tp>
+    _Tp
+    __bincoef(unsigned int __n, unsigned int __k)
+    {
+
+      static const _Tp __max_bincoeff
+                      = std::numeric_limits<_Tp>::max_exponent10
+                      * std::log(_Tp(10)) - _Tp(1);
+
+      const _Tp __log_coeff = __log_bincoef<_Tp>(__n, __k);
+      if (__log_coeff > __max_bincoeff)
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else
+        return std::exp(__log_coeff);
+    }
+# 337 "/usr/include/c++/10.2.0/tr1/gamma.tcc" 3
+    template<typename _Tp>
+    inline _Tp
+    __gamma(_Tp __x)
+    { return std::exp(__log_gamma(__x)); }
+# 356 "/usr/include/c++/10.2.0/tr1/gamma.tcc" 3
+    template<typename _Tp>
+    _Tp
+    __psi_series(_Tp __x)
+    {
+      _Tp __sum = -__numeric_constants<_Tp>::__gamma_e() - _Tp(1) / __x;
+      const unsigned int __max_iter = 100000;
+      for (unsigned int __k = 1; __k < __max_iter; ++__k)
+        {
+          const _Tp __term = __x / (__k * (__k + __x));
+          __sum += __term;
+          if (std::abs(__term / __sum) < std::numeric_limits<_Tp>::epsilon())
+            break;
+        }
+      return __sum;
+    }
+# 386 "/usr/include/c++/10.2.0/tr1/gamma.tcc" 3
+    template<typename _Tp>
+    _Tp
+    __psi_asymp(_Tp __x)
+    {
+      _Tp __sum = std::log(__x) - _Tp(0.5L) / __x;
+      const _Tp __xx = __x * __x;
+      _Tp __xp = __xx;
+      const unsigned int __max_iter = 100;
+      for (unsigned int __k = 1; __k < __max_iter; ++__k)
+        {
+          const _Tp __term = __bernoulli<_Tp>(2 * __k) / (2 * __k * __xp);
+          __sum -= __term;
+          if (std::abs(__term / __sum) < std::numeric_limits<_Tp>::epsilon())
+            break;
+          __xp *= __xx;
+        }
+      return __sum;
+    }
+# 417 "/usr/include/c++/10.2.0/tr1/gamma.tcc" 3
+    template<typename _Tp>
+    _Tp
+    __psi(_Tp __x)
+    {
+      const int __n = static_cast<int>(__x + 0.5L);
+      const _Tp __eps = _Tp(4) * std::numeric_limits<_Tp>::epsilon();
+      if (__n <= 0 && std::abs(__x - _Tp(__n)) < __eps)
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (__x < _Tp(0))
+        {
+          const _Tp __pi = __numeric_constants<_Tp>::__pi();
+          return __psi(_Tp(1) - __x)
+               - __pi * std::cos(__pi * __x) / std::sin(__pi * __x);
+        }
+      else if (__x > _Tp(100))
+        return __psi_asymp(__x);
+      else
+        return __psi_series(__x);
+    }
+# 446 "/usr/include/c++/10.2.0/tr1/gamma.tcc" 3
+    template<typename _Tp>
+    _Tp
+    __psi(unsigned int __n, _Tp __x)
+    {
+      if (__x <= _Tp(0))
+        std::__throw_domain_error(("Argument out of range " "in __psi")
+                                                 );
+      else if (__n == 0)
+        return __psi(__x);
+      else
+        {
+          const _Tp __hzeta = __hurwitz_zeta(_Tp(__n + 1), __x);
+
+          const _Tp __ln_nfact = ::std::lgamma(_Tp(__n + 1));
+
+
+
+          _Tp __result = std::exp(__ln_nfact) * __hzeta;
+          if (__n % 2 == 1)
+            __result = -__result;
+          return __result;
+        }
+    }
+  }
+#undef _GLIBCXX_MATH_NS
+
+
+
+
+
+}
+# 50 "/usr/include/c++/10.2.0/bits/specfun.h" 2 3
+# 1 "/usr/include/c++/10.2.0/tr1/bessel_function.tcc" 1 3
+# 51 "/usr/include/c++/10.2.0/tr1/bessel_function.tcc" 3
+#define _GLIBCXX_TR1_BESSEL_FUNCTION_TCC 1
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+#define _GLIBCXX_MATH_NS ::std
+# 71 "/usr/include/c++/10.2.0/tr1/bessel_function.tcc" 3
+  namespace __detail
+  {
+# 98 "/usr/include/c++/10.2.0/tr1/bessel_function.tcc" 3
+    template <typename _Tp>
+    void
+    __gamma_temme(_Tp __mu,
+                  _Tp & __gam1, _Tp & __gam2, _Tp & __gampl, _Tp & __gammi)
+    {
+
+      __gampl = _Tp(1) / ::std::tgamma(_Tp(1) + __mu);
+      __gammi = _Tp(1) / ::std::tgamma(_Tp(1) - __mu);
+
+
+
+
+
+      if (std::abs(__mu) < std::numeric_limits<_Tp>::epsilon())
+        __gam1 = -_Tp(__numeric_constants<_Tp>::__gamma_e());
+      else
+        __gam1 = (__gammi - __gampl) / (_Tp(2) * __mu);
+
+      __gam2 = (__gammi + __gampl) / (_Tp(2));
+
+      return;
+    }
+# 136 "/usr/include/c++/10.2.0/tr1/bessel_function.tcc" 3
+    template <typename _Tp>
+    void
+    __bessel_jn(_Tp __nu, _Tp __x,
+                _Tp & __Jnu, _Tp & __Nnu, _Tp & __Jpnu, _Tp & __Npnu)
+    {
+      if (__x == _Tp(0))
+        {
+          if (__nu == _Tp(0))
+            {
+              __Jnu = _Tp(1);
+              __Jpnu = _Tp(0);
+            }
+          else if (__nu == _Tp(1))
+            {
+              __Jnu = _Tp(0);
+              __Jpnu = _Tp(0.5L);
+            }
+          else
+            {
+              __Jnu = _Tp(0);
+              __Jpnu = _Tp(0);
+            }
+          __Nnu = -std::numeric_limits<_Tp>::infinity();
+          __Npnu = std::numeric_limits<_Tp>::infinity();
+          return;
+        }
+
+      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
+
+
+
+
+      const _Tp __fp_min = std::sqrt(std::numeric_limits<_Tp>::min());
+      const int __max_iter = 15000;
+      const _Tp __x_min = _Tp(2);
+
+      const int __nl = (__x < __x_min
+                    ? static_cast<int>(__nu + _Tp(0.5L))
+                    : std::max(0, static_cast<int>(__nu - __x + _Tp(1.5L))));
+
+      const _Tp __mu = __nu - __nl;
+      const _Tp __mu2 = __mu * __mu;
+      const _Tp __xi = _Tp(1) / __x;
+      const _Tp __xi2 = _Tp(2) * __xi;
+      _Tp __w = __xi2 / __numeric_constants<_Tp>::__pi();
+      int __isign = 1;
+      _Tp __h = __nu * __xi;
+      if (__h < __fp_min)
+        __h = __fp_min;
+      _Tp __b = __xi2 * __nu;
+      _Tp __d = _Tp(0);
+      _Tp __c = __h;
+      int __i;
+      for (__i = 1; __i <= __max_iter; ++__i)
+        {
+          __b += __xi2;
+          __d = __b - __d;
+          if (std::abs(__d) < __fp_min)
+            __d = __fp_min;
+          __c = __b - _Tp(1) / __c;
+          if (std::abs(__c) < __fp_min)
+            __c = __fp_min;
+          __d = _Tp(1) / __d;
+          const _Tp __del = __c * __d;
+          __h *= __del;
+          if (__d < _Tp(0))
+            __isign = -__isign;
+          if (std::abs(__del - _Tp(1)) < __eps)
+            break;
+        }
+      if (__i > __max_iter)
+        std::__throw_runtime_error(("Argument x too large in __bessel_jn; " "try asymptotic expansion.")
+                                                                   );
+      _Tp __Jnul = __isign * __fp_min;
+      _Tp __Jpnul = __h * __Jnul;
+      _Tp __Jnul1 = __Jnul;
+      _Tp __Jpnu1 = __Jpnul;
+      _Tp __fact = __nu * __xi;
+      for ( int __l = __nl; __l >= 1; --__l )
+        {
+          const _Tp __Jnutemp = __fact * __Jnul + __Jpnul;
+          __fact -= __xi;
+          __Jpnul = __fact * __Jnutemp - __Jnul;
+          __Jnul = __Jnutemp;
+        }
+      if (__Jnul == _Tp(0))
+        __Jnul = __eps;
+      _Tp __f= __Jpnul / __Jnul;
+      _Tp __Nmu, __Nnu1, __Npmu, __Jmu;
+      if (__x < __x_min)
+        {
+          const _Tp __x2 = __x / _Tp(2);
+          const _Tp __pimu = __numeric_constants<_Tp>::__pi() * __mu;
+          _Tp __fact = (std::abs(__pimu) < __eps
+                      ? _Tp(1) : __pimu / std::sin(__pimu));
+          _Tp __d = -std::log(__x2);
+          _Tp __e = __mu * __d;
+          _Tp __fact2 = (std::abs(__e) < __eps
+                       ? _Tp(1) : std::sinh(__e) / __e);
+          _Tp __gam1, __gam2, __gampl, __gammi;
+          __gamma_temme(__mu, __gam1, __gam2, __gampl, __gammi);
+          _Tp __ff = (_Tp(2) / __numeric_constants<_Tp>::__pi())
+                   * __fact * (__gam1 * std::cosh(__e) + __gam2 * __fact2 * __d);
+          __e = std::exp(__e);
+          _Tp __p = __e / (__numeric_constants<_Tp>::__pi() * __gampl);
+          _Tp __q = _Tp(1) / (__e * __numeric_constants<_Tp>::__pi() * __gammi);
+          const _Tp __pimu2 = __pimu / _Tp(2);
+          _Tp __fact3 = (std::abs(__pimu2) < __eps
+                       ? _Tp(1) : std::sin(__pimu2) / __pimu2 );
+          _Tp __r = __numeric_constants<_Tp>::__pi() * __pimu2 * __fact3 * __fact3;
+          _Tp __c = _Tp(1);
+          __d = -__x2 * __x2;
+          _Tp __sum = __ff + __r * __q;
+          _Tp __sum1 = __p;
+          for (__i = 1; __i <= __max_iter; ++__i)
+            {
+              __ff = (__i * __ff + __p + __q) / (__i * __i - __mu2);
+              __c *= __d / _Tp(__i);
+              __p /= _Tp(__i) - __mu;
+              __q /= _Tp(__i) + __mu;
+              const _Tp __del = __c * (__ff + __r * __q);
+              __sum += __del;
+              const _Tp __del1 = __c * __p - __i * __del;
+              __sum1 += __del1;
+              if ( std::abs(__del) < __eps * (_Tp(1) + std::abs(__sum)) )
+                break;
+            }
+          if ( __i > __max_iter )
+            std::__throw_runtime_error(("Bessel y series failed to converge " "in __bessel_jn.")
+                                                             );
+          __Nmu = -__sum;
+          __Nnu1 = -__sum1 * __xi2;
+          __Npmu = __mu * __xi * __Nmu - __Nnu1;
+          __Jmu = __w / (__Npmu - __f * __Nmu);
+        }
+      else
+        {
+          _Tp __a = _Tp(0.25L) - __mu2;
+          _Tp __q = _Tp(1);
+          _Tp __p = -__xi / _Tp(2);
+          _Tp __br = _Tp(2) * __x;
+          _Tp __bi = _Tp(2);
+          _Tp __fact = __a * __xi / (__p * __p + __q * __q);
+          _Tp __cr = __br + __q * __fact;
+          _Tp __ci = __bi + __p * __fact;
+          _Tp __den = __br * __br + __bi * __bi;
+          _Tp __dr = __br / __den;
+          _Tp __di = -__bi / __den;
+          _Tp __dlr = __cr * __dr - __ci * __di;
+          _Tp __dli = __cr * __di + __ci * __dr;
+          _Tp __temp = __p * __dlr - __q * __dli;
+          __q = __p * __dli + __q * __dlr;
+          __p = __temp;
+          int __i;
+          for (__i = 2; __i <= __max_iter; ++__i)
+            {
+              __a += _Tp(2 * (__i - 1));
+              __bi += _Tp(2);
+              __dr = __a * __dr + __br;
+              __di = __a * __di + __bi;
+              if (std::abs(__dr) + std::abs(__di) < __fp_min)
+                __dr = __fp_min;
+              __fact = __a / (__cr * __cr + __ci * __ci);
+              __cr = __br + __cr * __fact;
+              __ci = __bi - __ci * __fact;
+              if (std::abs(__cr) + std::abs(__ci) < __fp_min)
+                __cr = __fp_min;
+              __den = __dr * __dr + __di * __di;
+              __dr /= __den;
+              __di /= -__den;
+              __dlr = __cr * __dr - __ci * __di;
+              __dli = __cr * __di + __ci * __dr;
+              __temp = __p * __dlr - __q * __dli;
+              __q = __p * __dli + __q * __dlr;
+              __p = __temp;
+              if (std::abs(__dlr - _Tp(1)) + std::abs(__dli) < __eps)
+                break;
+          }
+          if (__i > __max_iter)
+            std::__throw_runtime_error(("Lentz's method failed " "in __bessel_jn.")
+                                                             );
+          const _Tp __gam = (__p - __f) / __q;
+          __Jmu = std::sqrt(__w / ((__p - __f) * __gam + __q));
+
+          __Jmu = ::std::copysign(__Jmu, __Jnul);
+
+
+
+
+          __Nmu = __gam * __Jmu;
+          __Npmu = (__p + __q / __gam) * __Nmu;
+          __Nnu1 = __mu * __xi * __Nmu - __Npmu;
+      }
+      __fact = __Jmu / __Jnul;
+      __Jnu = __fact * __Jnul1;
+      __Jpnu = __fact * __Jpnu1;
+      for (__i = 1; __i <= __nl; ++__i)
+        {
+          const _Tp __Nnutemp = (__mu + __i) * __xi2 * __Nnu1 - __Nmu;
+          __Nmu = __Nnu1;
+          __Nnu1 = __Nnutemp;
+        }
+      __Nnu = __Nmu;
+      __Npnu = __nu * __xi * __Nmu - __Nnu1;
+
+      return;
+    }
+# 361 "/usr/include/c++/10.2.0/tr1/bessel_function.tcc" 3
+    template <typename _Tp>
+    void
+    __cyl_bessel_jn_asymp(_Tp __nu, _Tp __x, _Tp & __Jnu, _Tp & __Nnu)
+    {
+      const _Tp __mu = _Tp(4) * __nu * __nu;
+      const _Tp __8x = _Tp(8) * __x;
+
+      _Tp __P = _Tp(0);
+      _Tp __Q = _Tp(0);
+
+      _Tp __k = _Tp(0);
+      _Tp __term = _Tp(1);
+
+      int __epsP = 0;
+      int __epsQ = 0;
+
+      _Tp __eps = std::numeric_limits<_Tp>::epsilon();
+
+      do
+        {
+          __term *= (__k == 0
+                     ? _Tp(1)
+                     : -(__mu - (2 * __k - 1) * (2 * __k - 1)) / (__k * __8x));
+
+          __epsP = std::abs(__term) < __eps * std::abs(__P);
+          __P += __term;
+
+          __k++;
+
+          __term *= (__mu - (2 * __k - 1) * (2 * __k - 1)) / (__k * __8x);
+          __epsQ = std::abs(__term) < __eps * std::abs(__Q);
+          __Q += __term;
+
+          if (__epsP && __epsQ && __k > (__nu / 2.))
+            break;
+
+          __k++;
+        }
+      while (__k < 1000);
+
+      const _Tp __chi = __x - (__nu + _Tp(0.5L))
+                             * __numeric_constants<_Tp>::__pi_2();
+
+      const _Tp __c = std::cos(__chi);
+      const _Tp __s = std::sin(__chi);
+
+      const _Tp __coef = std::sqrt(_Tp(2)
+                             / (__numeric_constants<_Tp>::__pi() * __x));
+
+      __Jnu = __coef * (__c * __P - __s * __Q);
+      __Nnu = __coef * (__s * __P + __c * __Q);
+
+      return;
+    }
+# 444 "/usr/include/c++/10.2.0/tr1/bessel_function.tcc" 3
+    template <typename _Tp>
+    _Tp
+    __cyl_bessel_ij_series(_Tp __nu, _Tp __x, _Tp __sgn,
+                           unsigned int __max_iter)
+    {
+      if (__x == _Tp(0))
+ return __nu == _Tp(0) ? _Tp(1) : _Tp(0);
+
+      const _Tp __x2 = __x / _Tp(2);
+      _Tp __fact = __nu * std::log(__x2);
+
+      __fact -= ::std::lgamma(__nu + _Tp(1));
+
+
+
+      __fact = std::exp(__fact);
+      const _Tp __xx4 = __sgn * __x2 * __x2;
+      _Tp __Jn = _Tp(1);
+      _Tp __term = _Tp(1);
+
+      for (unsigned int __i = 1; __i < __max_iter; ++__i)
+        {
+          __term *= __xx4 / (_Tp(__i) * (__nu + _Tp(__i)));
+          __Jn += __term;
+          if (std::abs(__term / __Jn) < std::numeric_limits<_Tp>::epsilon())
+            break;
+        }
+
+      return __fact * __Jn;
+    }
+# 490 "/usr/include/c++/10.2.0/tr1/bessel_function.tcc" 3
+    template<typename _Tp>
+    _Tp
+    __cyl_bessel_j(_Tp __nu, _Tp __x)
+    {
+      if (__nu < _Tp(0) || __x < _Tp(0))
+        std::__throw_domain_error(("Bad argument " "in __cyl_bessel_j.")
+                                                           );
+      else if (__isnan(__nu) || __isnan(__x))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (__x * __x < _Tp(10) * (__nu + _Tp(1)))
+        return __cyl_bessel_ij_series(__nu, __x, -_Tp(1), 200);
+      else if (__x > _Tp(1000))
+        {
+          _Tp __J_nu, __N_nu;
+          __cyl_bessel_jn_asymp(__nu, __x, __J_nu, __N_nu);
+          return __J_nu;
+        }
+      else
+        {
+          _Tp __J_nu, __N_nu, __Jp_nu, __Np_nu;
+          __bessel_jn(__nu, __x, __J_nu, __N_nu, __Jp_nu, __Np_nu);
+          return __J_nu;
+        }
+    }
+# 532 "/usr/include/c++/10.2.0/tr1/bessel_function.tcc" 3
+    template<typename _Tp>
+    _Tp
+    __cyl_neumann_n(_Tp __nu, _Tp __x)
+    {
+      if (__nu < _Tp(0) || __x < _Tp(0))
+        std::__throw_domain_error(("Bad argument " "in __cyl_neumann_n.")
+                                                            );
+      else if (__isnan(__nu) || __isnan(__x))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (__x > _Tp(1000))
+        {
+          _Tp __J_nu, __N_nu;
+          __cyl_bessel_jn_asymp(__nu, __x, __J_nu, __N_nu);
+          return __N_nu;
+        }
+      else
+        {
+          _Tp __J_nu, __N_nu, __Jp_nu, __Np_nu;
+          __bessel_jn(__nu, __x, __J_nu, __N_nu, __Jp_nu, __Np_nu);
+          return __N_nu;
+        }
+    }
+# 569 "/usr/include/c++/10.2.0/tr1/bessel_function.tcc" 3
+    template <typename _Tp>
+    void
+    __sph_bessel_jn(unsigned int __n, _Tp __x,
+                    _Tp & __j_n, _Tp & __n_n, _Tp & __jp_n, _Tp & __np_n)
+    {
+      const _Tp __nu = _Tp(__n) + _Tp(0.5L);
+
+      _Tp __J_nu, __N_nu, __Jp_nu, __Np_nu;
+      __bessel_jn(__nu, __x, __J_nu, __N_nu, __Jp_nu, __Np_nu);
+
+      const _Tp __factor = __numeric_constants<_Tp>::__sqrtpio2()
+                         / std::sqrt(__x);
+
+      __j_n = __factor * __J_nu;
+      __n_n = __factor * __N_nu;
+      __jp_n = __factor * __Jp_nu - __j_n / (_Tp(2) * __x);
+      __np_n = __factor * __Np_nu - __n_n / (_Tp(2) * __x);
+
+      return;
+    }
+# 604 "/usr/include/c++/10.2.0/tr1/bessel_function.tcc" 3
+    template <typename _Tp>
+    _Tp
+    __sph_bessel(unsigned int __n, _Tp __x)
+    {
+      if (__x < _Tp(0))
+        std::__throw_domain_error(("Bad argument " "in __sph_bessel.")
+                                                         );
+      else if (__isnan(__x))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (__x == _Tp(0))
+        {
+          if (__n == 0)
+            return _Tp(1);
+          else
+            return _Tp(0);
+        }
+      else
+        {
+          _Tp __j_n, __n_n, __jp_n, __np_n;
+          __sph_bessel_jn(__n, __x, __j_n, __n_n, __jp_n, __np_n);
+          return __j_n;
+        }
+    }
+# 642 "/usr/include/c++/10.2.0/tr1/bessel_function.tcc" 3
+    template <typename _Tp>
+    _Tp
+    __sph_neumann(unsigned int __n, _Tp __x)
+    {
+      if (__x < _Tp(0))
+        std::__throw_domain_error(("Bad argument " "in __sph_neumann.")
+                                                          );
+      else if (__isnan(__x))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (__x == _Tp(0))
+        return -std::numeric_limits<_Tp>::infinity();
+      else
+        {
+          _Tp __j_n, __n_n, __jp_n, __np_n;
+          __sph_bessel_jn(__n, __x, __j_n, __n_n, __jp_n, __np_n);
+          return __n_n;
+        }
+    }
+  }
+#undef _GLIBCXX_MATH_NS
+
+
+
+
+
+}
+# 51 "/usr/include/c++/10.2.0/bits/specfun.h" 2 3
+# 1 "/usr/include/c++/10.2.0/tr1/beta_function.tcc" 1 3
+# 47 "/usr/include/c++/10.2.0/tr1/beta_function.tcc" 3
+#define _GLIBCXX_TR1_BETA_FUNCTION_TCC 1
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+#define _GLIBCXX_MATH_NS ::std
+# 65 "/usr/include/c++/10.2.0/tr1/beta_function.tcc" 3
+  namespace __detail
+  {
+# 79 "/usr/include/c++/10.2.0/tr1/beta_function.tcc" 3
+    template<typename _Tp>
+    _Tp
+    __beta_gamma(_Tp __x, _Tp __y)
+    {
+
+      _Tp __bet;
+
+      if (__x > __y)
+        {
+          __bet = ::std::tgamma(__x)
+                / ::std::tgamma(__x + __y);
+          __bet *= ::std::tgamma(__y);
+        }
+      else
+        {
+          __bet = ::std::tgamma(__y)
+                / ::std::tgamma(__x + __y);
+          __bet *= ::std::tgamma(__x);
+        }
+# 111 "/usr/include/c++/10.2.0/tr1/beta_function.tcc" 3
+      return __bet;
+    }
+# 127 "/usr/include/c++/10.2.0/tr1/beta_function.tcc" 3
+    template<typename _Tp>
+    _Tp
+    __beta_lgamma(_Tp __x, _Tp __y)
+    {
+
+      _Tp __bet = ::std::lgamma(__x)
+                + ::std::lgamma(__y)
+                - ::std::lgamma(__x + __y);
+
+
+
+
+
+      __bet = std::exp(__bet);
+      return __bet;
+    }
+# 158 "/usr/include/c++/10.2.0/tr1/beta_function.tcc" 3
+    template<typename _Tp>
+    _Tp
+    __beta_product(_Tp __x, _Tp __y)
+    {
+
+      _Tp __bet = (__x + __y) / (__x * __y);
+
+      unsigned int __max_iter = 1000000;
+      for (unsigned int __k = 1; __k < __max_iter; ++__k)
+        {
+          _Tp __term = (_Tp(1) + (__x + __y) / __k)
+                     / ((_Tp(1) + __x / __k) * (_Tp(1) + __y / __k));
+          __bet *= __term;
+        }
+
+      return __bet;
+    }
+# 189 "/usr/include/c++/10.2.0/tr1/beta_function.tcc" 3
+    template<typename _Tp>
+    inline _Tp
+    __beta(_Tp __x, _Tp __y)
+    {
+      if (__isnan(__x) || __isnan(__y))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else
+        return __beta_lgamma(__x, __y);
+    }
+  }
+#undef _GLIBCXX_MATH_NS
+
+
+
+
+
+}
+# 52 "/usr/include/c++/10.2.0/bits/specfun.h" 2 3
+# 1 "/usr/include/c++/10.2.0/tr1/ell_integral.tcc" 1 3
+# 43 "/usr/include/c++/10.2.0/tr1/ell_integral.tcc" 3
+#define _GLIBCXX_TR1_ELL_INTEGRAL_TCC 1
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 59 "/usr/include/c++/10.2.0/tr1/ell_integral.tcc" 3
+  namespace __detail
+  {
+# 76 "/usr/include/c++/10.2.0/tr1/ell_integral.tcc" 3
+    template<typename _Tp>
+    _Tp
+    __ellint_rf(_Tp __x, _Tp __y, _Tp __z)
+    {
+      const _Tp __min = std::numeric_limits<_Tp>::min();
+      const _Tp __max = std::numeric_limits<_Tp>::max();
+      const _Tp __lolim = _Tp(5) * __min;
+      const _Tp __uplim = __max / _Tp(5);
+
+      if (__x < _Tp(0) || __y < _Tp(0) || __z < _Tp(0))
+        std::__throw_domain_error(("Argument less than zero " "in __ellint_rf.")
+                                                        );
+      else if (__x + __y < __lolim || __x + __z < __lolim
+            || __y + __z < __lolim)
+        std::__throw_domain_error(("Argument too small in __ellint_rf"));
+      else
+        {
+          const _Tp __c0 = _Tp(1) / _Tp(4);
+          const _Tp __c1 = _Tp(1) / _Tp(24);
+          const _Tp __c2 = _Tp(1) / _Tp(10);
+          const _Tp __c3 = _Tp(3) / _Tp(44);
+          const _Tp __c4 = _Tp(1) / _Tp(14);
+
+          _Tp __xn = __x;
+          _Tp __yn = __y;
+          _Tp __zn = __z;
+
+          const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
+          const _Tp __errtol = std::pow(__eps, _Tp(1) / _Tp(6));
+          _Tp __mu;
+          _Tp __xndev, __yndev, __zndev;
+
+          const unsigned int __max_iter = 100;
+          for (unsigned int __iter = 0; __iter < __max_iter; ++__iter)
+            {
+              __mu = (__xn + __yn + __zn) / _Tp(3);
+              __xndev = 2 - (__mu + __xn) / __mu;
+              __yndev = 2 - (__mu + __yn) / __mu;
+              __zndev = 2 - (__mu + __zn) / __mu;
+              _Tp __epsilon = std::max(std::abs(__xndev), std::abs(__yndev));
+              __epsilon = std::max(__epsilon, std::abs(__zndev));
+              if (__epsilon < __errtol)
+                break;
+              const _Tp __xnroot = std::sqrt(__xn);
+              const _Tp __ynroot = std::sqrt(__yn);
+              const _Tp __znroot = std::sqrt(__zn);
+              const _Tp __lambda = __xnroot * (__ynroot + __znroot)
+                                 + __ynroot * __znroot;
+              __xn = __c0 * (__xn + __lambda);
+              __yn = __c0 * (__yn + __lambda);
+              __zn = __c0 * (__zn + __lambda);
+            }
+
+          const _Tp __e2 = __xndev * __yndev - __zndev * __zndev;
+          const _Tp __e3 = __xndev * __yndev * __zndev;
+          const _Tp __s = _Tp(1) + (__c1 * __e2 - __c2 - __c3 * __e3) * __e2
+                   + __c4 * __e3;
+
+          return __s / std::sqrt(__mu);
+        }
+    }
+# 155 "/usr/include/c++/10.2.0/tr1/ell_integral.tcc" 3
+    template<typename _Tp>
+    _Tp
+    __comp_ellint_1_series(_Tp __k)
+    {
+
+      const _Tp __kk = __k * __k;
+
+      _Tp __term = __kk / _Tp(4);
+      _Tp __sum = _Tp(1) + __term;
+
+      const unsigned int __max_iter = 1000;
+      for (unsigned int __i = 2; __i < __max_iter; ++__i)
+        {
+          __term *= (2 * __i - 1) * __kk / (2 * __i);
+          if (__term < std::numeric_limits<_Tp>::epsilon())
+            break;
+          __sum += __term;
+        }
+
+      return __numeric_constants<_Tp>::__pi_2() * __sum;
+    }
+# 193 "/usr/include/c++/10.2.0/tr1/ell_integral.tcc" 3
+    template<typename _Tp>
+    _Tp
+    __comp_ellint_1(_Tp __k)
+    {
+
+      if (__isnan(__k))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (std::abs(__k) >= _Tp(1))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else
+        return __ellint_rf(_Tp(0), _Tp(1) - __k * __k, _Tp(1));
+    }
+# 221 "/usr/include/c++/10.2.0/tr1/ell_integral.tcc" 3
+    template<typename _Tp>
+    _Tp
+    __ellint_1(_Tp __k, _Tp __phi)
+    {
+
+      if (__isnan(__k) || __isnan(__phi))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (std::abs(__k) > _Tp(1))
+        std::__throw_domain_error(("Bad argument in __ellint_1."));
+      else
+        {
+
+          const int __n = std::floor(__phi / __numeric_constants<_Tp>::__pi()
+                                   + _Tp(0.5L));
+          const _Tp __phi_red = __phi
+                              - __n * __numeric_constants<_Tp>::__pi();
+
+          const _Tp __s = std::sin(__phi_red);
+          const _Tp __c = std::cos(__phi_red);
+
+          const _Tp __F = __s
+                        * __ellint_rf(__c * __c,
+                                _Tp(1) - __k * __k * __s * __s, _Tp(1));
+
+          if (__n == 0)
+            return __F;
+          else
+            return __F + _Tp(2) * __n * __comp_ellint_1(__k);
+        }
+    }
+# 268 "/usr/include/c++/10.2.0/tr1/ell_integral.tcc" 3
+    template<typename _Tp>
+    _Tp
+    __comp_ellint_2_series(_Tp __k)
+    {
+
+      const _Tp __kk = __k * __k;
+
+      _Tp __term = __kk;
+      _Tp __sum = __term;
+
+      const unsigned int __max_iter = 1000;
+      for (unsigned int __i = 2; __i < __max_iter; ++__i)
+        {
+          const _Tp __i2m = 2 * __i - 1;
+          const _Tp __i2 = 2 * __i;
+          __term *= __i2m * __i2m * __kk / (__i2 * __i2);
+          if (__term < std::numeric_limits<_Tp>::epsilon())
+            break;
+          __sum += __term / __i2m;
+        }
+
+      return __numeric_constants<_Tp>::__pi_2() * (_Tp(1) - __sum);
+    }
+# 316 "/usr/include/c++/10.2.0/tr1/ell_integral.tcc" 3
+    template<typename _Tp>
+    _Tp
+    __ellint_rd(_Tp __x, _Tp __y, _Tp __z)
+    {
+      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
+      const _Tp __errtol = std::pow(__eps / _Tp(8), _Tp(1) / _Tp(6));
+      const _Tp __min = std::numeric_limits<_Tp>::min();
+      const _Tp __max = std::numeric_limits<_Tp>::max();
+      const _Tp __lolim = _Tp(2) / std::pow(__max, _Tp(2) / _Tp(3));
+      const _Tp __uplim = std::pow(_Tp(0.1L) * __errtol / __min, _Tp(2) / _Tp(3));
+
+      if (__x < _Tp(0) || __y < _Tp(0))
+        std::__throw_domain_error(("Argument less than zero " "in __ellint_rd.")
+                                                        );
+      else if (__x + __y < __lolim || __z < __lolim)
+        std::__throw_domain_error(("Argument too small " "in __ellint_rd.")
+                                                        );
+      else
+        {
+          const _Tp __c0 = _Tp(1) / _Tp(4);
+          const _Tp __c1 = _Tp(3) / _Tp(14);
+          const _Tp __c2 = _Tp(1) / _Tp(6);
+          const _Tp __c3 = _Tp(9) / _Tp(22);
+          const _Tp __c4 = _Tp(3) / _Tp(26);
+
+          _Tp __xn = __x;
+          _Tp __yn = __y;
+          _Tp __zn = __z;
+          _Tp __sigma = _Tp(0);
+          _Tp __power4 = _Tp(1);
+
+          _Tp __mu;
+          _Tp __xndev, __yndev, __zndev;
+
+          const unsigned int __max_iter = 100;
+          for (unsigned int __iter = 0; __iter < __max_iter; ++__iter)
+            {
+              __mu = (__xn + __yn + _Tp(3) * __zn) / _Tp(5);
+              __xndev = (__mu - __xn) / __mu;
+              __yndev = (__mu - __yn) / __mu;
+              __zndev = (__mu - __zn) / __mu;
+              _Tp __epsilon = std::max(std::abs(__xndev), std::abs(__yndev));
+              __epsilon = std::max(__epsilon, std::abs(__zndev));
+              if (__epsilon < __errtol)
+                break;
+              _Tp __xnroot = std::sqrt(__xn);
+              _Tp __ynroot = std::sqrt(__yn);
+              _Tp __znroot = std::sqrt(__zn);
+              _Tp __lambda = __xnroot * (__ynroot + __znroot)
+                           + __ynroot * __znroot;
+              __sigma += __power4 / (__znroot * (__zn + __lambda));
+              __power4 *= __c0;
+              __xn = __c0 * (__xn + __lambda);
+              __yn = __c0 * (__yn + __lambda);
+              __zn = __c0 * (__zn + __lambda);
+            }
+
+          _Tp __ea = __xndev * __yndev;
+          _Tp __eb = __zndev * __zndev;
+          _Tp __ec = __ea - __eb;
+          _Tp __ed = __ea - _Tp(6) * __eb;
+          _Tp __ef = __ed + __ec + __ec;
+          _Tp __s1 = __ed * (-__c1 + __c3 * __ed
+                                   / _Tp(3) - _Tp(3) * __c4 * __zndev * __ef
+                                   / _Tp(2));
+          _Tp __s2 = __zndev
+                   * (__c2 * __ef
+                    + __zndev * (-__c3 * __ec - __zndev * __c4 - __ea));
+
+          return _Tp(3) * __sigma + __power4 * (_Tp(1) + __s1 + __s2)
+                                        / (__mu * std::sqrt(__mu));
+        }
+    }
+# 403 "/usr/include/c++/10.2.0/tr1/ell_integral.tcc" 3
+    template<typename _Tp>
+    _Tp
+    __comp_ellint_2(_Tp __k)
+    {
+
+      if (__isnan(__k))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (std::abs(__k) == 1)
+        return _Tp(1);
+      else if (std::abs(__k) > _Tp(1))
+        std::__throw_domain_error(("Bad argument in __comp_ellint_2."));
+      else
+        {
+          const _Tp __kk = __k * __k;
+
+          return __ellint_rf(_Tp(0), _Tp(1) - __kk, _Tp(1))
+               - __kk * __ellint_rd(_Tp(0), _Tp(1) - __kk, _Tp(1)) / _Tp(3);
+        }
+    }
+# 437 "/usr/include/c++/10.2.0/tr1/ell_integral.tcc" 3
+    template<typename _Tp>
+    _Tp
+    __ellint_2(_Tp __k, _Tp __phi)
+    {
+
+      if (__isnan(__k) || __isnan(__phi))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (std::abs(__k) > _Tp(1))
+        std::__throw_domain_error(("Bad argument in __ellint_2."));
+      else
+        {
+
+          const int __n = std::floor(__phi / __numeric_constants<_Tp>::__pi()
+                                   + _Tp(0.5L));
+          const _Tp __phi_red = __phi
+                              - __n * __numeric_constants<_Tp>::__pi();
+
+          const _Tp __kk = __k * __k;
+          const _Tp __s = std::sin(__phi_red);
+          const _Tp __ss = __s * __s;
+          const _Tp __sss = __ss * __s;
+          const _Tp __c = std::cos(__phi_red);
+          const _Tp __cc = __c * __c;
+
+          const _Tp __E = __s
+                        * __ellint_rf(__cc, _Tp(1) - __kk * __ss, _Tp(1))
+                        - __kk * __sss
+                        * __ellint_rd(__cc, _Tp(1) - __kk * __ss, _Tp(1))
+                        / _Tp(3);
+
+          if (__n == 0)
+            return __E;
+          else
+            return __E + _Tp(2) * __n * __comp_ellint_2(__k);
+        }
+    }
+# 496 "/usr/include/c++/10.2.0/tr1/ell_integral.tcc" 3
+    template<typename _Tp>
+    _Tp
+    __ellint_rc(_Tp __x, _Tp __y)
+    {
+      const _Tp __min = std::numeric_limits<_Tp>::min();
+      const _Tp __max = std::numeric_limits<_Tp>::max();
+      const _Tp __lolim = _Tp(5) * __min;
+      const _Tp __uplim = __max / _Tp(5);
+
+      if (__x < _Tp(0) || __y < _Tp(0) || __x + __y < __lolim)
+        std::__throw_domain_error(("Argument less than zero " "in __ellint_rc.")
+                                                        );
+      else
+        {
+          const _Tp __c0 = _Tp(1) / _Tp(4);
+          const _Tp __c1 = _Tp(1) / _Tp(7);
+          const _Tp __c2 = _Tp(9) / _Tp(22);
+          const _Tp __c3 = _Tp(3) / _Tp(10);
+          const _Tp __c4 = _Tp(3) / _Tp(8);
+
+          _Tp __xn = __x;
+          _Tp __yn = __y;
+
+          const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
+          const _Tp __errtol = std::pow(__eps / _Tp(30), _Tp(1) / _Tp(6));
+          _Tp __mu;
+          _Tp __sn;
+
+          const unsigned int __max_iter = 100;
+          for (unsigned int __iter = 0; __iter < __max_iter; ++__iter)
+            {
+              __mu = (__xn + _Tp(2) * __yn) / _Tp(3);
+              __sn = (__yn + __mu) / __mu - _Tp(2);
+              if (std::abs(__sn) < __errtol)
+                break;
+              const _Tp __lambda = _Tp(2) * std::sqrt(__xn) * std::sqrt(__yn)
+                             + __yn;
+              __xn = __c0 * (__xn + __lambda);
+              __yn = __c0 * (__yn + __lambda);
+            }
+
+          _Tp __s = __sn * __sn
+                  * (__c3 + __sn*(__c1 + __sn * (__c4 + __sn * __c2)));
+
+          return (_Tp(1) + __s) / std::sqrt(__mu);
+        }
+    }
+# 567 "/usr/include/c++/10.2.0/tr1/ell_integral.tcc" 3
+    template<typename _Tp>
+    _Tp
+    __ellint_rj(_Tp __x, _Tp __y, _Tp __z, _Tp __p)
+    {
+      const _Tp __min = std::numeric_limits<_Tp>::min();
+      const _Tp __max = std::numeric_limits<_Tp>::max();
+      const _Tp __lolim = std::pow(_Tp(5) * __min, _Tp(1)/_Tp(3));
+      const _Tp __uplim = _Tp(0.3L)
+                        * std::pow(_Tp(0.2L) * __max, _Tp(1)/_Tp(3));
+
+      if (__x < _Tp(0) || __y < _Tp(0) || __z < _Tp(0))
+        std::__throw_domain_error(("Argument less than zero " "in __ellint_rj.")
+                                                        );
+      else if (__x + __y < __lolim || __x + __z < __lolim
+            || __y + __z < __lolim || __p < __lolim)
+        std::__throw_domain_error(("Argument too small " "in __ellint_rj")
+                                                       );
+      else
+        {
+          const _Tp __c0 = _Tp(1) / _Tp(4);
+          const _Tp __c1 = _Tp(3) / _Tp(14);
+          const _Tp __c2 = _Tp(1) / _Tp(3);
+          const _Tp __c3 = _Tp(3) / _Tp(22);
+          const _Tp __c4 = _Tp(3) / _Tp(26);
+
+          _Tp __xn = __x;
+          _Tp __yn = __y;
+          _Tp __zn = __z;
+          _Tp __pn = __p;
+          _Tp __sigma = _Tp(0);
+          _Tp __power4 = _Tp(1);
+
+          const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
+          const _Tp __errtol = std::pow(__eps / _Tp(8), _Tp(1) / _Tp(6));
+
+          _Tp __lambda, __mu;
+          _Tp __xndev, __yndev, __zndev, __pndev;
+
+          const unsigned int __max_iter = 100;
+          for (unsigned int __iter = 0; __iter < __max_iter; ++__iter)
+            {
+              __mu = (__xn + __yn + __zn + _Tp(2) * __pn) / _Tp(5);
+              __xndev = (__mu - __xn) / __mu;
+              __yndev = (__mu - __yn) / __mu;
+              __zndev = (__mu - __zn) / __mu;
+              __pndev = (__mu - __pn) / __mu;
+              _Tp __epsilon = std::max(std::abs(__xndev), std::abs(__yndev));
+              __epsilon = std::max(__epsilon, std::abs(__zndev));
+              __epsilon = std::max(__epsilon, std::abs(__pndev));
+              if (__epsilon < __errtol)
+                break;
+              const _Tp __xnroot = std::sqrt(__xn);
+              const _Tp __ynroot = std::sqrt(__yn);
+              const _Tp __znroot = std::sqrt(__zn);
+              const _Tp __lambda = __xnroot * (__ynroot + __znroot)
+                                 + __ynroot * __znroot;
+              const _Tp __alpha1 = __pn * (__xnroot + __ynroot + __znroot)
+                                + __xnroot * __ynroot * __znroot;
+              const _Tp __alpha2 = __alpha1 * __alpha1;
+              const _Tp __beta = __pn * (__pn + __lambda)
+                                      * (__pn + __lambda);
+              __sigma += __power4 * __ellint_rc(__alpha2, __beta);
+              __power4 *= __c0;
+              __xn = __c0 * (__xn + __lambda);
+              __yn = __c0 * (__yn + __lambda);
+              __zn = __c0 * (__zn + __lambda);
+              __pn = __c0 * (__pn + __lambda);
+            }
+
+          _Tp __ea = __xndev * (__yndev + __zndev) + __yndev * __zndev;
+          _Tp __eb = __xndev * __yndev * __zndev;
+          _Tp __ec = __pndev * __pndev;
+          _Tp __e2 = __ea - _Tp(3) * __ec;
+          _Tp __e3 = __eb + _Tp(2) * __pndev * (__ea - __ec);
+          _Tp __s1 = _Tp(1) + __e2 * (-__c1 + _Tp(3) * __c3 * __e2 / _Tp(4)
+                            - _Tp(3) * __c4 * __e3 / _Tp(2));
+          _Tp __s2 = __eb * (__c2 / _Tp(2)
+                   + __pndev * (-__c3 - __c3 + __pndev * __c4));
+          _Tp __s3 = __pndev * __ea * (__c2 - __pndev * __c3)
+                   - __c2 * __pndev * __ec;
+
+          return _Tp(3) * __sigma + __power4 * (__s1 + __s2 + __s3)
+                                             / (__mu * std::sqrt(__mu));
+        }
+    }
+# 670 "/usr/include/c++/10.2.0/tr1/ell_integral.tcc" 3
+    template<typename _Tp>
+    _Tp
+    __comp_ellint_3(_Tp __k, _Tp __nu)
+    {
+
+      if (__isnan(__k) || __isnan(__nu))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (__nu == _Tp(1))
+        return std::numeric_limits<_Tp>::infinity();
+      else if (std::abs(__k) > _Tp(1))
+        std::__throw_domain_error(("Bad argument in __comp_ellint_3."));
+      else
+        {
+          const _Tp __kk = __k * __k;
+
+          return __ellint_rf(_Tp(0), _Tp(1) - __kk, _Tp(1))
+               + __nu
+               * __ellint_rj(_Tp(0), _Tp(1) - __kk, _Tp(1), _Tp(1) - __nu)
+               / _Tp(3);
+        }
+    }
+# 710 "/usr/include/c++/10.2.0/tr1/ell_integral.tcc" 3
+    template<typename _Tp>
+    _Tp
+    __ellint_3(_Tp __k, _Tp __nu, _Tp __phi)
+    {
+
+      if (__isnan(__k) || __isnan(__nu) || __isnan(__phi))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (std::abs(__k) > _Tp(1))
+        std::__throw_domain_error(("Bad argument in __ellint_3."));
+      else
+        {
+
+          const int __n = std::floor(__phi / __numeric_constants<_Tp>::__pi()
+                                   + _Tp(0.5L));
+          const _Tp __phi_red = __phi
+                              - __n * __numeric_constants<_Tp>::__pi();
+
+          const _Tp __kk = __k * __k;
+          const _Tp __s = std::sin(__phi_red);
+          const _Tp __ss = __s * __s;
+          const _Tp __sss = __ss * __s;
+          const _Tp __c = std::cos(__phi_red);
+          const _Tp __cc = __c * __c;
+
+          const _Tp __Pi = __s
+                         * __ellint_rf(__cc, _Tp(1) - __kk * __ss, _Tp(1))
+                         + __nu * __sss
+                         * __ellint_rj(__cc, _Tp(1) - __kk * __ss, _Tp(1),
+                                       _Tp(1) - __nu * __ss) / _Tp(3);
+
+          if (__n == 0)
+            return __Pi;
+          else
+            return __Pi + _Tp(2) * __n * __comp_ellint_3(__k, __nu);
+        }
+    }
+  }
+
+
+
+
+
+}
+# 53 "/usr/include/c++/10.2.0/bits/specfun.h" 2 3
+# 1 "/usr/include/c++/10.2.0/tr1/exp_integral.tcc" 1 3
+# 46 "/usr/include/c++/10.2.0/tr1/exp_integral.tcc" 3
+#define _GLIBCXX_TR1_EXP_INTEGRAL_TCC 1
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 64 "/usr/include/c++/10.2.0/tr1/exp_integral.tcc" 3
+  namespace __detail
+  {
+    template<typename _Tp> _Tp __expint_E1(_Tp);
+# 81 "/usr/include/c++/10.2.0/tr1/exp_integral.tcc" 3
+    template<typename _Tp>
+    _Tp
+    __expint_E1_series(_Tp __x)
+    {
+      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
+      _Tp __term = _Tp(1);
+      _Tp __esum = _Tp(0);
+      _Tp __osum = _Tp(0);
+      const unsigned int __max_iter = 1000;
+      for (unsigned int __i = 1; __i < __max_iter; ++__i)
+        {
+          __term *= - __x / __i;
+          if (std::abs(__term) < __eps)
+            break;
+          if (__term >= _Tp(0))
+            __esum += __term / __i;
+          else
+            __osum += __term / __i;
+        }
+
+      return - __esum - __osum
+             - __numeric_constants<_Tp>::__gamma_e() - std::log(__x);
+    }
+# 118 "/usr/include/c++/10.2.0/tr1/exp_integral.tcc" 3
+    template<typename _Tp>
+    _Tp
+    __expint_E1_asymp(_Tp __x)
+    {
+      _Tp __term = _Tp(1);
+      _Tp __esum = _Tp(1);
+      _Tp __osum = _Tp(0);
+      const unsigned int __max_iter = 1000;
+      for (unsigned int __i = 1; __i < __max_iter; ++__i)
+        {
+          _Tp __prev = __term;
+          __term *= - __i / __x;
+          if (std::abs(__term) > std::abs(__prev))
+            break;
+          if (__term >= _Tp(0))
+            __esum += __term;
+          else
+            __osum += __term;
+        }
+
+      return std::exp(- __x) * (__esum + __osum) / __x;
+    }
+# 155 "/usr/include/c++/10.2.0/tr1/exp_integral.tcc" 3
+    template<typename _Tp>
+    _Tp
+    __expint_En_series(unsigned int __n, _Tp __x)
+    {
+      const unsigned int __max_iter = 1000;
+      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
+      const int __nm1 = __n - 1;
+      _Tp __ans = (__nm1 != 0
+                ? _Tp(1) / __nm1 : -std::log(__x)
+                                   - __numeric_constants<_Tp>::__gamma_e());
+      _Tp __fact = _Tp(1);
+      for (int __i = 1; __i <= __max_iter; ++__i)
+        {
+          __fact *= -__x / _Tp(__i);
+          _Tp __del;
+          if ( __i != __nm1 )
+            __del = -__fact / _Tp(__i - __nm1);
+          else
+            {
+              _Tp __psi = -__numeric_constants<_Tp>::gamma_e();
+              for (int __ii = 1; __ii <= __nm1; ++__ii)
+                __psi += _Tp(1) / _Tp(__ii);
+              __del = __fact * (__psi - std::log(__x));
+            }
+          __ans += __del;
+          if (std::abs(__del) < __eps * std::abs(__ans))
+            return __ans;
+        }
+      std::__throw_runtime_error(("Series summation failed " "in __expint_En_series.")
+                                                              );
+    }
+# 201 "/usr/include/c++/10.2.0/tr1/exp_integral.tcc" 3
+    template<typename _Tp>
+    _Tp
+    __expint_En_cont_frac(unsigned int __n, _Tp __x)
+    {
+      const unsigned int __max_iter = 1000;
+      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
+      const _Tp __fp_min = std::numeric_limits<_Tp>::min();
+      const int __nm1 = __n - 1;
+      _Tp __b = __x + _Tp(__n);
+      _Tp __c = _Tp(1) / __fp_min;
+      _Tp __d = _Tp(1) / __b;
+      _Tp __h = __d;
+      for ( unsigned int __i = 1; __i <= __max_iter; ++__i )
+        {
+          _Tp __a = -_Tp(__i * (__nm1 + __i));
+          __b += _Tp(2);
+          __d = _Tp(1) / (__a * __d + __b);
+          __c = __b + __a / __c;
+          const _Tp __del = __c * __d;
+          __h *= __del;
+          if (std::abs(__del - _Tp(1)) < __eps)
+            {
+              const _Tp __ans = __h * std::exp(-__x);
+              return __ans;
+            }
+        }
+      std::__throw_runtime_error(("Continued fraction failed " "in __expint_En_cont_frac.")
+                                                                 );
+    }
+# 246 "/usr/include/c++/10.2.0/tr1/exp_integral.tcc" 3
+    template<typename _Tp>
+    _Tp
+    __expint_En_recursion(unsigned int __n, _Tp __x)
+    {
+      _Tp __En;
+      _Tp __E1 = __expint_E1(__x);
+      if (__x < _Tp(__n))
+        {
+
+          __En = __E1;
+          for (unsigned int __j = 2; __j < __n; ++__j)
+            __En = (std::exp(-__x) - __x * __En) / _Tp(__j - 1);
+        }
+      else
+        {
+
+          __En = _Tp(1);
+          const int __N = __n + 20;
+          _Tp __save = _Tp(0);
+          for (int __j = __N; __j > 0; --__j)
+            {
+              __En = (std::exp(-__x) - __j * __En) / __x;
+              if (__j == __n)
+                __save = __En;
+            }
+            _Tp __norm = __En / __E1;
+            __En /= __norm;
+        }
+
+      return __En;
+    }
+# 290 "/usr/include/c++/10.2.0/tr1/exp_integral.tcc" 3
+    template<typename _Tp>
+    _Tp
+    __expint_Ei_series(_Tp __x)
+    {
+      _Tp __term = _Tp(1);
+      _Tp __sum = _Tp(0);
+      const unsigned int __max_iter = 1000;
+      for (unsigned int __i = 1; __i < __max_iter; ++__i)
+        {
+          __term *= __x / __i;
+          __sum += __term / __i;
+          if (__term < std::numeric_limits<_Tp>::epsilon() * __sum)
+            break;
+        }
+
+      return __numeric_constants<_Tp>::__gamma_e() + __sum + std::log(__x);
+    }
+# 321 "/usr/include/c++/10.2.0/tr1/exp_integral.tcc" 3
+    template<typename _Tp>
+    _Tp
+    __expint_Ei_asymp(_Tp __x)
+    {
+      _Tp __term = _Tp(1);
+      _Tp __sum = _Tp(1);
+      const unsigned int __max_iter = 1000;
+      for (unsigned int __i = 1; __i < __max_iter; ++__i)
+        {
+          _Tp __prev = __term;
+          __term *= __i / __x;
+          if (__term < std::numeric_limits<_Tp>::epsilon())
+            break;
+          if (__term >= __prev)
+            break;
+          __sum += __term;
+        }
+
+      return std::exp(__x) * __sum / __x;
+    }
+# 354 "/usr/include/c++/10.2.0/tr1/exp_integral.tcc" 3
+    template<typename _Tp>
+    _Tp
+    __expint_Ei(_Tp __x)
+    {
+      if (__x < _Tp(0))
+        return -__expint_E1(-__x);
+      else if (__x < -std::log(std::numeric_limits<_Tp>::epsilon()))
+        return __expint_Ei_series(__x);
+      else
+        return __expint_Ei_asymp(__x);
+    }
+# 378 "/usr/include/c++/10.2.0/tr1/exp_integral.tcc" 3
+    template<typename _Tp>
+    _Tp
+    __expint_E1(_Tp __x)
+    {
+      if (__x < _Tp(0))
+        return -__expint_Ei(-__x);
+      else if (__x < _Tp(1))
+        return __expint_E1_series(__x);
+      else if (__x < _Tp(100))
+        return __expint_En_cont_frac(1, __x);
+      else
+        return __expint_E1_asymp(__x);
+    }
+# 408 "/usr/include/c++/10.2.0/tr1/exp_integral.tcc" 3
+    template<typename _Tp>
+    _Tp
+    __expint_asymp(unsigned int __n, _Tp __x)
+    {
+      _Tp __term = _Tp(1);
+      _Tp __sum = _Tp(1);
+      for (unsigned int __i = 1; __i <= __n; ++__i)
+        {
+          _Tp __prev = __term;
+          __term *= -(__n - __i + 1) / __x;
+          if (std::abs(__term) > std::abs(__prev))
+            break;
+          __sum += __term;
+        }
+
+      return std::exp(-__x) * __sum / __x;
+    }
+# 442 "/usr/include/c++/10.2.0/tr1/exp_integral.tcc" 3
+    template<typename _Tp>
+    _Tp
+    __expint_large_n(unsigned int __n, _Tp __x)
+    {
+      const _Tp __xpn = __x + __n;
+      const _Tp __xpn2 = __xpn * __xpn;
+      _Tp __term = _Tp(1);
+      _Tp __sum = _Tp(1);
+      for (unsigned int __i = 1; __i <= __n; ++__i)
+        {
+          _Tp __prev = __term;
+          __term *= (__n - 2 * (__i - 1) * __x) / __xpn2;
+          if (std::abs(__term) < std::numeric_limits<_Tp>::epsilon())
+            break;
+          __sum += __term;
+        }
+
+      return std::exp(-__x) * __sum / __xpn;
+    }
+# 476 "/usr/include/c++/10.2.0/tr1/exp_integral.tcc" 3
+    template<typename _Tp>
+    _Tp
+    __expint(unsigned int __n, _Tp __x)
+    {
+
+      if (__isnan(__x))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (__n <= 1 && __x == _Tp(0))
+        return std::numeric_limits<_Tp>::infinity();
+      else
+        {
+          _Tp __E0 = std::exp(__x) / __x;
+          if (__n == 0)
+            return __E0;
+
+          _Tp __E1 = __expint_E1(__x);
+          if (__n == 1)
+            return __E1;
+
+          if (__x == _Tp(0))
+            return _Tp(1) / static_cast<_Tp>(__n - 1);
+
+          _Tp __En = __expint_En_recursion(__n, __x);
+
+          return __En;
+        }
+    }
+# 516 "/usr/include/c++/10.2.0/tr1/exp_integral.tcc" 3
+    template<typename _Tp>
+    inline _Tp
+    __expint(_Tp __x)
+    {
+      if (__isnan(__x))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else
+        return __expint_Ei(__x);
+    }
+  }
+
+
+
+
+
+}
+# 54 "/usr/include/c++/10.2.0/bits/specfun.h" 2 3
+# 1 "/usr/include/c++/10.2.0/tr1/hypergeometric.tcc" 1 3
+# 42 "/usr/include/c++/10.2.0/tr1/hypergeometric.tcc" 3
+#define _GLIBCXX_TR1_HYPERGEOMETRIC_TCC 1
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+#define _GLIBCXX_MATH_NS ::std
+# 60 "/usr/include/c++/10.2.0/tr1/hypergeometric.tcc" 3
+  namespace __detail
+  {
+# 83 "/usr/include/c++/10.2.0/tr1/hypergeometric.tcc" 3
+    template<typename _Tp>
+    _Tp
+    __conf_hyperg_series(_Tp __a, _Tp __c, _Tp __x)
+    {
+      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
+
+      _Tp __term = _Tp(1);
+      _Tp __Fac = _Tp(1);
+      const unsigned int __max_iter = 100000;
+      unsigned int __i;
+      for (__i = 0; __i < __max_iter; ++__i)
+        {
+          __term *= (__a + _Tp(__i)) * __x
+                  / ((__c + _Tp(__i)) * _Tp(1 + __i));
+          if (std::abs(__term) < __eps)
+            {
+              break;
+            }
+          __Fac += __term;
+        }
+      if (__i == __max_iter)
+        std::__throw_runtime_error(("Series failed to converge " "in __conf_hyperg_series.")
+                                                                  );
+
+      return __Fac;
+    }
+# 120 "/usr/include/c++/10.2.0/tr1/hypergeometric.tcc" 3
+    template<typename _Tp>
+    _Tp
+    __conf_hyperg_luke(_Tp __a, _Tp __c, _Tp __xin)
+    {
+      const _Tp __big = std::pow(std::numeric_limits<_Tp>::max(), _Tp(0.16L));
+      const int __nmax = 20000;
+      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
+      const _Tp __x = -__xin;
+      const _Tp __x3 = __x * __x * __x;
+      const _Tp __t0 = __a / __c;
+      const _Tp __t1 = (__a + _Tp(1)) / (_Tp(2) * __c);
+      const _Tp __t2 = (__a + _Tp(2)) / (_Tp(2) * (__c + _Tp(1)));
+      _Tp __F = _Tp(1);
+      _Tp __prec;
+
+      _Tp __Bnm3 = _Tp(1);
+      _Tp __Bnm2 = _Tp(1) + __t1 * __x;
+      _Tp __Bnm1 = _Tp(1) + __t2 * __x * (_Tp(1) + __t1 / _Tp(3) * __x);
+
+      _Tp __Anm3 = _Tp(1);
+      _Tp __Anm2 = __Bnm2 - __t0 * __x;
+      _Tp __Anm1 = __Bnm1 - __t0 * (_Tp(1) + __t2 * __x) * __x
+                 + __t0 * __t1 * (__c / (__c + _Tp(1))) * __x * __x;
+
+      int __n = 3;
+      while(1)
+        {
+          _Tp __npam1 = _Tp(__n - 1) + __a;
+          _Tp __npcm1 = _Tp(__n - 1) + __c;
+          _Tp __npam2 = _Tp(__n - 2) + __a;
+          _Tp __npcm2 = _Tp(__n - 2) + __c;
+          _Tp __tnm1 = _Tp(2 * __n - 1);
+          _Tp __tnm3 = _Tp(2 * __n - 3);
+          _Tp __tnm5 = _Tp(2 * __n - 5);
+          _Tp __F1 = (_Tp(__n - 2) - __a) / (_Tp(2) * __tnm3 * __npcm1);
+          _Tp __F2 = (_Tp(__n) + __a) * __npam1
+                   / (_Tp(4) * __tnm1 * __tnm3 * __npcm2 * __npcm1);
+          _Tp __F3 = -__npam2 * __npam1 * (_Tp(__n - 2) - __a)
+                   / (_Tp(8) * __tnm3 * __tnm3 * __tnm5
+                   * (_Tp(__n - 3) + __c) * __npcm2 * __npcm1);
+          _Tp __E = -__npam1 * (_Tp(__n - 1) - __c)
+                   / (_Tp(2) * __tnm3 * __npcm2 * __npcm1);
+
+          _Tp __An = (_Tp(1) + __F1 * __x) * __Anm1
+                   + (__E + __F2 * __x) * __x * __Anm2 + __F3 * __x3 * __Anm3;
+          _Tp __Bn = (_Tp(1) + __F1 * __x) * __Bnm1
+                   + (__E + __F2 * __x) * __x * __Bnm2 + __F3 * __x3 * __Bnm3;
+          _Tp __r = __An / __Bn;
+
+          __prec = std::abs((__F - __r) / __F);
+          __F = __r;
+
+          if (__prec < __eps || __n > __nmax)
+            break;
+
+          if (std::abs(__An) > __big || std::abs(__Bn) > __big)
+            {
+              __An /= __big;
+              __Bn /= __big;
+              __Anm1 /= __big;
+              __Bnm1 /= __big;
+              __Anm2 /= __big;
+              __Bnm2 /= __big;
+              __Anm3 /= __big;
+              __Bnm3 /= __big;
+            }
+          else if (std::abs(__An) < _Tp(1) / __big
+                || std::abs(__Bn) < _Tp(1) / __big)
+            {
+              __An *= __big;
+              __Bn *= __big;
+              __Anm1 *= __big;
+              __Bnm1 *= __big;
+              __Anm2 *= __big;
+              __Bnm2 *= __big;
+              __Anm3 *= __big;
+              __Bnm3 *= __big;
+            }
+
+          ++__n;
+          __Bnm3 = __Bnm2;
+          __Bnm2 = __Bnm1;
+          __Bnm1 = __Bn;
+          __Anm3 = __Anm2;
+          __Anm2 = __Anm1;
+          __Anm1 = __An;
+        }
+
+      if (__n >= __nmax)
+        std::__throw_runtime_error(("Iteration failed to converge " "in __conf_hyperg_luke.")
+                                                                );
+
+      return __F;
+    }
+# 227 "/usr/include/c++/10.2.0/tr1/hypergeometric.tcc" 3
+    template<typename _Tp>
+    _Tp
+    __conf_hyperg(_Tp __a, _Tp __c, _Tp __x)
+    {
+
+      const _Tp __c_nint = ::std::nearbyint(__c);
+
+
+
+      if (__isnan(__a) || __isnan(__c) || __isnan(__x))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (__c_nint == __c && __c_nint <= 0)
+        return std::numeric_limits<_Tp>::infinity();
+      else if (__a == _Tp(0))
+        return _Tp(1);
+      else if (__c == __a)
+        return std::exp(__x);
+      else if (__x < _Tp(0))
+        return __conf_hyperg_luke(__a, __c, __x);
+      else
+        return __conf_hyperg_series(__a, __c, __x);
+    }
+# 271 "/usr/include/c++/10.2.0/tr1/hypergeometric.tcc" 3
+    template<typename _Tp>
+    _Tp
+    __hyperg_series(_Tp __a, _Tp __b, _Tp __c, _Tp __x)
+    {
+      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
+
+      _Tp __term = _Tp(1);
+      _Tp __Fabc = _Tp(1);
+      const unsigned int __max_iter = 100000;
+      unsigned int __i;
+      for (__i = 0; __i < __max_iter; ++__i)
+        {
+          __term *= (__a + _Tp(__i)) * (__b + _Tp(__i)) * __x
+                  / ((__c + _Tp(__i)) * _Tp(1 + __i));
+          if (std::abs(__term) < __eps)
+            {
+              break;
+            }
+          __Fabc += __term;
+        }
+      if (__i == __max_iter)
+        std::__throw_runtime_error(("Series failed to converge " "in __hyperg_series.")
+                                                             );
+
+      return __Fabc;
+    }
+
+
+
+
+
+
+
+    template<typename _Tp>
+    _Tp
+    __hyperg_luke(_Tp __a, _Tp __b, _Tp __c, _Tp __xin)
+    {
+      const _Tp __big = std::pow(std::numeric_limits<_Tp>::max(), _Tp(0.16L));
+      const int __nmax = 20000;
+      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
+      const _Tp __x = -__xin;
+      const _Tp __x3 = __x * __x * __x;
+      const _Tp __t0 = __a * __b / __c;
+      const _Tp __t1 = (__a + _Tp(1)) * (__b + _Tp(1)) / (_Tp(2) * __c);
+      const _Tp __t2 = (__a + _Tp(2)) * (__b + _Tp(2))
+                     / (_Tp(2) * (__c + _Tp(1)));
+
+      _Tp __F = _Tp(1);
+
+      _Tp __Bnm3 = _Tp(1);
+      _Tp __Bnm2 = _Tp(1) + __t1 * __x;
+      _Tp __Bnm1 = _Tp(1) + __t2 * __x * (_Tp(1) + __t1 / _Tp(3) * __x);
+
+      _Tp __Anm3 = _Tp(1);
+      _Tp __Anm2 = __Bnm2 - __t0 * __x;
+      _Tp __Anm1 = __Bnm1 - __t0 * (_Tp(1) + __t2 * __x) * __x
+                 + __t0 * __t1 * (__c / (__c + _Tp(1))) * __x * __x;
+
+      int __n = 3;
+      while (1)
+        {
+          const _Tp __npam1 = _Tp(__n - 1) + __a;
+          const _Tp __npbm1 = _Tp(__n - 1) + __b;
+          const _Tp __npcm1 = _Tp(__n - 1) + __c;
+          const _Tp __npam2 = _Tp(__n - 2) + __a;
+          const _Tp __npbm2 = _Tp(__n - 2) + __b;
+          const _Tp __npcm2 = _Tp(__n - 2) + __c;
+          const _Tp __tnm1 = _Tp(2 * __n - 1);
+          const _Tp __tnm3 = _Tp(2 * __n - 3);
+          const _Tp __tnm5 = _Tp(2 * __n - 5);
+          const _Tp __n2 = __n * __n;
+          const _Tp __F1 = (_Tp(3) * __n2 + (__a + __b - _Tp(6)) * __n
+                         + _Tp(2) - __a * __b - _Tp(2) * (__a + __b))
+                         / (_Tp(2) * __tnm3 * __npcm1);
+          const _Tp __F2 = -(_Tp(3) * __n2 - (__a + __b + _Tp(6)) * __n
+                         + _Tp(2) - __a * __b) * __npam1 * __npbm1
+                         / (_Tp(4) * __tnm1 * __tnm3 * __npcm2 * __npcm1);
+          const _Tp __F3 = (__npam2 * __npam1 * __npbm2 * __npbm1
+                         * (_Tp(__n - 2) - __a) * (_Tp(__n - 2) - __b))
+                         / (_Tp(8) * __tnm3 * __tnm3 * __tnm5
+                         * (_Tp(__n - 3) + __c) * __npcm2 * __npcm1);
+          const _Tp __E = -__npam1 * __npbm1 * (_Tp(__n - 1) - __c)
+                         / (_Tp(2) * __tnm3 * __npcm2 * __npcm1);
+
+          _Tp __An = (_Tp(1) + __F1 * __x) * __Anm1
+                   + (__E + __F2 * __x) * __x * __Anm2 + __F3 * __x3 * __Anm3;
+          _Tp __Bn = (_Tp(1) + __F1 * __x) * __Bnm1
+                   + (__E + __F2 * __x) * __x * __Bnm2 + __F3 * __x3 * __Bnm3;
+          const _Tp __r = __An / __Bn;
+
+          const _Tp __prec = std::abs((__F - __r) / __F);
+          __F = __r;
+
+          if (__prec < __eps || __n > __nmax)
+            break;
+
+          if (std::abs(__An) > __big || std::abs(__Bn) > __big)
+            {
+              __An /= __big;
+              __Bn /= __big;
+              __Anm1 /= __big;
+              __Bnm1 /= __big;
+              __Anm2 /= __big;
+              __Bnm2 /= __big;
+              __Anm3 /= __big;
+              __Bnm3 /= __big;
+            }
+          else if (std::abs(__An) < _Tp(1) / __big
+                || std::abs(__Bn) < _Tp(1) / __big)
+            {
+              __An *= __big;
+              __Bn *= __big;
+              __Anm1 *= __big;
+              __Bnm1 *= __big;
+              __Anm2 *= __big;
+              __Bnm2 *= __big;
+              __Anm3 *= __big;
+              __Bnm3 *= __big;
+            }
+
+          ++__n;
+          __Bnm3 = __Bnm2;
+          __Bnm2 = __Bnm1;
+          __Bnm1 = __Bn;
+          __Anm3 = __Anm2;
+          __Anm2 = __Anm1;
+          __Anm1 = __An;
+        }
+
+      if (__n >= __nmax)
+        std::__throw_runtime_error(("Iteration failed to converge " "in __hyperg_luke.")
+                                                           );
+
+      return __F;
+    }
+# 438 "/usr/include/c++/10.2.0/tr1/hypergeometric.tcc" 3
+    template<typename _Tp>
+    _Tp
+    __hyperg_reflect(_Tp __a, _Tp __b, _Tp __c, _Tp __x)
+    {
+      const _Tp __d = __c - __a - __b;
+      const int __intd = std::floor(__d + _Tp(0.5L));
+      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
+      const _Tp __toler = _Tp(1000) * __eps;
+      const _Tp __log_max = std::log(std::numeric_limits<_Tp>::max());
+      const bool __d_integer = (std::abs(__d - __intd) < __toler);
+
+      if (__d_integer)
+        {
+          const _Tp __ln_omx = std::log(_Tp(1) - __x);
+          const _Tp __ad = std::abs(__d);
+          _Tp __F1, __F2;
+
+          _Tp __d1, __d2;
+          if (__d >= _Tp(0))
+            {
+              __d1 = __d;
+              __d2 = _Tp(0);
+            }
+          else
+            {
+              __d1 = _Tp(0);
+              __d2 = __d;
+            }
+
+          const _Tp __lng_c = __log_gamma(__c);
+
+
+          if (__ad < __eps)
+            {
+
+              __F1 = _Tp(0);
+            }
+          else
+            {
+
+              bool __ok_d1 = true;
+              _Tp __lng_ad, __lng_ad1, __lng_bd1;
+              try
+                {
+                  __lng_ad = __log_gamma(__ad);
+                  __lng_ad1 = __log_gamma(__a + __d1);
+                  __lng_bd1 = __log_gamma(__b + __d1);
+                }
+              catch(...)
+                {
+                  __ok_d1 = false;
+                }
+
+              if (__ok_d1)
+                {
+
+
+
+                  _Tp __sum1 = _Tp(1);
+                  _Tp __term = _Tp(1);
+                  _Tp __ln_pre1 = __lng_ad + __lng_c + __d2 * __ln_omx
+                                - __lng_ad1 - __lng_bd1;
+
+
+
+                  for (int __i = 1; __i < __ad; ++__i)
+                    {
+                      const int __j = __i - 1;
+                      __term *= (__a + __d2 + __j) * (__b + __d2 + __j)
+                              / (_Tp(1) + __d2 + __j) / __i * (_Tp(1) - __x);
+                      __sum1 += __term;
+                    }
+
+                  if (__ln_pre1 > __log_max)
+                    std::__throw_runtime_error(("Overflow of gamma functions" " in __hyperg_luke.")
+                                                                        );
+                  else
+                    __F1 = std::exp(__ln_pre1) * __sum1;
+                }
+              else
+                {
+
+
+                  __F1 = _Tp(0);
+                }
+            }
+
+
+          bool __ok_d2 = true;
+          _Tp __lng_ad2, __lng_bd2;
+          try
+            {
+              __lng_ad2 = __log_gamma(__a + __d2);
+              __lng_bd2 = __log_gamma(__b + __d2);
+            }
+          catch(...)
+            {
+              __ok_d2 = false;
+            }
+
+          if (__ok_d2)
+            {
+
+
+              const int __maxiter = 2000;
+              const _Tp __psi_1 = -__numeric_constants<_Tp>::__gamma_e();
+              const _Tp __psi_1pd = __psi(_Tp(1) + __ad);
+              const _Tp __psi_apd1 = __psi(__a + __d1);
+              const _Tp __psi_bpd1 = __psi(__b + __d1);
+
+              _Tp __psi_term = __psi_1 + __psi_1pd - __psi_apd1
+                             - __psi_bpd1 - __ln_omx;
+              _Tp __fact = _Tp(1);
+              _Tp __sum2 = __psi_term;
+              _Tp __ln_pre2 = __lng_c + __d1 * __ln_omx
+                            - __lng_ad2 - __lng_bd2;
+
+
+              int __j;
+              for (__j = 1; __j < __maxiter; ++__j)
+                {
+
+
+                  const _Tp __term1 = _Tp(1) / _Tp(__j)
+                                    + _Tp(1) / (__ad + __j);
+                  const _Tp __term2 = _Tp(1) / (__a + __d1 + _Tp(__j - 1))
+                                    + _Tp(1) / (__b + __d1 + _Tp(__j - 1));
+                  __psi_term += __term1 - __term2;
+                  __fact *= (__a + __d1 + _Tp(__j - 1))
+                          * (__b + __d1 + _Tp(__j - 1))
+                          / ((__ad + __j) * __j) * (_Tp(1) - __x);
+                  const _Tp __delta = __fact * __psi_term;
+                  __sum2 += __delta;
+                  if (std::abs(__delta) < __eps * std::abs(__sum2))
+                    break;
+                }
+              if (__j == __maxiter)
+                std::__throw_runtime_error(("Sum F2 failed to converge " "in __hyperg_reflect")
+                                                                     );
+
+              if (__sum2 == _Tp(0))
+                __F2 = _Tp(0);
+              else
+                __F2 = std::exp(__ln_pre2) * __sum2;
+            }
+          else
+            {
+
+
+              __F2 = _Tp(0);
+            }
+
+          const _Tp __sgn_2 = (__intd % 2 == 1 ? -_Tp(1) : _Tp(1));
+          const _Tp __F = __F1 + __sgn_2 * __F2;
+
+          return __F;
+        }
+      else
+        {
+
+
+
+
+          bool __ok1 = true;
+          _Tp __sgn_g1ca = _Tp(0), __ln_g1ca = _Tp(0);
+          _Tp __sgn_g1cb = _Tp(0), __ln_g1cb = _Tp(0);
+          try
+            {
+              __sgn_g1ca = __log_gamma_sign(__c - __a);
+              __ln_g1ca = __log_gamma(__c - __a);
+              __sgn_g1cb = __log_gamma_sign(__c - __b);
+              __ln_g1cb = __log_gamma(__c - __b);
+            }
+          catch(...)
+            {
+              __ok1 = false;
+            }
+
+          bool __ok2 = true;
+          _Tp __sgn_g2a = _Tp(0), __ln_g2a = _Tp(0);
+          _Tp __sgn_g2b = _Tp(0), __ln_g2b = _Tp(0);
+          try
+            {
+              __sgn_g2a = __log_gamma_sign(__a);
+              __ln_g2a = __log_gamma(__a);
+              __sgn_g2b = __log_gamma_sign(__b);
+              __ln_g2b = __log_gamma(__b);
+            }
+          catch(...)
+            {
+              __ok2 = false;
+            }
+
+          const _Tp __sgn_gc = __log_gamma_sign(__c);
+          const _Tp __ln_gc = __log_gamma(__c);
+          const _Tp __sgn_gd = __log_gamma_sign(__d);
+          const _Tp __ln_gd = __log_gamma(__d);
+          const _Tp __sgn_gmd = __log_gamma_sign(-__d);
+          const _Tp __ln_gmd = __log_gamma(-__d);
+
+          const _Tp __sgn1 = __sgn_gc * __sgn_gd * __sgn_g1ca * __sgn_g1cb;
+          const _Tp __sgn2 = __sgn_gc * __sgn_gmd * __sgn_g2a * __sgn_g2b;
+
+          _Tp __pre1, __pre2;
+          if (__ok1 && __ok2)
+            {
+              _Tp __ln_pre1 = __ln_gc + __ln_gd - __ln_g1ca - __ln_g1cb;
+              _Tp __ln_pre2 = __ln_gc + __ln_gmd - __ln_g2a - __ln_g2b
+                            + __d * std::log(_Tp(1) - __x);
+              if (__ln_pre1 < __log_max && __ln_pre2 < __log_max)
+                {
+                  __pre1 = std::exp(__ln_pre1);
+                  __pre2 = std::exp(__ln_pre2);
+                  __pre1 *= __sgn1;
+                  __pre2 *= __sgn2;
+                }
+              else
+                {
+                  std::__throw_runtime_error(("Overflow of gamma functions " "in __hyperg_reflect")
+                                                                       );
+                }
+            }
+          else if (__ok1 && !__ok2)
+            {
+              _Tp __ln_pre1 = __ln_gc + __ln_gd - __ln_g1ca - __ln_g1cb;
+              if (__ln_pre1 < __log_max)
+                {
+                  __pre1 = std::exp(__ln_pre1);
+                  __pre1 *= __sgn1;
+                  __pre2 = _Tp(0);
+                }
+              else
+                {
+                  std::__throw_runtime_error(("Overflow of gamma functions " "in __hyperg_reflect")
+                                                                       );
+                }
+            }
+          else if (!__ok1 && __ok2)
+            {
+              _Tp __ln_pre2 = __ln_gc + __ln_gmd - __ln_g2a - __ln_g2b
+                            + __d * std::log(_Tp(1) - __x);
+              if (__ln_pre2 < __log_max)
+                {
+                  __pre1 = _Tp(0);
+                  __pre2 = std::exp(__ln_pre2);
+                  __pre2 *= __sgn2;
+                }
+              else
+                {
+                  std::__throw_runtime_error(("Overflow of gamma functions " "in __hyperg_reflect")
+                                                                       );
+                }
+            }
+          else
+            {
+              __pre1 = _Tp(0);
+              __pre2 = _Tp(0);
+              std::__throw_runtime_error(("Underflow of gamma functions " "in __hyperg_reflect")
+                                                                   );
+            }
+
+          const _Tp __F1 = __hyperg_series(__a, __b, _Tp(1) - __d,
+                                           _Tp(1) - __x);
+          const _Tp __F2 = __hyperg_series(__c - __a, __c - __b, _Tp(1) + __d,
+                                           _Tp(1) - __x);
+
+          const _Tp __F = __pre1 * __F1 + __pre2 * __F2;
+
+          return __F;
+        }
+    }
+# 728 "/usr/include/c++/10.2.0/tr1/hypergeometric.tcc" 3
+    template<typename _Tp>
+    _Tp
+    __hyperg(_Tp __a, _Tp __b, _Tp __c, _Tp __x)
+    {
+
+      const _Tp __a_nint = ::std::nearbyint(__a);
+      const _Tp __b_nint = ::std::nearbyint(__b);
+      const _Tp __c_nint = ::std::nearbyint(__c);
+
+
+
+
+
+      const _Tp __toler = _Tp(1000) * std::numeric_limits<_Tp>::epsilon();
+      if (std::abs(__x) >= _Tp(1))
+        std::__throw_domain_error(("Argument outside unit circle " "in __hyperg.")
+                                                     );
+      else if (__isnan(__a) || __isnan(__b)
+            || __isnan(__c) || __isnan(__x))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (__c_nint == __c && __c_nint <= _Tp(0))
+        return std::numeric_limits<_Tp>::infinity();
+      else if (std::abs(__c - __b) < __toler || std::abs(__c - __a) < __toler)
+        return std::pow(_Tp(1) - __x, __c - __a - __b);
+      else if (__a >= _Tp(0) && __b >= _Tp(0) && __c >= _Tp(0)
+            && __x >= _Tp(0) && __x < _Tp(0.995L))
+        return __hyperg_series(__a, __b, __c, __x);
+      else if (std::abs(__a) < _Tp(10) && std::abs(__b) < _Tp(10))
+        {
+
+
+          if (__a < _Tp(0) && std::abs(__a - __a_nint) < __toler)
+            return __hyperg_series(__a_nint, __b, __c, __x);
+          else if (__b < _Tp(0) && std::abs(__b - __b_nint) < __toler)
+            return __hyperg_series(__a, __b_nint, __c, __x);
+          else if (__x < -_Tp(0.25L))
+            return __hyperg_luke(__a, __b, __c, __x);
+          else if (__x < _Tp(0.5L))
+            return __hyperg_series(__a, __b, __c, __x);
+          else
+            if (std::abs(__c) > _Tp(10))
+              return __hyperg_series(__a, __b, __c, __x);
+            else
+              return __hyperg_reflect(__a, __b, __c, __x);
+        }
+      else
+        return __hyperg_luke(__a, __b, __c, __x);
+    }
+  }
+#undef _GLIBCXX_MATH_NS
+
+
+
+
+
+}
+# 55 "/usr/include/c++/10.2.0/bits/specfun.h" 2 3
+# 1 "/usr/include/c++/10.2.0/tr1/legendre_function.tcc" 1 3
+# 45 "/usr/include/c++/10.2.0/tr1/legendre_function.tcc" 3
+#define _GLIBCXX_TR1_LEGENDRE_FUNCTION_TCC 1
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+#define _GLIBCXX_MATH_NS ::std
+# 65 "/usr/include/c++/10.2.0/tr1/legendre_function.tcc" 3
+  namespace __detail
+  {
+# 80 "/usr/include/c++/10.2.0/tr1/legendre_function.tcc" 3
+    template<typename _Tp>
+    _Tp
+    __poly_legendre_p(unsigned int __l, _Tp __x)
+    {
+
+      if (__isnan(__x))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (__x == +_Tp(1))
+        return +_Tp(1);
+      else if (__x == -_Tp(1))
+        return (__l % 2 == 1 ? -_Tp(1) : +_Tp(1));
+      else
+        {
+          _Tp __p_lm2 = _Tp(1);
+          if (__l == 0)
+            return __p_lm2;
+
+          _Tp __p_lm1 = __x;
+          if (__l == 1)
+            return __p_lm1;
+
+          _Tp __p_l = 0;
+          for (unsigned int __ll = 2; __ll <= __l; ++__ll)
+            {
+
+
+              __p_l = _Tp(2) * __x * __p_lm1 - __p_lm2
+                    - (__x * __p_lm1 - __p_lm2) / _Tp(__ll);
+              __p_lm2 = __p_lm1;
+              __p_lm1 = __p_l;
+            }
+
+          return __p_l;
+        }
+    }
+# 136 "/usr/include/c++/10.2.0/tr1/legendre_function.tcc" 3
+    template<typename _Tp>
+    _Tp
+    __assoc_legendre_p(unsigned int __l, unsigned int __m, _Tp __x,
+         _Tp __phase = _Tp(+1))
+    {
+
+      if (__m > __l)
+        return _Tp(0);
+      else if (__isnan(__x))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (__m == 0)
+        return __poly_legendre_p(__l, __x);
+      else
+        {
+          _Tp __p_mm = _Tp(1);
+          if (__m > 0)
+            {
+
+
+              _Tp __root = std::sqrt(_Tp(1) - __x) * std::sqrt(_Tp(1) + __x);
+              _Tp __fact = _Tp(1);
+              for (unsigned int __i = 1; __i <= __m; ++__i)
+                {
+                  __p_mm *= __phase * __fact * __root;
+                  __fact += _Tp(2);
+                }
+            }
+          if (__l == __m)
+            return __p_mm;
+
+          _Tp __p_mp1m = _Tp(2 * __m + 1) * __x * __p_mm;
+          if (__l == __m + 1)
+            return __p_mp1m;
+
+          _Tp __p_lm2m = __p_mm;
+          _Tp __P_lm1m = __p_mp1m;
+          _Tp __p_lm = _Tp(0);
+          for (unsigned int __j = __m + 2; __j <= __l; ++__j)
+            {
+              __p_lm = (_Tp(2 * __j - 1) * __x * __P_lm1m
+                      - _Tp(__j + __m - 1) * __p_lm2m) / _Tp(__j - __m);
+              __p_lm2m = __P_lm1m;
+              __P_lm1m = __p_lm;
+            }
+
+          return __p_lm;
+        }
+    }
+# 214 "/usr/include/c++/10.2.0/tr1/legendre_function.tcc" 3
+    template <typename _Tp>
+    _Tp
+    __sph_legendre(unsigned int __l, unsigned int __m, _Tp __theta)
+    {
+      if (__isnan(__theta))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+
+      const _Tp __x = std::cos(__theta);
+
+      if (__m > __l)
+        return _Tp(0);
+      else if (__m == 0)
+        {
+          _Tp __P = __poly_legendre_p(__l, __x);
+          _Tp __fact = std::sqrt(_Tp(2 * __l + 1)
+                     / (_Tp(4) * __numeric_constants<_Tp>::__pi()));
+          __P *= __fact;
+          return __P;
+        }
+      else if (__x == _Tp(1) || __x == -_Tp(1))
+        {
+
+          return _Tp(0);
+        }
+      else
+        {
+
+
+
+
+
+          const _Tp __sgn = ( __m % 2 == 1 ? -_Tp(1) : _Tp(1));
+          const _Tp __y_mp1m_factor = __x * std::sqrt(_Tp(2 * __m + 3));
+
+          const _Tp __lncirc = ::std::log1p(-__x * __x);
+
+
+
+
+
+          const _Tp __lnpoch = ::std::lgamma(_Tp(__m + _Tp(0.5L)))
+                             - ::std::lgamma(_Tp(__m));
+
+
+
+
+          const _Tp __lnpre_val =
+                    -_Tp(0.25L) * __numeric_constants<_Tp>::__lnpi()
+                    + _Tp(0.5L) * (__lnpoch + __m * __lncirc);
+          const _Tp __sr = std::sqrt((_Tp(2) + _Tp(1) / __m)
+                         / (_Tp(4) * __numeric_constants<_Tp>::__pi()));
+          _Tp __y_mm = __sgn * __sr * std::exp(__lnpre_val);
+          _Tp __y_mp1m = __y_mp1m_factor * __y_mm;
+
+          if (__l == __m)
+            return __y_mm;
+          else if (__l == __m + 1)
+            return __y_mp1m;
+          else
+            {
+              _Tp __y_lm = _Tp(0);
+
+
+              for (int __ll = __m + 2; __ll <= __l; ++__ll)
+                {
+                  const _Tp __rat1 = _Tp(__ll - __m) / _Tp(__ll + __m);
+                  const _Tp __rat2 = _Tp(__ll - __m - 1) / _Tp(__ll + __m - 1);
+                  const _Tp __fact1 = std::sqrt(__rat1 * _Tp(2 * __ll + 1)
+                                                       * _Tp(2 * __ll - 1));
+                  const _Tp __fact2 = std::sqrt(__rat1 * __rat2 * _Tp(2 * __ll + 1)
+                                                                / _Tp(2 * __ll - 3));
+                  __y_lm = (__x * __y_mp1m * __fact1
+                         - (__ll + __m - 1) * __y_mm * __fact2) / _Tp(__ll - __m);
+                  __y_mm = __y_mp1m;
+                  __y_mp1m = __y_lm;
+                }
+
+              return __y_lm;
+            }
+        }
+    }
+  }
+#undef _GLIBCXX_MATH_NS
+
+
+
+
+
+}
+# 56 "/usr/include/c++/10.2.0/bits/specfun.h" 2 3
+# 1 "/usr/include/c++/10.2.0/tr1/modified_bessel_func.tcc" 1 3
+# 47 "/usr/include/c++/10.2.0/tr1/modified_bessel_func.tcc" 3
+#define _GLIBCXX_TR1_MODIFIED_BESSEL_FUNC_TCC 1
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 65 "/usr/include/c++/10.2.0/tr1/modified_bessel_func.tcc" 3
+  namespace __detail
+  {
+# 83 "/usr/include/c++/10.2.0/tr1/modified_bessel_func.tcc" 3
+    template <typename _Tp>
+    void
+    __bessel_ik(_Tp __nu, _Tp __x,
+                _Tp & __Inu, _Tp & __Knu, _Tp & __Ipnu, _Tp & __Kpnu)
+    {
+      if (__x == _Tp(0))
+        {
+          if (__nu == _Tp(0))
+            {
+              __Inu = _Tp(1);
+              __Ipnu = _Tp(0);
+            }
+          else if (__nu == _Tp(1))
+            {
+              __Inu = _Tp(0);
+              __Ipnu = _Tp(0.5L);
+            }
+          else
+            {
+              __Inu = _Tp(0);
+              __Ipnu = _Tp(0);
+            }
+          __Knu = std::numeric_limits<_Tp>::infinity();
+          __Kpnu = -std::numeric_limits<_Tp>::infinity();
+          return;
+        }
+
+      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
+      const _Tp __fp_min = _Tp(10) * std::numeric_limits<_Tp>::epsilon();
+      const int __max_iter = 15000;
+      const _Tp __x_min = _Tp(2);
+
+      const int __nl = static_cast<int>(__nu + _Tp(0.5L));
+
+      const _Tp __mu = __nu - __nl;
+      const _Tp __mu2 = __mu * __mu;
+      const _Tp __xi = _Tp(1) / __x;
+      const _Tp __xi2 = _Tp(2) * __xi;
+      _Tp __h = __nu * __xi;
+      if ( __h < __fp_min )
+        __h = __fp_min;
+      _Tp __b = __xi2 * __nu;
+      _Tp __d = _Tp(0);
+      _Tp __c = __h;
+      int __i;
+      for ( __i = 1; __i <= __max_iter; ++__i )
+        {
+          __b += __xi2;
+          __d = _Tp(1) / (__b + __d);
+          __c = __b + _Tp(1) / __c;
+          const _Tp __del = __c * __d;
+          __h *= __del;
+          if (std::abs(__del - _Tp(1)) < __eps)
+            break;
+        }
+      if (__i > __max_iter)
+        std::__throw_runtime_error(("Argument x too large " "in __bessel_ik; " "try asymptotic expansion.")
+
+                                                                   );
+      _Tp __Inul = __fp_min;
+      _Tp __Ipnul = __h * __Inul;
+      _Tp __Inul1 = __Inul;
+      _Tp __Ipnu1 = __Ipnul;
+      _Tp __fact = __nu * __xi;
+      for (int __l = __nl; __l >= 1; --__l)
+        {
+          const _Tp __Inutemp = __fact * __Inul + __Ipnul;
+          __fact -= __xi;
+          __Ipnul = __fact * __Inutemp + __Inul;
+          __Inul = __Inutemp;
+        }
+      _Tp __f = __Ipnul / __Inul;
+      _Tp __Kmu, __Knu1;
+      if (__x < __x_min)
+        {
+          const _Tp __x2 = __x / _Tp(2);
+          const _Tp __pimu = __numeric_constants<_Tp>::__pi() * __mu;
+          const _Tp __fact = (std::abs(__pimu) < __eps
+                            ? _Tp(1) : __pimu / std::sin(__pimu));
+          _Tp __d = -std::log(__x2);
+          _Tp __e = __mu * __d;
+          const _Tp __fact2 = (std::abs(__e) < __eps
+                            ? _Tp(1) : std::sinh(__e) / __e);
+          _Tp __gam1, __gam2, __gampl, __gammi;
+          __gamma_temme(__mu, __gam1, __gam2, __gampl, __gammi);
+          _Tp __ff = __fact
+                   * (__gam1 * std::cosh(__e) + __gam2 * __fact2 * __d);
+          _Tp __sum = __ff;
+          __e = std::exp(__e);
+          _Tp __p = __e / (_Tp(2) * __gampl);
+          _Tp __q = _Tp(1) / (_Tp(2) * __e * __gammi);
+          _Tp __c = _Tp(1);
+          __d = __x2 * __x2;
+          _Tp __sum1 = __p;
+          int __i;
+          for (__i = 1; __i <= __max_iter; ++__i)
+            {
+              __ff = (__i * __ff + __p + __q) / (__i * __i - __mu2);
+              __c *= __d / __i;
+              __p /= __i - __mu;
+              __q /= __i + __mu;
+              const _Tp __del = __c * __ff;
+              __sum += __del;
+              const _Tp __del1 = __c * (__p - __i * __ff);
+              __sum1 += __del1;
+              if (std::abs(__del) < __eps * std::abs(__sum))
+                break;
+            }
+          if (__i > __max_iter)
+            std::__throw_runtime_error(("Bessel k series failed to converge " "in __bessel_ik.")
+                                                             );
+          __Kmu = __sum;
+          __Knu1 = __sum1 * __xi2;
+        }
+      else
+        {
+          _Tp __b = _Tp(2) * (_Tp(1) + __x);
+          _Tp __d = _Tp(1) / __b;
+          _Tp __delh = __d;
+          _Tp __h = __delh;
+          _Tp __q1 = _Tp(0);
+          _Tp __q2 = _Tp(1);
+          _Tp __a1 = _Tp(0.25L) - __mu2;
+          _Tp __q = __c = __a1;
+          _Tp __a = -__a1;
+          _Tp __s = _Tp(1) + __q * __delh;
+          int __i;
+          for (__i = 2; __i <= __max_iter; ++__i)
+            {
+              __a -= 2 * (__i - 1);
+              __c = -__a * __c / __i;
+              const _Tp __qnew = (__q1 - __b * __q2) / __a;
+              __q1 = __q2;
+              __q2 = __qnew;
+              __q += __c * __qnew;
+              __b += _Tp(2);
+              __d = _Tp(1) / (__b + __a * __d);
+              __delh = (__b * __d - _Tp(1)) * __delh;
+              __h += __delh;
+              const _Tp __dels = __q * __delh;
+              __s += __dels;
+              if ( std::abs(__dels / __s) < __eps )
+                break;
+            }
+          if (__i > __max_iter)
+            std::__throw_runtime_error(("Steed's method failed " "in __bessel_ik.")
+                                                             );
+          __h = __a1 * __h;
+          __Kmu = std::sqrt(__numeric_constants<_Tp>::__pi() / (_Tp(2) * __x))
+                * std::exp(-__x) / __s;
+          __Knu1 = __Kmu * (__mu + __x + _Tp(0.5L) - __h) * __xi;
+        }
+
+      _Tp __Kpmu = __mu * __xi * __Kmu - __Knu1;
+      _Tp __Inumu = __xi / (__f * __Kmu - __Kpmu);
+      __Inu = __Inumu * __Inul1 / __Inul;
+      __Ipnu = __Inumu * __Ipnu1 / __Inul;
+      for ( __i = 1; __i <= __nl; ++__i )
+        {
+          const _Tp __Knutemp = (__mu + __i) * __xi2 * __Knu1 + __Kmu;
+          __Kmu = __Knu1;
+          __Knu1 = __Knutemp;
+        }
+      __Knu = __Kmu;
+      __Kpnu = __nu * __xi * __Kmu - __Knu1;
+
+      return;
+    }
+# 267 "/usr/include/c++/10.2.0/tr1/modified_bessel_func.tcc" 3
+    template<typename _Tp>
+    _Tp
+    __cyl_bessel_i(_Tp __nu, _Tp __x)
+    {
+      if (__nu < _Tp(0) || __x < _Tp(0))
+        std::__throw_domain_error(("Bad argument " "in __cyl_bessel_i.")
+                                                           );
+      else if (__isnan(__nu) || __isnan(__x))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (__x * __x < _Tp(10) * (__nu + _Tp(1)))
+        return __cyl_bessel_ij_series(__nu, __x, +_Tp(1), 200);
+      else
+        {
+          _Tp __I_nu, __K_nu, __Ip_nu, __Kp_nu;
+          __bessel_ik(__nu, __x, __I_nu, __K_nu, __Ip_nu, __Kp_nu);
+          return __I_nu;
+        }
+    }
+# 303 "/usr/include/c++/10.2.0/tr1/modified_bessel_func.tcc" 3
+    template<typename _Tp>
+    _Tp
+    __cyl_bessel_k(_Tp __nu, _Tp __x)
+    {
+      if (__nu < _Tp(0) || __x < _Tp(0))
+        std::__throw_domain_error(("Bad argument " "in __cyl_bessel_k.")
+                                                           );
+      else if (__isnan(__nu) || __isnan(__x))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else
+        {
+          _Tp __I_nu, __K_nu, __Ip_nu, __Kp_nu;
+          __bessel_ik(__nu, __x, __I_nu, __K_nu, __Ip_nu, __Kp_nu);
+          return __K_nu;
+        }
+    }
+# 337 "/usr/include/c++/10.2.0/tr1/modified_bessel_func.tcc" 3
+    template <typename _Tp>
+    void
+    __sph_bessel_ik(unsigned int __n, _Tp __x,
+                    _Tp & __i_n, _Tp & __k_n, _Tp & __ip_n, _Tp & __kp_n)
+    {
+      const _Tp __nu = _Tp(__n) + _Tp(0.5L);
+
+      _Tp __I_nu, __Ip_nu, __K_nu, __Kp_nu;
+      __bessel_ik(__nu, __x, __I_nu, __K_nu, __Ip_nu, __Kp_nu);
+
+      const _Tp __factor = __numeric_constants<_Tp>::__sqrtpio2()
+                         / std::sqrt(__x);
+
+      __i_n = __factor * __I_nu;
+      __k_n = __factor * __K_nu;
+      __ip_n = __factor * __Ip_nu - __i_n / (_Tp(2) * __x);
+      __kp_n = __factor * __Kp_nu - __k_n / (_Tp(2) * __x);
+
+      return;
+    }
+# 373 "/usr/include/c++/10.2.0/tr1/modified_bessel_func.tcc" 3
+    template <typename _Tp>
+    void
+    __airy(_Tp __x, _Tp & __Ai, _Tp & __Bi, _Tp & __Aip, _Tp & __Bip)
+    {
+      const _Tp __absx = std::abs(__x);
+      const _Tp __rootx = std::sqrt(__absx);
+      const _Tp __z = _Tp(2) * __absx * __rootx / _Tp(3);
+      const _Tp _S_NaN = std::numeric_limits<_Tp>::quiet_NaN();
+      const _Tp _S_inf = std::numeric_limits<_Tp>::infinity();
+
+      if (__isnan(__x))
+        __Bip = __Aip = __Bi = __Ai = std::numeric_limits<_Tp>::quiet_NaN();
+      else if (__z == _S_inf)
+        {
+   __Aip = __Ai = _Tp(0);
+   __Bip = __Bi = _S_inf;
+ }
+      else if (__z == -_S_inf)
+ __Bip = __Aip = __Bi = __Ai = _Tp(0);
+      else if (__x > _Tp(0))
+        {
+          _Tp __I_nu, __Ip_nu, __K_nu, __Kp_nu;
+
+          __bessel_ik(_Tp(1) / _Tp(3), __z, __I_nu, __K_nu, __Ip_nu, __Kp_nu);
+          __Ai = __rootx * __K_nu
+               / (__numeric_constants<_Tp>::__sqrt3()
+                * __numeric_constants<_Tp>::__pi());
+          __Bi = __rootx * (__K_nu / __numeric_constants<_Tp>::__pi()
+                 + _Tp(2) * __I_nu / __numeric_constants<_Tp>::__sqrt3());
+
+          __bessel_ik(_Tp(2) / _Tp(3), __z, __I_nu, __K_nu, __Ip_nu, __Kp_nu);
+          __Aip = -__x * __K_nu
+                / (__numeric_constants<_Tp>::__sqrt3()
+                 * __numeric_constants<_Tp>::__pi());
+          __Bip = __x * (__K_nu / __numeric_constants<_Tp>::__pi()
+                      + _Tp(2) * __I_nu
+                      / __numeric_constants<_Tp>::__sqrt3());
+        }
+      else if (__x < _Tp(0))
+        {
+          _Tp __J_nu, __Jp_nu, __N_nu, __Np_nu;
+
+          __bessel_jn(_Tp(1) / _Tp(3), __z, __J_nu, __N_nu, __Jp_nu, __Np_nu);
+          __Ai = __rootx * (__J_nu
+                    - __N_nu / __numeric_constants<_Tp>::__sqrt3()) / _Tp(2);
+          __Bi = -__rootx * (__N_nu
+                    + __J_nu / __numeric_constants<_Tp>::__sqrt3()) / _Tp(2);
+
+          __bessel_jn(_Tp(2) / _Tp(3), __z, __J_nu, __N_nu, __Jp_nu, __Np_nu);
+          __Aip = __absx * (__N_nu / __numeric_constants<_Tp>::__sqrt3()
+                          + __J_nu) / _Tp(2);
+          __Bip = __absx * (__J_nu / __numeric_constants<_Tp>::__sqrt3()
+                          - __N_nu) / _Tp(2);
+        }
+      else
+        {
+
+
+
+          __Ai = _Tp(0.35502805388781723926L);
+          __Bi = __Ai * __numeric_constants<_Tp>::__sqrt3();
+
+
+
+
+          __Aip = -_Tp(0.25881940379280679840L);
+          __Bip = -__Aip * __numeric_constants<_Tp>::__sqrt3();
+        }
+
+      return;
+    }
+  }
+
+
+
+
+
+}
+# 57 "/usr/include/c++/10.2.0/bits/specfun.h" 2 3
+# 1 "/usr/include/c++/10.2.0/tr1/poly_hermite.tcc" 1 3
+# 40 "/usr/include/c++/10.2.0/tr1/poly_hermite.tcc" 3
+#define _GLIBCXX_TR1_POLY_HERMITE_TCC 1
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 56 "/usr/include/c++/10.2.0/tr1/poly_hermite.tcc" 3
+  namespace __detail
+  {
+# 72 "/usr/include/c++/10.2.0/tr1/poly_hermite.tcc" 3
+    template<typename _Tp>
+    _Tp
+    __poly_hermite_recursion(unsigned int __n, _Tp __x)
+    {
+
+      _Tp __H_0 = 1;
+      if (__n == 0)
+        return __H_0;
+
+
+      _Tp __H_1 = 2 * __x;
+      if (__n == 1)
+        return __H_1;
+
+
+      _Tp __H_n, __H_nm1, __H_nm2;
+      unsigned int __i;
+      for (__H_nm2 = __H_0, __H_nm1 = __H_1, __i = 2; __i <= __n; ++__i)
+        {
+          __H_n = 2 * (__x * __H_nm1 - (__i - 1) * __H_nm2);
+          __H_nm2 = __H_nm1;
+          __H_nm1 = __H_n;
+        }
+
+      return __H_n;
+    }
+# 114 "/usr/include/c++/10.2.0/tr1/poly_hermite.tcc" 3
+    template<typename _Tp>
+    inline _Tp
+    __poly_hermite(unsigned int __n, _Tp __x)
+    {
+      if (__isnan(__x))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else
+        return __poly_hermite_recursion(__n, __x);
+    }
+  }
+
+
+
+
+
+}
+# 58 "/usr/include/c++/10.2.0/bits/specfun.h" 2 3
+# 1 "/usr/include/c++/10.2.0/tr1/poly_laguerre.tcc" 1 3
+# 42 "/usr/include/c++/10.2.0/tr1/poly_laguerre.tcc" 3
+#define _GLIBCXX_TR1_POLY_LAGUERRE_TCC 1
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+#define _GLIBCXX_MATH_NS ::std
+# 60 "/usr/include/c++/10.2.0/tr1/poly_laguerre.tcc" 3
+  namespace __detail
+  {
+# 75 "/usr/include/c++/10.2.0/tr1/poly_laguerre.tcc" 3
+    template<typename _Tpa, typename _Tp>
+    _Tp
+    __poly_laguerre_large_n(unsigned __n, _Tpa __alpha1, _Tp __x)
+    {
+      const _Tp __a = -_Tp(__n);
+      const _Tp __b = _Tp(__alpha1) + _Tp(1);
+      const _Tp __eta = _Tp(2) * __b - _Tp(4) * __a;
+      const _Tp __cos2th = __x / __eta;
+      const _Tp __sin2th = _Tp(1) - __cos2th;
+      const _Tp __th = std::acos(std::sqrt(__cos2th));
+      const _Tp __pre_h = __numeric_constants<_Tp>::__pi_2()
+                        * __numeric_constants<_Tp>::__pi_2()
+                        * __eta * __eta * __cos2th * __sin2th;
+
+
+      const _Tp __lg_b = ::std::lgamma(_Tp(__n) + __b);
+      const _Tp __lnfact = ::std::lgamma(_Tp(__n + 1));
+
+
+
+
+
+      _Tp __pre_term1 = _Tp(0.5L) * (_Tp(1) - __b)
+                      * std::log(_Tp(0.25L) * __x * __eta);
+      _Tp __pre_term2 = _Tp(0.25L) * std::log(__pre_h);
+      _Tp __lnpre = __lg_b - __lnfact + _Tp(0.5L) * __x
+                      + __pre_term1 - __pre_term2;
+      _Tp __ser_term1 = std::sin(__a * __numeric_constants<_Tp>::__pi());
+      _Tp __ser_term2 = std::sin(_Tp(0.25L) * __eta
+                              * (_Tp(2) * __th
+                               - std::sin(_Tp(2) * __th))
+                               + __numeric_constants<_Tp>::__pi_4());
+      _Tp __ser = __ser_term1 + __ser_term2;
+
+      return std::exp(__lnpre) * __ser;
+    }
+# 129 "/usr/include/c++/10.2.0/tr1/poly_laguerre.tcc" 3
+    template<typename _Tpa, typename _Tp>
+    _Tp
+    __poly_laguerre_hyperg(unsigned int __n, _Tpa __alpha1, _Tp __x)
+    {
+      const _Tp __b = _Tp(__alpha1) + _Tp(1);
+      const _Tp __mx = -__x;
+      const _Tp __tc_sgn = (__x < _Tp(0) ? _Tp(1)
+                         : ((__n % 2 == 1) ? -_Tp(1) : _Tp(1)));
+
+      _Tp __tc = _Tp(1);
+      const _Tp __ax = std::abs(__x);
+      for (unsigned int __k = 1; __k <= __n; ++__k)
+        __tc *= (__ax / __k);
+
+      _Tp __term = __tc * __tc_sgn;
+      _Tp __sum = __term;
+      for (int __k = int(__n) - 1; __k >= 0; --__k)
+        {
+          __term *= ((__b + _Tp(__k)) / _Tp(int(__n) - __k))
+                  * _Tp(__k + 1) / __mx;
+          __sum += __term;
+        }
+
+      return __sum;
+    }
+# 185 "/usr/include/c++/10.2.0/tr1/poly_laguerre.tcc" 3
+    template<typename _Tpa, typename _Tp>
+    _Tp
+    __poly_laguerre_recursion(unsigned int __n, _Tpa __alpha1, _Tp __x)
+    {
+
+      _Tp __l_0 = _Tp(1);
+      if (__n == 0)
+        return __l_0;
+
+
+      _Tp __l_1 = -__x + _Tp(1) + _Tp(__alpha1);
+      if (__n == 1)
+        return __l_1;
+
+
+      _Tp __l_n2 = __l_0;
+      _Tp __l_n1 = __l_1;
+      _Tp __l_n = _Tp(0);
+      for (unsigned int __nn = 2; __nn <= __n; ++__nn)
+        {
+            __l_n = (_Tp(2 * __nn - 1) + _Tp(__alpha1) - __x)
+                  * __l_n1 / _Tp(__nn)
+                  - (_Tp(__nn - 1) + _Tp(__alpha1)) * __l_n2 / _Tp(__nn);
+            __l_n2 = __l_n1;
+            __l_n1 = __l_n;
+        }
+
+      return __l_n;
+    }
+# 244 "/usr/include/c++/10.2.0/tr1/poly_laguerre.tcc" 3
+    template<typename _Tpa, typename _Tp>
+    _Tp
+    __poly_laguerre(unsigned int __n, _Tpa __alpha1, _Tp __x)
+    {
+      if (__x < _Tp(0))
+        std::__throw_domain_error(("Negative argument " "in __poly_laguerre.")
+                                                            );
+
+      else if (__isnan(__x))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (__n == 0)
+        return _Tp(1);
+      else if (__n == 1)
+        return _Tp(1) + _Tp(__alpha1) - __x;
+      else if (__x == _Tp(0))
+        {
+          _Tp __prod = _Tp(__alpha1) + _Tp(1);
+          for (unsigned int __k = 2; __k <= __n; ++__k)
+            __prod *= (_Tp(__alpha1) + _Tp(__k)) / _Tp(__k);
+          return __prod;
+        }
+      else if (__n > 10000000 && _Tp(__alpha1) > -_Tp(1)
+            && __x < _Tp(2) * (_Tp(__alpha1) + _Tp(1)) + _Tp(4 * __n))
+        return __poly_laguerre_large_n(__n, __alpha1, __x);
+      else if (_Tp(__alpha1) >= _Tp(0)
+           || (__x > _Tp(0) && _Tp(__alpha1) < -_Tp(__n + 1)))
+        return __poly_laguerre_recursion(__n, __alpha1, __x);
+      else
+        return __poly_laguerre_hyperg(__n, __alpha1, __x);
+    }
+# 296 "/usr/include/c++/10.2.0/tr1/poly_laguerre.tcc" 3
+    template<typename _Tp>
+    inline _Tp
+    __assoc_laguerre(unsigned int __n, unsigned int __m, _Tp __x)
+    { return __poly_laguerre<unsigned int, _Tp>(__n, __m, __x); }
+# 316 "/usr/include/c++/10.2.0/tr1/poly_laguerre.tcc" 3
+    template<typename _Tp>
+    inline _Tp
+    __laguerre(unsigned int __n, _Tp __x)
+    { return __poly_laguerre<unsigned int, _Tp>(__n, 0, __x); }
+  }
+#undef _GLIBCXX_MATH_NS
+
+
+
+
+
+}
+# 59 "/usr/include/c++/10.2.0/bits/specfun.h" 2 3
+# 1 "/usr/include/c++/10.2.0/tr1/riemann_zeta.tcc" 1 3
+# 43 "/usr/include/c++/10.2.0/tr1/riemann_zeta.tcc" 3
+#define _GLIBCXX_TR1_RIEMANN_ZETA_TCC 1
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+#define _GLIBCXX_MATH_NS ::std
+# 63 "/usr/include/c++/10.2.0/tr1/riemann_zeta.tcc" 3
+  namespace __detail
+  {
+# 78 "/usr/include/c++/10.2.0/tr1/riemann_zeta.tcc" 3
+    template<typename _Tp>
+    _Tp
+    __riemann_zeta_sum(_Tp __s)
+    {
+
+      if (__s < _Tp(1))
+        std::__throw_domain_error(("Bad argument in zeta sum."));
+
+      const unsigned int max_iter = 10000;
+      _Tp __zeta = _Tp(0);
+      for (unsigned int __k = 1; __k < max_iter; ++__k)
+        {
+          _Tp __term = std::pow(static_cast<_Tp>(__k), -__s);
+          if (__term < std::numeric_limits<_Tp>::epsilon())
+            {
+              break;
+            }
+          __zeta += __term;
+        }
+
+      return __zeta;
+    }
+# 115 "/usr/include/c++/10.2.0/tr1/riemann_zeta.tcc" 3
+    template<typename _Tp>
+    _Tp
+    __riemann_zeta_alt(_Tp __s)
+    {
+      _Tp __sgn = _Tp(1);
+      _Tp __zeta = _Tp(0);
+      for (unsigned int __i = 1; __i < 10000000; ++__i)
+        {
+          _Tp __term = __sgn / std::pow(__i, __s);
+          if (std::abs(__term) < std::numeric_limits<_Tp>::epsilon())
+            break;
+          __zeta += __term;
+          __sgn *= _Tp(-1);
+        }
+      __zeta /= _Tp(1) - std::pow(_Tp(2), _Tp(1) - __s);
+
+      return __zeta;
+    }
+# 157 "/usr/include/c++/10.2.0/tr1/riemann_zeta.tcc" 3
+    template<typename _Tp>
+    _Tp
+    __riemann_zeta_glob(_Tp __s)
+    {
+      _Tp __zeta = _Tp(0);
+
+      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
+
+      const _Tp __max_bincoeff = std::numeric_limits<_Tp>::max_exponent10
+                               * std::log(_Tp(10)) - _Tp(1);
+
+
+
+      if (__s < _Tp(0))
+        {
+
+          if (::std::fmod(__s,_Tp(2)) == _Tp(0))
+            return _Tp(0);
+          else
+
+            {
+              _Tp __zeta = __riemann_zeta_glob(_Tp(1) - __s);
+              __zeta *= std::pow(_Tp(2)
+                     * __numeric_constants<_Tp>::__pi(), __s)
+                     * std::sin(__numeric_constants<_Tp>::__pi_2() * __s)
+
+                     * std::exp(::std::lgamma(_Tp(1) - __s))
+
+
+
+                     / __numeric_constants<_Tp>::__pi();
+              return __zeta;
+            }
+        }
+
+      _Tp __num = _Tp(0.5L);
+      const unsigned int __maxit = 10000;
+      for (unsigned int __i = 0; __i < __maxit; ++__i)
+        {
+          bool __punt = false;
+          _Tp __sgn = _Tp(1);
+          _Tp __term = _Tp(0);
+          for (unsigned int __j = 0; __j <= __i; ++__j)
+            {
+
+              _Tp __bincoeff = ::std::lgamma(_Tp(1 + __i))
+                              - ::std::lgamma(_Tp(1 + __j))
+                              - ::std::lgamma(_Tp(1 + __i - __j));
+
+
+
+
+
+              if (__bincoeff > __max_bincoeff)
+                {
+
+                  __punt = true;
+                  break;
+                }
+              __bincoeff = std::exp(__bincoeff);
+              __term += __sgn * __bincoeff * std::pow(_Tp(1 + __j), -__s);
+              __sgn *= _Tp(-1);
+            }
+          if (__punt)
+            break;
+          __term *= __num;
+          __zeta += __term;
+          if (std::abs(__term/__zeta) < __eps)
+            break;
+          __num *= _Tp(0.5L);
+        }
+
+      __zeta /= _Tp(1) - std::pow(_Tp(2), _Tp(1) - __s);
+
+      return __zeta;
+    }
+# 252 "/usr/include/c++/10.2.0/tr1/riemann_zeta.tcc" 3
+    template<typename _Tp>
+    _Tp
+    __riemann_zeta_product(_Tp __s)
+    {
+      static const _Tp __prime[] = {
+        _Tp(2), _Tp(3), _Tp(5), _Tp(7), _Tp(11), _Tp(13), _Tp(17), _Tp(19),
+        _Tp(23), _Tp(29), _Tp(31), _Tp(37), _Tp(41), _Tp(43), _Tp(47),
+        _Tp(53), _Tp(59), _Tp(61), _Tp(67), _Tp(71), _Tp(73), _Tp(79),
+        _Tp(83), _Tp(89), _Tp(97), _Tp(101), _Tp(103), _Tp(107), _Tp(109)
+      };
+      static const unsigned int __num_primes = sizeof(__prime) / sizeof(_Tp);
+
+      _Tp __zeta = _Tp(1);
+      for (unsigned int __i = 0; __i < __num_primes; ++__i)
+        {
+          const _Tp __fact = _Tp(1) - std::pow(__prime[__i], -__s);
+          __zeta *= __fact;
+          if (_Tp(1) - __fact < std::numeric_limits<_Tp>::epsilon())
+            break;
+        }
+
+      __zeta = _Tp(1) / __zeta;
+
+      return __zeta;
+    }
+# 293 "/usr/include/c++/10.2.0/tr1/riemann_zeta.tcc" 3
+    template<typename _Tp>
+    _Tp
+    __riemann_zeta(_Tp __s)
+    {
+      if (__isnan(__s))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (__s == _Tp(1))
+        return std::numeric_limits<_Tp>::infinity();
+      else if (__s < -_Tp(19))
+        {
+          _Tp __zeta = __riemann_zeta_product(_Tp(1) - __s);
+          __zeta *= std::pow(_Tp(2) * __numeric_constants<_Tp>::__pi(), __s)
+                 * std::sin(__numeric_constants<_Tp>::__pi_2() * __s)
+
+                 * std::exp(::std::lgamma(_Tp(1) - __s))
+
+
+
+                 / __numeric_constants<_Tp>::__pi();
+          return __zeta;
+        }
+      else if (__s < _Tp(20))
+        {
+
+          bool __glob = true;
+          if (__glob)
+            return __riemann_zeta_glob(__s);
+          else
+            {
+              if (__s > _Tp(1))
+                return __riemann_zeta_sum(__s);
+              else
+                {
+                  _Tp __zeta = std::pow(_Tp(2)
+                                * __numeric_constants<_Tp>::__pi(), __s)
+                         * std::sin(__numeric_constants<_Tp>::__pi_2() * __s)
+
+                             * ::std::tgamma(_Tp(1) - __s)
+
+
+
+                             * __riemann_zeta_sum(_Tp(1) - __s);
+                  return __zeta;
+                }
+            }
+        }
+      else
+        return __riemann_zeta_product(__s);
+    }
+# 365 "/usr/include/c++/10.2.0/tr1/riemann_zeta.tcc" 3
+    template<typename _Tp>
+    _Tp
+    __hurwitz_zeta_glob(_Tp __a, _Tp __s)
+    {
+      _Tp __zeta = _Tp(0);
+
+      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
+
+      const _Tp __max_bincoeff = std::numeric_limits<_Tp>::max_exponent10
+                               * std::log(_Tp(10)) - _Tp(1);
+
+      const unsigned int __maxit = 10000;
+      for (unsigned int __i = 0; __i < __maxit; ++__i)
+        {
+          bool __punt = false;
+          _Tp __sgn = _Tp(1);
+          _Tp __term = _Tp(0);
+          for (unsigned int __j = 0; __j <= __i; ++__j)
+            {
+
+              _Tp __bincoeff = ::std::lgamma(_Tp(1 + __i))
+                              - ::std::lgamma(_Tp(1 + __j))
+                              - ::std::lgamma(_Tp(1 + __i - __j));
+
+
+
+
+
+              if (__bincoeff > __max_bincoeff)
+                {
+
+                  __punt = true;
+                  break;
+                }
+              __bincoeff = std::exp(__bincoeff);
+              __term += __sgn * __bincoeff * std::pow(_Tp(__a + __j), -__s);
+              __sgn *= _Tp(-1);
+            }
+          if (__punt)
+            break;
+          __term /= _Tp(__i + 1);
+          if (std::abs(__term / __zeta) < __eps)
+            break;
+          __zeta += __term;
+        }
+
+      __zeta /= __s - _Tp(1);
+
+      return __zeta;
+    }
+# 430 "/usr/include/c++/10.2.0/tr1/riemann_zeta.tcc" 3
+    template<typename _Tp>
+    inline _Tp
+    __hurwitz_zeta(_Tp __a, _Tp __s)
+    { return __hurwitz_zeta_glob(__a, __s); }
+  }
+#undef _GLIBCXX_MATH_NS
+
+
+
+
+
+}
+# 60 "/usr/include/c++/10.2.0/bits/specfun.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 205 "/usr/include/c++/10.2.0/bits/specfun.h" 3
+  inline float
+  assoc_laguerref(unsigned int __n, unsigned int __m, float __x)
+  { return __detail::__assoc_laguerre<float>(__n, __m, __x); }
+
+
+
+
+
+
+
+  inline long double
+  assoc_laguerrel(unsigned int __n, unsigned int __m, long double __x)
+  { return __detail::__assoc_laguerre<long double>(__n, __m, __x); }
+# 250 "/usr/include/c++/10.2.0/bits/specfun.h" 3
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type
+    assoc_laguerre(unsigned int __n, unsigned int __m, _Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __detail::__assoc_laguerre<__type>(__n, __m, __x);
+    }
+# 266 "/usr/include/c++/10.2.0/bits/specfun.h" 3
+  inline float
+  assoc_legendref(unsigned int __l, unsigned int __m, float __x)
+  { return __detail::__assoc_legendre_p<float>(__l, __m, __x); }
+
+
+
+
+
+
+  inline long double
+  assoc_legendrel(unsigned int __l, unsigned int __m, long double __x)
+  { return __detail::__assoc_legendre_p<long double>(__l, __m, __x); }
+# 296 "/usr/include/c++/10.2.0/bits/specfun.h" 3
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type
+    assoc_legendre(unsigned int __l, unsigned int __m, _Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __detail::__assoc_legendre_p<__type>(__l, __m, __x);
+    }
+# 311 "/usr/include/c++/10.2.0/bits/specfun.h" 3
+  inline float
+  betaf(float __a, float __b)
+  { return __detail::__beta<float>(__a, __b); }
+
+
+
+
+
+
+
+  inline long double
+  betal(long double __a, long double __b)
+  { return __detail::__beta<long double>(__a, __b); }
+# 341 "/usr/include/c++/10.2.0/bits/specfun.h" 3
+  template<typename _Tpa, typename _Tpb>
+    inline typename __gnu_cxx::__promote_2<_Tpa, _Tpb>::__type
+    beta(_Tpa __a, _Tpb __b)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tpa, _Tpb>::__type __type;
+      return __detail::__beta<__type>(__a, __b);
+    }
+# 357 "/usr/include/c++/10.2.0/bits/specfun.h" 3
+  inline float
+  comp_ellint_1f(float __k)
+  { return __detail::__comp_ellint_1<float>(__k); }
+
+
+
+
+
+
+
+  inline long double
+  comp_ellint_1l(long double __k)
+  { return __detail::__comp_ellint_1<long double>(__k); }
+# 389 "/usr/include/c++/10.2.0/bits/specfun.h" 3
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type
+    comp_ellint_1(_Tp __k)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __detail::__comp_ellint_1<__type>(__k);
+    }
+# 405 "/usr/include/c++/10.2.0/bits/specfun.h" 3
+  inline float
+  comp_ellint_2f(float __k)
+  { return __detail::__comp_ellint_2<float>(__k); }
+
+
+
+
+
+
+
+  inline long double
+  comp_ellint_2l(long double __k)
+  { return __detail::__comp_ellint_2<long double>(__k); }
+# 436 "/usr/include/c++/10.2.0/bits/specfun.h" 3
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type
+    comp_ellint_2(_Tp __k)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __detail::__comp_ellint_2<__type>(__k);
+    }
+# 452 "/usr/include/c++/10.2.0/bits/specfun.h" 3
+  inline float
+  comp_ellint_3f(float __k, float __nu)
+  { return __detail::__comp_ellint_3<float>(__k, __nu); }
+
+
+
+
+
+
+
+  inline long double
+  comp_ellint_3l(long double __k, long double __nu)
+  { return __detail::__comp_ellint_3<long double>(__k, __nu); }
+# 487 "/usr/include/c++/10.2.0/bits/specfun.h" 3
+  template<typename _Tp, typename _Tpn>
+    inline typename __gnu_cxx::__promote_2<_Tp, _Tpn>::__type
+    comp_ellint_3(_Tp __k, _Tpn __nu)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Tpn>::__type __type;
+      return __detail::__comp_ellint_3<__type>(__k, __nu);
+    }
+# 503 "/usr/include/c++/10.2.0/bits/specfun.h" 3
+  inline float
+  cyl_bessel_if(float __nu, float __x)
+  { return __detail::__cyl_bessel_i<float>(__nu, __x); }
+
+
+
+
+
+
+
+  inline long double
+  cyl_bessel_il(long double __nu, long double __x)
+  { return __detail::__cyl_bessel_i<long double>(__nu, __x); }
+# 533 "/usr/include/c++/10.2.0/bits/specfun.h" 3
+  template<typename _Tpnu, typename _Tp>
+    inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type
+    cyl_bessel_i(_Tpnu __nu, _Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type;
+      return __detail::__cyl_bessel_i<__type>(__nu, __x);
+    }
+# 549 "/usr/include/c++/10.2.0/bits/specfun.h" 3
+  inline float
+  cyl_bessel_jf(float __nu, float __x)
+  { return __detail::__cyl_bessel_j<float>(__nu, __x); }
+
+
+
+
+
+
+
+  inline long double
+  cyl_bessel_jl(long double __nu, long double __x)
+  { return __detail::__cyl_bessel_j<long double>(__nu, __x); }
+# 579 "/usr/include/c++/10.2.0/bits/specfun.h" 3
+  template<typename _Tpnu, typename _Tp>
+    inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type
+    cyl_bessel_j(_Tpnu __nu, _Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type;
+      return __detail::__cyl_bessel_j<__type>(__nu, __x);
+    }
+# 595 "/usr/include/c++/10.2.0/bits/specfun.h" 3
+  inline float
+  cyl_bessel_kf(float __nu, float __x)
+  { return __detail::__cyl_bessel_k<float>(__nu, __x); }
+
+
+
+
+
+
+
+  inline long double
+  cyl_bessel_kl(long double __nu, long double __x)
+  { return __detail::__cyl_bessel_k<long double>(__nu, __x); }
+# 631 "/usr/include/c++/10.2.0/bits/specfun.h" 3
+  template<typename _Tpnu, typename _Tp>
+    inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type
+    cyl_bessel_k(_Tpnu __nu, _Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type;
+      return __detail::__cyl_bessel_k<__type>(__nu, __x);
+    }
+# 647 "/usr/include/c++/10.2.0/bits/specfun.h" 3
+  inline float
+  cyl_neumannf(float __nu, float __x)
+  { return __detail::__cyl_neumann_n<float>(__nu, __x); }
+
+
+
+
+
+
+
+  inline long double
+  cyl_neumannl(long double __nu, long double __x)
+  { return __detail::__cyl_neumann_n<long double>(__nu, __x); }
+# 679 "/usr/include/c++/10.2.0/bits/specfun.h" 3
+  template<typename _Tpnu, typename _Tp>
+    inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type
+    cyl_neumann(_Tpnu __nu, _Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type;
+      return __detail::__cyl_neumann_n<__type>(__nu, __x);
+    }
+# 695 "/usr/include/c++/10.2.0/bits/specfun.h" 3
+  inline float
+  ellint_1f(float __k, float __phi)
+  { return __detail::__ellint_1<float>(__k, __phi); }
+
+
+
+
+
+
+
+  inline long double
+  ellint_1l(long double __k, long double __phi)
+  { return __detail::__ellint_1<long double>(__k, __phi); }
+# 727 "/usr/include/c++/10.2.0/bits/specfun.h" 3
+  template<typename _Tp, typename _Tpp>
+    inline typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type
+    ellint_1(_Tp __k, _Tpp __phi)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type __type;
+      return __detail::__ellint_1<__type>(__k, __phi);
+    }
+# 743 "/usr/include/c++/10.2.0/bits/specfun.h" 3
+  inline float
+  ellint_2f(float __k, float __phi)
+  { return __detail::__ellint_2<float>(__k, __phi); }
+
+
+
+
+
+
+
+  inline long double
+  ellint_2l(long double __k, long double __phi)
+  { return __detail::__ellint_2<long double>(__k, __phi); }
+# 775 "/usr/include/c++/10.2.0/bits/specfun.h" 3
+  template<typename _Tp, typename _Tpp>
+    inline typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type
+    ellint_2(_Tp __k, _Tpp __phi)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type __type;
+      return __detail::__ellint_2<__type>(__k, __phi);
+    }
+# 791 "/usr/include/c++/10.2.0/bits/specfun.h" 3
+  inline float
+  ellint_3f(float __k, float __nu, float __phi)
+  { return __detail::__ellint_3<float>(__k, __nu, __phi); }
+
+
+
+
+
+
+
+  inline long double
+  ellint_3l(long double __k, long double __nu, long double __phi)
+  { return __detail::__ellint_3<long double>(__k, __nu, __phi); }
+# 828 "/usr/include/c++/10.2.0/bits/specfun.h" 3
+  template<typename _Tp, typename _Tpn, typename _Tpp>
+    inline typename __gnu_cxx::__promote_3<_Tp, _Tpn, _Tpp>::__type
+    ellint_3(_Tp __k, _Tpn __nu, _Tpp __phi)
+    {
+      typedef typename __gnu_cxx::__promote_3<_Tp, _Tpn, _Tpp>::__type __type;
+      return __detail::__ellint_3<__type>(__k, __nu, __phi);
+    }
+# 843 "/usr/include/c++/10.2.0/bits/specfun.h" 3
+  inline float
+  expintf(float __x)
+  { return __detail::__expint<float>(__x); }
+
+
+
+
+
+
+
+  inline long double
+  expintl(long double __x)
+  { return __detail::__expint<long double>(__x); }
+# 868 "/usr/include/c++/10.2.0/bits/specfun.h" 3
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type
+    expint(_Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __detail::__expint<__type>(__x);
+    }
+# 884 "/usr/include/c++/10.2.0/bits/specfun.h" 3
+  inline float
+  hermitef(unsigned int __n, float __x)
+  { return __detail::__poly_hermite<float>(__n, __x); }
+
+
+
+
+
+
+
+  inline long double
+  hermitel(unsigned int __n, long double __x)
+  { return __detail::__poly_hermite<long double>(__n, __x); }
+# 916 "/usr/include/c++/10.2.0/bits/specfun.h" 3
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type
+    hermite(unsigned int __n, _Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __detail::__poly_hermite<__type>(__n, __x);
+    }
+# 932 "/usr/include/c++/10.2.0/bits/specfun.h" 3
+  inline float
+  laguerref(unsigned int __n, float __x)
+  { return __detail::__laguerre<float>(__n, __x); }
+
+
+
+
+
+
+
+  inline long double
+  laguerrel(unsigned int __n, long double __x)
+  { return __detail::__laguerre<long double>(__n, __x); }
+# 960 "/usr/include/c++/10.2.0/bits/specfun.h" 3
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type
+    laguerre(unsigned int __n, _Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __detail::__laguerre<__type>(__n, __x);
+    }
+# 976 "/usr/include/c++/10.2.0/bits/specfun.h" 3
+  inline float
+  legendref(unsigned int __l, float __x)
+  { return __detail::__poly_legendre_p<float>(__l, __x); }
+
+
+
+
+
+
+
+  inline long double
+  legendrel(unsigned int __l, long double __x)
+  { return __detail::__poly_legendre_p<long double>(__l, __x); }
+# 1005 "/usr/include/c++/10.2.0/bits/specfun.h" 3
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type
+    legendre(unsigned int __l, _Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __detail::__poly_legendre_p<__type>(__l, __x);
+    }
+# 1021 "/usr/include/c++/10.2.0/bits/specfun.h" 3
+  inline float
+  riemann_zetaf(float __s)
+  { return __detail::__riemann_zeta<float>(__s); }
+
+
+
+
+
+
+
+  inline long double
+  riemann_zetal(long double __s)
+  { return __detail::__riemann_zeta<long double>(__s); }
+# 1056 "/usr/include/c++/10.2.0/bits/specfun.h" 3
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type
+    riemann_zeta(_Tp __s)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __detail::__riemann_zeta<__type>(__s);
+    }
+# 1072 "/usr/include/c++/10.2.0/bits/specfun.h" 3
+  inline float
+  sph_besself(unsigned int __n, float __x)
+  { return __detail::__sph_bessel<float>(__n, __x); }
+
+
+
+
+
+
+
+  inline long double
+  sph_bessell(unsigned int __n, long double __x)
+  { return __detail::__sph_bessel<long double>(__n, __x); }
+# 1100 "/usr/include/c++/10.2.0/bits/specfun.h" 3
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type
+    sph_bessel(unsigned int __n, _Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __detail::__sph_bessel<__type>(__n, __x);
+    }
+# 1116 "/usr/include/c++/10.2.0/bits/specfun.h" 3
+  inline float
+  sph_legendref(unsigned int __l, unsigned int __m, float __theta)
+  { return __detail::__sph_legendre<float>(__l, __m, __theta); }
+# 1127 "/usr/include/c++/10.2.0/bits/specfun.h" 3
+  inline long double
+  sph_legendrel(unsigned int __l, unsigned int __m, long double __theta)
+  { return __detail::__sph_legendre<long double>(__l, __m, __theta); }
+# 1147 "/usr/include/c++/10.2.0/bits/specfun.h" 3
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type
+    sph_legendre(unsigned int __l, unsigned int __m, _Tp __theta)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __detail::__sph_legendre<__type>(__l, __m, __theta);
+    }
+# 1163 "/usr/include/c++/10.2.0/bits/specfun.h" 3
+  inline float
+  sph_neumannf(unsigned int __n, float __x)
+  { return __detail::__sph_neumann<float>(__n, __x); }
+
+
+
+
+
+
+
+  inline long double
+  sph_neumannl(unsigned int __n, long double __x)
+  { return __detail::__sph_neumann<long double>(__n, __x); }
+# 1191 "/usr/include/c++/10.2.0/bits/specfun.h" 3
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type
+    sph_neumann(unsigned int __n, _Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __detail::__sph_neumann<__type>(__n, __x);
+    }
+
+
+
+
+}
+# 1388 "/usr/include/c++/10.2.0/bits/specfun.h" 3
+#pragma GCC visibility pop
+# 1928 "/usr/include/c++/10.2.0/cmath" 2 3
+
+
+}
+# 62 "/usr/include/boost/test/impl/framework.ipp" 2 3 4
+
+
+
+
+
+
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 69 "/usr/include/boost/test/impl/framework.ipp" 2 3 4
+
+
+
+namespace boost {
+namespace unit_test {
+namespace framework {
+
+namespace impl {
+
+
+
+
+
+struct order_info {
+    order_info() : depth(-1) {}
+
+    int depth;
+    std::vector<test_unit_id> dependant_siblings;
+};
+
+typedef std::set<test_unit_id> tu_id_set;
+typedef std::map<test_unit_id,order_info> order_info_per_tu;
+
+
+
+static test_unit_id
+get_tu_parent( test_unit_id tu_id )
+{
+    return framework::get( tu_id, TUT_ANY ).p_parent_id;
+}
+
+
+
+static int
+tu_depth( test_unit_id tu_id, test_unit_id master_tu_id, order_info_per_tu& tuoi )
+{
+    if( tu_id == master_tu_id )
+        return 0;
+
+    order_info& info = tuoi[tu_id];
+
+    if( info.depth == -1 )
+        info.depth = tu_depth( get_tu_parent( tu_id ), master_tu_id, tuoi ) + 1;
+
+    return info.depth;
+}
+
+
+
+static void
+collect_dependant_siblings( test_unit_id from, test_unit_id to, test_unit_id master_tu_id, order_info_per_tu& tuoi )
+{
+    int from_depth = tu_depth( from, master_tu_id, tuoi );
+    int to_depth = tu_depth( to, master_tu_id, tuoi );
+
+    while(from_depth > to_depth) {
+        from = get_tu_parent( from );
+        --from_depth;
+    }
+
+    while(from_depth < to_depth) {
+        to = get_tu_parent( to );
+        --to_depth;
+    }
+
+    while(true) {
+        test_unit_id from_parent = get_tu_parent( from );
+        test_unit_id to_parent = get_tu_parent( to );
+        if( from_parent == to_parent )
+            break;
+        from = from_parent;
+        to = to_parent;
+    }
+
+    tuoi[from].dependant_siblings.push_back( to );
+}
+
+
+
+static counter_t
+assign_sibling_rank( test_unit_id tu_id, order_info_per_tu& tuoi )
+{
+    test_unit& tu = framework::get( tu_id, TUT_ANY );
+
+    if( tu.p_sibling_rank != (std::numeric_limits<counter_t>::max)() ) {} else unit_test::ut_detail::throw_exception( unit_test::framework::setup_error( "Cyclic dependency detected involving test unit \"" + tu.full_name() + "\"" ) )
+                                                                                                          ;
+
+    if( tu.p_sibling_rank != 0 )
+        return tu.p_sibling_rank;
+
+    order_info const& info = tuoi[tu_id];
+
+
+    tu.p_sibling_rank.value = (std::numeric_limits<counter_t>::max)();
+
+    counter_t new_rank = 1;
+    if( ::boost::unit_test::for_each::static_any_t _fe_cur_165 = ::boost::unit_test::for_each::begin( info.dependant_siblings, ::boost::unit_test::for_each::is_const_coll( info.dependant_siblings ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_165 = ::boost::unit_test::for_each::end( info.dependant_siblings, ::boost::unit_test::for_each::is_const_coll( info.dependant_siblings ) ) ) {} else for( bool _fe_con_165 = true; _fe_con_165 && !::boost::unit_test::for_each::done( _fe_cur_165, _fe_end_165, info.dependant_siblings, ::boost::unit_test::for_each::is_const_coll( info.dependant_siblings ) ); _fe_con_165 ? ::boost::unit_test::for_each::next( _fe_cur_165, info.dependant_siblings, ::boost::unit_test::for_each::is_const_coll( info.dependant_siblings ) ) : ((void)&(info.dependant_siblings))) if( (_fe_con_165 = false, false) ) {} else for( test_unit_id sibling_id = ::boost::unit_test::for_each::deref( _fe_cur_165, info.dependant_siblings, ::boost::type<test_unit_id >(), ::boost::unit_test::for_each::is_const_coll( info.dependant_siblings ) ); !_fe_con_165; _fe_con_165 = true )
+        new_rank = (std::max)(new_rank, assign_sibling_rank( sibling_id, tuoi ) + 1);
+
+    return tu.p_sibling_rank.value = new_rank;
+}
+
+
+
+
+
+
+
+static void
+invoke_init_func( init_unit_test_func init_func )
+{
+
+
+
+    test_suite* manual_test_units = (*init_func)( framework::master_test_suite().argc, framework::master_test_suite().argv );
+
+    if( manual_test_units )
+        framework::master_test_suite().add( manual_test_units );
+
+}
+
+
+
+
+
+class name_filter : public test_tree_visitor {
+    struct component {
+        component( const_string name )
+        {
+            if( name == "*" )
+                m_kind = SFK_ALL;
+            else if( first_char( name ) == '*' && last_char( name ) == '*' ) {
+                m_kind = SFK_SUBSTR;
+                m_name = name.substr( 1, name.size()-1 );
+            }
+            else if( first_char( name ) == '*' ) {
+                m_kind = SFK_TRAILING;
+                m_name = name.substr( 1 );
+            }
+            else if( last_char( name ) == '*' ) {
+                m_kind = SFK_LEADING;
+                m_name = name.substr( 0, name.size()-1 );
+            }
+            else {
+                m_kind = SFK_MATCH;
+                m_name = name;
+            }
+        }
+
+        bool pass( test_unit const& tu ) const
+        {
+            const_string name( tu.p_name );
+
+            switch( m_kind ) {
+            default:
+            case SFK_ALL:
+                return true;
+            case SFK_LEADING:
+                return name.substr( 0, m_name.size() ) == m_name;
+            case SFK_TRAILING:
+                return name.size() >= m_name.size() && name.substr( name.size() - m_name.size() ) == m_name;
+            case SFK_SUBSTR:
+                return name.find( m_name ) != const_string::npos;
+            case SFK_MATCH:
+                return m_name == tu.p_name.get();
+            }
+        }
+        enum kind { SFK_ALL, SFK_LEADING, SFK_TRAILING, SFK_SUBSTR, SFK_MATCH };
+
+        kind m_kind;
+        const_string m_name;
+    };
+
+public:
+
+    name_filter( test_unit_id_list& targ_list, const_string filter_expr ) : m_targ_list( targ_list ), m_depth( 0 )
+    {
+
+        utils::string_token_iterator tit( filter_expr, (utils::dropped_delimeters = "/",
+                                                        utils::kept_delimeters = utils::dt_none) );
+
+        while( tit != utils::string_token_iterator() ) {
+            m_components.push_back(
+                std::vector<component>( utils::string_token_iterator( *tit, (utils::dropped_delimeters = ",",
+                                                                             utils::kept_delimeters = utils::dt_none) ),
+                                        utils::string_token_iterator() ) );
+
+            ++tit;
+        }
+
+    }
+
+private:
+    bool filter_unit( test_unit const& tu )
+    {
+
+        if( m_depth == 0 )
+            return true;
+
+
+        std::vector<component> const& filters = m_components[m_depth-1];
+
+
+        using namespace boost::placeholders;
+        return std::find_if( filters.begin(), filters.end(), bind( &component::pass, _1, boost::ref(tu) ) ) != filters.end();
+    }
+
+
+    virtual void visit( test_case const& tc )
+    {
+
+        if( m_depth == m_components.size() && filter_unit( tc ) )
+            m_targ_list.push_back( tc.p_id );
+    }
+    virtual bool test_suite_start( test_suite const& ts )
+    {
+        if( !filter_unit( ts ) )
+            return false;
+
+        if( m_depth < m_components.size() ) {
+            ++m_depth;
+            return true;
+        }
+
+        m_targ_list.push_back( ts.p_id );
+
+        return false;
+    }
+    virtual void test_suite_finish( test_suite const& )
+    {
+        --m_depth;
+    }
+
+
+    typedef std::vector<std::vector<component> > components_per_level;
+
+    components_per_level m_components;
+    test_unit_id_list& m_targ_list;
+    unsigned m_depth;
+};
+
+
+
+
+
+class label_filter : public test_tree_visitor {
+public:
+    label_filter( test_unit_id_list& targ_list, const_string label )
+    : m_targ_list( targ_list )
+    , m_label( label )
+    {}
+
+private:
+
+    virtual bool visit( test_unit const& tu )
+    {
+        if( tu.has_label( m_label ) ) {
+
+            m_targ_list.push_back( tu.p_id );
+            return false;
+        }
+
+        return true;
+    }
+
+
+    test_unit_id_list& m_targ_list;
+    const_string m_label;
+};
+
+
+
+
+
+class set_run_status : public test_tree_visitor {
+public:
+    explicit set_run_status( test_unit::run_status rs, test_unit_id_list* dep_collector = 0 )
+    : m_new_status( rs )
+    , m_dep_collector( dep_collector )
+    {}
+
+
+    virtual bool visit( test_unit const& tu )
+    {
+        const_cast<test_unit&>(tu).p_run_status.value = m_new_status == test_unit::RS_INVALID ? tu.p_default_status : m_new_status;
+        if( m_dep_collector ) {
+            if( ::boost::unit_test::for_each::static_any_t _fe_cur_355 = ::boost::unit_test::for_each::begin( tu.p_dependencies.get(), ::boost::unit_test::for_each::is_const_coll( tu.p_dependencies.get() ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_355 = ::boost::unit_test::for_each::end( tu.p_dependencies.get(), ::boost::unit_test::for_each::is_const_coll( tu.p_dependencies.get() ) ) ) {} else for( bool _fe_con_355 = true; _fe_con_355 && !::boost::unit_test::for_each::done( _fe_cur_355, _fe_end_355, tu.p_dependencies.get(), ::boost::unit_test::for_each::is_const_coll( tu.p_dependencies.get() ) ); _fe_con_355 ? ::boost::unit_test::for_each::next( _fe_cur_355, tu.p_dependencies.get(), ::boost::unit_test::for_each::is_const_coll( tu.p_dependencies.get() ) ) : ((void)&(tu.p_dependencies.get()))) if( (_fe_con_355 = false, false) ) {} else for( test_unit_id dep_id = ::boost::unit_test::for_each::deref( _fe_cur_355, tu.p_dependencies.get(), ::boost::type<test_unit_id >(), ::boost::unit_test::for_each::is_const_coll( tu.p_dependencies.get() ) ); !_fe_con_355; _fe_con_355 = true ) {
+                test_unit const& dep = framework::get( dep_id, TUT_ANY );
+
+                if( dep.p_run_status == tu.p_run_status )
+                    continue;
+
+                (::boost::unit_test::unit_test_log << ::boost::unit_test::log::begin( "boost.test framework", 0 )) ( ::boost::unit_test::log_messages ) << (::boost::unit_test::lazy_ostream::instance() << "Including test " << dep.p_type_name << ' ' << dep.full_name() << " as a dependency of test " << tu.p_type_name << ' ' << tu.full_name())
+                                                                                                                      ;
+
+                m_dep_collector->push_back( dep_id );
+            }
+        }
+        return true;
+    }
+
+private:
+
+    test_unit::run_status m_new_status;
+    test_unit_id_list* m_dep_collector;
+};
+
+
+
+
+
+static void
+add_filtered_test_units( test_unit_id master_tu_id, const_string filter, test_unit_id_list& targ )
+{
+
+    if( filter[0] == '@' ) {
+        filter.trim_left( 1 );
+        label_filter lf( targ, filter );
+        traverse_test_tree( master_tu_id, lf, true );
+    }
+    else {
+        name_filter nf( targ, filter );
+        traverse_test_tree( master_tu_id, nf, true );
+    }
+}
+
+
+
+static bool
+parse_filters( test_unit_id master_tu_id, test_unit_id_list& tu_to_enable, test_unit_id_list& tu_to_disable )
+{
+
+    bool had_selector_filter = false;
+
+    std::vector<std::string> const& filters = runtime_config::get<std::vector<std::string> >( runtime_config::btrt_run_filters );
+
+    if( ::boost::unit_test::for_each::static_any_t _fe_cur_405 = ::boost::unit_test::for_each::begin( filters, ::boost::unit_test::for_each::is_const_coll( filters ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_405 = ::boost::unit_test::for_each::end( filters, ::boost::unit_test::for_each::is_const_coll( filters ) ) ) {} else for( bool _fe_con_405 = true; _fe_con_405 && !::boost::unit_test::for_each::done( _fe_cur_405, _fe_end_405, filters, ::boost::unit_test::for_each::is_const_coll( filters ) ); _fe_con_405 ? ::boost::unit_test::for_each::next( _fe_cur_405, filters, ::boost::unit_test::for_each::is_const_coll( filters ) ) : ((void)&(filters))) if( (_fe_con_405 = false, false) ) {} else for( const_string filter = ::boost::unit_test::for_each::deref( _fe_cur_405, filters, ::boost::type<const_string >(), ::boost::unit_test::for_each::is_const_coll( filters ) ); !_fe_con_405; _fe_con_405 = true ) {
+        if( !filter.is_empty() ) {} else unit_test::ut_detail::throw_exception( unit_test::framework::setup_error( "Invalid filter specification" ) );
+
+
+        utils::string_token_iterator t_filter_it( filter, (utils::dropped_delimeters = ":",
+                                                           utils::kept_delimeters = utils::dt_none) );
+
+        while( t_filter_it != utils::string_token_iterator() ) {
+            const_string filter_token = *t_filter_it;
+
+            enum { SELECTOR, ENABLER, DISABLER } filter_type = SELECTOR;
+
+
+            if( filter_token[0] == '!' || filter_token[0] == '+' ) {
+                filter_type = filter_token[0] == '+' ? ENABLER : DISABLER;
+                filter_token.trim_left( 1 );
+                if( !filter_token.is_empty() ) {} else unit_test::ut_detail::throw_exception( unit_test::framework::setup_error( "Invalid filter specification" ) );
+            }
+
+            had_selector_filter |= filter_type == SELECTOR;
+
+
+            switch( filter_type ) {
+            case SELECTOR:
+            case ENABLER: add_filtered_test_units( master_tu_id, filter_token, tu_to_enable ); break;
+            case DISABLER: add_filtered_test_units( master_tu_id, filter_token, tu_to_disable ); break;
+            }
+
+            ++t_filter_it;
+        }
+    }
+
+    return had_selector_filter;
+}
+
+
+
+
+template< class RandomIt, class RandomFunc >
+void random_shuffle( RandomIt first, RandomIt last, RandomFunc &r )
+{
+    typedef typename std::iterator_traits<RandomIt>::difference_type difference_type;
+    difference_type n = last - first;
+    for (difference_type i = n-1; i > 0; --i) {
+        difference_type j = r(i+1);
+        if (j != i) {
+            using std::swap;
+            swap(first[i], first[j]);
+        }
+    }
+}
+
+
+
+
+class global_fixture_handle : public test_unit_fixture {
+public:
+    global_fixture_handle(test_unit_fixture* fixture) : m_global_fixture(fixture) {}
+    ~global_fixture_handle() {}
+
+    virtual void setup() {
+        m_global_fixture->setup();
+    }
+    virtual void teardown() {
+        m_global_fixture->teardown();
+    }
+
+private:
+    test_unit_fixture* m_global_fixture;
+};
+
+
+}
+
+
+
+
+
+unsigned long int const TIMEOUT_EXCEEDED = static_cast<unsigned long int>( -1 );
+
+class state {
+public:
+    state()
+    : m_master_test_suite( 0 )
+    , m_curr_test_unit( INV_TEST_UNIT_ID )
+    , m_next_test_case_id( MIN_TEST_CASE_ID )
+    , m_next_test_suite_id( MIN_TEST_SUITE_ID )
+    , m_test_in_progress( false )
+    , m_context_idx( 0 )
+    , m_log_sinks( )
+    , m_report_sink( std::cerr )
+    {
+    }
+
+    ~state() { clear(); }
+
+    void clear()
+    {
+        while( !m_test_units.empty() ) {
+            test_unit_store::value_type const& tu = *m_test_units.begin();
+            test_unit const* tu_ptr = tu.second;
+
+
+            if( ut_detail::test_id_2_unit_type( tu.second->p_id ) == TUT_SUITE )
+                delete static_cast<test_suite const*>(tu_ptr);
+            else
+                delete static_cast<test_case const*>(tu_ptr);
+        }
+    }
+
+    void set_tu_id( test_unit& tu, test_unit_id id ) { tu.p_id.value = id; }
+
+
+
+
+    void deduce_siblings_order( test_unit_id tu_id, test_unit_id master_tu_id, impl::order_info_per_tu& tuoi )
+    {
+        test_unit& tu = framework::get( tu_id, TUT_ANY );
+
+
+        if( ::boost::unit_test::for_each::static_any_t _fe_cur_525 = ::boost::unit_test::for_each::begin( tu.p_dependencies.get(), ::boost::unit_test::for_each::is_const_coll( tu.p_dependencies.get() ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_525 = ::boost::unit_test::for_each::end( tu.p_dependencies.get(), ::boost::unit_test::for_each::is_const_coll( tu.p_dependencies.get() ) ) ) {} else for( bool _fe_con_525 = true; _fe_con_525 && !::boost::unit_test::for_each::done( _fe_cur_525, _fe_end_525, tu.p_dependencies.get(), ::boost::unit_test::for_each::is_const_coll( tu.p_dependencies.get() ) ); _fe_con_525 ? ::boost::unit_test::for_each::next( _fe_cur_525, tu.p_dependencies.get(), ::boost::unit_test::for_each::is_const_coll( tu.p_dependencies.get() ) ) : ((void)&(tu.p_dependencies.get()))) if( (_fe_con_525 = false, false) ) {} else for( test_unit_id dep_id = ::boost::unit_test::for_each::deref( _fe_cur_525, tu.p_dependencies.get(), ::boost::type<test_unit_id >(), ::boost::unit_test::for_each::is_const_coll( tu.p_dependencies.get() ) ); !_fe_con_525; _fe_con_525 = true )
+            collect_dependant_siblings( tu_id, dep_id, master_tu_id, tuoi );
+
+        if( tu.p_type != TUT_SUITE )
+            return;
+
+        test_suite& ts = static_cast<test_suite&>(tu);
+
+
+        if( ::boost::unit_test::for_each::static_any_t _fe_cur_534 = ::boost::unit_test::for_each::begin( ts.m_children, ::boost::unit_test::for_each::is_const_coll( ts.m_children ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_534 = ::boost::unit_test::for_each::end( ts.m_children, ::boost::unit_test::for_each::is_const_coll( ts.m_children ) ) ) {} else for( bool _fe_con_534 = true; _fe_con_534 && !::boost::unit_test::for_each::done( _fe_cur_534, _fe_end_534, ts.m_children, ::boost::unit_test::for_each::is_const_coll( ts.m_children ) ); _fe_con_534 ? ::boost::unit_test::for_each::next( _fe_cur_534, ts.m_children, ::boost::unit_test::for_each::is_const_coll( ts.m_children ) ) : ((void)&(ts.m_children))) if( (_fe_con_534 = false, false) ) {} else for( test_unit_id chld_id = ::boost::unit_test::for_each::deref( _fe_cur_534, ts.m_children, ::boost::type<test_unit_id >(), ::boost::unit_test::for_each::is_const_coll( ts.m_children ) ); !_fe_con_534; _fe_con_534 = true )
+            deduce_siblings_order( chld_id, master_tu_id, tuoi );
+
+        ts.m_ranked_children.clear();
+        if( ::boost::unit_test::for_each::static_any_t _fe_cur_538 = ::boost::unit_test::for_each::begin( ts.m_children, ::boost::unit_test::for_each::is_const_coll( ts.m_children ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_538 = ::boost::unit_test::for_each::end( ts.m_children, ::boost::unit_test::for_each::is_const_coll( ts.m_children ) ) ) {} else for( bool _fe_con_538 = true; _fe_con_538 && !::boost::unit_test::for_each::done( _fe_cur_538, _fe_end_538, ts.m_children, ::boost::unit_test::for_each::is_const_coll( ts.m_children ) ); _fe_con_538 ? ::boost::unit_test::for_each::next( _fe_cur_538, ts.m_children, ::boost::unit_test::for_each::is_const_coll( ts.m_children ) ) : ((void)&(ts.m_children))) if( (_fe_con_538 = false, false) ) {} else for( test_unit_id chld_id = ::boost::unit_test::for_each::deref( _fe_cur_538, ts.m_children, ::boost::type<test_unit_id >(), ::boost::unit_test::for_each::is_const_coll( ts.m_children ) ); !_fe_con_538; _fe_con_538 = true ) {
+            counter_t rank = assign_sibling_rank( chld_id, tuoi );
+            ts.m_ranked_children.insert( std::make_pair( rank, chld_id ) );
+        }
+    }
+
+
+
+
+
+
+    bool finalize_default_run_status( test_unit_id tu_id, test_unit::run_status parent_status )
+    {
+        test_unit& tu = framework::get( tu_id, TUT_ANY );
+
+        if( tu.p_default_status == test_suite::RS_INHERIT )
+            tu.p_default_status.value = parent_status;
+
+
+        if( tu.p_type == TUT_SUITE ) {
+            bool has_enabled_child = false;
+            if( ::boost::unit_test::for_each::static_any_t _fe_cur_559 = ::boost::unit_test::for_each::begin( static_cast<test_suite const&>(tu).m_children, ::boost::unit_test::for_each::is_const_coll( static_cast<test_suite const&>(tu).m_children ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_559 = ::boost::unit_test::for_each::end( static_cast<test_suite const&>(tu).m_children, ::boost::unit_test::for_each::is_const_coll( static_cast<test_suite const&>(tu).m_children ) ) ) {} else for( bool _fe_con_559 = true; _fe_con_559 && !::boost::unit_test::for_each::done( _fe_cur_559, _fe_end_559, static_cast<test_suite const&>(tu).m_children, ::boost::unit_test::for_each::is_const_coll( static_cast<test_suite const&>(tu).m_children ) ); _fe_con_559 ? ::boost::unit_test::for_each::next( _fe_cur_559, static_cast<test_suite const&>(tu).m_children, ::boost::unit_test::for_each::is_const_coll( static_cast<test_suite const&>(tu).m_children ) ) : ((void)&(static_cast<test_suite const&>(tu).m_children))) if( (_fe_con_559 = false, false) ) {} else for( test_unit_id chld_id = ::boost::unit_test::for_each::deref( _fe_cur_559, static_cast<test_suite const&>(tu).m_children, ::boost::type<test_unit_id >(), ::boost::unit_test::for_each::is_const_coll( static_cast<test_suite const&>(tu).m_children ) ); !_fe_con_559; _fe_con_559 = true )
+                has_enabled_child |= finalize_default_run_status( chld_id, tu.p_default_status );
+
+            tu.p_default_status.value = has_enabled_child ? test_suite::RS_ENABLED : test_suite::RS_DISABLED;
+        }
+
+        return tu.p_default_status == test_suite::RS_ENABLED;
+    }
+
+
+
+    bool finalize_run_status( test_unit_id tu_id )
+    {
+        test_unit& tu = framework::get( tu_id, TUT_ANY );
+
+
+        if( tu.p_type == TUT_SUITE ) {
+            bool has_enabled_child = false;
+            if( ::boost::unit_test::for_each::static_any_t _fe_cur_577 = ::boost::unit_test::for_each::begin( static_cast<test_suite const&>(tu).m_children, ::boost::unit_test::for_each::is_const_coll( static_cast<test_suite const&>(tu).m_children ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_577 = ::boost::unit_test::for_each::end( static_cast<test_suite const&>(tu).m_children, ::boost::unit_test::for_each::is_const_coll( static_cast<test_suite const&>(tu).m_children ) ) ) {} else for( bool _fe_con_577 = true; _fe_con_577 && !::boost::unit_test::for_each::done( _fe_cur_577, _fe_end_577, static_cast<test_suite const&>(tu).m_children, ::boost::unit_test::for_each::is_const_coll( static_cast<test_suite const&>(tu).m_children ) ); _fe_con_577 ? ::boost::unit_test::for_each::next( _fe_cur_577, static_cast<test_suite const&>(tu).m_children, ::boost::unit_test::for_each::is_const_coll( static_cast<test_suite const&>(tu).m_children ) ) : ((void)&(static_cast<test_suite const&>(tu).m_children))) if( (_fe_con_577 = false, false) ) {} else for( test_unit_id chld_id = ::boost::unit_test::for_each::deref( _fe_cur_577, static_cast<test_suite const&>(tu).m_children, ::boost::type<test_unit_id >(), ::boost::unit_test::for_each::is_const_coll( static_cast<test_suite const&>(tu).m_children ) ); !_fe_con_577; _fe_con_577 = true )
+                has_enabled_child |= finalize_run_status( chld_id );
+
+            tu.p_run_status.value = has_enabled_child ? test_suite::RS_ENABLED : test_suite::RS_DISABLED;
+        }
+
+        return tu.is_enabled();
+    }
+
+
+
+    void deduce_run_status( test_unit_id master_tu_id )
+    {
+        using namespace framework::impl;
+        test_unit_id_list tu_to_enable;
+        test_unit_id_list tu_to_disable;
+
+
+        bool had_selector_filter = !runtime_config::get<std::vector<std::string> >( runtime_config::btrt_run_filters ).empty() &&
+                                   parse_filters( master_tu_id, tu_to_enable, tu_to_disable );
+
+
+        set_run_status initial_setter( had_selector_filter ? test_unit::RS_DISABLED : test_unit::RS_INVALID );
+        traverse_test_tree( master_tu_id, initial_setter, true );
+
+
+        while( !tu_to_enable.empty() ) {
+            test_unit& tu = framework::get( tu_to_enable.back(), TUT_ANY );
+
+            tu_to_enable.pop_back();
+
+
+            if( tu.is_enabled() )
+                continue;
+
+
+            set_run_status enabler( test_unit::RS_ENABLED, &tu_to_enable );
+            traverse_test_tree( tu.p_id, enabler, true );
+
+
+            test_unit_id parent_id = tu.p_parent_id;
+            while( parent_id != INV_TEST_UNIT_ID
+                  && parent_id != master_tu_id )
+            {
+
+
+
+
+                test_unit& tu_parent = framework::get( parent_id, TUT_ANY );
+                enabler.visit( tu_parent );
+                parent_id = tu_parent.p_parent_id;
+            }
+        }
+
+
+        while( !tu_to_disable.empty() ) {
+            test_unit const& tu = framework::get( tu_to_disable.back(), TUT_ANY );
+
+            tu_to_disable.pop_back();
+
+
+            if( !tu.is_enabled() )
+                continue;
+
+            set_run_status disabler( test_unit::RS_DISABLED );
+            traverse_test_tree( tu.p_id, disabler, true );
+        }
+
+
+        finalize_run_status( master_tu_id );
+    }
+
+
+
+    typedef unit_test_monitor_t::error_level execution_result;
+
+
+    struct random_generator_helper {
+      size_t operator()(size_t i) const {
+        return std::rand() % i;
+      }
+    };
+
+
+    execution_result execute_test_tree( test_unit_id tu_id,
+                                        unsigned long int timeout_microseconds = 0,
+                                        random_generator_helper const * const p_random_generator = 0)
+    {
+        test_unit const& tu = framework::get( tu_id, TUT_ANY );
+
+        execution_result result = unit_test_monitor_t::test_ok;
+
+        if( !tu.is_enabled() ) {
+            if( ::boost::unit_test::for_each::static_any_t _fe_cur_670 = ::boost::unit_test::for_each::begin( m_observers, ::boost::unit_test::for_each::is_const_coll( m_observers ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_670 = ::boost::unit_test::for_each::end( m_observers, ::boost::unit_test::for_each::is_const_coll( m_observers ) ) ) {} else for( bool _fe_con_670 = true; _fe_con_670 && !::boost::unit_test::for_each::done( _fe_cur_670, _fe_end_670, m_observers, ::boost::unit_test::for_each::is_const_coll( m_observers ) ); _fe_con_670 ? ::boost::unit_test::for_each::next( _fe_cur_670, m_observers, ::boost::unit_test::for_each::is_const_coll( m_observers ) ) : ((void)&(m_observers))) if( (_fe_con_670 = false, false) ) {} else for( test_observer* to = ::boost::unit_test::for_each::deref( _fe_cur_670, m_observers, ::boost::type<test_observer* >(), ::boost::unit_test::for_each::is_const_coll( m_observers ) ); !_fe_con_670; _fe_con_670 = true )
+                to->test_unit_skipped( tu, "disabled" );
+            return result;
+        }
+
+
+
+        if( timeout_microseconds == TIMEOUT_EXCEEDED ) {
+
+            if( ::boost::unit_test::for_each::static_any_t _fe_cur_679 = ::boost::unit_test::for_each::begin( m_observers, ::boost::unit_test::for_each::is_const_coll( m_observers ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_679 = ::boost::unit_test::for_each::end( m_observers, ::boost::unit_test::for_each::is_const_coll( m_observers ) ) ) {} else for( bool _fe_con_679 = true; _fe_con_679 && !::boost::unit_test::for_each::done( _fe_cur_679, _fe_end_679, m_observers, ::boost::unit_test::for_each::is_const_coll( m_observers ) ); _fe_con_679 ? ::boost::unit_test::for_each::next( _fe_cur_679, m_observers, ::boost::unit_test::for_each::is_const_coll( m_observers ) ) : ((void)&(m_observers))) if( (_fe_con_679 = false, false) ) {} else for( test_observer* to = ::boost::unit_test::for_each::deref( _fe_cur_679, m_observers, ::boost::type<test_observer* >(), ::boost::unit_test::for_each::is_const_coll( m_observers ) ); !_fe_con_679; _fe_con_679 = true )
+                to->test_unit_skipped( tu, "timeout for the test unit is exceeded" );
+
+            return unit_test_monitor_t::os_timeout;
+        }
+        else if( timeout_microseconds == 0 || (tu.p_timeout > 0 && timeout_microseconds > (tu.p_timeout * 1000000) ) )
+            timeout_microseconds = tu.p_timeout * 1000000;
+
+
+        test_tools::assertion_result const precondition_res = tu.check_preconditions();
+        if( !precondition_res ) {
+
+            if( ::boost::unit_test::for_each::static_any_t _fe_cur_691 = ::boost::unit_test::for_each::begin( m_observers, ::boost::unit_test::for_each::is_const_coll( m_observers ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_691 = ::boost::unit_test::for_each::end( m_observers, ::boost::unit_test::for_each::is_const_coll( m_observers ) ) ) {} else for( bool _fe_con_691 = true; _fe_con_691 && !::boost::unit_test::for_each::done( _fe_cur_691, _fe_end_691, m_observers, ::boost::unit_test::for_each::is_const_coll( m_observers ) ); _fe_con_691 ? ::boost::unit_test::for_each::next( _fe_cur_691, m_observers, ::boost::unit_test::for_each::is_const_coll( m_observers ) ) : ((void)&(m_observers))) if( (_fe_con_691 = false, false) ) {} else for( test_observer* to = ::boost::unit_test::for_each::deref( _fe_cur_691, m_observers, ::boost::type<test_observer* >(), ::boost::unit_test::for_each::is_const_coll( m_observers ) ); !_fe_con_691; _fe_con_691 = true )
+                to->test_unit_skipped( tu, precondition_res.message() );
+
+
+
+
+            return unit_test_monitor_t::test_ok;
+        }
+
+
+        if( ::boost::unit_test::for_each::static_any_t _fe_cur_701 = ::boost::unit_test::for_each::begin( m_observers, ::boost::unit_test::for_each::is_const_coll( m_observers ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_701 = ::boost::unit_test::for_each::end( m_observers, ::boost::unit_test::for_each::is_const_coll( m_observers ) ) ) {} else for( bool _fe_con_701 = true; _fe_con_701 && !::boost::unit_test::for_each::done( _fe_cur_701, _fe_end_701, m_observers, ::boost::unit_test::for_each::is_const_coll( m_observers ) ); _fe_con_701 ? ::boost::unit_test::for_each::next( _fe_cur_701, m_observers, ::boost::unit_test::for_each::is_const_coll( m_observers ) ) : ((void)&(m_observers))) if( (_fe_con_701 = false, false) ) {} else for( test_observer* to = ::boost::unit_test::for_each::deref( _fe_cur_701, m_observers, ::boost::type<test_observer* >(), ::boost::unit_test::for_each::is_const_coll( m_observers ) ); !_fe_con_701; _fe_con_701 = true )
+            to->test_unit_start( tu );
+
+
+        if( ::boost::unit_test::for_each::static_any_t _fe_cur_705 = ::boost::unit_test::for_each::begin( tu.p_fixtures.get(), ::boost::unit_test::for_each::is_const_coll( tu.p_fixtures.get() ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_705 = ::boost::unit_test::for_each::end( tu.p_fixtures.get(), ::boost::unit_test::for_each::is_const_coll( tu.p_fixtures.get() ) ) ) {} else for( bool _fe_con_705 = true; _fe_con_705 && !::boost::unit_test::for_each::done( _fe_cur_705, _fe_end_705, tu.p_fixtures.get(), ::boost::unit_test::for_each::is_const_coll( tu.p_fixtures.get() ) ); _fe_con_705 ? ::boost::unit_test::for_each::next( _fe_cur_705, tu.p_fixtures.get(), ::boost::unit_test::for_each::is_const_coll( tu.p_fixtures.get() ) ) : ((void)&(tu.p_fixtures.get()))) if( (_fe_con_705 = false, false) ) {} else for( test_unit_fixture_ptr F = ::boost::unit_test::for_each::deref( _fe_cur_705, tu.p_fixtures.get(), ::boost::type<test_unit_fixture_ptr >(), ::boost::unit_test::for_each::is_const_coll( tu.p_fixtures.get() ) ); !_fe_con_705; _fe_con_705 = true ) {
+            ut_detail::test_unit_id_restore restore_current_test_unit(m_curr_test_unit, tu.p_id);
+            result = unit_test_monitor.execute_and_translate( boost::bind( &test_unit_fixture::setup, F ) );
+            if( result != unit_test_monitor_t::test_ok )
+                break;
+            test_results const& test_rslt = unit_test::results_collector.results( m_curr_test_unit );
+            if( test_rslt.aborted() ) {
+                result = unit_test_monitor_t::test_setup_failure;
+                break;
+            }
+        }
+
+
+
+        unsigned long elapsed_microseconds = 0;
+
+        if( result == unit_test_monitor_t::test_ok ) {
+
+            boost::unit_test::timer::timer tu_timer;
+
+
+            const random_generator_helper& rand_gen = p_random_generator ? *p_random_generator : random_generator_helper();
+
+            if( tu.p_type == TUT_SUITE ) {
+                test_suite const& ts = static_cast<test_suite const&>( tu );
+
+                if( runtime_config::get<unsigned>( runtime_config::btrt_random_seed ) == 0 ) {
+                    typedef std::pair<counter_t,test_unit_id> value_type;
+
+                    if( ::boost::unit_test::for_each::static_any_t _fe_cur_734 = ::boost::unit_test::for_each::begin( ts.m_ranked_children, ::boost::unit_test::for_each::is_const_coll( ts.m_ranked_children ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_734 = ::boost::unit_test::for_each::end( ts.m_ranked_children, ::boost::unit_test::for_each::is_const_coll( ts.m_ranked_children ) ) ) {} else for( bool _fe_con_734 = true; _fe_con_734 && !::boost::unit_test::for_each::done( _fe_cur_734, _fe_end_734, ts.m_ranked_children, ::boost::unit_test::for_each::is_const_coll( ts.m_ranked_children ) ); _fe_con_734 ? ::boost::unit_test::for_each::next( _fe_cur_734, ts.m_ranked_children, ::boost::unit_test::for_each::is_const_coll( ts.m_ranked_children ) ) : ((void)&(ts.m_ranked_children))) if( (_fe_con_734 = false, false) ) {} else for( value_type chld = ::boost::unit_test::for_each::deref( _fe_cur_734, ts.m_ranked_children, ::boost::type<value_type >(), ::boost::unit_test::for_each::is_const_coll( ts.m_ranked_children ) ); !_fe_con_734; _fe_con_734 = true ) {
+
+                        unsigned long int chld_timeout = child_timeout(
+                            timeout_microseconds,
+                            static_cast<unsigned long int>( microsecond_wall_time(tu_timer.elapsed()) ));
+
+                        result = (std::min)( result, execute_test_tree( chld.second, chld_timeout, &rand_gen ) );
+
+                        if( unit_test_monitor.is_critical_error( result ) )
+                            break;
+
+
+                        elapsed_microseconds = static_cast<unsigned long int>( microsecond_wall_time(tu_timer.elapsed()) );
+
+                        if( (timeout_microseconds > 0) && (elapsed_microseconds > timeout_microseconds) && (timeout_microseconds != TIMEOUT_EXCEEDED ) ) {
+                            if( ::boost::unit_test::for_each::static_any_t _fe_cur_749 = ::boost::unit_test::for_each::begin( m_observers, ::boost::unit_test::for_each::is_const_coll( m_observers ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_749 = ::boost::unit_test::for_each::end( m_observers, ::boost::unit_test::for_each::is_const_coll( m_observers ) ) ) {} else for( bool _fe_con_749 = true; _fe_con_749 && !::boost::unit_test::for_each::done( _fe_cur_749, _fe_end_749, m_observers, ::boost::unit_test::for_each::is_const_coll( m_observers ) ); _fe_con_749 ? ::boost::unit_test::for_each::next( _fe_cur_749, m_observers, ::boost::unit_test::for_each::is_const_coll( m_observers ) ) : ((void)&(m_observers))) if( (_fe_con_749 = false, false) ) {} else for( test_observer* to = ::boost::unit_test::for_each::deref( _fe_cur_749, m_observers, ::boost::type<test_observer* >(), ::boost::unit_test::for_each::is_const_coll( m_observers ) ); !_fe_con_749; _fe_con_749 = true ) {
+                                to->test_unit_timed_out(tu);
+                            }
+                            result = (std::min)( result, unit_test_monitor_t::os_timeout );
+                            timeout_microseconds = TIMEOUT_EXCEEDED;
+
+
+
+                        }
+                    }
+                }
+                else {
+
+
+                    test_unit_id_list children_with_the_same_rank;
+
+                    typedef test_suite::children_per_rank::const_iterator it_type;
+                    it_type it = ts.m_ranked_children.begin();
+                    while( it != ts.m_ranked_children.end() ) {
+                        children_with_the_same_rank.clear();
+
+                        std::pair<it_type,it_type> range = ts.m_ranked_children.equal_range( it->first );
+                        it = range.first;
+                        while( it != range.second ) {
+                            children_with_the_same_rank.push_back( it->second );
+                            it++;
+                        }
+
+                        impl::random_shuffle( children_with_the_same_rank.begin(), children_with_the_same_rank.end(), rand_gen );
+
+                        if( ::boost::unit_test::for_each::static_any_t _fe_cur_779 = ::boost::unit_test::for_each::begin( children_with_the_same_rank, ::boost::unit_test::for_each::is_const_coll( children_with_the_same_rank ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_779 = ::boost::unit_test::for_each::end( children_with_the_same_rank, ::boost::unit_test::for_each::is_const_coll( children_with_the_same_rank ) ) ) {} else for( bool _fe_con_779 = true; _fe_con_779 && !::boost::unit_test::for_each::done( _fe_cur_779, _fe_end_779, children_with_the_same_rank, ::boost::unit_test::for_each::is_const_coll( children_with_the_same_rank ) ); _fe_con_779 ? ::boost::unit_test::for_each::next( _fe_cur_779, children_with_the_same_rank, ::boost::unit_test::for_each::is_const_coll( children_with_the_same_rank ) ) : ((void)&(children_with_the_same_rank))) if( (_fe_con_779 = false, false) ) {} else for( test_unit_id chld = ::boost::unit_test::for_each::deref( _fe_cur_779, children_with_the_same_rank, ::boost::type<test_unit_id >(), ::boost::unit_test::for_each::is_const_coll( children_with_the_same_rank ) ); !_fe_con_779; _fe_con_779 = true ) {
+                            unsigned long int chld_timeout = child_timeout(
+                                timeout_microseconds,
+                                static_cast<unsigned long int>(microsecond_wall_time(tu_timer.elapsed())) );
+
+                            result = (std::min)( result, execute_test_tree( chld, chld_timeout, &rand_gen ) );
+
+                            if( unit_test_monitor.is_critical_error( result ) )
+                                break;
+
+
+                            elapsed_microseconds = static_cast<unsigned long int>( microsecond_wall_time(tu_timer.elapsed()) );
+                            if( (timeout_microseconds > 0) && (elapsed_microseconds > timeout_microseconds) && (timeout_microseconds != TIMEOUT_EXCEEDED ) ) {
+                                if( ::boost::unit_test::for_each::static_any_t _fe_cur_792 = ::boost::unit_test::for_each::begin( m_observers, ::boost::unit_test::for_each::is_const_coll( m_observers ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_792 = ::boost::unit_test::for_each::end( m_observers, ::boost::unit_test::for_each::is_const_coll( m_observers ) ) ) {} else for( bool _fe_con_792 = true; _fe_con_792 && !::boost::unit_test::for_each::done( _fe_cur_792, _fe_end_792, m_observers, ::boost::unit_test::for_each::is_const_coll( m_observers ) ); _fe_con_792 ? ::boost::unit_test::for_each::next( _fe_cur_792, m_observers, ::boost::unit_test::for_each::is_const_coll( m_observers ) ) : ((void)&(m_observers))) if( (_fe_con_792 = false, false) ) {} else for( test_observer* to = ::boost::unit_test::for_each::deref( _fe_cur_792, m_observers, ::boost::type<test_observer* >(), ::boost::unit_test::for_each::is_const_coll( m_observers ) ); !_fe_con_792; _fe_con_792 = true ) {
+                                    to->test_unit_timed_out(tu);
+                                }
+                                result = (std::min)( result, unit_test_monitor_t::os_timeout );
+                                timeout_microseconds = TIMEOUT_EXCEEDED;
+
+
+
+                            }
+                        }
+                    }
+                }
+            }
+            else {
+                test_case const& tc = static_cast<test_case const&>( tu );
+
+
+                m_context_idx = 0;
+
+
+                ut_detail::test_unit_id_restore restore_current_test_unit(m_curr_test_unit, tc.p_id);
+
+
+                result = unit_test_monitor.execute_and_translate( tc.p_test_func, timeout_microseconds );
+                elapsed_microseconds = static_cast<unsigned long int>( microsecond_wall_time(tu_timer.elapsed()) );
+
+
+                m_context.clear();
+
+
+            }
+        }
+
+
+        if( !unit_test_monitor.is_critical_error( result ) ) {
+
+            if( ::boost::unit_test::for_each::static_any_t _fe_cur_828 = ::boost::unit_test::for_each::end( tu.p_fixtures.get(), ::boost::unit_test::for_each::is_const_coll( tu.p_fixtures.get() ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_828 = ::boost::unit_test::for_each::begin( tu.p_fixtures.get(), ::boost::unit_test::for_each::is_const_coll( tu.p_fixtures.get() ) ) ) {} else for( bool _fe_con_828 = true; _fe_con_828 && !::boost::unit_test::for_each::done( _fe_cur_828, _fe_end_828, tu.p_fixtures.get(), ::boost::unit_test::for_each::is_const_coll( tu.p_fixtures.get() ) ); ) if( (_fe_con_828 = false, false) ) {} else if( (::boost::unit_test::for_each::prev( _fe_cur_828, tu.p_fixtures.get(), ::boost::unit_test::for_each::is_const_coll( tu.p_fixtures.get() ) ), false) ) {} else for( test_unit_fixture_ptr F = ::boost::unit_test::for_each::deref( _fe_cur_828, tu.p_fixtures.get(), ::boost::type<test_unit_fixture_ptr >(), ::boost::unit_test::for_each::is_const_coll( tu.p_fixtures.get() ) ); !_fe_con_828; _fe_con_828 = true ) {
+                ut_detail::test_unit_id_restore restore_current_test_unit(m_curr_test_unit, tu.p_id);
+                result = (std::min)( result, unit_test_monitor.execute_and_translate( boost::bind( &test_unit_fixture::teardown, F ), 0 ) );
+
+                if( unit_test_monitor.is_critical_error( result ) )
+                    break;
+            }
+        }
+
+
+        if( unit_test_monitor.is_critical_error( result ) ) {
+            if( ::boost::unit_test::for_each::static_any_t _fe_cur_839 = ::boost::unit_test::for_each::begin( m_observers, ::boost::unit_test::for_each::is_const_coll( m_observers ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_839 = ::boost::unit_test::for_each::end( m_observers, ::boost::unit_test::for_each::is_const_coll( m_observers ) ) ) {} else for( bool _fe_con_839 = true; _fe_con_839 && !::boost::unit_test::for_each::done( _fe_cur_839, _fe_end_839, m_observers, ::boost::unit_test::for_each::is_const_coll( m_observers ) ); _fe_con_839 ? ::boost::unit_test::for_each::next( _fe_cur_839, m_observers, ::boost::unit_test::for_each::is_const_coll( m_observers ) ) : ((void)&(m_observers))) if( (_fe_con_839 = false, false) ) {} else for( test_observer* to = ::boost::unit_test::for_each::deref( _fe_cur_839, m_observers, ::boost::type<test_observer* >(), ::boost::unit_test::for_each::is_const_coll( m_observers ) ); !_fe_con_839; _fe_con_839 = true )
+                to->test_aborted();
+        }
+
+
+        if( ::boost::unit_test::for_each::static_any_t _fe_cur_844 = ::boost::unit_test::for_each::end( m_observers, ::boost::unit_test::for_each::is_const_coll( m_observers ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_844 = ::boost::unit_test::for_each::begin( m_observers, ::boost::unit_test::for_each::is_const_coll( m_observers ) ) ) {} else for( bool _fe_con_844 = true; _fe_con_844 && !::boost::unit_test::for_each::done( _fe_cur_844, _fe_end_844, m_observers, ::boost::unit_test::for_each::is_const_coll( m_observers ) ); ) if( (_fe_con_844 = false, false) ) {} else if( (::boost::unit_test::for_each::prev( _fe_cur_844, m_observers, ::boost::unit_test::for_each::is_const_coll( m_observers ) ), false) ) {} else for( test_observer* to = ::boost::unit_test::for_each::deref( _fe_cur_844, m_observers, ::boost::type<test_observer* >(), ::boost::unit_test::for_each::is_const_coll( m_observers ) ); !_fe_con_844; _fe_con_844 = true )
+            to->test_unit_finish( tu, elapsed_microseconds );
+
+        return result;
+    }
+
+
+
+    unsigned long int child_timeout( unsigned long tu_timeout_microseconds, unsigned long elpsed_microsec )
+    {
+      if( tu_timeout_microseconds == 0UL || tu_timeout_microseconds == TIMEOUT_EXCEEDED)
+          return tu_timeout_microseconds;
+
+      return tu_timeout_microseconds > elpsed_microsec ?
+                tu_timeout_microseconds - elpsed_microsec
+                : TIMEOUT_EXCEEDED;
+    }
+
+    struct priority_order {
+        bool operator()( test_observer* lhs, test_observer* rhs ) const
+        {
+            return (lhs->priority() < rhs->priority()) || ((lhs->priority() == rhs->priority()) && (lhs < rhs));
+        }
+    };
+
+
+    typedef std::map<test_unit_id,test_unit*> test_unit_store;
+    typedef std::set<test_observer*,priority_order> observer_store;
+    struct context_frame {
+        context_frame( std::string const& d, int id, bool sticky )
+        : descr( d )
+        , frame_id( id )
+        , is_sticky( sticky )
+        {}
+
+        std::string descr;
+        int frame_id;
+        bool is_sticky;
+    };
+    typedef std::vector<context_frame> context_data;
+
+    master_test_suite_t* m_master_test_suite;
+    std::vector<test_suite*> m_auto_test_suites;
+
+    test_unit_id m_curr_test_unit;
+    test_unit_store m_test_units;
+
+    test_unit_id m_next_test_case_id;
+    test_unit_id m_next_test_suite_id;
+
+    bool m_test_in_progress;
+
+    observer_store m_observers;
+    context_data m_context;
+    int m_context_idx;
+
+    std::set<global_fixture*> m_global_fixtures;
+
+    boost::execution_monitor m_aux_em;
+
+    std::map<output_format, runtime_config::stream_holder> m_log_sinks;
+    runtime_config::stream_holder m_report_sink;
+};
+
+
+
+namespace impl {
+namespace {
+
+
+
+
+framework::state& s_frk_state() { static framework::state the_inst; return the_inst; }
+
+
+}
+
+void
+setup_for_execution( test_unit const& tu )
+{
+    s_frk_state().deduce_run_status( tu.p_id );
+}
+
+struct sum_to_first_only {
+    sum_to_first_only() : is_first(true) {}
+    template <class T, class U>
+    T operator()(T const& l_, U const& r_) {
+        if(is_first) {
+            is_first = false;
+            return l_ + r_.first;
+        }
+        return l_ + ", " + r_.first;
+    }
+
+    bool is_first;
+};
+
+void
+shutdown_loggers_and_reports()
+{
+    s_frk_state().m_log_sinks.clear();
+    s_frk_state().m_report_sink.setup( "stderr" );
+}
+
+void
+unregister_global_fixture_and_configuration()
+{
+
+    std::set<global_fixture*> gfixture_copy(s_frk_state().m_global_fixtures);
+    if( ::boost::unit_test::for_each::static_any_t _fe_cur_953 = ::boost::unit_test::for_each::begin( gfixture_copy, ::boost::unit_test::for_each::is_const_coll( gfixture_copy ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_953 = ::boost::unit_test::for_each::end( gfixture_copy, ::boost::unit_test::for_each::is_const_coll( gfixture_copy ) ) ) {} else for( bool _fe_con_953 = true; _fe_con_953 && !::boost::unit_test::for_each::done( _fe_cur_953, _fe_end_953, gfixture_copy, ::boost::unit_test::for_each::is_const_coll( gfixture_copy ) ); _fe_con_953 ? ::boost::unit_test::for_each::next( _fe_cur_953, gfixture_copy, ::boost::unit_test::for_each::is_const_coll( gfixture_copy ) ) : ((void)&(gfixture_copy))) if( (_fe_con_953 = false, false) ) {} else for( global_fixture* tuf = ::boost::unit_test::for_each::deref( _fe_cur_953, gfixture_copy, ::boost::type<global_fixture* >(), ::boost::unit_test::for_each::is_const_coll( gfixture_copy ) ); !_fe_con_953; _fe_con_953 = true ) {
+        tuf->unregister_from_framework();
+    }
+    s_frk_state().m_global_fixtures.clear();
+
+    state::observer_store gobserver_copy(s_frk_state().m_observers);
+    if( ::boost::unit_test::for_each::static_any_t _fe_cur_959 = ::boost::unit_test::for_each::begin( gobserver_copy, ::boost::unit_test::for_each::is_const_coll( gobserver_copy ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_959 = ::boost::unit_test::for_each::end( gobserver_copy, ::boost::unit_test::for_each::is_const_coll( gobserver_copy ) ) ) {} else for( bool _fe_con_959 = true; _fe_con_959 && !::boost::unit_test::for_each::done( _fe_cur_959, _fe_end_959, gobserver_copy, ::boost::unit_test::for_each::is_const_coll( gobserver_copy ) ); _fe_con_959 ? ::boost::unit_test::for_each::next( _fe_cur_959, gobserver_copy, ::boost::unit_test::for_each::is_const_coll( gobserver_copy ) ) : ((void)&(gobserver_copy))) if( (_fe_con_959 = false, false) ) {} else for( test_observer* to = ::boost::unit_test::for_each::deref( _fe_cur_959, gobserver_copy, ::boost::type<test_observer* >(), ::boost::unit_test::for_each::is_const_coll( gobserver_copy ) ); !_fe_con_959; _fe_con_959 = true ) {
+        framework::deregister_observer( *to );
+    }
+    s_frk_state().m_observers.clear();
+}
+
+void
+setup_loggers()
+{
+
+    try {
+
+
+        bool has_combined_logger = runtime_config::has( runtime_config::btrt_combined_logger )
+            && !runtime_config::get< std::vector<std::string> >( runtime_config::btrt_combined_logger ).empty();
+
+
+
+
+        if( !has_combined_logger ) {
+            unit_test_log.set_threshold_level( runtime_config::get<log_level>( runtime_config::btrt_log_level ) );
+            const output_format format = runtime_config::get<output_format>( runtime_config::btrt_log_format );
+            unit_test_log.set_format( format );
+
+            runtime_config::stream_holder& stream_logger = s_frk_state().m_log_sinks[format];
+            if( runtime_config::has( runtime_config::btrt_log_sink ) ) {
+
+                boost::function< void () > log_cleaner = boost::bind( &unit_test_log_t::set_stream,
+                                                                      &unit_test_log,
+                                                                      boost::ref(std::cout)
+                                                                      );
+                stream_logger.setup( runtime_config::get<std::string>( runtime_config::btrt_log_sink ),
+                                     log_cleaner );
+            }
+            unit_test_log.set_stream( stream_logger.ref() );
+        }
+        else
+        {
+
+            const std::vector<std::string>& v_output_format = runtime_config::get< std::vector<std::string> >( runtime_config::btrt_combined_logger ) ;
+
+            static const std::pair<const char*, log_level> all_log_levels[] = {
+                std::make_pair( "all" , log_successful_tests ),
+                std::make_pair( "success" , log_successful_tests ),
+                std::make_pair( "test_suite" , log_test_units ),
+                std::make_pair( "unit_scope" , log_test_units ),
+                std::make_pair( "message" , log_messages ),
+                std::make_pair( "warning" , log_warnings ),
+                std::make_pair( "error" , log_all_errors ),
+                std::make_pair( "cpp_exception" , log_cpp_exception_errors ),
+                std::make_pair( "system_error" , log_system_errors ),
+                std::make_pair( "fatal_error" , log_fatal_errors ),
+                std::make_pair( "nothing" , log_nothing )
+            };
+
+            static const std::pair<const char*, output_format> all_formats[] = {
+                std::make_pair( "HRF" , OF_CLF ),
+                std::make_pair( "CLF" , OF_CLF ),
+                std::make_pair( "XML" , OF_XML ),
+                std::make_pair( "JUNIT", OF_JUNIT )
+            };
+
+
+            bool is_first = true;
+
+            if( ::boost::unit_test::for_each::static_any_t _fe_cur_1024 = ::boost::unit_test::for_each::begin( v_output_format, ::boost::unit_test::for_each::is_const_coll( v_output_format ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_1024 = ::boost::unit_test::for_each::end( v_output_format, ::boost::unit_test::for_each::is_const_coll( v_output_format ) ) ) {} else for( bool _fe_con_1024 = true; _fe_con_1024 && !::boost::unit_test::for_each::done( _fe_cur_1024, _fe_end_1024, v_output_format, ::boost::unit_test::for_each::is_const_coll( v_output_format ) ); _fe_con_1024 ? ::boost::unit_test::for_each::next( _fe_cur_1024, v_output_format, ::boost::unit_test::for_each::is_const_coll( v_output_format ) ) : ((void)&(v_output_format))) if( (_fe_con_1024 = false, false) ) {} else for( const_string current_multi_config = ::boost::unit_test::for_each::deref( _fe_cur_1024, v_output_format, ::boost::type<const_string >(), ::boost::unit_test::for_each::is_const_coll( v_output_format ) ); !_fe_con_1024; _fe_con_1024 = true ) {
+
+
+
+
+
+                std::vector<std::string> v_processed_tokens;
+
+                {
+                    utils::string_token_iterator current_config( current_multi_config, (utils::dropped_delimeters = ":",
+                                                                                        utils::kept_delimeters = utils::dt_none) );
+
+                    for( ; current_config != utils::string_token_iterator() ; ++current_config) {
+                        std::string str_copy(current_config->begin(), current_config->end());
+                        if( ( str_copy[0] == '\\' || str_copy[0] == '/' )
+                            && v_processed_tokens.size() > 0) {
+                            v_processed_tokens.back() += ":" + str_copy;
+                        }
+                        else {
+                            v_processed_tokens.push_back(str_copy);
+                        }
+                    }
+                }
+
+                if( ::boost::unit_test::for_each::static_any_t _fe_cur_1048 = ::boost::unit_test::for_each::begin( v_processed_tokens, ::boost::unit_test::for_each::is_const_coll( v_processed_tokens ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_1048 = ::boost::unit_test::for_each::end( v_processed_tokens, ::boost::unit_test::for_each::is_const_coll( v_processed_tokens ) ) ) {} else for( bool _fe_con_1048 = true; _fe_con_1048 && !::boost::unit_test::for_each::done( _fe_cur_1048, _fe_end_1048, v_processed_tokens, ::boost::unit_test::for_each::is_const_coll( v_processed_tokens ) ); _fe_con_1048 ? ::boost::unit_test::for_each::next( _fe_cur_1048, v_processed_tokens, ::boost::unit_test::for_each::is_const_coll( v_processed_tokens ) ) : ((void)&(v_processed_tokens))) if( (_fe_con_1048 = false, false) ) {} else for( std::string const& current_config = ::boost::unit_test::for_each::deref( _fe_cur_1048, v_processed_tokens, ::boost::type<std::string const& >(), ::boost::unit_test::for_each::is_const_coll( v_processed_tokens ) ); !_fe_con_1048; _fe_con_1048 = true ) {
+
+                    utils::string_token_iterator current_format_specs( current_config, (utils::keep_empty_tokens,
+                                                                                        utils::dropped_delimeters = ",",
+                                                                                        utils::kept_delimeters = utils::dt_none) );
+
+                    output_format format = OF_INVALID ;
+                    if( current_format_specs != utils::string_token_iterator() &&
+                        current_format_specs->size() ) {
+
+                        for(size_t elem=0; elem < sizeof(all_formats)/sizeof(all_formats[0]); elem++) {
+                            if(const_string(all_formats[elem].first) == *current_format_specs) {
+                                format = all_formats[elem].second;
+                                break;
+                            }
+                        }
+                    }
+
+                    if( format != OF_INVALID ) {} else unit_test::ut_detail::throw_exception( boost::runtime::access_to_missing_argument() << "Unable to determine the logger type from '" << current_config << "'. Possible choices are: " << std::accumulate(all_formats, all_formats + sizeof(all_formats)/sizeof(all_formats[0]), std::string(""), sum_to_first_only()) )
+# 1075 "/usr/include/boost/test/impl/framework.ipp" 3 4
+                                       ;
+
+
+                    if( is_first ) {
+                        unit_test_log.set_format( format );
+                    }
+                    else {
+                        unit_test_log.add_format( format );
+                    }
+                    is_first = false;
+
+                    unit_test_log_formatter * const formatter = unit_test_log.get_formatter(format);
+                    if( formatter ) {} else unit_test::ut_detail::throw_exception( unit_test::framework::setup_error( "Logger setup error" ) );
+
+                    log_level formatter_log_level = invalid_log_level;
+                    ++current_format_specs ;
+                    if( !current_format_specs->size() ) {
+                        formatter_log_level = formatter->get_log_level();
+                    }
+                    else if( current_format_specs != utils::string_token_iterator() ) {
+
+                        for(size_t elem=0; elem < sizeof(all_log_levels)/sizeof(all_log_levels[0]); elem++) {
+                            if(const_string(all_log_levels[elem].first) == *current_format_specs) {
+                                formatter_log_level = all_log_levels[elem].second;
+                                break;
+                            }
+                        }
+                    }
+
+                    if( formatter_log_level != invalid_log_level ) {} else unit_test::ut_detail::throw_exception( boost::runtime::access_to_missing_argument() << "Unable to determine the log level from '" << current_config << "'. Possible choices are: " << std::accumulate(all_log_levels, all_log_levels + sizeof(all_log_levels)/sizeof(all_log_levels[0]), std::string(""), sum_to_first_only()) )
+# 1113 "/usr/include/boost/test/impl/framework.ipp" 3 4
+                                        ;
+
+                    unit_test_log.set_threshold_level( format, formatter_log_level );
+
+                    runtime_config::stream_holder& stream_logger = s_frk_state().m_log_sinks[format];
+                    boost::function< void () > log_cleaner = boost::bind( &unit_test_log_t::set_stream,
+                                                                          &unit_test_log,
+                                                                          format,
+                                                                          boost::ref(std::cout) );
+                    if( ++current_format_specs != utils::string_token_iterator() &&
+                        current_format_specs->size() ) {
+                        stream_logger.setup( *current_format_specs,
+                                             log_cleaner );
+                    }
+                    else {
+                        stream_logger.setup( formatter->get_default_stream_description(),
+                                             log_cleaner );
+                    }
+                    unit_test_log.set_stream( format, stream_logger.ref() );
+                }
+
+            }
+
+        }
+    }
+    catch( boost::runtime::init_error const& ex ) {
+        if( false ) {} else unit_test::ut_detail::throw_exception( unit_test::framework::setup_error( ex.msg ) );
+    }
+    catch( boost::runtime::input_error const& ex ) {
+        std::cerr << ex.msg << "\n\n";
+
+        unit_test::ut_detail::throw_exception( framework::nothing_to_test( boost::exit_exception_failure ) );
+    }
+
+
+}
+
+
+
+}
+
+
+
+
+
+
+
+void
+init( init_unit_test_func init_func, int argc, char* argv[] )
+{
+    using namespace impl;
+
+
+    runtime_config::init( argc, argv );
+
+
+    impl::setup_loggers();
+
+
+    results_reporter::set_level( runtime_config::get<report_level>( runtime_config::btrt_report_level ) );
+    results_reporter::set_format( runtime_config::get<output_format>( runtime_config::btrt_report_format ) );
+
+    if( runtime_config::has( runtime_config::btrt_report_sink ) ) {
+        boost::function< void () > report_cleaner = boost::bind( &results_reporter::set_stream,
+                                                                 boost::ref(std::cerr)
+                                                                );
+        s_frk_state().m_report_sink.setup( runtime_config::get<std::string>( runtime_config::btrt_report_sink ),
+                                           report_cleaner );
+    }
+
+    results_reporter::set_stream( s_frk_state().m_report_sink.ref() );
+
+
+    register_observer( results_collector );
+    register_observer( unit_test_log );
+    register_observer( framework_init_observer );
+
+    if( runtime_config::get<bool>( runtime_config::btrt_show_progress ) ) {
+        progress_monitor.set_stream( std::cout );
+        register_observer( progress_monitor );
+    }
+
+
+    unsigned long detect_mem_leak = runtime_config::get<unsigned long>( runtime_config::btrt_detect_mem_leaks );
+    if( detect_mem_leak > 0 ) {
+        debug::detect_memory_leaks( true, runtime_config::get<std::string>( runtime_config::btrt_report_mem_leaks ) );
+        debug::break_memory_alloc( (long)detect_mem_leak );
+    }
+
+
+    master_test_suite().argc = argc;
+    master_test_suite().argv = argv;
+
+
+    try {
+        s_frk_state().m_aux_em.vexecute( boost::bind( &impl::invoke_init_func, init_func ) );
+    }
+    catch( execution_exception const& ex ) {
+        if( false ) {} else unit_test::ut_detail::throw_exception( unit_test::framework::setup_error( ex.what() ) );
+    }
+}
+
+
+
+void
+finalize_setup_phase( test_unit_id master_tu_id )
+{
+    if( master_tu_id == INV_TEST_UNIT_ID )
+        master_tu_id = master_test_suite().p_id;
+
+
+
+    class apply_decorators : public test_tree_visitor {
+    private:
+
+
+        virtual bool test_suite_start( test_suite const& ts)
+        {
+            const_cast<test_suite&>(ts).generate();
+            const_cast<test_suite&>(ts).check_for_duplicate_test_cases();
+            return test_tree_visitor::test_suite_start(ts);
+        }
+
+        virtual bool visit( test_unit const& tu )
+        {
+            if( ::boost::unit_test::for_each::static_any_t _fe_cur_1238 = ::boost::unit_test::for_each::begin( tu.p_decorators.get(), ::boost::unit_test::for_each::is_const_coll( tu.p_decorators.get() ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_1238 = ::boost::unit_test::for_each::end( tu.p_decorators.get(), ::boost::unit_test::for_each::is_const_coll( tu.p_decorators.get() ) ) ) {} else for( bool _fe_con_1238 = true; _fe_con_1238 && !::boost::unit_test::for_each::done( _fe_cur_1238, _fe_end_1238, tu.p_decorators.get(), ::boost::unit_test::for_each::is_const_coll( tu.p_decorators.get() ) ); _fe_con_1238 ? ::boost::unit_test::for_each::next( _fe_cur_1238, tu.p_decorators.get(), ::boost::unit_test::for_each::is_const_coll( tu.p_decorators.get() ) ) : ((void)&(tu.p_decorators.get()))) if( (_fe_con_1238 = false, false) ) {} else for( decorator::base_ptr d = ::boost::unit_test::for_each::deref( _fe_cur_1238, tu.p_decorators.get(), ::boost::type<decorator::base_ptr >(), ::boost::unit_test::for_each::is_const_coll( tu.p_decorators.get() ) ); !_fe_con_1238; _fe_con_1238 = true )
+                d->apply( const_cast<test_unit&>(tu) );
+
+            return true;
+        }
+    } ad;
+    traverse_test_tree( master_tu_id, ad, true );
+
+
+    impl::order_info_per_tu tuoi;
+    impl::s_frk_state().deduce_siblings_order( master_tu_id, master_tu_id, tuoi );
+    impl::s_frk_state().finalize_default_run_status( master_tu_id, test_unit::RS_INVALID );
+}
+
+
+
+
+
+bool
+test_in_progress()
+{
+    return impl::s_frk_state().m_test_in_progress;
+}
+
+
+
+
+
+
+
+void
+shutdown()
+{
+
+
+    impl::shutdown_loggers_and_reports();
+
+
+    impl::unregister_global_fixture_and_configuration();
+# 1299 "/usr/include/boost/test/impl/framework.ipp" 3 4
+}
+
+
+
+
+
+
+
+void
+register_test_unit( test_case* tc )
+{
+    if( tc->p_id == INV_TEST_UNIT_ID ) {} else unit_test::ut_detail::throw_exception( unit_test::framework::setup_error( ::boost::unit_test::const_string( "test case already registered", sizeof( "test case already registered" ) - 1 ) ) );
+
+    test_unit_id new_id = impl::s_frk_state().m_next_test_case_id;
+
+    if( new_id != MAX_TEST_CASE_ID ) {} else unit_test::ut_detail::throw_exception( unit_test::framework::setup_error( ::boost::unit_test::const_string( "too many test cases", sizeof( "too many test cases" ) - 1 ) ) );
+
+    typedef state::test_unit_store::value_type map_value_type;
+
+    impl::s_frk_state().m_test_units.insert( map_value_type( new_id, tc ) );
+    impl::s_frk_state().m_next_test_case_id++;
+
+    impl::s_frk_state().set_tu_id( *tc, new_id );
+}
+
+
+
+
+
+
+
+void
+register_test_unit( test_suite* ts )
+{
+    if( ts->p_id == INV_TEST_UNIT_ID ) {} else unit_test::ut_detail::throw_exception( unit_test::framework::setup_error( ::boost::unit_test::const_string( "test suite already registered", sizeof( "test suite already registered" ) - 1 ) ) );
+
+    test_unit_id new_id = impl::s_frk_state().m_next_test_suite_id;
+
+    if( new_id != MAX_TEST_SUITE_ID ) {} else unit_test::ut_detail::throw_exception( unit_test::framework::setup_error( ::boost::unit_test::const_string( "too many test suites", sizeof( "too many test suites" ) - 1 ) ) );
+
+    typedef state::test_unit_store::value_type map_value_type;
+
+    impl::s_frk_state().m_test_units.insert( map_value_type( new_id, ts ) );
+    impl::s_frk_state().m_next_test_suite_id++;
+
+    impl::s_frk_state().set_tu_id( *ts, new_id );
+}
+
+
+
+
+
+
+
+void
+deregister_test_unit( test_unit* tu )
+{
+    impl::s_frk_state().m_test_units.erase( tu->p_id );
+}
+
+
+
+
+
+
+
+void
+clear()
+{
+    impl::s_frk_state().clear();
+}
+
+
+
+
+
+
+
+void
+register_observer( test_observer& to )
+{
+    impl::s_frk_state().m_observers.insert( &to );
+}
+
+
+
+
+
+
+
+void
+deregister_observer( test_observer& to )
+{
+    impl::s_frk_state().m_observers.erase( &to );
+}
+
+
+
+
+
+
+
+void
+register_global_fixture( global_fixture& tuf )
+{
+    impl::s_frk_state().m_global_fixtures.insert( &tuf );
+}
+
+
+
+
+
+
+
+void
+deregister_global_fixture( global_fixture &tuf )
+{
+    impl::s_frk_state().m_global_fixtures.erase( &tuf );
+}
+
+
+
+
+
+
+
+int
+add_context( ::boost::unit_test::lazy_ostream const& context_descr, bool sticky )
+{
+    std::stringstream buffer;
+    context_descr( buffer );
+    int res_idx = impl::s_frk_state().m_context_idx++;
+
+    impl::s_frk_state().m_context.push_back( state::context_frame( buffer.str(), res_idx, sticky ) );
+
+    return res_idx;
+}
+
+
+
+
+
+
+
+struct frame_with_id {
+    explicit frame_with_id( int id ) : m_id( id ) {}
+
+    bool operator()( state::context_frame const& f )
+    {
+        return f.frame_id == m_id;
+    }
+    int m_id;
+};
+
+
+
+void
+clear_context( int frame_id )
+{
+    if( frame_id == -1 ) {
+        for( int i=static_cast<int>(impl::s_frk_state().m_context.size())-1; i>=0; i-- )
+            if( !impl::s_frk_state().m_context[i].is_sticky )
+                impl::s_frk_state().m_context.erase( impl::s_frk_state().m_context.begin()+i );
+    }
+
+    else {
+        state::context_data::iterator it =
+            std::find_if( impl::s_frk_state().m_context.begin(), impl::s_frk_state().m_context.end(), frame_with_id( frame_id ) );
+
+        if( it != impl::s_frk_state().m_context.end() )
+            impl::s_frk_state().m_context.erase( it );
+    }
+}
+
+
+
+
+
+
+
+context_generator
+get_context()
+{
+    return context_generator();
+}
+
+
+
+
+
+
+
+bool
+context_generator::is_empty() const
+{
+    return impl::s_frk_state().m_context.empty();
+}
+
+
+
+const_string
+context_generator::next() const
+{
+    return m_curr_frame < impl::s_frk_state().m_context.size() ? impl::s_frk_state().m_context[m_curr_frame++].descr : const_string();
+}
+
+
+
+
+
+
+
+master_test_suite_t&
+master_test_suite()
+{
+    if( !impl::s_frk_state().m_master_test_suite )
+        impl::s_frk_state().m_master_test_suite = new master_test_suite_t;
+
+    return *impl::s_frk_state().m_master_test_suite;
+}
+
+namespace impl {
+
+master_test_suite_name_setter::master_test_suite_name_setter(const_string name) {
+  assign_op( master_test_suite().p_name.value, name.trim( "\"" ), 0 );
+}
+
+}
+
+
+
+
+
+
+
+test_suite&
+current_auto_test_suite( test_suite* ts, bool push_or_pop )
+{
+    if( impl::s_frk_state().m_auto_test_suites.empty() )
+        impl::s_frk_state().m_auto_test_suites.push_back( &framework::master_test_suite() );
+
+    if( !push_or_pop )
+        impl::s_frk_state().m_auto_test_suites.pop_back();
+    else if( ts )
+        impl::s_frk_state().m_auto_test_suites.push_back( ts );
+
+    return *impl::s_frk_state().m_auto_test_suites.back();
+}
+
+
+
+
+
+
+
+test_case const&
+current_test_case()
+{
+    return get<test_case>( impl::s_frk_state().m_curr_test_unit );
+}
+
+
+test_unit const&
+current_test_unit()
+{
+    return *impl::s_frk_state().m_test_units[impl::s_frk_state().m_curr_test_unit];
+}
+
+
+
+test_unit_id
+current_test_case_id()
+{
+    return impl::s_frk_state().m_curr_test_unit;
+}
+
+
+
+
+
+
+
+test_unit&
+get( test_unit_id id, test_unit_type t )
+{
+    test_unit* res = impl::s_frk_state().m_test_units[id];
+
+    if( (res->p_type & t) != 0 ) {} else unit_test::ut_detail::throw_exception( internal_error( "Invalid test unit type" ) );
+
+    return *res;
+}
+
+
+
+
+
+
+
+template <class Cont>
+struct swap_on_delete {
+    swap_on_delete(Cont& c1, Cont& c2) : m_c1(c1), m_c2(c2){}
+    ~swap_on_delete() {
+        m_c1.swap(m_c2);
+    }
+
+    Cont& m_c1;
+    Cont& m_c2;
+};
+
+void
+run( test_unit_id id, bool continue_test )
+{
+    if( id == INV_TEST_UNIT_ID )
+        id = master_test_suite().p_id;
+
+
+    impl::s_frk_state().deduce_run_status( id );
+
+    test_case_counter tcc;
+    traverse_test_tree( id, tcc );
+
+    if( tcc.p_count != 0 ) {} else unit_test::ut_detail::throw_exception( unit_test::framework::setup_error( runtime_config::get<std::vector<std::string> >( runtime_config::btrt_run_filters ).empty() ? ::boost::unit_test::const_string( "test tree is empty", sizeof( "test tree is empty" ) - 1 ) : ::boost::unit_test::const_string( "no test cases matching filter or all test cases were disabled", sizeof( "no test cases matching filter or all test cases were disabled" ) - 1 ) ) )
+
+                                                                                           ;
+
+    bool was_in_progress = framework::test_in_progress();
+    bool call_start_finish = !continue_test || !was_in_progress;
+    bool init_ok = true;
+    const_string setup_error;
+
+    if( call_start_finish ) {
+
+        impl::s_frk_state().m_test_in_progress = false;
+
+        if( ::boost::unit_test::for_each::static_any_t _fe_cur_1633 = ::boost::unit_test::for_each::begin( impl::s_frk_state().m_observers, ::boost::unit_test::for_each::is_const_coll( impl::s_frk_state().m_observers ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_1633 = ::boost::unit_test::for_each::end( impl::s_frk_state().m_observers, ::boost::unit_test::for_each::is_const_coll( impl::s_frk_state().m_observers ) ) ) {} else for( bool _fe_con_1633 = true; _fe_con_1633 && !::boost::unit_test::for_each::done( _fe_cur_1633, _fe_end_1633, impl::s_frk_state().m_observers, ::boost::unit_test::for_each::is_const_coll( impl::s_frk_state().m_observers ) ); _fe_con_1633 ? ::boost::unit_test::for_each::next( _fe_cur_1633, impl::s_frk_state().m_observers, ::boost::unit_test::for_each::is_const_coll( impl::s_frk_state().m_observers ) ) : ((void)&(impl::s_frk_state().m_observers))) if( (_fe_con_1633 = false, false) ) {} else for( test_observer* to = ::boost::unit_test::for_each::deref( _fe_cur_1633, impl::s_frk_state().m_observers, ::boost::type<test_observer* >(), ::boost::unit_test::for_each::is_const_coll( impl::s_frk_state().m_observers ) ); !_fe_con_1633; _fe_con_1633 = true ) {
+            try {
+                ut_detail::test_unit_id_restore restore_current_test_unit(impl::s_frk_state().m_curr_test_unit, id);
+                unit_test_monitor_t::error_level result = unit_test_monitor.execute_and_translate( boost::bind( &test_observer::test_start, to, tcc.p_count ) );
+                if( init_ok ) {
+                    if( result != unit_test_monitor_t::test_ok ) {
+                        init_ok = false;
+                    }
+                    else {
+                        if( unit_test::framework_init_observer.has_failed() ) {
+                            init_ok = false;
+                        }
+                    }
+                }
+            }
+            catch( execution_exception const& ex ) {
+                if( init_ok ) {
+
+                    init_ok = false;
+                    setup_error = ex.what();
+                }
+
+            }
+        }
+    }
+
+    if( init_ok ) {
+
+
+        test_unit& entry_test_unit = framework::get( id, TUT_ANY );
+        std::vector<test_unit_fixture_ptr> v_saved_fixture(entry_test_unit.p_fixtures.value.begin(),
+                                                           entry_test_unit.p_fixtures.value.end());
+
+        if( ::boost::unit_test::for_each::static_any_t _fe_cur_1666 = ::boost::unit_test::for_each::begin( impl::s_frk_state().m_global_fixtures, ::boost::unit_test::for_each::is_const_coll( impl::s_frk_state().m_global_fixtures ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_1666 = ::boost::unit_test::for_each::end( impl::s_frk_state().m_global_fixtures, ::boost::unit_test::for_each::is_const_coll( impl::s_frk_state().m_global_fixtures ) ) ) {} else for( bool _fe_con_1666 = true; _fe_con_1666 && !::boost::unit_test::for_each::done( _fe_cur_1666, _fe_end_1666, impl::s_frk_state().m_global_fixtures, ::boost::unit_test::for_each::is_const_coll( impl::s_frk_state().m_global_fixtures ) ); _fe_con_1666 ? ::boost::unit_test::for_each::next( _fe_cur_1666, impl::s_frk_state().m_global_fixtures, ::boost::unit_test::for_each::is_const_coll( impl::s_frk_state().m_global_fixtures ) ) : ((void)&(impl::s_frk_state().m_global_fixtures))) if( (_fe_con_1666 = false, false) ) {} else for( test_unit_fixture* tuf = ::boost::unit_test::for_each::deref( _fe_cur_1666, impl::s_frk_state().m_global_fixtures, ::boost::type<test_unit_fixture* >(), ::boost::unit_test::for_each::is_const_coll( impl::s_frk_state().m_global_fixtures ) ); !_fe_con_1666; _fe_con_1666 = true ) {
+            entry_test_unit.p_fixtures.value.insert( entry_test_unit.p_fixtures.value.begin(),
+                                                     test_unit_fixture_ptr(new impl::global_fixture_handle(tuf)) );
+        }
+
+        swap_on_delete< std::vector<test_unit_fixture_ptr> > raii_fixture(v_saved_fixture, entry_test_unit.p_fixtures.value);
+
+
+        impl::s_frk_state().m_test_in_progress = true;
+        unsigned seed = runtime_config::get<unsigned>( runtime_config::btrt_random_seed );
+        switch( seed ) {
+        case 0:
+            break;
+        case 1:
+            seed = static_cast<unsigned>( std::rand() ^ std::time( 0 ) );
+            __attribute__((fallthrough));
+        default:
+            (::boost::unit_test::unit_test_log << ::boost::unit_test::log::begin( "boost.test framework", 0 )) ( ::boost::unit_test::log_messages ) << (::boost::unit_test::lazy_ostream::instance() << "Test cases order is shuffled using seed: " << seed);
+            std::srand( seed );
+        }
+
+
+        impl::s_frk_state().execute_test_tree( id );
+
+
+    }
+
+    impl::s_frk_state().m_test_in_progress = false;
+
+    results_reporter::make_report( INV_REPORT_LEVEL, id );
+
+    unit_test::framework_init_observer.clear();
+    if( call_start_finish ) {
+
+
+
+        impl::s_frk_state().m_test_in_progress = false;
+        if( ::boost::unit_test::for_each::static_any_t _fe_cur_1703 = ::boost::unit_test::for_each::end( impl::s_frk_state().m_observers, ::boost::unit_test::for_each::is_const_coll( impl::s_frk_state().m_observers ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_1703 = ::boost::unit_test::for_each::begin( impl::s_frk_state().m_observers, ::boost::unit_test::for_each::is_const_coll( impl::s_frk_state().m_observers ) ) ) {} else for( bool _fe_con_1703 = true; _fe_con_1703 && !::boost::unit_test::for_each::done( _fe_cur_1703, _fe_end_1703, impl::s_frk_state().m_observers, ::boost::unit_test::for_each::is_const_coll( impl::s_frk_state().m_observers ) ); ) if( (_fe_con_1703 = false, false) ) {} else if( (::boost::unit_test::for_each::prev( _fe_cur_1703, impl::s_frk_state().m_observers, ::boost::unit_test::for_each::is_const_coll( impl::s_frk_state().m_observers ) ), false) ) {} else for( test_observer* to = ::boost::unit_test::for_each::deref( _fe_cur_1703, impl::s_frk_state().m_observers, ::boost::type<test_observer* >(), ::boost::unit_test::for_each::is_const_coll( impl::s_frk_state().m_observers ) ); !_fe_con_1703; _fe_con_1703 = true ) {
+            ut_detail::test_unit_id_restore restore_current_test_unit(impl::s_frk_state().m_curr_test_unit, id);
+            to->test_finish();
+        }
+    }
+
+    impl::s_frk_state().m_test_in_progress = was_in_progress;
+
+
+    if( init_ok && !unit_test::framework_init_observer.has_failed() ) {} else unit_test::ut_detail::throw_exception( unit_test::framework::setup_error( setup_error ) );
+}
+
+
+
+void
+run( test_unit const* tu, bool continue_test )
+{
+    run( tu->p_id, continue_test );
+}
+
+
+
+
+
+
+
+void
+assertion_result( unit_test::assertion_result ar )
+{
+    if( ::boost::unit_test::for_each::static_any_t _fe_cur_1732 = ::boost::unit_test::for_each::begin( impl::s_frk_state().m_observers, ::boost::unit_test::for_each::is_const_coll( impl::s_frk_state().m_observers ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_1732 = ::boost::unit_test::for_each::end( impl::s_frk_state().m_observers, ::boost::unit_test::for_each::is_const_coll( impl::s_frk_state().m_observers ) ) ) {} else for( bool _fe_con_1732 = true; _fe_con_1732 && !::boost::unit_test::for_each::done( _fe_cur_1732, _fe_end_1732, impl::s_frk_state().m_observers, ::boost::unit_test::for_each::is_const_coll( impl::s_frk_state().m_observers ) ); _fe_con_1732 ? ::boost::unit_test::for_each::next( _fe_cur_1732, impl::s_frk_state().m_observers, ::boost::unit_test::for_each::is_const_coll( impl::s_frk_state().m_observers ) ) : ((void)&(impl::s_frk_state().m_observers))) if( (_fe_con_1732 = false, false) ) {} else for( test_observer* to = ::boost::unit_test::for_each::deref( _fe_cur_1732, impl::s_frk_state().m_observers, ::boost::type<test_observer* >(), ::boost::unit_test::for_each::is_const_coll( impl::s_frk_state().m_observers ) ); !_fe_con_1732; _fe_con_1732 = true )
+        to->assertion_result( ar );
+}
+
+
+
+
+
+
+
+void
+exception_caught( execution_exception const& ex )
+{
+    if( ::boost::unit_test::for_each::static_any_t _fe_cur_1745 = ::boost::unit_test::for_each::begin( impl::s_frk_state().m_observers, ::boost::unit_test::for_each::is_const_coll( impl::s_frk_state().m_observers ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_1745 = ::boost::unit_test::for_each::end( impl::s_frk_state().m_observers, ::boost::unit_test::for_each::is_const_coll( impl::s_frk_state().m_observers ) ) ) {} else for( bool _fe_con_1745 = true; _fe_con_1745 && !::boost::unit_test::for_each::done( _fe_cur_1745, _fe_end_1745, impl::s_frk_state().m_observers, ::boost::unit_test::for_each::is_const_coll( impl::s_frk_state().m_observers ) ); _fe_con_1745 ? ::boost::unit_test::for_each::next( _fe_cur_1745, impl::s_frk_state().m_observers, ::boost::unit_test::for_each::is_const_coll( impl::s_frk_state().m_observers ) ) : ((void)&(impl::s_frk_state().m_observers))) if( (_fe_con_1745 = false, false) ) {} else for( test_observer* to = ::boost::unit_test::for_each::deref( _fe_cur_1745, impl::s_frk_state().m_observers, ::boost::type<test_observer* >(), ::boost::unit_test::for_each::is_const_coll( impl::s_frk_state().m_observers ) ); !_fe_con_1745; _fe_con_1745 = true )
+        to->exception_caught( ex );
+}
+
+
+
+
+
+
+
+void
+test_unit_aborted( test_unit const& tu )
+{
+    if( ::boost::unit_test::for_each::static_any_t _fe_cur_1758 = ::boost::unit_test::for_each::begin( impl::s_frk_state().m_observers, ::boost::unit_test::for_each::is_const_coll( impl::s_frk_state().m_observers ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_1758 = ::boost::unit_test::for_each::end( impl::s_frk_state().m_observers, ::boost::unit_test::for_each::is_const_coll( impl::s_frk_state().m_observers ) ) ) {} else for( bool _fe_con_1758 = true; _fe_con_1758 && !::boost::unit_test::for_each::done( _fe_cur_1758, _fe_end_1758, impl::s_frk_state().m_observers, ::boost::unit_test::for_each::is_const_coll( impl::s_frk_state().m_observers ) ); _fe_con_1758 ? ::boost::unit_test::for_each::next( _fe_cur_1758, impl::s_frk_state().m_observers, ::boost::unit_test::for_each::is_const_coll( impl::s_frk_state().m_observers ) ) : ((void)&(impl::s_frk_state().m_observers))) if( (_fe_con_1758 = false, false) ) {} else for( test_observer* to = ::boost::unit_test::for_each::deref( _fe_cur_1758, impl::s_frk_state().m_observers, ::boost::type<test_observer* >(), ::boost::unit_test::for_each::is_const_coll( impl::s_frk_state().m_observers ) ); !_fe_con_1758; _fe_con_1758 = true )
+        to->test_unit_aborted( tu );
+}
+
+
+
+
+
+void
+test_aborted( )
+{
+    if( ::boost::unit_test::for_each::static_any_t _fe_cur_1769 = ::boost::unit_test::for_each::begin( impl::s_frk_state().m_observers, ::boost::unit_test::for_each::is_const_coll( impl::s_frk_state().m_observers ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_1769 = ::boost::unit_test::for_each::end( impl::s_frk_state().m_observers, ::boost::unit_test::for_each::is_const_coll( impl::s_frk_state().m_observers ) ) ) {} else for( bool _fe_con_1769 = true; _fe_con_1769 && !::boost::unit_test::for_each::done( _fe_cur_1769, _fe_end_1769, impl::s_frk_state().m_observers, ::boost::unit_test::for_each::is_const_coll( impl::s_frk_state().m_observers ) ); _fe_con_1769 ? ::boost::unit_test::for_each::next( _fe_cur_1769, impl::s_frk_state().m_observers, ::boost::unit_test::for_each::is_const_coll( impl::s_frk_state().m_observers ) ) : ((void)&(impl::s_frk_state().m_observers))) if( (_fe_con_1769 = false, false) ) {} else for( test_observer* to = ::boost::unit_test::for_each::deref( _fe_cur_1769, impl::s_frk_state().m_observers, ::boost::type<test_observer* >(), ::boost::unit_test::for_each::is_const_coll( impl::s_frk_state().m_observers ) ); !_fe_con_1769; _fe_con_1769 = true )
+        to->test_aborted( );
+}
+
+
+
+
+}
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 1781 "/usr/include/boost/test/impl/framework.ipp" 2 3 4
+# 23 "/usr/include/boost/test/included/unit_test.hpp" 2 3 4
+# 1 "/usr/include/boost/test/impl/execution_monitor.ipp" 1 3 4
+# 22 "/usr/include/boost/test/impl/execution_monitor.ipp" 3 4
+#define BOOST_TEST_EXECUTION_MONITOR_IPP_012205GER 
+# 35 "/usr/include/boost/test/impl/execution_monitor.ipp" 3 4
+# 1 "/usr/include/boost/exception/get_error_info.hpp" 1 3 4
+
+
+
+
+
+
+#define UUID_1A590226753311DD9E4CCF6156D89593 
+
+
+
+# 1 "/usr/include/boost/exception/detail/error_info_impl.hpp" 1 3 4
+
+
+
+
+
+
+#define UUID_CE6983AC753411DDA764247956D89593 
+
+
+
+# 1 "/usr/include/boost/type_traits/is_nothrow_move_constructible.hpp" 1 3 4
+# 12 "/usr/include/boost/type_traits/is_nothrow_move_constructible.hpp" 3 4
+#define BOOST_TT_IS_NOTHROW_MOVE_CONSTRUCTIBLE_HPP_INCLUDED 
+# 40 "/usr/include/boost/type_traits/is_nothrow_move_constructible.hpp" 3 4
+namespace boost{ namespace detail{
+
+template <class T, class Enable = void>
+struct false_or_cpp11_noexcept_move_constructible: public ::boost::false_type {};
+
+template <class T>
+struct false_or_cpp11_noexcept_move_constructible <
+        T,
+        typename ::boost::enable_if_<sizeof(T) && noexcept((T(::boost::declval<T>())))>::type
+    > : public ::boost::integral_constant<bool, noexcept((T(::boost::declval<T>())))>
+{};
+
+}
+
+template <class T> struct is_nothrow_move_constructible
+   : public integral_constant<bool, ::boost::detail::false_or_cpp11_noexcept_move_constructible<T>::value>
+{
+   static_assert(boost::is_complete<T>::value, "Arguments to is_nothrow_move_constructible must be complete types");
+};
+
+template <class T> struct is_nothrow_move_constructible<volatile T> : public ::boost::false_type {};
+template <class T> struct is_nothrow_move_constructible<const volatile T> : public ::boost::false_type{};
+template <class T, std::size_t N> struct is_nothrow_move_constructible<T[N]> : public ::boost::false_type{};
+template <class T> struct is_nothrow_move_constructible<T[]> : public ::boost::false_type{};
+# 83 "/usr/include/boost/type_traits/is_nothrow_move_constructible.hpp" 3 4
+template <> struct is_nothrow_move_constructible<void> : false_type{};
+
+template <> struct is_nothrow_move_constructible<void const> : false_type{};
+template <> struct is_nothrow_move_constructible<void volatile> : false_type{};
+template <> struct is_nothrow_move_constructible<void const volatile> : false_type{};
+
+
+template <class T> struct is_nothrow_move_constructible<T&> : public ::boost::true_type{};
+
+template <class T> struct is_nothrow_move_constructible<T&&> : public ::boost::true_type{};
+
+
+}
+# 12 "/usr/include/boost/exception/detail/error_info_impl.hpp" 2 3 4
+
+
+
+
+
+       
+# 18 "/usr/include/boost/exception/detail/error_info_impl.hpp" 3
+
+
+
+
+
+namespace
+boost
+    {
+    namespace
+    exception_detail
+        {
+        class
+        error_info_base
+            {
+            public:
+
+            virtual std::string name_value_string() const = 0;
+            virtual error_info_base * clone() const = 0;
+
+            virtual
+            ~error_info_base() noexcept
+                {
+                }
+            };
+        }
+
+    template <class Tag,class T>
+    class
+    error_info:
+        public exception_detail::error_info_base
+        {
+        exception_detail::error_info_base *
+        clone() const
+            {
+            return new error_info<Tag,T>(*this);
+            }
+        public:
+        typedef T value_type;
+        error_info( value_type const & v ):
+            v_(v)
+            {
+            }
+
+
+        error_info( error_info const & x ):
+            v_(x.v_)
+            {
+            }
+        error_info( T && v ) noexcept((boost::is_nothrow_move_constructible<T>::value)):
+            v_(std::move(v))
+            {
+            }
+        error_info( error_info && x ) noexcept((boost::is_nothrow_move_constructible<T>::value)):
+            v_(std::move(x.v_))
+            {
+            }
+
+
+        ~error_info() noexcept
+            {
+            }
+        value_type const &
+        value() const
+            {
+            return v_;
+            }
+        value_type &
+        value()
+            {
+            return v_;
+            }
+        private:
+        error_info & operator=( error_info const & );
+
+        error_info & operator=( error_info && x );
+
+        std::string name_value_string() const;
+        value_type v_;
+        };
+    }
+# 12 "/usr/include/boost/exception/get_error_info.hpp" 2 3 4
+# 1 "/usr/include/boost/exception/detail/type_info.hpp" 1 3 4
+
+
+
+
+
+
+#define UUID_C3E1741C754311DDB2834CCA55D89593 
+
+
+# 1 "/usr/include/boost/core/typeinfo.hpp" 1 3 4
+
+#define BOOST_CORE_TYPEINFO_HPP_INCLUDED 
+# 138 "/usr/include/boost/core/typeinfo.hpp" 3 4
+namespace boost
+{
+
+namespace core
+{
+
+
+
+
+
+
+
+typedef std::type_info typeinfo;
+
+
+
+inline std::string demangled_name( core::typeinfo const & ti )
+{
+    return core::demangle( ti.name() );
+}
+
+}
+
+}
+
+#define BOOST_CORE_TYPEID(T) typeid(T)
+# 11 "/usr/include/boost/exception/detail/type_info.hpp" 2 3 4
+
+
+
+
+
+       
+# 17 "/usr/include/boost/exception/detail/type_info.hpp" 3
+
+
+
+
+
+namespace
+boost
+    {
+    template <class T>
+    inline
+    std::string
+    tag_type_name()
+        {
+
+
+
+        return core::demangle(typeid(T*).name());
+
+        }
+
+    template <class T>
+    inline
+    std::string
+    type_name()
+        {
+
+
+
+        return core::demangle(typeid(T).name());
+
+        }
+
+    namespace
+    exception_detail
+        {
+        struct
+        type_info_
+            {
+            core::typeinfo const * type_;
+
+            explicit
+            type_info_( core::typeinfo const & type ):
+                type_(&type)
+                {
+                }
+
+            friend
+            bool
+            operator<( type_info_ const & a, type_info_ const & b )
+                {
+                return 0!=(a.type_->before(*b.type_));
+                }
+            };
+        }
+    }
+
+#define BOOST_EXCEPTION_STATIC_TYPEID(T) ::boost::exception_detail::type_info_(BOOST_CORE_TYPEID(T))
+
+
+#define BOOST_EXCEPTION_DYNAMIC_TYPEID(x) ::boost::exception_detail::type_info_(typeid(x))
+# 13 "/usr/include/boost/exception/get_error_info.hpp" 2 3 4
+# 1 "/usr/include/boost/exception/detail/shared_ptr.hpp" 1 3 4
+
+
+
+
+
+
+#define UUID_837060E885AF11E68DA91D15E31AC075 
+
+
+
+
+
+
+namespace boost { namespace exception_detail { using boost::shared_ptr; } }
+# 14 "/usr/include/boost/exception/get_error_info.hpp" 2 3 4
+# 1 "/usr/include/boost/assert.hpp" 1 3 4
+# 32 "/usr/include/boost/assert.hpp" 3 4
+#undef BOOST_ASSERT
+#undef BOOST_ASSERT_MSG
+#undef BOOST_ASSERT_IS_VOID
+# 58 "/usr/include/boost/assert.hpp" 3 4
+# 1 "/usr/include/assert.h" 1 3 4
+# 24 "/usr/include/assert.h" 3 4
+#undef _ASSERT_H
+#undef assert
+#undef __ASSERT_VOID_CAST
+
+
+#undef assert_perror
+
+
+
+
+#define _ASSERT_H 1
+
+
+
+#define __ASSERT_VOID_CAST static_cast<void>
+# 64 "/usr/include/assert.h" 3 4
+extern "C" {
+
+
+extern void __assert_fail (const char *__assertion, const char *__file,
+      unsigned int __line, const char *__function)
+     throw () __attribute__ ((__noreturn__));
+
+
+extern void __assert_perror_fail (int __errnum, const char *__file,
+      unsigned int __line, const char *__function)
+     throw () __attribute__ ((__noreturn__));
+
+
+
+
+extern void __assert (const char *__assertion, const char *__file, int __line)
+     throw () __attribute__ ((__noreturn__));
+
+
+}
+
+
+
+
+
+#define assert(expr) (static_cast <bool> (expr) ? void (0) : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
+# 114 "/usr/include/assert.h" 3 4
+#define assert_perror(errnum) (!(errnum) ? __ASSERT_VOID_CAST (0) : __assert_perror_fail ((errnum), __FILE__, __LINE__, __ASSERT_FUNCTION))
+# 126 "/usr/include/assert.h" 3 4
+#define __ASSERT_FUNCTION __extension__ __PRETTY_FUNCTION__
+# 59 "/usr/include/boost/assert.hpp" 2 3 4
+
+#define BOOST_ASSERT(expr) assert(expr)
+#define BOOST_ASSERT_MSG(expr,msg) assert((expr)&&(msg))
+# 72 "/usr/include/boost/assert.hpp" 3 4
+#undef BOOST_VERIFY
+#undef BOOST_VERIFY_MSG
+# 82 "/usr/include/boost/assert.hpp" 3 4
+#define BOOST_VERIFY(expr) BOOST_ASSERT(expr)
+#define BOOST_VERIFY_MSG(expr,msg) BOOST_ASSERT_MSG(expr,msg)
+# 15 "/usr/include/boost/exception/get_error_info.hpp" 2 3 4
+
+
+       
+# 18 "/usr/include/boost/exception/get_error_info.hpp" 3
+
+
+
+
+
+namespace
+boost
+    {
+    namespace
+    exception_detail
+        {
+        template <class ErrorInfo>
+        struct
+        get_info
+            {
+            static
+            typename ErrorInfo::value_type *
+            get( exception const & x )
+                {
+                if( exception_detail::error_info_container * c=x.data_.get() )
+                    if( shared_ptr<exception_detail::error_info_base> eib = c->get(::boost::exception_detail::type_info_(typeid(ErrorInfo))) )
+                        {
+
+                        (static_cast <bool> (0!=dynamic_cast<ErrorInfo *>(eib.get())) ? void (0) : __assert_fail ("0!=dynamic_cast<ErrorInfo *>(eib.get())", "/usr/include/boost/exception/get_error_info.hpp", 41, __extension__ __PRETTY_FUNCTION__));
+
+                        ErrorInfo * w = static_cast<ErrorInfo *>(eib.get());
+                        return &w->value();
+                        }
+                return 0;
+                }
+            };
+
+        template <>
+        struct
+        get_info<throw_function>
+            {
+            static
+            char const * *
+            get( exception const & x )
+                {
+                return x.throw_function_ ? &x.throw_function_ : 0;
+                }
+            };
+
+        template <>
+        struct
+        get_info<throw_file>
+            {
+            static
+            char const * *
+            get( exception const & x )
+                {
+                return x.throw_file_ ? &x.throw_file_ : 0;
+                }
+            };
+
+        template <>
+        struct
+        get_info<throw_line>
+            {
+            static
+            int *
+            get( exception const & x )
+                {
+                return x.throw_line_!=-1 ? &x.throw_line_ : 0;
+                }
+            };
+
+        template <class T,class R>
+        struct
+        get_error_info_return_type
+            {
+            typedef R * type;
+            };
+
+        template <class T,class R>
+        struct
+        get_error_info_return_type<T const,R>
+            {
+            typedef R const * type;
+            };
+        }
+# 117 "/usr/include/boost/exception/get_error_info.hpp" 3
+    template <class ErrorInfo,class E>
+    inline
+    typename exception_detail::get_error_info_return_type<E,typename ErrorInfo::value_type>::type
+    get_error_info( E & some_exception )
+        {
+        if( exception const * x = dynamic_cast<exception const *>(&some_exception) )
+            return exception_detail::get_info<ErrorInfo>::get(*x);
+        else
+            return 0;
+        }
+
+    }
+# 36 "/usr/include/boost/test/impl/execution_monitor.ipp" 2 3 4
+# 1 "/usr/include/boost/exception/current_exception_cast.hpp" 1 3 4
+
+
+
+
+
+
+#define UUID_7E83C166200811DE885E826156D89593 
+
+       
+# 10 "/usr/include/boost/exception/current_exception_cast.hpp" 3
+
+
+
+
+
+namespace
+boost
+    {
+    template <class E>
+    inline
+    E *
+    current_exception_cast()
+        {
+        try
+            {
+            throw;
+            }
+        catch(
+        E & e )
+            {
+            return &e;
+            }
+        catch(
+        ...)
+            {
+            return 0;
+            }
+        }
+    }
+# 37 "/usr/include/boost/test/impl/execution_monitor.ipp" 2 3 4
+# 1 "/usr/include/boost/exception/diagnostic_information.hpp" 1 3 4
+
+
+
+
+
+
+#define UUID_0552D49838DD11DD90146B8956D89593 
+
+
+
+# 1 "/usr/include/boost/exception/info.hpp" 1 3 4
+
+
+
+
+
+
+#define UUID_8D22C4CA9CC811DCAA9133D256D89593 
+
+
+
+# 1 "/usr/include/boost/exception/to_string_stub.hpp" 1 3 4
+
+
+
+
+
+
+#define UUID_E788439ED9F011DCB181F25B55D89593 
+
+# 1 "/usr/include/boost/exception/to_string.hpp" 1 3 4
+
+
+
+
+
+
+#define UUID_7E48761AD92811DC9011477D56D89593 
+
+
+# 1 "/usr/include/boost/exception/detail/is_output_streamable.hpp" 1 3 4
+
+
+
+
+
+
+#define UUID_898984B4076411DD973EDFA055D89593 
+
+
+
+
+       
+# 13 "/usr/include/boost/exception/detail/is_output_streamable.hpp" 3
+
+
+
+
+
+namespace
+boost
+    {
+    namespace
+    to_string_detail
+        {
+        struct
+        partial_ordering_helper1
+            {
+            template <class CharT,class Traits>
+            partial_ordering_helper1( std::basic_ostream<CharT,Traits> & );
+            };
+
+        struct
+        partial_ordering_helper2
+            {
+            template <class T>
+            partial_ordering_helper2( T const & );
+            };
+
+        char operator<<( partial_ordering_helper1, partial_ordering_helper2 );
+
+        template <class T,class CharT,class Traits>
+        struct
+        is_output_streamable_impl
+            {
+            static std::basic_ostream<CharT,Traits> & f();
+            static T const & g();
+            enum e { value=1!=(sizeof(f()<<g())) };
+            };
+        }
+
+    template <class T, class CharT=char, class Traits=std::char_traits<CharT> >
+    struct
+    is_output_streamable
+        {
+        enum e { value=to_string_detail::is_output_streamable_impl<T,CharT,Traits>::value };
+        };
+    }
+# 11 "/usr/include/boost/exception/to_string.hpp" 2 3 4
+
+
+
+       
+# 15 "/usr/include/boost/exception/to_string.hpp" 3
+
+
+
+
+
+namespace
+boost
+    {
+    template <class T,class U>
+    std::string to_string( std::pair<T,U> const & );
+    std::string to_string( std::exception const & );
+
+    namespace
+    to_string_detail
+        {
+        template <class T>
+        typename disable_if<is_output_streamable<T>,char>::type to_string( T const & );
+        using boost::to_string;
+
+        template <class,bool IsOutputStreamable>
+        struct has_to_string_impl;
+
+        template <class T>
+        struct
+        has_to_string_impl<T,true>
+            {
+            enum e { value=1 };
+            };
+
+        template <class T>
+        struct
+        has_to_string_impl<T,false>
+            {
+            static T const & f();
+            enum e { value=1!=sizeof(to_string(f())) };
+            };
+        }
+
+    template <class T>
+    inline
+    typename enable_if<is_output_streamable<T>,std::string>::type
+    to_string( T const & x )
+        {
+        std::ostringstream out;
+        out << x;
+        return out.str();
+        }
+
+    template <class T>
+    struct
+    has_to_string
+        {
+        enum e { value=to_string_detail::has_to_string_impl<T,is_output_streamable<T>::value>::value };
+        };
+
+    template <class T,class U>
+    inline
+    std::string
+    to_string( std::pair<T,U> const & x )
+        {
+        return std::string("(") + to_string(x.first) + ',' + to_string(x.second) + ')';
+        }
+
+    inline
+    std::string
+    to_string( std::exception const & x )
+        {
+        return x.what();
+        }
+    }
+# 10 "/usr/include/boost/exception/to_string_stub.hpp" 2 3 4
+# 1 "/usr/include/boost/exception/detail/object_hex_dump.hpp" 1 3 4
+
+
+
+
+
+
+#define UUID_6F463AC838DF11DDA3E6909F56D89593 
+
+
+# 1 "/usr/include/c++/10.2.0/iomanip" 1 3 4
+# 34 "/usr/include/c++/10.2.0/iomanip" 3 4
+#define _GLIBCXX_IOMANIP 1
+
+       
+# 37 "/usr/include/c++/10.2.0/iomanip" 3
+
+
+
+
+
+
+# 1 "/usr/include/c++/10.2.0/locale" 1 3
+# 34 "/usr/include/c++/10.2.0/locale" 3
+#define _GLIBCXX_LOCALE 1
+
+       
+# 37 "/usr/include/c++/10.2.0/locale" 3
+
+
+
+
+# 1 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 1 3
+# 35 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+#define _LOCALE_FACETS_NONIO_H 1
+
+       
+# 38 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+
+# 1 "/usr/include/c++/10.2.0/ctime" 1 3
+# 39 "/usr/include/c++/10.2.0/ctime" 3
+       
+# 40 "/usr/include/c++/10.2.0/ctime" 3
+# 40 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 52 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+  class time_base
+  {
+  public:
+    enum dateorder { no_order, dmy, mdy, ymd, ydm };
+  };
+
+  template<typename _CharT>
+    struct __timepunct_cache : public locale::facet
+    {
+
+      static const _CharT* _S_timezones[14];
+
+      const _CharT* _M_date_format;
+      const _CharT* _M_date_era_format;
+      const _CharT* _M_time_format;
+      const _CharT* _M_time_era_format;
+      const _CharT* _M_date_time_format;
+      const _CharT* _M_date_time_era_format;
+      const _CharT* _M_am;
+      const _CharT* _M_pm;
+      const _CharT* _M_am_pm_format;
+
+
+      const _CharT* _M_day1;
+      const _CharT* _M_day2;
+      const _CharT* _M_day3;
+      const _CharT* _M_day4;
+      const _CharT* _M_day5;
+      const _CharT* _M_day6;
+      const _CharT* _M_day7;
+
+
+      const _CharT* _M_aday1;
+      const _CharT* _M_aday2;
+      const _CharT* _M_aday3;
+      const _CharT* _M_aday4;
+      const _CharT* _M_aday5;
+      const _CharT* _M_aday6;
+      const _CharT* _M_aday7;
+
+
+      const _CharT* _M_month01;
+      const _CharT* _M_month02;
+      const _CharT* _M_month03;
+      const _CharT* _M_month04;
+      const _CharT* _M_month05;
+      const _CharT* _M_month06;
+      const _CharT* _M_month07;
+      const _CharT* _M_month08;
+      const _CharT* _M_month09;
+      const _CharT* _M_month10;
+      const _CharT* _M_month11;
+      const _CharT* _M_month12;
+
+
+      const _CharT* _M_amonth01;
+      const _CharT* _M_amonth02;
+      const _CharT* _M_amonth03;
+      const _CharT* _M_amonth04;
+      const _CharT* _M_amonth05;
+      const _CharT* _M_amonth06;
+      const _CharT* _M_amonth07;
+      const _CharT* _M_amonth08;
+      const _CharT* _M_amonth09;
+      const _CharT* _M_amonth10;
+      const _CharT* _M_amonth11;
+      const _CharT* _M_amonth12;
+
+      bool _M_allocated;
+
+      __timepunct_cache(size_t __refs = 0) : facet(__refs),
+      _M_date_format(0), _M_date_era_format(0), _M_time_format(0),
+      _M_time_era_format(0), _M_date_time_format(0),
+      _M_date_time_era_format(0), _M_am(0), _M_pm(0),
+      _M_am_pm_format(0), _M_day1(0), _M_day2(0), _M_day3(0),
+      _M_day4(0), _M_day5(0), _M_day6(0), _M_day7(0),
+      _M_aday1(0), _M_aday2(0), _M_aday3(0), _M_aday4(0),
+      _M_aday5(0), _M_aday6(0), _M_aday7(0), _M_month01(0),
+      _M_month02(0), _M_month03(0), _M_month04(0), _M_month05(0),
+      _M_month06(0), _M_month07(0), _M_month08(0), _M_month09(0),
+      _M_month10(0), _M_month11(0), _M_month12(0), _M_amonth01(0),
+      _M_amonth02(0), _M_amonth03(0), _M_amonth04(0),
+      _M_amonth05(0), _M_amonth06(0), _M_amonth07(0),
+      _M_amonth08(0), _M_amonth09(0), _M_amonth10(0),
+      _M_amonth11(0), _M_amonth12(0), _M_allocated(false)
+      { }
+
+      ~__timepunct_cache();
+
+    private:
+      __timepunct_cache&
+      operator=(const __timepunct_cache&);
+
+      explicit
+      __timepunct_cache(const __timepunct_cache&);
+    };
+
+  template<typename _CharT>
+    __timepunct_cache<_CharT>::~__timepunct_cache()
+    {
+      if (_M_allocated)
+ {
+
+ }
+    }
+
+
+  template<>
+    const char*
+    __timepunct_cache<char>::_S_timezones[14];
+
+
+  template<>
+    const wchar_t*
+    __timepunct_cache<wchar_t>::_S_timezones[14];
+
+
+
+  template<typename _CharT>
+    const _CharT* __timepunct_cache<_CharT>::_S_timezones[14];
+
+  template<typename _CharT>
+    class __timepunct : public locale::facet
+    {
+    public:
+
+      typedef _CharT __char_type;
+      typedef __timepunct_cache<_CharT> __cache_type;
+
+    protected:
+      __cache_type* _M_data;
+      __c_locale _M_c_locale_timepunct;
+      const char* _M_name_timepunct;
+
+    public:
+
+      static locale::id id;
+
+      explicit
+      __timepunct(size_t __refs = 0);
+
+      explicit
+      __timepunct(__cache_type* __cache, size_t __refs = 0);
+# 206 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      explicit
+      __timepunct(__c_locale __cloc, const char* __s, size_t __refs = 0);
+
+
+
+      void
+      _M_put(_CharT* __s, size_t __maxlen, const _CharT* __format,
+      const tm* __tm) const throw ();
+
+      void
+      _M_date_formats(const _CharT** __date) const
+      {
+
+ __date[0] = _M_data->_M_date_format;
+ __date[1] = _M_data->_M_date_era_format;
+      }
+
+      void
+      _M_time_formats(const _CharT** __time) const
+      {
+
+ __time[0] = _M_data->_M_time_format;
+ __time[1] = _M_data->_M_time_era_format;
+      }
+
+      void
+      _M_date_time_formats(const _CharT** __dt) const
+      {
+
+ __dt[0] = _M_data->_M_date_time_format;
+ __dt[1] = _M_data->_M_date_time_era_format;
+      }
+
+
+      void
+      _M_am_pm_format(const _CharT*) const
+      { }
+
+
+      void
+      _M_am_pm(const _CharT** __ampm) const
+      {
+ __ampm[0] = _M_data->_M_am;
+ __ampm[1] = _M_data->_M_pm;
+      }
+
+      void
+      _M_days(const _CharT** __days) const
+      {
+ __days[0] = _M_data->_M_day1;
+ __days[1] = _M_data->_M_day2;
+ __days[2] = _M_data->_M_day3;
+ __days[3] = _M_data->_M_day4;
+ __days[4] = _M_data->_M_day5;
+ __days[5] = _M_data->_M_day6;
+ __days[6] = _M_data->_M_day7;
+      }
+
+      void
+      _M_days_abbreviated(const _CharT** __days) const
+      {
+ __days[0] = _M_data->_M_aday1;
+ __days[1] = _M_data->_M_aday2;
+ __days[2] = _M_data->_M_aday3;
+ __days[3] = _M_data->_M_aday4;
+ __days[4] = _M_data->_M_aday5;
+ __days[5] = _M_data->_M_aday6;
+ __days[6] = _M_data->_M_aday7;
+      }
+
+      void
+      _M_months(const _CharT** __months) const
+      {
+ __months[0] = _M_data->_M_month01;
+ __months[1] = _M_data->_M_month02;
+ __months[2] = _M_data->_M_month03;
+ __months[3] = _M_data->_M_month04;
+ __months[4] = _M_data->_M_month05;
+ __months[5] = _M_data->_M_month06;
+ __months[6] = _M_data->_M_month07;
+ __months[7] = _M_data->_M_month08;
+ __months[8] = _M_data->_M_month09;
+ __months[9] = _M_data->_M_month10;
+ __months[10] = _M_data->_M_month11;
+ __months[11] = _M_data->_M_month12;
+      }
+
+      void
+      _M_months_abbreviated(const _CharT** __months) const
+      {
+ __months[0] = _M_data->_M_amonth01;
+ __months[1] = _M_data->_M_amonth02;
+ __months[2] = _M_data->_M_amonth03;
+ __months[3] = _M_data->_M_amonth04;
+ __months[4] = _M_data->_M_amonth05;
+ __months[5] = _M_data->_M_amonth06;
+ __months[6] = _M_data->_M_amonth07;
+ __months[7] = _M_data->_M_amonth08;
+ __months[8] = _M_data->_M_amonth09;
+ __months[9] = _M_data->_M_amonth10;
+ __months[10] = _M_data->_M_amonth11;
+ __months[11] = _M_data->_M_amonth12;
+      }
+
+    protected:
+      virtual
+      ~__timepunct();
+
+
+      void
+      _M_initialize_timepunct(__c_locale __cloc = 0);
+    };
+
+  template<typename _CharT>
+    locale::id __timepunct<_CharT>::id;
+
+
+  template<>
+    void
+    __timepunct<char>::_M_initialize_timepunct(__c_locale __cloc);
+
+  template<>
+    void
+    __timepunct<char>::_M_put(char*, size_t, const char*, const tm*) const throw ();
+
+
+  template<>
+    void
+    __timepunct<wchar_t>::_M_initialize_timepunct(__c_locale __cloc);
+
+  template<>
+    void
+    __timepunct<wchar_t>::_M_put(wchar_t*, size_t, const wchar_t*,
+     const tm*) const throw ();
+
+
+
+}
+
+
+# 1 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/time_members.h" 1 3
+# 37 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/time_members.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  template<typename _CharT>
+    __timepunct<_CharT>::__timepunct(size_t __refs)
+    : facet(__refs), _M_data(0), _M_c_locale_timepunct(0),
+      _M_name_timepunct(_S_get_c_name())
+    { _M_initialize_timepunct(); }
+
+  template<typename _CharT>
+    __timepunct<_CharT>::__timepunct(__cache_type* __cache, size_t __refs)
+    : facet(__refs), _M_data(__cache), _M_c_locale_timepunct(0),
+      _M_name_timepunct(_S_get_c_name())
+    { _M_initialize_timepunct(); }
+
+  template<typename _CharT>
+    __timepunct<_CharT>::__timepunct(__c_locale __cloc, const char* __s,
+         size_t __refs)
+    : facet(__refs), _M_data(0), _M_c_locale_timepunct(0),
+      _M_name_timepunct(0)
+    {
+      if (__builtin_strcmp(__s, _S_get_c_name()) != 0)
+ {
+   const size_t __len = __builtin_strlen(__s) + 1;
+   char* __tmp = new char[__len];
+   __builtin_memcpy(__tmp, __s, __len);
+   _M_name_timepunct = __tmp;
+ }
+      else
+ _M_name_timepunct = _S_get_c_name();
+
+      try
+ { _M_initialize_timepunct(__cloc); }
+      catch(...)
+ {
+   if (_M_name_timepunct != _S_get_c_name())
+     delete [] _M_name_timepunct;
+   throw;
+ }
+    }
+
+  template<typename _CharT>
+    __timepunct<_CharT>::~__timepunct()
+    {
+      if (_M_name_timepunct != _S_get_c_name())
+ delete [] _M_name_timepunct;
+      delete _M_data;
+      _S_destroy_c_locale(_M_c_locale_timepunct);
+    }
+
+
+}
+# 347 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+namespace __cxx11 {
+# 367 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+  template<typename _CharT, typename _InIter>
+    class time_get : public locale::facet, public time_base
+    {
+    public:
+
+
+
+      typedef _CharT char_type;
+      typedef _InIter iter_type;
+
+
+
+      static locale::id id;
+# 388 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      explicit
+      time_get(size_t __refs = 0)
+      : facet (__refs) { }
+# 405 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      dateorder
+      date_order() const
+      { return this->do_date_order(); }
+# 429 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      iter_type
+      get_time(iter_type __beg, iter_type __end, ios_base& __io,
+        ios_base::iostate& __err, tm* __tm) const
+      { return this->do_get_time(__beg, __end, __io, __err, __tm); }
+# 454 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      iter_type
+      get_date(iter_type __beg, iter_type __end, ios_base& __io,
+        ios_base::iostate& __err, tm* __tm) const
+      { return this->do_get_date(__beg, __end, __io, __err, __tm); }
+# 482 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      iter_type
+      get_weekday(iter_type __beg, iter_type __end, ios_base& __io,
+    ios_base::iostate& __err, tm* __tm) const
+      { return this->do_get_weekday(__beg, __end, __io, __err, __tm); }
+# 511 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      iter_type
+      get_monthname(iter_type __beg, iter_type __end, ios_base& __io,
+      ios_base::iostate& __err, tm* __tm) const
+      { return this->do_get_monthname(__beg, __end, __io, __err, __tm); }
+# 537 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      iter_type
+      get_year(iter_type __beg, iter_type __end, ios_base& __io,
+        ios_base::iostate& __err, tm* __tm) const
+      { return this->do_get_year(__beg, __end, __io, __err, __tm); }
+# 558 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      inline
+      iter_type get(iter_type __s, iter_type __end, ios_base& __io,
+                    ios_base::iostate& __err, tm* __tm, char __format,
+                    char __modifier = 0) const
+      {
+        return this->do_get(__s, __end, __io, __err, __tm, __format,
+                            __modifier);
+      }
+# 585 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      iter_type get(iter_type __s, iter_type __end, ios_base& __io,
+                    ios_base::iostate& __err, tm* __tm, const char_type* __fmt,
+                    const char_type* __fmtend) const;
+
+
+    protected:
+
+      virtual
+      ~time_get() { }
+# 605 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      virtual dateorder
+      do_date_order() const;
+# 623 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      virtual iter_type
+      do_get_time(iter_type __beg, iter_type __end, ios_base& __io,
+    ios_base::iostate& __err, tm* __tm) const;
+# 642 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      virtual iter_type
+      do_get_date(iter_type __beg, iter_type __end, ios_base& __io,
+    ios_base::iostate& __err, tm* __tm) const;
+# 661 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      virtual iter_type
+      do_get_weekday(iter_type __beg, iter_type __end, ios_base&,
+       ios_base::iostate& __err, tm* __tm) const;
+# 680 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      virtual iter_type
+      do_get_monthname(iter_type __beg, iter_type __end, ios_base&,
+         ios_base::iostate& __err, tm* __tm) const;
+# 699 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      virtual iter_type
+      do_get_year(iter_type __beg, iter_type __end, ios_base& __io,
+    ios_base::iostate& __err, tm* __tm) const;
+# 722 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      virtual
+
+      iter_type
+      do_get(iter_type __s, iter_type __end, ios_base& __f,
+             ios_base::iostate& __err, tm* __tm,
+             char __format, char __modifier) const;
+
+
+
+      iter_type
+      _M_extract_num(iter_type __beg, iter_type __end, int& __member,
+       int __min, int __max, size_t __len,
+       ios_base& __io, ios_base::iostate& __err) const;
+
+
+      iter_type
+      _M_extract_name(iter_type __beg, iter_type __end, int& __member,
+        const _CharT** __names, size_t __indexlen,
+        ios_base& __io, ios_base::iostate& __err) const;
+
+
+      iter_type
+      _M_extract_wday_or_month(iter_type __beg, iter_type __end, int& __member,
+          const _CharT** __names, size_t __indexlen,
+          ios_base& __io, ios_base::iostate& __err) const;
+
+
+      iter_type
+      _M_extract_via_format(iter_type __beg, iter_type __end, ios_base& __io,
+       ios_base::iostate& __err, tm* __tm,
+       const _CharT* __format) const;
+    };
+
+  template<typename _CharT, typename _InIter>
+    locale::id time_get<_CharT, _InIter>::id;
+
+
+  template<typename _CharT, typename _InIter>
+    class time_get_byname : public time_get<_CharT, _InIter>
+    {
+    public:
+
+      typedef _CharT char_type;
+      typedef _InIter iter_type;
+
+      explicit
+      time_get_byname(const char*, size_t __refs = 0)
+      : time_get<_CharT, _InIter>(__refs) { }
+
+
+      explicit
+      time_get_byname(const string& __s, size_t __refs = 0)
+      : time_get_byname(__s.c_str(), __refs) { }
+
+
+    protected:
+      virtual
+      ~time_get_byname() { }
+    };
+
+}
+# 796 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+  template<typename _CharT, typename _OutIter>
+    class time_put : public locale::facet
+    {
+    public:
+
+
+
+      typedef _CharT char_type;
+      typedef _OutIter iter_type;
+
+
+
+      static locale::id id;
+# 817 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      explicit
+      time_put(size_t __refs = 0)
+      : facet(__refs) { }
+# 836 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      iter_type
+      put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm,
+   const _CharT* __beg, const _CharT* __end) const;
+# 856 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      iter_type
+      put(iter_type __s, ios_base& __io, char_type __fill,
+   const tm* __tm, char __format, char __mod = 0) const
+      { return this->do_put(__s, __io, __fill, __tm, __format, __mod); }
+
+    protected:
+
+      virtual
+      ~time_put()
+      { }
+# 883 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      virtual iter_type
+      do_put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm,
+      char __format, char __mod) const;
+    };
+
+  template<typename _CharT, typename _OutIter>
+    locale::id time_put<_CharT, _OutIter>::id;
+
+
+  template<typename _CharT, typename _OutIter>
+    class time_put_byname : public time_put<_CharT, _OutIter>
+    {
+    public:
+
+      typedef _CharT char_type;
+      typedef _OutIter iter_type;
+
+      explicit
+      time_put_byname(const char*, size_t __refs = 0)
+      : time_put<_CharT, _OutIter>(__refs)
+      { }
+
+
+      explicit
+      time_put_byname(const string& __s, size_t __refs = 0)
+      : time_put_byname(__s.c_str(), __refs) { }
+
+
+    protected:
+      virtual
+      ~time_put_byname() { }
+    };
+# 928 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+  class money_base
+  {
+  public:
+    enum part { none, space, symbol, sign, value };
+    struct pattern { char field[4]; };
+
+    static const pattern _S_default_pattern;
+
+    enum
+    {
+      _S_minus,
+      _S_zero,
+      _S_end = 11
+    };
+
+
+
+    static const char* _S_atoms;
+
+
+
+    __attribute__ ((__const__)) static pattern
+    _S_construct_pattern(char __precedes, char __space, char __posn) throw ();
+  };
+
+  template<typename _CharT, bool _Intl>
+    struct __moneypunct_cache : public locale::facet
+    {
+      const char* _M_grouping;
+      size_t _M_grouping_size;
+      bool _M_use_grouping;
+      _CharT _M_decimal_point;
+      _CharT _M_thousands_sep;
+      const _CharT* _M_curr_symbol;
+      size_t _M_curr_symbol_size;
+      const _CharT* _M_positive_sign;
+      size_t _M_positive_sign_size;
+      const _CharT* _M_negative_sign;
+      size_t _M_negative_sign_size;
+      int _M_frac_digits;
+      money_base::pattern _M_pos_format;
+      money_base::pattern _M_neg_format;
+
+
+
+
+      _CharT _M_atoms[money_base::_S_end];
+
+      bool _M_allocated;
+
+      __moneypunct_cache(size_t __refs = 0) : facet(__refs),
+      _M_grouping(0), _M_grouping_size(0), _M_use_grouping(false),
+      _M_decimal_point(_CharT()), _M_thousands_sep(_CharT()),
+      _M_curr_symbol(0), _M_curr_symbol_size(0),
+      _M_positive_sign(0), _M_positive_sign_size(0),
+      _M_negative_sign(0), _M_negative_sign_size(0),
+      _M_frac_digits(0),
+      _M_pos_format(money_base::pattern()),
+      _M_neg_format(money_base::pattern()), _M_allocated(false)
+      { }
+
+      ~__moneypunct_cache();
+
+      void
+      _M_cache(const locale& __loc);
+
+    private:
+      __moneypunct_cache&
+      operator=(const __moneypunct_cache&);
+
+      explicit
+      __moneypunct_cache(const __moneypunct_cache&);
+    };
+
+  template<typename _CharT, bool _Intl>
+    __moneypunct_cache<_CharT, _Intl>::~__moneypunct_cache()
+    {
+      if (_M_allocated)
+ {
+   delete [] _M_grouping;
+   delete [] _M_curr_symbol;
+   delete [] _M_positive_sign;
+   delete [] _M_negative_sign;
+ }
+    }
+
+namespace __cxx11 {
+# 1023 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+  template<typename _CharT, bool _Intl>
+    class moneypunct : public locale::facet, public money_base
+    {
+    public:
+
+
+
+      typedef _CharT char_type;
+      typedef basic_string<_CharT> string_type;
+
+      typedef __moneypunct_cache<_CharT, _Intl> __cache_type;
+
+    private:
+      __cache_type* _M_data;
+
+    public:
+
+
+      static const bool intl = _Intl;
+
+      static locale::id id;
+# 1052 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      explicit
+      moneypunct(size_t __refs = 0)
+      : facet(__refs), _M_data(0)
+      { _M_initialize_moneypunct(); }
+# 1065 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      explicit
+      moneypunct(__cache_type* __cache, size_t __refs = 0)
+      : facet(__refs), _M_data(__cache)
+      { _M_initialize_moneypunct(); }
+# 1080 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      explicit
+      moneypunct(__c_locale __cloc, const char* __s, size_t __refs = 0)
+      : facet(__refs), _M_data(0)
+      { _M_initialize_moneypunct(__cloc, __s); }
+# 1094 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      char_type
+      decimal_point() const
+      { return this->do_decimal_point(); }
+# 1107 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      char_type
+      thousands_sep() const
+      { return this->do_thousands_sep(); }
+# 1137 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      string
+      grouping() const
+      { return this->do_grouping(); }
+# 1150 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      string_type
+      curr_symbol() const
+      { return this->do_curr_symbol(); }
+# 1167 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      string_type
+      positive_sign() const
+      { return this->do_positive_sign(); }
+# 1184 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      string_type
+      negative_sign() const
+      { return this->do_negative_sign(); }
+# 1200 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      int
+      frac_digits() const
+      { return this->do_frac_digits(); }
+# 1236 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      pattern
+      pos_format() const
+      { return this->do_pos_format(); }
+
+      pattern
+      neg_format() const
+      { return this->do_neg_format(); }
+
+
+    protected:
+
+      virtual
+      ~moneypunct();
+# 1258 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      virtual char_type
+      do_decimal_point() const
+      { return _M_data->_M_decimal_point; }
+# 1270 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      virtual char_type
+      do_thousands_sep() const
+      { return _M_data->_M_thousands_sep; }
+# 1283 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      virtual string
+      do_grouping() const
+      { return _M_data->_M_grouping; }
+# 1296 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      virtual string_type
+      do_curr_symbol() const
+      { return _M_data->_M_curr_symbol; }
+# 1309 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      virtual string_type
+      do_positive_sign() const
+      { return _M_data->_M_positive_sign; }
+# 1322 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      virtual string_type
+      do_negative_sign() const
+      { return _M_data->_M_negative_sign; }
+# 1336 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      virtual int
+      do_frac_digits() const
+      { return _M_data->_M_frac_digits; }
+# 1350 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      virtual pattern
+      do_pos_format() const
+      { return _M_data->_M_pos_format; }
+# 1364 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      virtual pattern
+      do_neg_format() const
+      { return _M_data->_M_neg_format; }
+
+
+       void
+       _M_initialize_moneypunct(__c_locale __cloc = 0,
+    const char* __name = 0);
+    };
+
+  template<typename _CharT, bool _Intl>
+    locale::id moneypunct<_CharT, _Intl>::id;
+
+  template<typename _CharT, bool _Intl>
+    const bool moneypunct<_CharT, _Intl>::intl;
+
+  template<>
+    moneypunct<char, true>::~moneypunct();
+
+  template<>
+    moneypunct<char, false>::~moneypunct();
+
+  template<>
+    void
+    moneypunct<char, true>::_M_initialize_moneypunct(__c_locale, const char*);
+
+  template<>
+    void
+    moneypunct<char, false>::_M_initialize_moneypunct(__c_locale, const char*);
+
+
+  template<>
+    moneypunct<wchar_t, true>::~moneypunct();
+
+  template<>
+    moneypunct<wchar_t, false>::~moneypunct();
+
+  template<>
+    void
+    moneypunct<wchar_t, true>::_M_initialize_moneypunct(__c_locale,
+       const char*);
+
+  template<>
+    void
+    moneypunct<wchar_t, false>::_M_initialize_moneypunct(__c_locale,
+        const char*);
+
+
+
+  template<typename _CharT, bool _Intl>
+    class moneypunct_byname : public moneypunct<_CharT, _Intl>
+    {
+    public:
+      typedef _CharT char_type;
+      typedef basic_string<_CharT> string_type;
+
+      static const bool intl = _Intl;
+
+      explicit
+      moneypunct_byname(const char* __s, size_t __refs = 0)
+      : moneypunct<_CharT, _Intl>(__refs)
+      {
+ if (__builtin_strcmp(__s, "C") != 0
+     && __builtin_strcmp(__s, "POSIX") != 0)
+   {
+     __c_locale __tmp;
+     this->_S_create_c_locale(__tmp, __s);
+     this->_M_initialize_moneypunct(__tmp);
+     this->_S_destroy_c_locale(__tmp);
+   }
+      }
+
+
+      explicit
+      moneypunct_byname(const string& __s, size_t __refs = 0)
+      : moneypunct_byname(__s.c_str(), __refs) { }
+
+
+    protected:
+      virtual
+      ~moneypunct_byname() { }
+    };
+
+  template<typename _CharT, bool _Intl>
+    const bool moneypunct_byname<_CharT, _Intl>::intl;
+
+}
+
+namespace __cxx11 {
+# 1467 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+  template<typename _CharT, typename _InIter>
+    class money_get : public locale::facet
+    {
+    public:
+
+
+
+      typedef _CharT char_type;
+      typedef _InIter iter_type;
+      typedef basic_string<_CharT> string_type;
+
+
+
+      static locale::id id;
+# 1489 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      explicit
+      money_get(size_t __refs = 0) : facet(__refs) { }
+# 1519 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      iter_type
+      get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
+   ios_base::iostate& __err, long double& __units) const
+      { return this->do_get(__s, __end, __intl, __io, __err, __units); }
+# 1550 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      iter_type
+      get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
+   ios_base::iostate& __err, string_type& __digits) const
+      { return this->do_get(__s, __end, __intl, __io, __err, __digits); }
+
+    protected:
+
+      virtual
+      ~money_get() { }
+# 1574 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      virtual iter_type
+      do_get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
+      ios_base::iostate& __err, long double& __units) const;
+# 1586 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      virtual iter_type
+      do_get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
+      ios_base::iostate& __err, string_type& __digits) const;
+# 1598 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      template<bool _Intl>
+        iter_type
+        _M_extract(iter_type __s, iter_type __end, ios_base& __io,
+     ios_base::iostate& __err, string& __digits) const;
+    };
+
+  template<typename _CharT, typename _InIter>
+    locale::id money_get<_CharT, _InIter>::id;
+# 1620 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+  template<typename _CharT, typename _OutIter>
+    class money_put : public locale::facet
+    {
+    public:
+
+
+      typedef _CharT char_type;
+      typedef _OutIter iter_type;
+      typedef basic_string<_CharT> string_type;
+
+
+
+      static locale::id id;
+# 1641 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      explicit
+      money_put(size_t __refs = 0) : facet(__refs) { }
+# 1661 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      iter_type
+      put(iter_type __s, bool __intl, ios_base& __io,
+   char_type __fill, long double __units) const
+      { return this->do_put(__s, __intl, __io, __fill, __units); }
+# 1684 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      iter_type
+      put(iter_type __s, bool __intl, ios_base& __io,
+   char_type __fill, const string_type& __digits) const
+      { return this->do_put(__s, __intl, __io, __fill, __digits); }
+
+    protected:
+
+      virtual
+      ~money_put() { }
+# 1719 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      virtual iter_type
+      do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
+      long double __units) const;
+# 1743 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      virtual iter_type
+      do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
+      const string_type& __digits) const;
+# 1755 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      template<bool _Intl>
+        iter_type
+        _M_insert(iter_type __s, ios_base& __io, char_type __fill,
+    const string_type& __digits) const;
+    };
+
+  template<typename _CharT, typename _OutIter>
+    locale::id money_put<_CharT, _OutIter>::id;
+
+}
+
+
+
+
+
+  struct messages_base
+  {
+    typedef int catalog;
+  };
+
+namespace __cxx11 {
+# 1798 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+  template<typename _CharT>
+    class messages : public locale::facet, public messages_base
+    {
+    public:
+
+
+
+      typedef _CharT char_type;
+      typedef basic_string<_CharT> string_type;
+
+
+    protected:
+
+
+      __c_locale _M_c_locale_messages;
+      const char* _M_name_messages;
+
+    public:
+
+      static locale::id id;
+# 1826 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      explicit
+      messages(size_t __refs = 0);
+# 1840 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      explicit
+      messages(__c_locale __cloc, const char* __s, size_t __refs = 0);
+# 1853 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      catalog
+      open(const basic_string<char>& __s, const locale& __loc) const
+      { return this->do_open(__s, __loc); }
+# 1871 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      catalog
+      open(const basic_string<char>&, const locale&, const char*) const;
+# 1889 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      string_type
+      get(catalog __c, int __set, int __msgid, const string_type& __s) const
+      { return this->do_get(__c, __set, __msgid, __s); }
+# 1900 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      void
+      close(catalog __c) const
+      { return this->do_close(__c); }
+
+    protected:
+
+      virtual
+      ~messages();
+# 1920 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      virtual catalog
+      do_open(const basic_string<char>&, const locale&) const;
+# 1939 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      virtual string_type
+      do_get(catalog, int, int, const string_type& __dfault) const;
+
+
+
+
+
+
+      virtual void
+      do_close(catalog) const;
+
+
+      char*
+      _M_convert_to_char(const string_type& __msg) const
+      {
+
+ return reinterpret_cast<char*>(const_cast<_CharT*>(__msg.c_str()));
+      }
+
+
+      string_type
+      _M_convert_from_char(char*) const
+      {
+
+ return string_type();
+      }
+     };
+
+  template<typename _CharT>
+    locale::id messages<_CharT>::id;
+
+
+  template<>
+    string
+    messages<char>::do_get(catalog, int, int, const string&) const;
+
+
+  template<>
+    wstring
+    messages<wchar_t>::do_get(catalog, int, int, const wstring&) const;
+
+
+
+   template<typename _CharT>
+    class messages_byname : public messages<_CharT>
+    {
+    public:
+      typedef _CharT char_type;
+      typedef basic_string<_CharT> string_type;
+
+      explicit
+      messages_byname(const char* __s, size_t __refs = 0);
+
+
+      explicit
+      messages_byname(const string& __s, size_t __refs = 0)
+      : messages_byname(__s.c_str(), __refs) { }
+
+
+    protected:
+      virtual
+      ~messages_byname()
+      { }
+    };
+
+}
+
+
+}
+
+
+# 1 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/messages_members.h" 1 3
+# 36 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/messages_members.h" 3
+# 1 "/usr/include/libintl.h" 1 3 4
+# 21 "/usr/include/libintl.h" 3 4
+#define _LIBINTL_H 1
+
+
+
+
+
+#define __USE_GNU_GETTEXT 1
+
+
+
+#define __GNU_GETTEXT_SUPPORTED_REVISION(major) ((major) == 0 ? 1 : -1)
+
+
+extern "C" {
+
+
+
+
+extern char *gettext (const char *__msgid)
+     throw () __attribute__ ((__format_arg__ (1)));
+
+
+
+extern char *dgettext (const char *__domainname, const char *__msgid)
+     throw () __attribute__ ((__format_arg__ (2)));
+extern char *__dgettext (const char *__domainname, const char *__msgid)
+     throw () __attribute__ ((__format_arg__ (2)));
+
+
+
+extern char *dcgettext (const char *__domainname,
+   const char *__msgid, int __category)
+     throw () __attribute__ ((__format_arg__ (2)));
+extern char *__dcgettext (const char *__domainname,
+     const char *__msgid, int __category)
+     throw () __attribute__ ((__format_arg__ (2)));
+
+
+
+
+extern char *ngettext (const char *__msgid1, const char *__msgid2,
+         unsigned long int __n)
+     throw () __attribute__ ((__format_arg__ (1))) __attribute__ ((__format_arg__ (2)));
+
+
+
+extern char *dngettext (const char *__domainname, const char *__msgid1,
+   const char *__msgid2, unsigned long int __n)
+     throw () __attribute__ ((__format_arg__ (2))) __attribute__ ((__format_arg__ (3)));
+
+
+
+extern char *dcngettext (const char *__domainname, const char *__msgid1,
+    const char *__msgid2, unsigned long int __n,
+    int __category)
+     throw () __attribute__ ((__format_arg__ (2))) __attribute__ ((__format_arg__ (3)));
+
+
+
+
+
+extern char *textdomain (const char *__domainname) throw ();
+
+
+
+extern char *bindtextdomain (const char *__domainname,
+        const char *__dirname) throw ();
+
+
+
+extern char *bind_textdomain_codeset (const char *__domainname,
+          const char *__codeset) throw ();
+# 121 "/usr/include/libintl.h" 3 4
+}
+# 37 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/messages_members.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+  template<typename _CharT>
+    messages<_CharT>::messages(size_t __refs)
+    : facet(__refs), _M_c_locale_messages(_S_get_c_locale()),
+      _M_name_messages(_S_get_c_name())
+    { }
+
+  template<typename _CharT>
+    messages<_CharT>::messages(__c_locale __cloc, const char* __s,
+          size_t __refs)
+    : facet(__refs), _M_c_locale_messages(0), _M_name_messages(0)
+    {
+      if (__builtin_strcmp(__s, _S_get_c_name()) != 0)
+ {
+   const size_t __len = __builtin_strlen(__s) + 1;
+   char* __tmp = new char[__len];
+   __builtin_memcpy(__tmp, __s, __len);
+   _M_name_messages = __tmp;
+ }
+      else
+ _M_name_messages = _S_get_c_name();
+
+
+      _M_c_locale_messages = _S_clone_c_locale(__cloc);
+    }
+
+  template<typename _CharT>
+    typename messages<_CharT>::catalog
+    messages<_CharT>::open(const basic_string<char>& __s, const locale& __loc,
+      const char* __dir) const
+    {
+      bindtextdomain(__s.c_str(), __dir);
+      return this->do_open(__s, __loc);
+    }
+
+
+  template<typename _CharT>
+    messages<_CharT>::~messages()
+    {
+      if (_M_name_messages != _S_get_c_name())
+ delete [] _M_name_messages;
+      _S_destroy_c_locale(_M_c_locale_messages);
+    }
+
+  template<typename _CharT>
+    typename messages<_CharT>::catalog
+    messages<_CharT>::do_open(const basic_string<char>& __s,
+         const locale&) const
+    {
+
+
+      textdomain(__s.c_str());
+      return 0;
+    }
+
+  template<typename _CharT>
+    void
+    messages<_CharT>::do_close(catalog) const
+    { }
+
+
+  template<typename _CharT>
+    messages_byname<_CharT>::messages_byname(const char* __s, size_t __refs)
+    : messages<_CharT>(__refs)
+    {
+      if (this->_M_name_messages != locale::facet::_S_get_c_name())
+ {
+   delete [] this->_M_name_messages;
+   if (__builtin_strcmp(__s, locale::facet::_S_get_c_name()) != 0)
+     {
+       const size_t __len = __builtin_strlen(__s) + 1;
+       char* __tmp = new char[__len];
+       __builtin_memcpy(__tmp, __s, __len);
+       this->_M_name_messages = __tmp;
+     }
+   else
+     this->_M_name_messages = locale::facet::_S_get_c_name();
+ }
+
+      if (__builtin_strcmp(__s, "C") != 0
+   && __builtin_strcmp(__s, "POSIX") != 0)
+ {
+   this->_S_destroy_c_locale(this->_M_c_locale_messages);
+   this->_S_create_c_locale(this->_M_c_locale_messages, __s);
+ }
+    }
+
+
+  template<>
+    typename messages<char>::catalog
+    messages<char>::do_open(const basic_string<char>&,
+       const locale&) const;
+
+  template<>
+    void
+    messages<char>::do_close(catalog) const;
+
+
+  template<>
+    typename messages<wchar_t>::catalog
+    messages<wchar_t>::do_open(const basic_string<char>&,
+          const locale&) const;
+
+  template<>
+    void
+    messages<wchar_t>::do_close(catalog) const;
+
+
+
+}
+# 2011 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 2 3
+
+
+
+
+# 1 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.tcc" 1 3
+# 31 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.tcc" 3
+#define _LOCALE_FACETS_NONIO_TCC 1
+
+       
+# 34 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.tcc" 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  template<typename _CharT, bool _Intl>
+    struct __use_cache<__moneypunct_cache<_CharT, _Intl> >
+    {
+      const __moneypunct_cache<_CharT, _Intl>*
+      operator() (const locale& __loc) const
+      {
+ const size_t __i = moneypunct<_CharT, _Intl>::id._M_id();
+ const locale::facet** __caches = __loc._M_impl->_M_caches;
+ if (!__caches[__i])
+   {
+     __moneypunct_cache<_CharT, _Intl>* __tmp = 0;
+     try
+       {
+  __tmp = new __moneypunct_cache<_CharT, _Intl>;
+  __tmp->_M_cache(__loc);
+       }
+     catch(...)
+       {
+  delete __tmp;
+  throw;
+       }
+     __loc._M_impl->_M_install_cache(__tmp, __i);
+   }
+ return static_cast<
+   const __moneypunct_cache<_CharT, _Intl>*>(__caches[__i]);
+      }
+    };
+
+  template<typename _CharT, bool _Intl>
+    void
+    __moneypunct_cache<_CharT, _Intl>::_M_cache(const locale& __loc)
+    {
+      const moneypunct<_CharT, _Intl>& __mp =
+ use_facet<moneypunct<_CharT, _Intl> >(__loc);
+
+      _M_decimal_point = __mp.decimal_point();
+      _M_thousands_sep = __mp.thousands_sep();
+      _M_frac_digits = __mp.frac_digits();
+
+      char* __grouping = 0;
+      _CharT* __curr_symbol = 0;
+      _CharT* __positive_sign = 0;
+      _CharT* __negative_sign = 0;
+      try
+ {
+   const string& __g = __mp.grouping();
+   _M_grouping_size = __g.size();
+   __grouping = new char[_M_grouping_size];
+   __g.copy(__grouping, _M_grouping_size);
+   _M_use_grouping = (_M_grouping_size
+        && static_cast<signed char>(__grouping[0]) > 0
+        && (__grouping[0]
+     != __gnu_cxx::__numeric_traits<char>::__max));
+
+   const basic_string<_CharT>& __cs = __mp.curr_symbol();
+   _M_curr_symbol_size = __cs.size();
+   __curr_symbol = new _CharT[_M_curr_symbol_size];
+   __cs.copy(__curr_symbol, _M_curr_symbol_size);
+
+   const basic_string<_CharT>& __ps = __mp.positive_sign();
+   _M_positive_sign_size = __ps.size();
+   __positive_sign = new _CharT[_M_positive_sign_size];
+   __ps.copy(__positive_sign, _M_positive_sign_size);
+
+   const basic_string<_CharT>& __ns = __mp.negative_sign();
+   _M_negative_sign_size = __ns.size();
+   __negative_sign = new _CharT[_M_negative_sign_size];
+   __ns.copy(__negative_sign, _M_negative_sign_size);
+
+   _M_pos_format = __mp.pos_format();
+   _M_neg_format = __mp.neg_format();
+
+   const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__loc);
+   __ct.widen(money_base::_S_atoms,
+       money_base::_S_atoms + money_base::_S_end, _M_atoms);
+
+   _M_grouping = __grouping;
+   _M_curr_symbol = __curr_symbol;
+   _M_positive_sign = __positive_sign;
+   _M_negative_sign = __negative_sign;
+   _M_allocated = true;
+ }
+      catch(...)
+ {
+   delete [] __grouping;
+   delete [] __curr_symbol;
+   delete [] __positive_sign;
+   delete [] __negative_sign;
+   throw;
+ }
+    }
+
+namespace __cxx11 {
+
+  template<typename _CharT, typename _InIter>
+    template<bool _Intl>
+      _InIter
+      money_get<_CharT, _InIter>::
+      _M_extract(iter_type __beg, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, string& __units) const
+      {
+ typedef char_traits<_CharT> __traits_type;
+ typedef typename string_type::size_type size_type;
+ typedef money_base::part part;
+ typedef __moneypunct_cache<_CharT, _Intl> __cache_type;
+
+ const locale& __loc = __io._M_getloc();
+ const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
+
+ __use_cache<__cache_type> __uc;
+ const __cache_type* __lc = __uc(__loc);
+ const char_type* __lit = __lc->_M_atoms;
+
+
+ bool __negative = false;
+
+ size_type __sign_size = 0;
+
+ const bool __mandatory_sign = (__lc->_M_positive_sign_size
+           && __lc->_M_negative_sign_size);
+
+ string __grouping_tmp;
+ if (__lc->_M_use_grouping)
+   __grouping_tmp.reserve(32);
+
+ int __last_pos = 0;
+
+ int __n = 0;
+
+ bool __testvalid = true;
+
+ bool __testdecfound = false;
+
+
+ string __res;
+ __res.reserve(32);
+
+ const char_type* __lit_zero = __lit + money_base::_S_zero;
+ const money_base::pattern __p = __lc->_M_neg_format;
+ for (int __i = 0; __i < 4 && __testvalid; ++__i)
+   {
+     const part __which = static_cast<part>(__p.field[__i]);
+     switch (__which)
+       {
+       case money_base::symbol:
+
+
+
+
+  if (__io.flags() & ios_base::showbase || __sign_size > 1
+      || __i == 0
+      || (__i == 1 && (__mandatory_sign
+         || (static_cast<part>(__p.field[0])
+      == money_base::sign)
+         || (static_cast<part>(__p.field[2])
+      == money_base::space)))
+      || (__i == 2 && ((static_cast<part>(__p.field[3])
+          == money_base::value)
+         || (__mandatory_sign
+      && (static_cast<part>(__p.field[3])
+          == money_base::sign)))))
+    {
+      const size_type __len = __lc->_M_curr_symbol_size;
+      size_type __j = 0;
+      for (; __beg != __end && __j < __len
+      && *__beg == __lc->_M_curr_symbol[__j];
+    ++__beg, (void)++__j);
+      if (__j != __len
+   && (__j || __io.flags() & ios_base::showbase))
+        __testvalid = false;
+    }
+  break;
+       case money_base::sign:
+
+  if (__lc->_M_positive_sign_size && __beg != __end
+      && *__beg == __lc->_M_positive_sign[0])
+    {
+      __sign_size = __lc->_M_positive_sign_size;
+      ++__beg;
+    }
+  else if (__lc->_M_negative_sign_size && __beg != __end
+    && *__beg == __lc->_M_negative_sign[0])
+    {
+      __negative = true;
+      __sign_size = __lc->_M_negative_sign_size;
+      ++__beg;
+    }
+  else if (__lc->_M_positive_sign_size
+    && !__lc->_M_negative_sign_size)
+
+
+    __negative = true;
+  else if (__mandatory_sign)
+    __testvalid = false;
+  break;
+       case money_base::value:
+
+
+  for (; __beg != __end; ++__beg)
+    {
+      const char_type __c = *__beg;
+      const char_type* __q = __traits_type::find(__lit_zero,
+              10, __c);
+      if (__q != 0)
+        {
+   __res += money_base::_S_atoms[__q - __lit];
+   ++__n;
+        }
+      else if (__c == __lc->_M_decimal_point
+        && !__testdecfound)
+        {
+   if (__lc->_M_frac_digits <= 0)
+     break;
+
+   __last_pos = __n;
+   __n = 0;
+   __testdecfound = true;
+        }
+      else if (__lc->_M_use_grouping
+        && __c == __lc->_M_thousands_sep
+        && !__testdecfound)
+        {
+   if (__n)
+     {
+
+       __grouping_tmp += static_cast<char>(__n);
+       __n = 0;
+     }
+   else
+     {
+       __testvalid = false;
+       break;
+     }
+        }
+      else
+        break;
+    }
+  if (__res.empty())
+    __testvalid = false;
+  break;
+       case money_base::space:
+
+  if (__beg != __end && __ctype.is(ctype_base::space, *__beg))
+    ++__beg;
+  else
+    __testvalid = false;
+
+       case money_base::none:
+
+  if (__i != 3)
+    for (; __beg != __end
+    && __ctype.is(ctype_base::space, *__beg); ++__beg);
+  break;
+       }
+   }
+
+
+ if (__sign_size > 1 && __testvalid)
+   {
+     const char_type* __sign = __negative ? __lc->_M_negative_sign
+                                          : __lc->_M_positive_sign;
+     size_type __i = 1;
+     for (; __beg != __end && __i < __sign_size
+     && *__beg == __sign[__i]; ++__beg, (void)++__i);
+
+     if (__i != __sign_size)
+       __testvalid = false;
+   }
+
+ if (__testvalid)
+   {
+
+     if (__res.size() > 1)
+       {
+  const size_type __first = __res.find_first_not_of('0');
+  const bool __only_zeros = __first == string::npos;
+  if (__first)
+    __res.erase(0, __only_zeros ? __res.size() - 1 : __first);
+       }
+
+
+     if (__negative && __res[0] != '0')
+       __res.insert(__res.begin(), '-');
+
+
+     if (__grouping_tmp.size())
+       {
+
+  __grouping_tmp += static_cast<char>(__testdecfound ? __last_pos
+                         : __n);
+  if (!std::__verify_grouping(__lc->_M_grouping,
+         __lc->_M_grouping_size,
+         __grouping_tmp))
+    __err |= ios_base::failbit;
+       }
+
+
+     if (__testdecfound && __n != __lc->_M_frac_digits)
+       __testvalid = false;
+   }
+
+
+ if (!__testvalid)
+   __err |= ios_base::failbit;
+ else
+   __units.swap(__res);
+
+
+ if (__beg == __end)
+   __err |= ios_base::eofbit;
+ return __beg;
+      }
+# 368 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.tcc" 3
+  template<typename _CharT, typename _InIter>
+    _InIter
+    money_get<_CharT, _InIter>::
+    do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io,
+    ios_base::iostate& __err, long double& __units) const
+    {
+      string __str;
+      __beg = __intl ? _M_extract<true>(__beg, __end, __io, __err, __str)
+              : _M_extract<false>(__beg, __end, __io, __err, __str);
+      std::__convert_to_v(__str.c_str(), __units, __err, _S_get_c_locale());
+      return __beg;
+    }
+
+  template<typename _CharT, typename _InIter>
+    _InIter
+    money_get<_CharT, _InIter>::
+    do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io,
+    ios_base::iostate& __err, string_type& __digits) const
+    {
+      typedef typename string::size_type size_type;
+
+      const locale& __loc = __io._M_getloc();
+      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
+
+      string __str;
+      __beg = __intl ? _M_extract<true>(__beg, __end, __io, __err, __str)
+              : _M_extract<false>(__beg, __end, __io, __err, __str);
+      const size_type __len = __str.size();
+      if (__len)
+ {
+   __digits.resize(__len);
+   __ctype.widen(__str.data(), __str.data() + __len, &__digits[0]);
+ }
+      return __beg;
+    }
+
+  template<typename _CharT, typename _OutIter>
+    template<bool _Intl>
+      _OutIter
+      money_put<_CharT, _OutIter>::
+      _M_insert(iter_type __s, ios_base& __io, char_type __fill,
+  const string_type& __digits) const
+      {
+ typedef typename string_type::size_type size_type;
+ typedef money_base::part part;
+ typedef __moneypunct_cache<_CharT, _Intl> __cache_type;
+
+ const locale& __loc = __io._M_getloc();
+ const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
+
+ __use_cache<__cache_type> __uc;
+ const __cache_type* __lc = __uc(__loc);
+ const char_type* __lit = __lc->_M_atoms;
+
+
+
+ const char_type* __beg = __digits.data();
+
+ money_base::pattern __p;
+ const char_type* __sign;
+ size_type __sign_size;
+ if (!(*__beg == __lit[money_base::_S_minus]))
+   {
+     __p = __lc->_M_pos_format;
+     __sign = __lc->_M_positive_sign;
+     __sign_size = __lc->_M_positive_sign_size;
+   }
+ else
+   {
+     __p = __lc->_M_neg_format;
+     __sign = __lc->_M_negative_sign;
+     __sign_size = __lc->_M_negative_sign_size;
+     if (__digits.size())
+       ++__beg;
+   }
+
+
+ size_type __len = __ctype.scan_not(ctype_base::digit, __beg,
+        __beg + __digits.size()) - __beg;
+ if (__len)
+   {
+
+
+
+     string_type __value;
+     __value.reserve(2 * __len);
+
+
+
+     long __paddec = __len - __lc->_M_frac_digits;
+     if (__paddec > 0)
+         {
+  if (__lc->_M_frac_digits < 0)
+    __paddec = __len;
+    if (__lc->_M_grouping_size)
+      {
+      __value.assign(2 * __paddec, char_type());
+       _CharT* __vend =
+        std::__add_grouping(&__value[0], __lc->_M_thousands_sep,
+       __lc->_M_grouping,
+       __lc->_M_grouping_size,
+       __beg, __beg + __paddec);
+      __value.erase(__vend - &__value[0]);
+      }
+    else
+    __value.assign(__beg, __paddec);
+       }
+
+
+     if (__lc->_M_frac_digits > 0)
+       {
+  __value += __lc->_M_decimal_point;
+  if (__paddec >= 0)
+    __value.append(__beg + __paddec, __lc->_M_frac_digits);
+  else
+    {
+
+      __value.append(-__paddec, __lit[money_base::_S_zero]);
+      __value.append(__beg, __len);
+    }
+         }
+
+
+     const ios_base::fmtflags __f = __io.flags()
+                                    & ios_base::adjustfield;
+     __len = __value.size() + __sign_size;
+     __len += ((__io.flags() & ios_base::showbase)
+        ? __lc->_M_curr_symbol_size : 0);
+
+     string_type __res;
+     __res.reserve(2 * __len);
+
+     const size_type __width = static_cast<size_type>(__io.width());
+     const bool __testipad = (__f == ios_base::internal
+         && __len < __width);
+
+     for (int __i = 0; __i < 4; ++__i)
+       {
+  const part __which = static_cast<part>(__p.field[__i]);
+  switch (__which)
+    {
+    case money_base::symbol:
+      if (__io.flags() & ios_base::showbase)
+        __res.append(__lc->_M_curr_symbol,
+       __lc->_M_curr_symbol_size);
+      break;
+    case money_base::sign:
+
+
+
+      if (__sign_size)
+        __res += __sign[0];
+      break;
+    case money_base::value:
+      __res += __value;
+      break;
+    case money_base::space:
+
+
+
+      if (__testipad)
+        __res.append(__width - __len, __fill);
+      else
+        __res += __fill;
+      break;
+    case money_base::none:
+      if (__testipad)
+        __res.append(__width - __len, __fill);
+      break;
+    }
+       }
+
+
+     if (__sign_size > 1)
+       __res.append(__sign + 1, __sign_size - 1);
+
+
+     __len = __res.size();
+     if (__width > __len)
+       {
+  if (__f == ios_base::left)
+
+    __res.append(__width - __len, __fill);
+  else
+
+    __res.insert(0, __width - __len, __fill);
+  __len = __width;
+       }
+
+
+     __s = std::__write(__s, __res.data(), __len);
+   }
+ __io.width(0);
+ return __s;
+      }
+# 574 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.tcc" 3
+  template<typename _CharT, typename _OutIter>
+    _OutIter
+    money_put<_CharT, _OutIter>::
+    do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
+    long double __units) const
+    {
+      const locale __loc = __io.getloc();
+      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
+
+
+      int __cs_size = 64;
+      char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
+
+
+      int __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
+     "%.*Lf", 0, __units);
+
+      if (__len >= __cs_size)
+ {
+   __cs_size = __len + 1;
+   __cs = static_cast<char*>(__builtin_alloca(__cs_size));
+   __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
+     "%.*Lf", 0, __units);
+ }
+# 606 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.tcc" 3
+      string_type __digits(__len, char_type());
+      __ctype.widen(__cs, __cs + __len, &__digits[0]);
+      return __intl ? _M_insert<true>(__s, __io, __fill, __digits)
+             : _M_insert<false>(__s, __io, __fill, __digits);
+    }
+
+  template<typename _CharT, typename _OutIter>
+    _OutIter
+    money_put<_CharT, _OutIter>::
+    do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
+    const string_type& __digits) const
+    { return __intl ? _M_insert<true>(__s, __io, __fill, __digits)
+             : _M_insert<false>(__s, __io, __fill, __digits); }
+
+}
+
+
+
+
+  template<typename _CharT, typename _InIter>
+    time_base::dateorder
+    time_get<_CharT, _InIter>::do_date_order() const
+    { return time_base::no_order; }
+
+
+
+  template<typename _CharT, typename _InIter>
+    _InIter
+    time_get<_CharT, _InIter>::
+    _M_extract_via_format(iter_type __beg, iter_type __end, ios_base& __io,
+     ios_base::iostate& __err, tm* __tm,
+     const _CharT* __format) const
+    {
+      const locale& __loc = __io._M_getloc();
+      const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
+      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
+      const size_t __len = char_traits<_CharT>::length(__format);
+
+      ios_base::iostate __tmperr = ios_base::goodbit;
+      size_t __i = 0;
+      for (; __beg != __end && __i < __len && !__tmperr; ++__i)
+ {
+   if (__ctype.narrow(__format[__i], 0) == '%')
+     {
+
+       char __c = __ctype.narrow(__format[++__i], 0);
+       int __mem = 0;
+       if (__c == 'E' || __c == 'O')
+  __c = __ctype.narrow(__format[++__i], 0);
+       switch (__c)
+  {
+    const char* __cs;
+    _CharT __wcs[10];
+  case 'a':
+
+    const char_type* __days1[7];
+    __tp._M_days_abbreviated(__days1);
+    __beg = _M_extract_name(__beg, __end, __mem, __days1,
+       7, __io, __tmperr);
+    if (!__tmperr)
+      __tm->tm_wday = __mem;
+    break;
+  case 'A':
+
+    const char_type* __days2[7];
+    __tp._M_days(__days2);
+    __beg = _M_extract_name(__beg, __end, __mem, __days2,
+       7, __io, __tmperr);
+    if (!__tmperr)
+      __tm->tm_wday = __mem;
+    break;
+  case 'h':
+  case 'b':
+
+    const char_type* __months1[12];
+    __tp._M_months_abbreviated(__months1);
+    __beg = _M_extract_name(__beg, __end, __mem,
+       __months1, 12, __io, __tmperr);
+    if (!__tmperr)
+      __tm->tm_mon = __mem;
+    break;
+  case 'B':
+
+    const char_type* __months2[12];
+    __tp._M_months(__months2);
+    __beg = _M_extract_name(__beg, __end, __mem,
+       __months2, 12, __io, __tmperr);
+    if (!__tmperr)
+      __tm->tm_mon = __mem;
+    break;
+  case 'c':
+
+    const char_type* __dt[2];
+    __tp._M_date_time_formats(__dt);
+    __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
+      __tm, __dt[0]);
+    break;
+  case 'd':
+
+    __beg = _M_extract_num(__beg, __end, __mem, 1, 31, 2,
+      __io, __tmperr);
+    if (!__tmperr)
+      __tm->tm_mday = __mem;
+    break;
+  case 'e':
+
+
+    if (__ctype.is(ctype_base::space, *__beg))
+      __beg = _M_extract_num(++__beg, __end, __mem, 1, 9,
+        1, __io, __tmperr);
+    else
+      __beg = _M_extract_num(__beg, __end, __mem, 10, 31,
+        2, __io, __tmperr);
+    if (!__tmperr)
+      __tm->tm_mday = __mem;
+    break;
+  case 'D':
+
+    __cs = "%m/%d/%y";
+    __ctype.widen(__cs, __cs + 9, __wcs);
+    __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
+      __tm, __wcs);
+    break;
+  case 'H':
+
+    __beg = _M_extract_num(__beg, __end, __mem, 0, 23, 2,
+      __io, __tmperr);
+    if (!__tmperr)
+      __tm->tm_hour = __mem;
+    break;
+  case 'I':
+
+    __beg = _M_extract_num(__beg, __end, __mem, 1, 12, 2,
+      __io, __tmperr);
+    if (!__tmperr)
+      __tm->tm_hour = __mem;
+    break;
+  case 'm':
+
+    __beg = _M_extract_num(__beg, __end, __mem, 1, 12, 2,
+      __io, __tmperr);
+    if (!__tmperr)
+      __tm->tm_mon = __mem - 1;
+    break;
+  case 'M':
+
+    __beg = _M_extract_num(__beg, __end, __mem, 0, 59, 2,
+      __io, __tmperr);
+    if (!__tmperr)
+      __tm->tm_min = __mem;
+    break;
+  case 'n':
+    if (__ctype.narrow(*__beg, 0) == '\n')
+      ++__beg;
+    else
+      __tmperr |= ios_base::failbit;
+    break;
+  case 'R':
+
+    __cs = "%H:%M";
+    __ctype.widen(__cs, __cs + 6, __wcs);
+    __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
+      __tm, __wcs);
+    break;
+  case 'S':
+
+
+
+    __beg = _M_extract_num(__beg, __end, __mem, 0, 60, 2,
+
+
+
+      __io, __tmperr);
+    if (!__tmperr)
+    __tm->tm_sec = __mem;
+    break;
+  case 't':
+    if (__ctype.narrow(*__beg, 0) == '\t')
+      ++__beg;
+    else
+      __tmperr |= ios_base::failbit;
+    break;
+  case 'T':
+
+    __cs = "%H:%M:%S";
+    __ctype.widen(__cs, __cs + 9, __wcs);
+    __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
+      __tm, __wcs);
+    break;
+  case 'x':
+
+    const char_type* __dates[2];
+    __tp._M_date_formats(__dates);
+    __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
+      __tm, __dates[0]);
+    break;
+  case 'X':
+
+    const char_type* __times[2];
+    __tp._M_time_formats(__times);
+    __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
+      __tm, __times[0]);
+    break;
+  case 'y':
+  case 'C':
+
+  case 'Y':
+
+
+
+
+    __beg = _M_extract_num(__beg, __end, __mem, 0, 9999, 4,
+      __io, __tmperr);
+    if (!__tmperr)
+      __tm->tm_year = __mem < 0 ? __mem + 100 : __mem - 1900;
+    break;
+  case 'Z':
+
+    if (__ctype.is(ctype_base::upper, *__beg))
+      {
+        int __tmp;
+        __beg = _M_extract_name(__beg, __end, __tmp,
+           __timepunct_cache<_CharT>::_S_timezones,
+           14, __io, __tmperr);
+
+
+        if (__beg != __end && !__tmperr && __tmp == 0
+     && (*__beg == __ctype.widen('-')
+         || *__beg == __ctype.widen('+')))
+   {
+     __beg = _M_extract_num(__beg, __end, __tmp, 0, 23, 2,
+       __io, __tmperr);
+     __beg = _M_extract_num(__beg, __end, __tmp, 0, 59, 2,
+       __io, __tmperr);
+   }
+      }
+    else
+      __tmperr |= ios_base::failbit;
+    break;
+  default:
+
+    __tmperr |= ios_base::failbit;
+  }
+     }
+   else
+     {
+
+       if (__format[__i] == *__beg)
+  ++__beg;
+       else
+  __tmperr |= ios_base::failbit;
+     }
+ }
+
+      if (__tmperr || __i != __len)
+ __err |= ios_base::failbit;
+
+      return __beg;
+    }
+
+  template<typename _CharT, typename _InIter>
+    _InIter
+    time_get<_CharT, _InIter>::
+    _M_extract_num(iter_type __beg, iter_type __end, int& __member,
+     int __min, int __max, size_t __len,
+     ios_base& __io, ios_base::iostate& __err) const
+    {
+      const locale& __loc = __io._M_getloc();
+      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
+
+
+      int __mult = __len == 2 ? 10 : (__len == 4 ? 1000 : 1);
+
+      ++__min;
+      size_t __i = 0;
+      int __value = 0;
+      for (; __beg != __end && __i < __len; ++__beg, (void)++__i)
+ {
+   const char __c = __ctype.narrow(*__beg, '*');
+   if (__c >= '0' && __c <= '9')
+     {
+       __value = __value * 10 + (__c - '0');
+       const int __valuec = __value * __mult;
+       if (__valuec > __max || __valuec + __mult < __min)
+  break;
+       __mult /= 10;
+     }
+   else
+     break;
+ }
+      if (__i == __len)
+ __member = __value;
+
+      else if (__len == 4 && __i == 2)
+ __member = __value - 100;
+      else
+ __err |= ios_base::failbit;
+
+      return __beg;
+    }
+
+
+
+  template<typename _CharT, typename _InIter>
+    _InIter
+    time_get<_CharT, _InIter>::
+    _M_extract_name(iter_type __beg, iter_type __end, int& __member,
+      const _CharT** __names, size_t __indexlen,
+      ios_base& __io, ios_base::iostate& __err) const
+    {
+      typedef char_traits<_CharT> __traits_type;
+      const locale& __loc = __io._M_getloc();
+      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
+
+      int* __matches = static_cast<int*>(__builtin_alloca(sizeof(int)
+         * __indexlen));
+      size_t __nmatches = 0;
+      size_t __pos = 0;
+      bool __testvalid = true;
+      const char_type* __name;
+
+
+
+
+
+      if (__beg != __end)
+ {
+   const char_type __c = *__beg;
+   for (size_t __i1 = 0; __i1 < __indexlen; ++__i1)
+     if (__c == __names[__i1][0]
+  || __c == __ctype.toupper(__names[__i1][0]))
+       __matches[__nmatches++] = __i1;
+ }
+
+      while (__nmatches > 1)
+ {
+
+   size_t __minlen = __traits_type::length(__names[__matches[0]]);
+   for (size_t __i2 = 1; __i2 < __nmatches; ++__i2)
+     __minlen = std::min(__minlen,
+         __traits_type::length(__names[__matches[__i2]]));
+   ++__beg;
+   ++__pos;
+   if (__pos < __minlen && __beg != __end)
+     for (size_t __i3 = 0; __i3 < __nmatches;)
+       {
+  __name = __names[__matches[__i3]];
+  if (!(__name[__pos] == *__beg))
+    __matches[__i3] = __matches[--__nmatches];
+  else
+    ++__i3;
+       }
+   else
+     break;
+ }
+
+      if (__nmatches == 1)
+ {
+
+   ++__beg;
+   ++__pos;
+   __name = __names[__matches[0]];
+   const size_t __len = __traits_type::length(__name);
+   while (__pos < __len && __beg != __end && __name[__pos] == *__beg)
+     ++__beg, (void)++__pos;
+
+   if (__len == __pos)
+     __member = __matches[0];
+   else
+     __testvalid = false;
+ }
+      else
+ __testvalid = false;
+      if (!__testvalid)
+ __err |= ios_base::failbit;
+
+      return __beg;
+    }
+
+  template<typename _CharT, typename _InIter>
+    _InIter
+    time_get<_CharT, _InIter>::
+    _M_extract_wday_or_month(iter_type __beg, iter_type __end, int& __member,
+        const _CharT** __names, size_t __indexlen,
+        ios_base& __io, ios_base::iostate& __err) const
+    {
+      typedef char_traits<_CharT> __traits_type;
+      const locale& __loc = __io._M_getloc();
+      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
+
+      int* __matches = static_cast<int*>(__builtin_alloca(2 * sizeof(int)
+         * __indexlen));
+      size_t __nmatches = 0;
+      size_t* __matches_lengths = 0;
+      size_t __pos = 0;
+
+      if (__beg != __end)
+ {
+   const char_type __c = *__beg;
+   for (size_t __i = 0; __i < 2 * __indexlen; ++__i)
+     if (__c == __names[__i][0]
+  || __c == __ctype.toupper(__names[__i][0]))
+       __matches[__nmatches++] = __i;
+ }
+
+      if (__nmatches)
+ {
+   ++__beg;
+   ++__pos;
+
+   __matches_lengths
+     = static_cast<size_t*>(__builtin_alloca(sizeof(size_t)
+          * __nmatches));
+   for (size_t __i = 0; __i < __nmatches; ++__i)
+     __matches_lengths[__i]
+       = __traits_type::length(__names[__matches[__i]]);
+ }
+
+      for (; __beg != __end; ++__beg, (void)++__pos)
+ {
+   size_t __nskipped = 0;
+   const char_type __c = *__beg;
+   for (size_t __i = 0; __i < __nmatches;)
+     {
+       const char_type* __name = __names[__matches[__i]];
+       if (__pos >= __matches_lengths[__i])
+  ++__nskipped, ++__i;
+       else if (!(__name[__pos] == __c))
+  {
+    --__nmatches;
+    __matches[__i] = __matches[__nmatches];
+    __matches_lengths[__i] = __matches_lengths[__nmatches];
+  }
+       else
+  ++__i;
+     }
+   if (__nskipped == __nmatches)
+     break;
+ }
+
+      if ((__nmatches == 1 && __matches_lengths[0] == __pos)
+   || (__nmatches == 2 && (__matches_lengths[0] == __pos
+      || __matches_lengths[1] == __pos)))
+ __member = (__matches[0] >= __indexlen
+      ? __matches[0] - __indexlen : __matches[0]);
+      else
+ __err |= ios_base::failbit;
+
+      return __beg;
+    }
+
+  template<typename _CharT, typename _InIter>
+    _InIter
+    time_get<_CharT, _InIter>::
+    do_get_time(iter_type __beg, iter_type __end, ios_base& __io,
+  ios_base::iostate& __err, tm* __tm) const
+    {
+      const locale& __loc = __io._M_getloc();
+      const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
+      const char_type* __times[2];
+      __tp._M_time_formats(__times);
+      __beg = _M_extract_via_format(__beg, __end, __io, __err,
+        __tm, __times[0]);
+      if (__beg == __end)
+ __err |= ios_base::eofbit;
+      return __beg;
+    }
+
+  template<typename _CharT, typename _InIter>
+    _InIter
+    time_get<_CharT, _InIter>::
+    do_get_date(iter_type __beg, iter_type __end, ios_base& __io,
+  ios_base::iostate& __err, tm* __tm) const
+    {
+      const locale& __loc = __io._M_getloc();
+      const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
+      const char_type* __dates[2];
+      __tp._M_date_formats(__dates);
+      __beg = _M_extract_via_format(__beg, __end, __io, __err,
+        __tm, __dates[0]);
+      if (__beg == __end)
+ __err |= ios_base::eofbit;
+      return __beg;
+    }
+
+  template<typename _CharT, typename _InIter>
+    _InIter
+    time_get<_CharT, _InIter>::
+    do_get_weekday(iter_type __beg, iter_type __end, ios_base& __io,
+     ios_base::iostate& __err, tm* __tm) const
+    {
+      const locale& __loc = __io._M_getloc();
+      const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
+      const char_type* __days[14];
+      __tp._M_days_abbreviated(__days);
+      __tp._M_days(__days + 7);
+      int __tmpwday;
+      ios_base::iostate __tmperr = ios_base::goodbit;
+
+      __beg = _M_extract_wday_or_month(__beg, __end, __tmpwday, __days, 7,
+           __io, __tmperr);
+      if (!__tmperr)
+ __tm->tm_wday = __tmpwday;
+      else
+ __err |= ios_base::failbit;
+
+      if (__beg == __end)
+ __err |= ios_base::eofbit;
+      return __beg;
+     }
+
+  template<typename _CharT, typename _InIter>
+    _InIter
+    time_get<_CharT, _InIter>::
+    do_get_monthname(iter_type __beg, iter_type __end,
+                     ios_base& __io, ios_base::iostate& __err, tm* __tm) const
+    {
+      const locale& __loc = __io._M_getloc();
+      const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
+      const char_type* __months[24];
+      __tp._M_months_abbreviated(__months);
+      __tp._M_months(__months + 12);
+      int __tmpmon;
+      ios_base::iostate __tmperr = ios_base::goodbit;
+
+      __beg = _M_extract_wday_or_month(__beg, __end, __tmpmon, __months, 12,
+           __io, __tmperr);
+      if (!__tmperr)
+ __tm->tm_mon = __tmpmon;
+      else
+ __err |= ios_base::failbit;
+
+      if (__beg == __end)
+ __err |= ios_base::eofbit;
+      return __beg;
+    }
+
+  template<typename _CharT, typename _InIter>
+    _InIter
+    time_get<_CharT, _InIter>::
+    do_get_year(iter_type __beg, iter_type __end, ios_base& __io,
+  ios_base::iostate& __err, tm* __tm) const
+    {
+      int __tmpyear;
+      ios_base::iostate __tmperr = ios_base::goodbit;
+
+      __beg = _M_extract_num(__beg, __end, __tmpyear, 0, 9999, 4,
+        __io, __tmperr);
+      if (!__tmperr)
+ __tm->tm_year = __tmpyear < 0 ? __tmpyear + 100 : __tmpyear - 1900;
+      else
+ __err |= ios_base::failbit;
+
+      if (__beg == __end)
+ __err |= ios_base::eofbit;
+      return __beg;
+    }
+
+
+  template<typename _CharT, typename _InIter>
+    inline
+    _InIter
+    time_get<_CharT, _InIter>::
+    get(iter_type __s, iter_type __end, ios_base& __io,
+        ios_base::iostate& __err, tm* __tm, const char_type* __fmt,
+        const char_type* __fmtend) const
+    {
+      const locale& __loc = __io._M_getloc();
+      ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
+      __err = ios_base::goodbit;
+      while (__fmt != __fmtend &&
+             __err == ios_base::goodbit)
+        {
+          if (__s == __end)
+            {
+              __err = ios_base::eofbit | ios_base::failbit;
+              break;
+            }
+          else if (__ctype.narrow(*__fmt, 0) == '%')
+            {
+              char __format;
+              char __mod = 0;
+              if (++__fmt == __fmtend)
+                {
+                  __err = ios_base::failbit;
+                  break;
+                }
+              const char __c = __ctype.narrow(*__fmt, 0);
+              if (__c != 'E' && __c != 'O')
+                __format = __c;
+              else if (++__fmt != __fmtend)
+                {
+                  __mod = __c;
+                  __format = __ctype.narrow(*__fmt, 0);
+                }
+              else
+                {
+                  __err = ios_base::failbit;
+                  break;
+                }
+              __s = this->do_get(__s, __end, __io, __err, __tm, __format,
+     __mod);
+              ++__fmt;
+            }
+          else if (__ctype.is(ctype_base::space, *__fmt))
+            {
+              ++__fmt;
+              while (__fmt != __fmtend &&
+                     __ctype.is(ctype_base::space, *__fmt))
+                ++__fmt;
+
+              while (__s != __end &&
+                     __ctype.is(ctype_base::space, *__s))
+                ++__s;
+            }
+
+          else if (__ctype.tolower(*__s) == __ctype.tolower(*__fmt) ||
+                   __ctype.toupper(*__s) == __ctype.toupper(*__fmt))
+            {
+              ++__s;
+              ++__fmt;
+            }
+          else
+            {
+              __err = ios_base::failbit;
+              break;
+            }
+        }
+      return __s;
+    }
+
+  template<typename _CharT, typename _InIter>
+    inline
+    _InIter
+    time_get<_CharT, _InIter>::
+    do_get(iter_type __beg, iter_type __end, ios_base& __io,
+           ios_base::iostate& __err, tm* __tm,
+           char __format, char __mod) const
+    {
+      const locale& __loc = __io._M_getloc();
+      ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
+      __err = ios_base::goodbit;
+
+      char_type __fmt[4];
+      __fmt[0] = __ctype.widen('%');
+      if (!__mod)
+        {
+          __fmt[1] = __format;
+          __fmt[2] = char_type();
+        }
+      else
+        {
+          __fmt[1] = __mod;
+          __fmt[2] = __format;
+          __fmt[3] = char_type();
+        }
+
+      __beg = _M_extract_via_format(__beg, __end, __io, __err, __tm, __fmt);
+      if (__beg == __end)
+ __err |= ios_base::eofbit;
+      return __beg;
+    }
+
+
+
+  template<typename _CharT, typename _OutIter>
+    _OutIter
+    time_put<_CharT, _OutIter>::
+    put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm,
+ const _CharT* __beg, const _CharT* __end) const
+    {
+      const locale& __loc = __io._M_getloc();
+      ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
+      for (; __beg != __end; ++__beg)
+ if (__ctype.narrow(*__beg, 0) != '%')
+   {
+     *__s = *__beg;
+     ++__s;
+   }
+ else if (++__beg != __end)
+   {
+     char __format;
+     char __mod = 0;
+     const char __c = __ctype.narrow(*__beg, 0);
+     if (__c != 'E' && __c != 'O')
+       __format = __c;
+     else if (++__beg != __end)
+       {
+  __mod = __c;
+  __format = __ctype.narrow(*__beg, 0);
+       }
+     else
+       break;
+     __s = this->do_put(__s, __io, __fill, __tm, __format, __mod);
+   }
+ else
+   break;
+      return __s;
+    }
+
+  template<typename _CharT, typename _OutIter>
+    _OutIter
+    time_put<_CharT, _OutIter>::
+    do_put(iter_type __s, ios_base& __io, char_type, const tm* __tm,
+    char __format, char __mod) const
+    {
+      const locale& __loc = __io._M_getloc();
+      ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
+      __timepunct<_CharT> const& __tp = use_facet<__timepunct<_CharT> >(__loc);
+
+
+
+      const size_t __maxlen = 128;
+      char_type __res[__maxlen];
+
+
+
+
+
+
+      char_type __fmt[4];
+      __fmt[0] = __ctype.widen('%');
+      if (!__mod)
+ {
+   __fmt[1] = __format;
+   __fmt[2] = char_type();
+ }
+      else
+ {
+   __fmt[1] = __mod;
+   __fmt[2] = __format;
+   __fmt[3] = char_type();
+ }
+
+      __tp._M_put(__res, __maxlen, __fmt, __tm);
+
+
+      return std::__write(__s, __res, char_traits<char_type>::length(__res));
+    }
+
+
+
+
+
+  extern template class moneypunct<char, false>;
+  extern template class moneypunct<char, true>;
+  extern template class moneypunct_byname<char, false>;
+  extern template class moneypunct_byname<char, true>;
+  extern template class __cxx11:: money_get<char>;
+  extern template class __cxx11:: money_put<char>;
+  extern template class __timepunct<char>;
+  extern template class time_put<char>;
+  extern template class time_put_byname<char>;
+  extern template class time_get<char>;
+  extern template class time_get_byname<char>;
+  extern template class messages<char>;
+  extern template class messages_byname<char>;
+
+  extern template
+    const moneypunct<char, true>&
+    use_facet<moneypunct<char, true> >(const locale&);
+
+  extern template
+    const moneypunct<char, false>&
+    use_facet<moneypunct<char, false> >(const locale&);
+
+  extern template
+    const money_put<char>&
+    use_facet<money_put<char> >(const locale&);
+
+  extern template
+    const money_get<char>&
+    use_facet<money_get<char> >(const locale&);
+
+  extern template
+    const __timepunct<char>&
+    use_facet<__timepunct<char> >(const locale&);
+
+  extern template
+    const time_put<char>&
+    use_facet<time_put<char> >(const locale&);
+
+  extern template
+    const time_get<char>&
+    use_facet<time_get<char> >(const locale&);
+
+  extern template
+    const messages<char>&
+    use_facet<messages<char> >(const locale&);
+
+  extern template
+    bool
+    has_facet<moneypunct<char> >(const locale&);
+
+  extern template
+    bool
+    has_facet<money_put<char> >(const locale&);
+
+  extern template
+    bool
+    has_facet<money_get<char> >(const locale&);
+
+  extern template
+    bool
+    has_facet<__timepunct<char> >(const locale&);
+
+  extern template
+    bool
+    has_facet<time_put<char> >(const locale&);
+
+  extern template
+    bool
+    has_facet<time_get<char> >(const locale&);
+
+  extern template
+    bool
+    has_facet<messages<char> >(const locale&);
+
+
+  extern template class moneypunct<wchar_t, false>;
+  extern template class moneypunct<wchar_t, true>;
+  extern template class moneypunct_byname<wchar_t, false>;
+  extern template class moneypunct_byname<wchar_t, true>;
+  extern template class __cxx11:: money_get<wchar_t>;
+  extern template class __cxx11:: money_put<wchar_t>;
+  extern template class __timepunct<wchar_t>;
+  extern template class time_put<wchar_t>;
+  extern template class time_put_byname<wchar_t>;
+  extern template class time_get<wchar_t>;
+  extern template class time_get_byname<wchar_t>;
+  extern template class messages<wchar_t>;
+  extern template class messages_byname<wchar_t>;
+
+  extern template
+    const moneypunct<wchar_t, true>&
+    use_facet<moneypunct<wchar_t, true> >(const locale&);
+
+  extern template
+    const moneypunct<wchar_t, false>&
+    use_facet<moneypunct<wchar_t, false> >(const locale&);
+
+  extern template
+    const money_put<wchar_t>&
+    use_facet<money_put<wchar_t> >(const locale&);
+
+  extern template
+    const money_get<wchar_t>&
+    use_facet<money_get<wchar_t> >(const locale&);
+
+  extern template
+    const __timepunct<wchar_t>&
+    use_facet<__timepunct<wchar_t> >(const locale&);
+
+  extern template
+    const time_put<wchar_t>&
+    use_facet<time_put<wchar_t> >(const locale&);
+
+  extern template
+    const time_get<wchar_t>&
+    use_facet<time_get<wchar_t> >(const locale&);
+
+  extern template
+    const messages<wchar_t>&
+    use_facet<messages<wchar_t> >(const locale&);
+
+  extern template
+    bool
+    has_facet<moneypunct<wchar_t> >(const locale&);
+
+  extern template
+    bool
+    has_facet<money_put<wchar_t> >(const locale&);
+
+  extern template
+    bool
+    has_facet<money_get<wchar_t> >(const locale&);
+
+  extern template
+    bool
+    has_facet<__timepunct<wchar_t> >(const locale&);
+
+  extern template
+    bool
+    has_facet<time_put<wchar_t> >(const locale&);
+
+  extern template
+    bool
+    has_facet<time_get<wchar_t> >(const locale&);
+
+  extern template
+    bool
+    has_facet<messages<wchar_t> >(const locale&);
+
+
+
+
+}
+# 2016 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 2 3
+# 42 "/usr/include/c++/10.2.0/locale" 2 3
+
+# 1 "/usr/include/c++/10.2.0/bits/locale_conv.h" 1 3
+# 31 "/usr/include/c++/10.2.0/bits/locale_conv.h" 3
+#define _LOCALE_CONV_H 1
+# 43 "/usr/include/c++/10.2.0/bits/locale_conv.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+
+
+  template<typename _OutStr, typename _InChar, typename _Codecvt,
+    typename _State, typename _Fn>
+    bool
+    __do_str_codecvt(const _InChar* __first, const _InChar* __last,
+       _OutStr& __outstr, const _Codecvt& __cvt, _State& __state,
+       size_t& __count, _Fn __fn)
+    {
+      if (__first == __last)
+ {
+   __outstr.clear();
+   __count = 0;
+   return true;
+ }
+
+      size_t __outchars = 0;
+      auto __next = __first;
+      const auto __maxlen = __cvt.max_length() + 1;
+
+      codecvt_base::result __result;
+      do
+ {
+   __outstr.resize(__outstr.size() + (__last - __next) * __maxlen);
+   auto __outnext = &__outstr.front() + __outchars;
+   auto const __outlast = &__outstr.back() + 1;
+   __result = (__cvt.*__fn)(__state, __next, __last, __next,
+     __outnext, __outlast, __outnext);
+   __outchars = __outnext - &__outstr.front();
+ }
+      while (__result == codecvt_base::partial && __next != __last
+      && (__outstr.size() - __outchars) < __maxlen);
+
+      if (__result == codecvt_base::error)
+ {
+   __count = __next - __first;
+   return false;
+ }
+
+
+
+      if constexpr (is_same<typename _Codecvt::intern_type,
+           typename _Codecvt::extern_type>())
+ if (__result == codecvt_base::noconv)
+   {
+     __outstr.assign(__first, __last);
+     __count = __last - __first;
+     return true;
+   }
+
+      __outstr.resize(__outchars);
+      __count = __next - __first;
+      return true;
+    }
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc, typename _State>
+    inline bool
+    __str_codecvt_in(const char* __first, const char* __last,
+       basic_string<_CharT, _Traits, _Alloc>& __outstr,
+       const codecvt<_CharT, char, _State>& __cvt,
+       _State& __state, size_t& __count)
+    {
+      using _Codecvt = codecvt<_CharT, char, _State>;
+      using _ConvFn
+ = codecvt_base::result
+   (_Codecvt::*)(_State&, const char*, const char*, const char*&,
+   _CharT*, _CharT*, _CharT*&) const;
+      _ConvFn __fn = &codecvt<_CharT, char, _State>::in;
+      return __do_str_codecvt(__first, __last, __outstr, __cvt, __state,
+         __count, __fn);
+    }
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc, typename _State>
+    inline bool
+    __str_codecvt_in(const char* __first, const char* __last,
+       basic_string<_CharT, _Traits, _Alloc>& __outstr,
+       const codecvt<_CharT, char, _State>& __cvt)
+    {
+      _State __state = {};
+      size_t __n;
+      return __str_codecvt_in(__first, __last, __outstr, __cvt, __state, __n);
+    }
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc, typename _State>
+    inline bool
+    __str_codecvt_in_all(const char* __first, const char* __last,
+    basic_string<_CharT, _Traits, _Alloc>& __outstr,
+    const codecvt<_CharT, char, _State>& __cvt)
+    {
+      _State __state = {};
+      size_t __n;
+      return __str_codecvt_in(__first, __last, __outstr, __cvt, __state, __n)
+ && (__n == (__last - __first));
+    }
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc, typename _State>
+    inline bool
+    __str_codecvt_out(const _CharT* __first, const _CharT* __last,
+        basic_string<char, _Traits, _Alloc>& __outstr,
+        const codecvt<_CharT, char, _State>& __cvt,
+        _State& __state, size_t& __count)
+    {
+      using _Codecvt = codecvt<_CharT, char, _State>;
+      using _ConvFn
+ = codecvt_base::result
+   (_Codecvt::*)(_State&, const _CharT*, const _CharT*, const _CharT*&,
+   char*, char*, char*&) const;
+      _ConvFn __fn = &codecvt<_CharT, char, _State>::out;
+      return __do_str_codecvt(__first, __last, __outstr, __cvt, __state,
+         __count, __fn);
+    }
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc, typename _State>
+    inline bool
+    __str_codecvt_out(const _CharT* __first, const _CharT* __last,
+        basic_string<char, _Traits, _Alloc>& __outstr,
+        const codecvt<_CharT, char, _State>& __cvt)
+    {
+      _State __state = {};
+      size_t __n;
+      return __str_codecvt_out(__first, __last, __outstr, __cvt, __state, __n);
+    }
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc, typename _State>
+    inline bool
+    __str_codecvt_out_all(const _CharT* __first, const _CharT* __last,
+     basic_string<char, _Traits, _Alloc>& __outstr,
+     const codecvt<_CharT, char, _State>& __cvt)
+    {
+      _State __state = {};
+      size_t __n;
+      return __str_codecvt_out(__first, __last, __outstr, __cvt, __state, __n)
+ && (__n == (__last - __first));
+    }
+# 226 "/usr/include/c++/10.2.0/bits/locale_conv.h" 3
+namespace __cxx11 {
+
+
+  template<typename _Codecvt, typename _Elem = wchar_t,
+    typename _Wide_alloc = allocator<_Elem>,
+    typename _Byte_alloc = allocator<char>>
+    class wstring_convert
+    {
+    public:
+      typedef basic_string<char, char_traits<char>, _Byte_alloc> byte_string;
+      typedef basic_string<_Elem, char_traits<_Elem>, _Wide_alloc> wide_string;
+      typedef typename _Codecvt::state_type state_type;
+      typedef typename wide_string::traits_type::int_type int_type;
+
+
+      wstring_convert() : _M_cvt(new _Codecvt()) { }
+
+
+
+
+
+
+
+      explicit
+      wstring_convert(_Codecvt* __pcvt) : _M_cvt(__pcvt)
+      {
+ if (!_M_cvt)
+   __throw_logic_error("wstring_convert");
+      }
+# 264 "/usr/include/c++/10.2.0/bits/locale_conv.h" 3
+      wstring_convert(_Codecvt* __pcvt, state_type __state)
+      : _M_cvt(__pcvt), _M_state(__state), _M_with_cvtstate(true)
+      {
+ if (!_M_cvt)
+   __throw_logic_error("wstring_convert");
+      }
+
+
+
+
+
+
+      explicit
+      wstring_convert(const byte_string& __byte_err,
+        const wide_string& __wide_err = wide_string())
+      : _M_cvt(new _Codecvt),
+ _M_byte_err_string(__byte_err), _M_wide_err_string(__wide_err),
+ _M_with_strings(true)
+      {
+ if (!_M_cvt)
+   __throw_logic_error("wstring_convert");
+      }
+
+      ~wstring_convert() = default;
+
+
+
+      wstring_convert(const wstring_convert&) = delete;
+      wstring_convert& operator=(const wstring_convert&) = delete;
+
+
+      wide_string
+      from_bytes(char __byte)
+      {
+ char __bytes[2] = { __byte };
+ return from_bytes(__bytes, __bytes+1);
+      }
+
+      wide_string
+      from_bytes(const char* __ptr)
+      { return from_bytes(__ptr, __ptr+char_traits<char>::length(__ptr)); }
+
+      wide_string
+      from_bytes(const byte_string& __str)
+      {
+ auto __ptr = __str.data();
+ return from_bytes(__ptr, __ptr + __str.size());
+      }
+
+      wide_string
+      from_bytes(const char* __first, const char* __last)
+      {
+ if (!_M_with_cvtstate)
+   _M_state = state_type();
+ wide_string __out{ _M_wide_err_string.get_allocator() };
+ if (__str_codecvt_in(__first, __last, __out, *_M_cvt, _M_state,
+        _M_count))
+   return __out;
+ if (_M_with_strings)
+   return _M_wide_err_string;
+ __throw_range_error("wstring_convert::from_bytes");
+      }
+
+
+
+      byte_string
+      to_bytes(_Elem __wchar)
+      {
+ _Elem __wchars[2] = { __wchar };
+ return to_bytes(__wchars, __wchars+1);
+      }
+
+      byte_string
+      to_bytes(const _Elem* __ptr)
+      {
+ return to_bytes(__ptr, __ptr+wide_string::traits_type::length(__ptr));
+      }
+
+      byte_string
+      to_bytes(const wide_string& __wstr)
+      {
+ auto __ptr = __wstr.data();
+ return to_bytes(__ptr, __ptr + __wstr.size());
+      }
+
+      byte_string
+      to_bytes(const _Elem* __first, const _Elem* __last)
+      {
+ if (!_M_with_cvtstate)
+   _M_state = state_type();
+ byte_string __out{ _M_byte_err_string.get_allocator() };
+ if (__str_codecvt_out(__first, __last, __out, *_M_cvt, _M_state,
+         _M_count))
+   return __out;
+ if (_M_with_strings)
+   return _M_byte_err_string;
+ __throw_range_error("wstring_convert::to_bytes");
+      }
+
+
+
+
+
+      size_t converted() const noexcept { return _M_count; }
+
+
+      state_type state() const { return _M_state; }
+
+    private:
+      unique_ptr<_Codecvt> _M_cvt;
+      byte_string _M_byte_err_string;
+      wide_string _M_wide_err_string;
+      state_type _M_state = state_type();
+      size_t _M_count = 0;
+      bool _M_with_cvtstate = false;
+      bool _M_with_strings = false;
+    };
+
+}
+
+
+  template<typename _Codecvt, typename _Elem = wchar_t,
+    typename _Tr = char_traits<_Elem>>
+    class wbuffer_convert : public basic_streambuf<_Elem, _Tr>
+    {
+      typedef basic_streambuf<_Elem, _Tr> _Wide_streambuf;
+
+    public:
+      typedef typename _Codecvt::state_type state_type;
+
+
+      wbuffer_convert() : wbuffer_convert(nullptr) { }
+# 405 "/usr/include/c++/10.2.0/bits/locale_conv.h" 3
+      explicit
+      wbuffer_convert(streambuf* __bytebuf, _Codecvt* __pcvt = new _Codecvt,
+        state_type __state = state_type())
+      : _M_buf(__bytebuf), _M_cvt(__pcvt), _M_state(__state)
+      {
+ if (!_M_cvt)
+   __throw_logic_error("wbuffer_convert");
+
+ _M_always_noconv = _M_cvt->always_noconv();
+
+ if (_M_buf)
+   {
+     this->setp(_M_put_area, _M_put_area + _S_buffer_length);
+     this->setg(_M_get_area + _S_putback_length,
+         _M_get_area + _S_putback_length,
+         _M_get_area + _S_putback_length);
+   }
+      }
+
+      ~wbuffer_convert() = default;
+
+
+
+      wbuffer_convert(const wbuffer_convert&) = delete;
+      wbuffer_convert& operator=(const wbuffer_convert&) = delete;
+
+      streambuf* rdbuf() const noexcept { return _M_buf; }
+
+      streambuf*
+      rdbuf(streambuf *__bytebuf) noexcept
+      {
+ auto __prev = _M_buf;
+ _M_buf = __bytebuf;
+ return __prev;
+      }
+
+
+      state_type state() const noexcept { return _M_state; }
+
+    protected:
+      int
+      sync()
+      { return _M_buf && _M_conv_put() && !_M_buf->pubsync() ? 0 : -1; }
+
+      typename _Wide_streambuf::int_type
+      overflow(typename _Wide_streambuf::int_type __out)
+      {
+ if (!_M_buf || !_M_conv_put())
+   return _Tr::eof();
+ else if (!_Tr::eq_int_type(__out, _Tr::eof()))
+   return this->sputc(__out);
+ return _Tr::not_eof(__out);
+      }
+
+      typename _Wide_streambuf::int_type
+      underflow()
+      {
+ if (!_M_buf)
+   return _Tr::eof();
+
+ if (this->gptr() < this->egptr() || (_M_buf && _M_conv_get()))
+   return _Tr::to_int_type(*this->gptr());
+ else
+   return _Tr::eof();
+      }
+
+      streamsize
+      xsputn(const typename _Wide_streambuf::char_type* __s, streamsize __n)
+      {
+ if (!_M_buf || __n == 0)
+   return 0;
+ streamsize __done = 0;
+ do
+ {
+   auto __nn = std::min<streamsize>(this->epptr() - this->pptr(),
+        __n - __done);
+   _Tr::copy(this->pptr(), __s + __done, __nn);
+   this->pbump(__nn);
+   __done += __nn;
+ } while (__done < __n && _M_conv_put());
+ return __done;
+      }
+
+    private:
+
+      bool
+      _M_conv_get()
+      {
+ const streamsize __pb1 = this->gptr() - this->eback();
+ const streamsize __pb2 = _S_putback_length;
+ const streamsize __npb = std::min(__pb1, __pb2);
+
+ _Tr::move(_M_get_area + _S_putback_length - __npb,
+    this->gptr() - __npb, __npb);
+
+ streamsize __nbytes = sizeof(_M_get_buf) - _M_unconv;
+ __nbytes = std::min(__nbytes, _M_buf->in_avail());
+ if (__nbytes < 1)
+   __nbytes = 1;
+ __nbytes = _M_buf->sgetn(_M_get_buf + _M_unconv, __nbytes);
+ if (__nbytes < 1)
+   return false;
+ __nbytes += _M_unconv;
+
+
+
+ _Elem* __outbuf = _M_get_area + _S_putback_length;
+ _Elem* __outnext = __outbuf;
+ const char* __bnext = _M_get_buf;
+
+ codecvt_base::result __result;
+ if (_M_always_noconv)
+   __result = codecvt_base::noconv;
+ else
+   {
+     _Elem* __outend = _M_get_area + _S_buffer_length;
+
+     __result = _M_cvt->in(_M_state,
+      __bnext, __bnext + __nbytes, __bnext,
+      __outbuf, __outend, __outnext);
+   }
+
+ if (__result == codecvt_base::noconv)
+   {
+
+     auto __get_buf = reinterpret_cast<const _Elem*>(_M_get_buf);
+     _Tr::copy(__outbuf, __get_buf, __nbytes);
+     _M_unconv = 0;
+     return true;
+   }
+
+ if ((_M_unconv = _M_get_buf + __nbytes - __bnext))
+   char_traits<char>::move(_M_get_buf, __bnext, _M_unconv);
+
+ this->setg(__outbuf, __outbuf, __outnext);
+
+ return __result != codecvt_base::error;
+      }
+
+
+      bool
+      _M_put(...)
+      { return false; }
+
+      bool
+      _M_put(const char* __p, streamsize __n)
+      {
+ if (_M_buf->sputn(__p, __n) < __n)
+   return false;
+ return true;
+      }
+
+
+      bool
+      _M_conv_put()
+      {
+ _Elem* const __first = this->pbase();
+ const _Elem* const __last = this->pptr();
+ const streamsize __pending = __last - __first;
+
+ if (_M_always_noconv)
+   return _M_put(__first, __pending);
+
+ char __outbuf[2 * _S_buffer_length];
+
+ const _Elem* __next = __first;
+ const _Elem* __start;
+ do
+   {
+     __start = __next;
+     char* __outnext = __outbuf;
+     char* const __outlast = __outbuf + sizeof(__outbuf);
+     auto __result = _M_cvt->out(_M_state, __next, __last, __next,
+     __outnext, __outlast, __outnext);
+     if (__result == codecvt_base::error)
+       return false;
+     else if (__result == codecvt_base::noconv)
+       return _M_put(__next, __pending);
+
+     if (!_M_put(__outbuf, __outnext - __outbuf))
+       return false;
+   }
+ while (__next != __last && __next != __start);
+
+ if (__next != __last)
+   _Tr::move(__first, __next, __last - __next);
+
+ this->pbump(__first - __next);
+ return __next != __first;
+      }
+
+      streambuf* _M_buf;
+      unique_ptr<_Codecvt> _M_cvt;
+      state_type _M_state;
+
+      static const streamsize _S_buffer_length = 32;
+      static const streamsize _S_putback_length = 3;
+      _Elem _M_put_area[_S_buffer_length];
+      _Elem _M_get_area[_S_buffer_length];
+      streamsize _M_unconv = 0;
+      char _M_get_buf[_S_buffer_length-_S_putback_length];
+      bool _M_always_noconv;
+    };
+
+
+
+
+
+
+}
+# 44 "/usr/include/c++/10.2.0/locale" 2 3
+# 44 "/usr/include/c++/10.2.0/iomanip" 2 3
+
+# 1 "/usr/include/c++/10.2.0/bits/quoted_string.h" 1 3
+# 31 "/usr/include/c++/10.2.0/bits/quoted_string.h" 3
+#define _GLIBCXX_QUOTED_STRING_H 1
+
+       
+# 34 "/usr/include/c++/10.2.0/bits/quoted_string.h" 3
+
+
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  namespace __detail {
+
+
+
+    template<typename _String, typename _CharT>
+      struct _Quoted_string
+      {
+ static_assert(is_reference<_String>::value
+     || is_pointer<_String>::value,
+        "String type must be pointer or reference");
+
+ _Quoted_string(_String __str, _CharT __del, _CharT __esc)
+ : _M_string(__str), _M_delim{__del}, _M_escape{__esc}
+ { }
+
+ _Quoted_string&
+ operator=(_Quoted_string&) = delete;
+
+ _String _M_string;
+ _CharT _M_delim;
+ _CharT _M_escape;
+      };
+
+
+    template<typename _CharT, typename _Traits>
+      struct _Quoted_string<basic_string_view<_CharT, _Traits>, _CharT>
+      {
+ _Quoted_string(basic_string_view<_CharT, _Traits> __str,
+         _CharT __del, _CharT __esc)
+ : _M_string(__str), _M_delim{__del}, _M_escape{__esc}
+ { }
+
+ _Quoted_string&
+ operator=(_Quoted_string&) = delete;
+
+ basic_string_view<_CharT, _Traits> _M_string;
+ _CharT _M_delim;
+ _CharT _M_escape;
+      };
+# 91 "/usr/include/c++/10.2.0/bits/quoted_string.h" 3
+    template<typename _CharT, typename _Traits>
+      std::basic_ostream<_CharT, _Traits>&
+      operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+   const _Quoted_string<const _CharT*, _CharT>& __str)
+      {
+ std::basic_ostringstream<_CharT, _Traits> __ostr;
+ __ostr << __str._M_delim;
+ for (const _CharT* __c = __str._M_string; *__c; ++__c)
+   {
+     if (*__c == __str._M_delim || *__c == __str._M_escape)
+       __ostr << __str._M_escape;
+     __ostr << *__c;
+   }
+ __ostr << __str._M_delim;
+
+ return __os << __ostr.str();
+      }
+
+
+
+
+
+
+
+    template<typename _CharT, typename _Traits, typename _String>
+      std::basic_ostream<_CharT, _Traits>&
+      operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+   const _Quoted_string<_String, _CharT>& __str)
+      {
+ std::basic_ostringstream<_CharT, _Traits> __ostr;
+ __ostr << __str._M_delim;
+ for (auto __c : __str._M_string)
+   {
+     if (__c == __str._M_delim || __c == __str._M_escape)
+       __ostr << __str._M_escape;
+     __ostr << __c;
+   }
+ __ostr << __str._M_delim;
+
+ return __os << __ostr.str();
+      }
+
+
+
+
+
+    template<typename _CharT, typename _Traits, typename _Alloc>
+      std::basic_istream<_CharT, _Traits>&
+      operator>>(std::basic_istream<_CharT, _Traits>& __is,
+   const _Quoted_string<basic_string<_CharT, _Traits, _Alloc>&,
+          _CharT>& __str)
+      {
+ _CharT __c;
+ __is >> __c;
+ if (!__is.good())
+   return __is;
+ if (__c != __str._M_delim)
+   {
+     __is.unget();
+     __is >> __str._M_string;
+     return __is;
+   }
+ __str._M_string.clear();
+ std::ios_base::fmtflags __flags
+   = __is.flags(__is.flags() & ~std::ios_base::skipws);
+ do
+   {
+     __is >> __c;
+     if (!__is.good())
+       break;
+     if (__c == __str._M_escape)
+       {
+  __is >> __c;
+  if (!__is.good())
+    break;
+       }
+     else if (__c == __str._M_delim)
+       break;
+     __str._M_string += __c;
+   }
+ while (true);
+ __is.setf(__flags);
+
+ return __is;
+      }
+  }
+
+
+}
+# 46 "/usr/include/c++/10.2.0/iomanip" 2 3
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+  struct _Resetiosflags { ios_base::fmtflags _M_mask; };
+# 65 "/usr/include/c++/10.2.0/iomanip" 3
+  inline _Resetiosflags
+  resetiosflags(ios_base::fmtflags __mask)
+  { return { __mask }; }
+
+  template<typename _CharT, typename _Traits>
+    inline basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __is, _Resetiosflags __f)
+    {
+      __is.setf(ios_base::fmtflags(0), __f._M_mask);
+      return __is;
+    }
+
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __os, _Resetiosflags __f)
+    {
+      __os.setf(ios_base::fmtflags(0), __f._M_mask);
+      return __os;
+    }
+
+
+  struct _Setiosflags { ios_base::fmtflags _M_mask; };
+# 95 "/usr/include/c++/10.2.0/iomanip" 3
+  inline _Setiosflags
+  setiosflags(ios_base::fmtflags __mask)
+  { return { __mask }; }
+
+  template<typename _CharT, typename _Traits>
+    inline basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __is, _Setiosflags __f)
+    {
+      __is.setf(__f._M_mask);
+      return __is;
+    }
+
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __os, _Setiosflags __f)
+    {
+      __os.setf(__f._M_mask);
+      return __os;
+    }
+
+
+  struct _Setbase { int _M_base; };
+# 126 "/usr/include/c++/10.2.0/iomanip" 3
+  inline _Setbase
+  setbase(int __base)
+  { return { __base }; }
+
+  template<typename _CharT, typename _Traits>
+    inline basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __is, _Setbase __f)
+    {
+      __is.setf(__f._M_base == 8 ? ios_base::oct :
+  __f._M_base == 10 ? ios_base::dec :
+  __f._M_base == 16 ? ios_base::hex :
+  ios_base::fmtflags(0), ios_base::basefield);
+      return __is;
+    }
+
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __os, _Setbase __f)
+    {
+      __os.setf(__f._M_base == 8 ? ios_base::oct :
+  __f._M_base == 10 ? ios_base::dec :
+  __f._M_base == 16 ? ios_base::hex :
+  ios_base::fmtflags(0), ios_base::basefield);
+      return __os;
+    }
+
+
+  template<typename _CharT>
+    struct _Setfill { _CharT _M_c; };
+# 163 "/usr/include/c++/10.2.0/iomanip" 3
+  template<typename _CharT>
+    inline _Setfill<_CharT>
+    setfill(_CharT __c)
+    { return { __c }; }
+
+  template<typename _CharT, typename _Traits>
+    inline basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __is, _Setfill<_CharT> __f)
+    {
+      __is.fill(__f._M_c);
+      return __is;
+    }
+
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __os, _Setfill<_CharT> __f)
+    {
+      __os.fill(__f._M_c);
+      return __os;
+    }
+
+
+  struct _Setprecision { int _M_n; };
+# 194 "/usr/include/c++/10.2.0/iomanip" 3
+  inline _Setprecision
+  setprecision(int __n)
+  { return { __n }; }
+
+  template<typename _CharT, typename _Traits>
+    inline basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __is, _Setprecision __f)
+    {
+      __is.precision(__f._M_n);
+      return __is;
+    }
+
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __os, _Setprecision __f)
+    {
+      __os.precision(__f._M_n);
+      return __os;
+    }
+
+
+  struct _Setw { int _M_n; };
+# 224 "/usr/include/c++/10.2.0/iomanip" 3
+  inline _Setw
+  setw(int __n)
+  { return { __n }; }
+
+  template<typename _CharT, typename _Traits>
+    inline basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __is, _Setw __f)
+    {
+      __is.width(__f._M_n);
+      return __is;
+    }
+
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __os, _Setw __f)
+    {
+      __os.width(__f._M_n);
+      return __os;
+    }
+
+
+
+  template<typename _MoneyT>
+    struct _Get_money { _MoneyT& _M_mon; bool _M_intl; };
+# 257 "/usr/include/c++/10.2.0/iomanip" 3
+  template<typename _MoneyT>
+    inline _Get_money<_MoneyT>
+    get_money(_MoneyT& __mon, bool __intl = false)
+    { return { __mon, __intl }; }
+
+  template<typename _CharT, typename _Traits, typename _MoneyT>
+    basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __is, _Get_money<_MoneyT> __f)
+    {
+      typename basic_istream<_CharT, _Traits>::sentry __cerb(__is, false);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       typedef istreambuf_iterator<_CharT, _Traits> _Iter;
+       typedef money_get<_CharT, _Iter> _MoneyGet;
+
+       const _MoneyGet& __mg = use_facet<_MoneyGet>(__is.getloc());
+       __mg.get(_Iter(__is.rdbuf()), _Iter(), __f._M_intl,
+         __is, __err, __f._M_mon);
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       __is._M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { __is._M_setstate(ios_base::badbit); }
+   if (__err)
+     __is.setstate(__err);
+ }
+      return __is;
+    }
+
+
+  template<typename _MoneyT>
+    struct _Put_money { const _MoneyT& _M_mon; bool _M_intl; };
+# 304 "/usr/include/c++/10.2.0/iomanip" 3
+  template<typename _MoneyT>
+    inline _Put_money<_MoneyT>
+    put_money(const _MoneyT& __mon, bool __intl = false)
+    { return { __mon, __intl }; }
+
+  template<typename _CharT, typename _Traits, typename _MoneyT>
+    basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __os, _Put_money<_MoneyT> __f)
+    {
+      typename basic_ostream<_CharT, _Traits>::sentry __cerb(__os);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       typedef ostreambuf_iterator<_CharT, _Traits> _Iter;
+       typedef money_put<_CharT, _Iter> _MoneyPut;
+
+       const _MoneyPut& __mp = use_facet<_MoneyPut>(__os.getloc());
+       if (__mp.put(_Iter(__os.rdbuf()), __f._M_intl, __os,
+      __os.fill(), __f._M_mon).failed())
+  __err |= ios_base::badbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       __os._M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { __os._M_setstate(ios_base::badbit); }
+   if (__err)
+     __os.setstate(__err);
+ }
+      return __os;
+    }
+
+  template<typename _CharT>
+    struct _Put_time
+    {
+      const std::tm* _M_tmb;
+      const _CharT* _M_fmt;
+    };
+# 356 "/usr/include/c++/10.2.0/iomanip" 3
+  template<typename _CharT>
+    inline _Put_time<_CharT>
+    put_time(const std::tm* __tmb, const _CharT* __fmt)
+    { return { __tmb, __fmt }; }
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __os, _Put_time<_CharT> __f)
+    {
+      typename basic_ostream<_CharT, _Traits>::sentry __cerb(__os);
+      if (__cerb)
+        {
+          ios_base::iostate __err = ios_base::goodbit;
+          try
+            {
+              typedef ostreambuf_iterator<_CharT, _Traits> _Iter;
+              typedef time_put<_CharT, _Iter> _TimePut;
+
+              const _CharT* const __fmt_end = __f._M_fmt +
+                _Traits::length(__f._M_fmt);
+
+              const _TimePut& __mp = use_facet<_TimePut>(__os.getloc());
+              if (__mp.put(_Iter(__os.rdbuf()), __os, __os.fill(),
+                           __f._M_tmb, __f._M_fmt, __fmt_end).failed())
+                __err |= ios_base::badbit;
+            }
+          catch(__cxxabiv1::__forced_unwind&)
+            {
+              __os._M_setstate(ios_base::badbit);
+              throw;
+            }
+          catch(...)
+            { __os._M_setstate(ios_base::badbit); }
+          if (__err)
+            __os.setstate(__err);
+        }
+      return __os;
+    }
+
+  template<typename _CharT>
+    struct _Get_time
+    {
+      std::tm* _M_tmb;
+      const _CharT* _M_fmt;
+    };
+# 411 "/usr/include/c++/10.2.0/iomanip" 3
+  template<typename _CharT>
+    inline _Get_time<_CharT>
+    get_time(std::tm* __tmb, const _CharT* __fmt)
+    { return { __tmb, __fmt }; }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __is, _Get_time<_CharT> __f)
+    {
+      typename basic_istream<_CharT, _Traits>::sentry __cerb(__is, false);
+      if (__cerb)
+        {
+          ios_base::iostate __err = ios_base::goodbit;
+          try
+            {
+              typedef istreambuf_iterator<_CharT, _Traits> _Iter;
+              typedef time_get<_CharT, _Iter> _TimeGet;
+
+              const _CharT* const __fmt_end = __f._M_fmt +
+                _Traits::length(__f._M_fmt);
+
+              const _TimeGet& __mg = use_facet<_TimeGet>(__is.getloc());
+              __mg.get(_Iter(__is.rdbuf()), _Iter(), __is,
+                       __err, __f._M_tmb, __f._M_fmt, __fmt_end);
+            }
+          catch(__cxxabiv1::__forced_unwind&)
+            {
+              __is._M_setstate(ios_base::badbit);
+              throw;
+            }
+          catch(...)
+            { __is._M_setstate(ios_base::badbit); }
+          if (__err)
+            __is.setstate(__err);
+        }
+      return __is;
+    }
+
+
+
+#define __cpp_lib_quoted_string_io 201304
+
+
+
+
+
+
+
+  template<typename _CharT>
+    inline auto
+    quoted(const _CharT* __string,
+    _CharT __delim = _CharT('"'), _CharT __escape = _CharT('\\'))
+    {
+      return __detail::_Quoted_string<const _CharT*, _CharT>(__string, __delim,
+            __escape);
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline auto
+    quoted(const basic_string<_CharT, _Traits, _Alloc>& __string,
+    _CharT __delim = _CharT('"'), _CharT __escape = _CharT('\\'))
+    {
+      return __detail::_Quoted_string<
+ const basic_string<_CharT, _Traits, _Alloc>&, _CharT>(
+     __string, __delim, __escape);
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline auto
+    quoted(basic_string<_CharT, _Traits, _Alloc>& __string,
+    _CharT __delim = _CharT('"'), _CharT __escape = _CharT('\\'))
+    {
+      return __detail::_Quoted_string<
+ basic_string<_CharT, _Traits, _Alloc>&, _CharT>(
+     __string, __delim, __escape);
+    }
+
+
+
+
+  template<typename _CharT, typename _Traits>
+    inline auto
+    quoted(basic_string_view<_CharT, _Traits> __sv,
+    _CharT __delim = _CharT('"'), _CharT __escape = _CharT('\\'))
+    {
+      return __detail::_Quoted_string<
+ basic_string_view<_CharT, _Traits>, _CharT>(__sv, __delim, __escape);
+    }
+# 508 "/usr/include/c++/10.2.0/iomanip" 3
+  extern template ostream& operator<<(ostream&, _Setfill<char>);
+  extern template ostream& operator<<(ostream&, _Setiosflags);
+  extern template ostream& operator<<(ostream&, _Resetiosflags);
+  extern template ostream& operator<<(ostream&, _Setbase);
+  extern template ostream& operator<<(ostream&, _Setprecision);
+  extern template ostream& operator<<(ostream&, _Setw);
+  extern template istream& operator>>(istream&, _Setfill<char>);
+  extern template istream& operator>>(istream&, _Setiosflags);
+  extern template istream& operator>>(istream&, _Resetiosflags);
+  extern template istream& operator>>(istream&, _Setbase);
+  extern template istream& operator>>(istream&, _Setprecision);
+  extern template istream& operator>>(istream&, _Setw);
+
+
+  extern template wostream& operator<<(wostream&, _Setfill<wchar_t>);
+  extern template wostream& operator<<(wostream&, _Setiosflags);
+  extern template wostream& operator<<(wostream&, _Resetiosflags);
+  extern template wostream& operator<<(wostream&, _Setbase);
+  extern template wostream& operator<<(wostream&, _Setprecision);
+  extern template wostream& operator<<(wostream&, _Setw);
+  extern template wistream& operator>>(wistream&, _Setfill<wchar_t>);
+  extern template wistream& operator>>(wistream&, _Setiosflags);
+  extern template wistream& operator>>(wistream&, _Resetiosflags);
+  extern template wistream& operator>>(wistream&, _Setbase);
+  extern template wistream& operator>>(wistream&, _Setprecision);
+  extern template wistream& operator>>(wistream&, _Setw);
+
+
+
+
+}
+# 11 "/usr/include/boost/exception/detail/object_hex_dump.hpp" 2 3 4
+
+
+
+# 1 "/usr/include/c++/10.2.0/cstdlib" 1 3 4
+# 39 "/usr/include/c++/10.2.0/cstdlib" 3 4
+       
+# 40 "/usr/include/c++/10.2.0/cstdlib" 3
+# 15 "/usr/include/boost/exception/detail/object_hex_dump.hpp" 2 3 4
+
+
+       
+# 18 "/usr/include/boost/exception/detail/object_hex_dump.hpp" 3
+
+
+
+
+
+namespace
+boost
+    {
+    namespace
+    exception_detail
+        {
+        template <class T>
+        inline
+        std::string
+        object_hex_dump( T const & x, std::size_t max_size=16 )
+            {
+            std::ostringstream s;
+            s << "type: " << type_name<T>() << ", size: " << sizeof(T) << ", dump: ";
+            std::size_t n=sizeof(T)>max_size?max_size:sizeof(T);
+            s.fill('0');
+            s.width(2);
+            unsigned char const * b=reinterpret_cast<unsigned char const *>(&x);
+            s << std::setw(2) << std::hex << (unsigned int)*b;
+            for( unsigned char const * e=b+n; ++b!=e; )
+                s << " " << std::setw(2) << std::hex << (unsigned int)*b;
+            return s.str();
+            }
+        }
+    }
+# 11 "/usr/include/boost/exception/to_string_stub.hpp" 2 3 4
+# 1 "/usr/include/boost/assert.hpp" 1 3 4
+# 32 "/usr/include/boost/assert.hpp" 3 4
+#undef BOOST_ASSERT
+#undef BOOST_ASSERT_MSG
+#undef BOOST_ASSERT_IS_VOID
+# 58 "/usr/include/boost/assert.hpp" 3 4
+# 1 "/usr/include/assert.h" 1 3 4
+# 24 "/usr/include/assert.h" 3 4
+#undef _ASSERT_H
+#undef assert
+#undef __ASSERT_VOID_CAST
+
+
+#undef assert_perror
+
+
+
+
+#define _ASSERT_H 1
+
+
+
+#define __ASSERT_VOID_CAST static_cast<void>
+# 64 "/usr/include/assert.h" 3 4
+extern "C" {
+
+
+extern void __assert_fail (const char *__assertion, const char *__file,
+      unsigned int __line, const char *__function)
+     throw () __attribute__ ((__noreturn__));
+
+
+extern void __assert_perror_fail (int __errnum, const char *__file,
+      unsigned int __line, const char *__function)
+     throw () __attribute__ ((__noreturn__));
+
+
+
+
+extern void __assert (const char *__assertion, const char *__file, int __line)
+     throw () __attribute__ ((__noreturn__));
+
+
+}
+
+
+
+
+
+#define assert(expr) (static_cast <bool> (expr) ? void (0) : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
+# 114 "/usr/include/assert.h" 3 4
+#define assert_perror(errnum) (!(errnum) ? __ASSERT_VOID_CAST (0) : __assert_perror_fail ((errnum), __FILE__, __LINE__, __ASSERT_FUNCTION))
+# 126 "/usr/include/assert.h" 3 4
+#define __ASSERT_FUNCTION __extension__ __PRETTY_FUNCTION__
+# 59 "/usr/include/boost/assert.hpp" 2 3 4
+
+#define BOOST_ASSERT(expr) assert(expr)
+#define BOOST_ASSERT_MSG(expr,msg) assert((expr)&&(msg))
+# 72 "/usr/include/boost/assert.hpp" 3 4
+#undef BOOST_VERIFY
+#undef BOOST_VERIFY_MSG
+# 82 "/usr/include/boost/assert.hpp" 3 4
+#define BOOST_VERIFY(expr) BOOST_ASSERT(expr)
+#define BOOST_VERIFY_MSG(expr,msg) BOOST_ASSERT_MSG(expr,msg)
+# 12 "/usr/include/boost/exception/to_string_stub.hpp" 2 3 4
+
+
+       
+# 15 "/usr/include/boost/exception/to_string_stub.hpp" 3
+
+
+
+
+
+namespace
+boost
+    {
+    namespace
+    exception_detail
+        {
+        template <bool ToStringAvailable>
+        struct
+        to_string_dispatcher
+            {
+            template <class T,class Stub>
+            static
+            std::string
+            convert( T const & x, Stub )
+                {
+                return to_string(x);
+                }
+            };
+
+        template <>
+        struct
+        to_string_dispatcher<false>
+            {
+            template <class T,class Stub>
+            static
+            std::string
+            convert( T const & x, Stub s )
+                {
+                return s(x);
+                }
+
+            template <class T>
+            static
+            std::string
+            convert( T const & x, std::string s )
+                {
+                return s;
+                }
+
+            template <class T>
+            static
+            std::string
+            convert( T const & x, char const * s )
+                {
+                (static_cast <bool> (s!=0) ? void (0) : __assert_fail ("s!=0", "/usr/include/boost/exception/to_string_stub.hpp", 64, __extension__ __PRETTY_FUNCTION__));
+                return s;
+                }
+            };
+
+        namespace
+        to_string_dispatch
+            {
+            template <class T,class Stub>
+            inline
+            std::string
+            dispatch( T const & x, Stub s )
+                {
+                return to_string_dispatcher<has_to_string<T>::value>::convert(x,s);
+                }
+            }
+
+        template <class T>
+        inline
+        std::string
+        string_stub_dump( T const & x )
+            {
+            return "[ " + exception_detail::object_hex_dump(x) + " ]";
+            }
+        }
+
+    template <class T>
+    inline
+    std::string
+    to_string_stub( T const & x )
+        {
+        return exception_detail::to_string_dispatch::dispatch(x,&exception_detail::string_stub_dump<T>);
+        }
+
+    template <class T,class Stub>
+    inline
+    std::string
+    to_string_stub( T const & x, Stub s )
+        {
+        return exception_detail::to_string_dispatch::dispatch(x,s);
+        }
+
+    template <class T,class U,class Stub>
+    inline
+    std::string
+    to_string_stub( std::pair<T,U> const & x, Stub s )
+        {
+        return std::string("(") + to_string_stub(x.first,s) + ',' + to_string_stub(x.second,s) + ')';
+        }
+    }
+# 12 "/usr/include/boost/exception/info.hpp" 2 3 4
+
+
+
+
+
+       
+# 18 "/usr/include/boost/exception/info.hpp" 3
+
+
+
+
+
+namespace
+boost
+    {
+    template <class Tag,class T>
+    inline
+    std::string
+    error_info_name( error_info<Tag,T> const & x )
+        {
+        return tag_type_name<Tag>();
+        }
+
+    template <class Tag,class T>
+    inline
+    std::string
+    to_string( error_info<Tag,T> const & x )
+        {
+        return '[' + error_info_name(x) + "] = " + to_string_stub(x.value()) + '\n';
+        }
+
+    template <class Tag,class T>
+    inline
+    std::string
+    error_info<Tag,T>::
+    name_value_string() const
+        {
+        return to_string_stub(*this);
+        }
+
+    namespace
+    exception_detail
+        {
+        class
+        error_info_container_impl:
+            public error_info_container
+            {
+            public:
+
+            error_info_container_impl():
+                count_(0)
+                {
+                }
+
+            ~error_info_container_impl() noexcept
+                {
+                }
+
+            void
+            set( shared_ptr<error_info_base> const & x, type_info_ const & typeid_ )
+                {
+                (static_cast <bool> (x) ? void (0) : __assert_fail ("x", "/usr/include/boost/exception/info.hpp", 72, __extension__ __PRETTY_FUNCTION__));
+                info_[typeid_] = x;
+                diagnostic_info_str_.clear();
+                }
+
+            shared_ptr<error_info_base>
+            get( type_info_ const & ti ) const
+                {
+                error_info_map::const_iterator i=info_.find(ti);
+                if( info_.end()!=i )
+                    {
+                    shared_ptr<error_info_base> const & p = i->second;
+
+                    (static_cast <bool> (*::boost::exception_detail::type_info_(typeid(*p)).type_==*ti.type_) ? void (0) : __assert_fail ("*::boost::exception_detail::type_info_(typeid(*p)).type_==*ti.type_", "/usr/include/boost/exception/info.hpp", 85, __extension__ __PRETTY_FUNCTION__));
+
+                    return p;
+                    }
+                return shared_ptr<error_info_base>();
+                }
+
+            char const *
+            diagnostic_information( char const * header ) const
+                {
+                if( header )
+                    {
+                    std::ostringstream tmp;
+                    tmp << header;
+                    for( error_info_map::const_iterator i=info_.begin(),end=info_.end(); i!=end; ++i )
+                        {
+                        error_info_base const & x = *i->second;
+                        tmp << x.name_value_string();
+                        }
+                    tmp.str().swap(diagnostic_info_str_);
+                    }
+                return diagnostic_info_str_.c_str();
+                }
+
+            private:
+
+            friend class boost::exception;
+
+            typedef std::map< type_info_, shared_ptr<error_info_base> > error_info_map;
+            error_info_map info_;
+            mutable std::string diagnostic_info_str_;
+            mutable int count_;
+
+            error_info_container_impl( error_info_container_impl const & );
+            error_info_container_impl & operator=( error_info_container const & );
+
+            void
+            add_ref() const
+                {
+                ++count_;
+                }
+
+            bool
+            release() const
+                {
+                if( --count_ )
+                    return false;
+                else
+                    {
+                    delete this;
+                    return true;
+                    }
+                }
+
+            refcount_ptr<error_info_container>
+            clone() const
+                {
+                refcount_ptr<error_info_container> p;
+                error_info_container_impl * c=new error_info_container_impl;
+                p.adopt(c);
+                for( error_info_map::const_iterator i=info_.begin(),e=info_.end(); i!=e; ++i )
+                    {
+                    shared_ptr<error_info_base> cp(i->second->clone());
+                    c->info_.insert(std::make_pair(i->first,cp));
+                    }
+                return p;
+                }
+            };
+
+        template <class E,class Tag,class T>
+        inline
+        E const &
+        set_info( E const & x, error_info<Tag,T> const & v )
+            {
+            typedef error_info<Tag,T> error_info_tag_t;
+            shared_ptr<error_info_tag_t> p( new error_info_tag_t(v) );
+            exception_detail::error_info_container * c=x.data_.get();
+            if( !c )
+                x.data_.adopt(c=new exception_detail::error_info_container_impl);
+            c->set(p,::boost::exception_detail::type_info_(typeid(error_info_tag_t)));
+            return x;
+            }
+
+
+        template <class E,class Tag,class T>
+        E const & set_info( E const &, error_info<Tag,T> && );
+        template <class T>
+        struct set_info_rv;
+        template <class Tag,class T>
+        struct
+        set_info_rv<error_info<Tag,T> >
+            {
+            template <class E,class Tag1,class T1>
+            friend E const & set_info( E const &, error_info<Tag1,T1> && );
+            template <class E>
+            static
+            E const &
+            set( E const & x, error_info<Tag,T> && v )
+                {
+                typedef error_info<Tag,T> error_info_tag_t;
+                shared_ptr<error_info_tag_t> p( new error_info_tag_t(std::move(v)) );
+                exception_detail::error_info_container * c=x.data_.get();
+                if( !c )
+                    x.data_.adopt(c=new exception_detail::error_info_container_impl);
+                c->set(p,::boost::exception_detail::type_info_(typeid(error_info_tag_t)));
+                return x;
+                }
+            };
+        template <>
+        struct
+        set_info_rv<throw_function>
+            {
+            template <class E,class Tag1,class T1>
+            friend E const & set_info( E const &, error_info<Tag1,T1> && );
+            template <class E>
+            static
+            E const &
+            set( E const & x, throw_function && y )
+                {
+                x.throw_function_=y.v_;
+                return x;
+                }
+            };
+        template <>
+        struct
+        set_info_rv<throw_file>
+            {
+            template <class E,class Tag1,class T1>
+            friend E const & set_info( E const &, error_info<Tag1,T1> && );
+            template <class E>
+            static
+            E const &
+            set( E const & x, throw_file && y )
+                {
+                x.throw_file_=y.v_;
+                return x;
+                }
+            };
+        template <>
+        struct
+        set_info_rv<throw_line>
+            {
+            template <class E,class Tag1,class T1>
+            friend E const & set_info( E const &, error_info<Tag1,T1> && );
+            template <class E>
+            static
+            E const &
+            set( E const & x, throw_line && y )
+                {
+                x.throw_line_=y.v_;
+                return x;
+                }
+            };
+        template <class E,class Tag,class T>
+        inline
+        E const &
+        set_info( E const & x, error_info<Tag,T> && v )
+            {
+            return set_info_rv<error_info<Tag,T> >::template set<E>(x,std::move(v));
+            }
+
+
+        template <class T>
+        struct
+        derives_boost_exception
+            {
+            enum e { value = (sizeof(dispatch_boost_exception((T*)0))==sizeof(large_size)) };
+            };
+        }
+
+    template <class E,class Tag,class T>
+    inline
+    typename enable_if<exception_detail::derives_boost_exception<E>,E const &>::type
+    operator<<( E const & x, error_info<Tag,T> const & v )
+        {
+        return exception_detail::set_info(x,v);
+        }
+
+
+    template <class E,class Tag,class T>
+    inline
+    typename enable_if<exception_detail::derives_boost_exception<E>,E const &>::type
+    operator<<( E const & x, error_info<Tag,T> && v )
+        {
+        return exception_detail::set_info(x,std::move(v));
+        }
+
+    }
+# 12 "/usr/include/boost/exception/diagnostic_information.hpp" 2 3 4
+# 24 "/usr/include/boost/exception/diagnostic_information.hpp" 3 4
+       
+# 25 "/usr/include/boost/exception/diagnostic_information.hpp" 3
+
+
+
+
+
+
+namespace
+boost
+    {
+    namespace
+    exception_detail
+        {
+        std::string diagnostic_information_impl( boost::exception const *, std::exception const *, bool, bool );
+        }
+
+    inline
+    std::string
+    current_exception_diagnostic_information( bool verbose=true)
+        {
+        boost::exception const * be=current_exception_cast<boost::exception const>();
+        std::exception const * se=current_exception_cast<std::exception const>();
+        if( be || se )
+            return exception_detail::diagnostic_information_impl(be,se,true,verbose);
+
+        else if (auto* p=std::current_exception().__cxa_exception_type())
+            return "Dynamic exception type: "+boost::core::demangle(p->name());
+
+        else
+            return "No diagnostic information available.";
+        }
+    }
+
+
+namespace
+boost
+    {
+    namespace
+    exception_detail
+        {
+        inline
+        exception const *
+        get_boost_exception( exception const * e )
+            {
+            return e;
+            }
+
+        inline
+        exception const *
+        get_boost_exception( ... )
+            {
+            return 0;
+            }
+
+        inline
+        std::exception const *
+        get_std_exception( std::exception const * e )
+            {
+            return e;
+            }
+
+        inline
+        std::exception const *
+        get_std_exception( ... )
+            {
+            return 0;
+            }
+
+        inline
+        char const *
+        get_diagnostic_information( exception const & x, char const * header )
+            {
+
+            try
+                {
+
+                error_info_container * c=x.data_.get();
+                if( !c )
+                    x.data_.adopt(c=new exception_detail::error_info_container_impl);
+                char const * di=c->diagnostic_information(header);
+                (static_cast <bool> (di!=0) ? void (0) : __assert_fail ("di!=0", "/usr/include/boost/exception/diagnostic_information.hpp", 104, __extension__ __PRETTY_FUNCTION__));
+                return di;
+
+                }
+            catch(...)
+                {
+                return 0;
+                }
+
+            }
+
+        inline
+        std::string
+        diagnostic_information_impl( boost::exception const * be, std::exception const * se, bool with_what, bool verbose )
+            {
+            if( !be && !se )
+                return "Unknown exception.";
+
+            if( !be )
+                be=dynamic_cast<boost::exception const *>(se);
+            if( !se )
+                se=dynamic_cast<std::exception const *>(be);
+
+            char const * wh=0;
+            if( with_what && se )
+                {
+                wh=se->what();
+                if( be && exception_detail::get_diagnostic_information(*be,0)==wh )
+                    return wh;
+                }
+            std::ostringstream tmp;
+            if( be && verbose )
+                {
+                char const * const * f=get_error_info<throw_file>(*be);
+                int const * l=get_error_info<throw_line>(*be);
+                char const * const * fn=get_error_info<throw_function>(*be);
+                if( !f && !l && !fn )
+                    tmp << "Throw location unknown (consider using BOOST_THROW_EXCEPTION)\n";
+                else
+                    {
+                    if( f )
+                        {
+                        tmp << *f;
+                        if( int const * l=get_error_info<throw_line>(*be) )
+                            tmp << '(' << *l << "): ";
+                        }
+                    tmp << "Throw in function ";
+                    if( char const * const * fn=get_error_info<throw_function>(*be) )
+                        tmp << *fn;
+                    else
+                        tmp << "(unknown)";
+                    tmp << '\n';
+                    }
+                }
+
+            if ( verbose )
+                tmp << std::string("Dynamic exception type: ") <<
+                    core::demangle((be?(::boost::exception_detail::type_info_(typeid(*be))):(::boost::exception_detail::type_info_(typeid(*se)))).type_->name()) << '\n';
+
+            if( with_what && se && verbose )
+                tmp << "std::exception::what: " << (wh ? wh : "(null)") << '\n';
+            if( be )
+                if( char const * s=exception_detail::get_diagnostic_information(*be,tmp.str().c_str()) )
+                    if( *s )
+                        return std::string(s);
+            return tmp.str();
+            }
+        }
+
+    template <class T>
+    std::string
+    diagnostic_information( T const & e, bool verbose=true )
+        {
+        return exception_detail::diagnostic_information_impl(exception_detail::get_boost_exception(&e),exception_detail::get_std_exception(&e),true,verbose);
+        }
+
+    inline
+    char const *
+    diagnostic_information_what( exception const & e, bool verbose=true ) noexcept
+        {
+        char const * w=0;
+
+        try
+            {
+
+            (void) exception_detail::diagnostic_information_impl(&e,0,false,verbose);
+            if( char const * di=exception_detail::get_diagnostic_information(e,0) )
+                return di;
+            else
+                return "Failed to produce boost::diagnostic_information_what()";
+
+            }
+        catch(
+        ... )
+            {
+            }
+
+        return w;
+        }
+    }
+# 38 "/usr/include/boost/test/impl/execution_monitor.ipp" 2 3 4
+# 46 "/usr/include/boost/test/impl/execution_monitor.ipp" 3 4
+# 1 "/usr/include/c++/10.2.0/cstring" 1 3 4
+# 39 "/usr/include/c++/10.2.0/cstring" 3 4
+       
+# 40 "/usr/include/c++/10.2.0/cstring" 3
+# 47 "/usr/include/boost/test/impl/execution_monitor.ipp" 2 3 4
+# 1 "/usr/include/c++/10.2.0/cassert" 1 3 4
+# 41 "/usr/include/c++/10.2.0/cassert" 3 4
+       
+# 42 "/usr/include/c++/10.2.0/cassert" 3
+
+
+# 1 "/usr/include/assert.h" 1 3 4
+# 24 "/usr/include/assert.h" 3 4
+#undef _ASSERT_H
+#undef assert
+#undef __ASSERT_VOID_CAST
+
+
+#undef assert_perror
+
+
+
+
+#define _ASSERT_H 1
+
+
+
+#define __ASSERT_VOID_CAST static_cast<void>
+# 64 "/usr/include/assert.h" 3 4
+extern "C" {
+
+
+extern void __assert_fail (const char *__assertion, const char *__file,
+      unsigned int __line, const char *__function)
+     throw () __attribute__ ((__noreturn__));
+
+
+extern void __assert_perror_fail (int __errnum, const char *__file,
+      unsigned int __line, const char *__function)
+     throw () __attribute__ ((__noreturn__));
+
+
+
+
+extern void __assert (const char *__assertion, const char *__file, int __line)
+     throw () __attribute__ ((__noreturn__));
+
+
+}
+
+
+
+
+
+#define assert(expr) (static_cast <bool> (expr) ? void (0) : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
+# 114 "/usr/include/assert.h" 3 4
+#define assert_perror(errnum) (!(errnum) ? __ASSERT_VOID_CAST (0) : __assert_perror_fail ((errnum), __FILE__, __LINE__, __ASSERT_FUNCTION))
+# 126 "/usr/include/assert.h" 3 4
+#define __ASSERT_FUNCTION __extension__ __PRETTY_FUNCTION__
+# 45 "/usr/include/c++/10.2.0/cassert" 2 3
+# 48 "/usr/include/boost/test/impl/execution_monitor.ipp" 2 3 4
+
+# 1 "/usr/include/c++/10.2.0/cstdio" 1 3 4
+# 39 "/usr/include/c++/10.2.0/cstdio" 3 4
+       
+# 40 "/usr/include/c++/10.2.0/cstdio" 3
+# 50 "/usr/include/boost/test/impl/execution_monitor.ipp" 2 3 4
+
+# 1 "/usr/include/c++/10.2.0/cstdarg" 1 3 4
+# 39 "/usr/include/c++/10.2.0/cstdarg" 3 4
+       
+# 40 "/usr/include/c++/10.2.0/cstdarg" 3
+
+#undef __need___va_list
+
+
+
+
+#define _GLIBCXX_CSTDARG 1
+
+
+
+
+
+
+namespace std
+{
+  using ::va_list;
+}
+# 52 "/usr/include/boost/test/impl/execution_monitor.ipp" 2 3 4
+
+# 1 "/usr/include/c++/10.2.0/cmath" 1 3 4
+# 39 "/usr/include/c++/10.2.0/cmath" 3 4
+       
+# 40 "/usr/include/c++/10.2.0/cmath" 3
+
+
+
+
+#define _GLIBCXX_INCLUDE_NEXT_C_HEADERS 
+
+#undef _GLIBCXX_INCLUDE_NEXT_C_HEADERS
+# 54 "/usr/include/boost/test/impl/execution_monitor.ipp" 2 3 4
+# 134 "/usr/include/boost/test/impl/execution_monitor.ipp" 3 4
+#define BOOST_SIGACTION_BASED_SIGNAL_HANDLING 
+
+
+
+# 1 "/usr/include/setjmp.h" 1 3 4
+# 23 "/usr/include/setjmp.h" 3 4
+#define _SETJMP_H 1
+
+
+
+extern "C" {
+
+
+
+
+
+struct __jmp_buf_tag
+  {
+
+
+
+
+    __jmp_buf __jmpbuf;
+    int __mask_was_saved;
+    __sigset_t __saved_mask;
+  };
+
+
+typedef struct __jmp_buf_tag jmp_buf[1];
+
+
+
+extern int setjmp (jmp_buf __env) throw ();
+
+
+
+
+extern int __sigsetjmp (struct __jmp_buf_tag __env[1], int __savemask) throw ();
+
+
+
+extern int _setjmp (struct __jmp_buf_tag __env[1]) throw ();
+
+
+
+#define setjmp(env) _setjmp (env)
+
+
+
+
+extern void longjmp (struct __jmp_buf_tag __env[1], int __val)
+     throw () __attribute__ ((__noreturn__));
+
+
+
+
+
+extern void _longjmp (struct __jmp_buf_tag __env[1], int __val)
+     throw () __attribute__ ((__noreturn__));
+
+
+
+
+
+
+
+typedef struct __jmp_buf_tag sigjmp_buf[1];
+
+
+
+#define sigsetjmp(env,savemask) __sigsetjmp (env, savemask)
+
+
+
+
+
+extern void siglongjmp (sigjmp_buf __env, int __val)
+     throw () __attribute__ ((__noreturn__));
+# 103 "/usr/include/setjmp.h" 3 4
+}
+# 139 "/usr/include/boost/test/impl/execution_monitor.ipp" 2 3 4
+# 168 "/usr/include/boost/test/impl/execution_monitor.ipp" 3 4
+#define BOOST_TEST_USE_ALT_STACK 
+
+
+
+
+
+
+#define BOOST_TEST_CATCH_SIGPOLL 
+
+
+
+#define BOOST_TEST_ALT_STACK_SIZE SIGSTKSZ
+# 197 "/usr/include/boost/test/impl/execution_monitor.ipp" 3 4
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 198 "/usr/include/boost/test/impl/execution_monitor.ipp" 2 3 4
+
+
+
+namespace boost {
+# 215 "/usr/include/boost/test/impl/execution_monitor.ipp" 3 4
+namespace detail {
+# 225 "/usr/include/boost/test/impl/execution_monitor.ipp" 3 4
+#define BOOST_TEST_VSNPRINTF(a1,a2,a3,a4) vsnprintf( (a1), (a2), (a3), (a4) )
+
+
+
+
+template <typename ErrorInfo>
+typename ErrorInfo::value_type
+extract( boost::exception const* ex )
+{
+    if( !ex )
+        return 0;
+
+    typename ErrorInfo::value_type const * val = boost::get_error_info<ErrorInfo>( *ex );
+
+    return val ? *val : 0;
+}
+
+
+
+static void
+
+__attribute__((__format__ (__printf__, 3, 0)))
+
+report_error( execution_exception::error_code ec, boost::exception const* be, char const* format, va_list* args )
+{
+    static const int REPORT_ERROR_BUFFER_SIZE = 4096;
+    static char buf[REPORT_ERROR_BUFFER_SIZE];
+
+    vsnprintf( (buf), (sizeof(buf)-1), (format), (*args) );
+    buf[sizeof(buf)-1] = 0;
+
+    __builtin_va_end(*args);
+
+    unit_test::ut_detail::throw_exception( execution_exception( ec, buf, execution_exception::location( extract<throw_file>( be ), (size_t)extract<throw_line>( be ), extract<throw_function>( be ) ) ) )
+
+                                                                                                                      ;
+}
+
+
+
+static void
+
+__attribute__((__format__ (__printf__, 3, 4)))
+
+report_error( execution_exception::error_code ec, boost::exception const* be, char const* format, ... )
+{
+    va_list args;
+    __builtin_va_start(args,format);
+
+    report_error( ec, be, format, &args );
+}
+
+
+
+
+
+static void
+
+__attribute__((__format__ (__printf__, 2, 3)))
+
+report_error( execution_exception::error_code ec, char const* format, ... )
+{
+    va_list args;
+    __builtin_va_start(args,format);
+
+    report_error( ec, 0, format, &args );
+}
+
+
+
+template<typename Tr,typename Functor>
+inline int
+do_invoke( Tr const& tr, Functor const& F )
+{
+    return tr ? (*tr)( F ) : F();
+}
+
+
+
+struct fpe_except_guard {
+    explicit fpe_except_guard( unsigned detect_fpe )
+    : m_detect_fpe( detect_fpe )
+    {
+
+        m_previously_enabled = fpe::disable( fpe::BOOST_FPE_ALL );
+        if( m_previously_enabled != fpe::BOOST_FPE_INV && detect_fpe != fpe::BOOST_FPE_OFF )
+            fpe::enable( detect_fpe );
+    }
+    ~fpe_except_guard()
+    {
+        if( m_detect_fpe != fpe::BOOST_FPE_OFF )
+            fpe::disable( m_detect_fpe );
+        if( m_previously_enabled != fpe::BOOST_FPE_INV )
+            fpe::enable( m_previously_enabled );
+    }
+
+    unsigned m_detect_fpe;
+    unsigned m_previously_enabled;
+};
+
+
+
+
+
+
+
+template<typename T>
+std::string
+typeid_name( T const& t )
+{
+    return boost::core::demangle(typeid(t).name());
+}
+
+
+}
+
+
+
+
+
+
+
+namespace detail {
+
+
+
+
+
+class system_signal_exception {
+public:
+
+    system_signal_exception()
+    : m_sig_info( 0 )
+    , m_context( 0 )
+    {}
+
+
+    void operator()( siginfo_t* i, void* c )
+    {
+        m_sig_info = i;
+        m_context = c;
+    }
+    void report() const;
+
+private:
+
+    siginfo_t* m_sig_info;
+    void* m_context;
+};
+
+
+
+void
+system_signal_exception::report() const
+{
+    if( !m_sig_info )
+        return;
+
+    switch( m_sig_info->si_code ) {
+
+
+
+
+
+    case SI_USER:
+        report_error( execution_exception::system_error,
+                      "signal: generated by kill() (or family); uid=%d; pid=%d",
+                      (int)m_sig_info->_sifields._kill.si_uid, (int)m_sig_info->_sifields._kill.si_pid );
+        break;
+
+    case SI_QUEUE:
+        report_error( execution_exception::system_error,
+                      "signal: sent by sigqueue()" );
+        break;
+    case SI_TIMER:
+        report_error( execution_exception::system_error,
+                      "signal: the expiration of a timer set by timer_settimer()" );
+        break;
+
+
+    case SI_ASYNCIO:
+        report_error( execution_exception::system_error,
+                      "signal: generated by the completion of an asynchronous I/O request" );
+        break;
+
+
+    case SI_MESGQ:
+        report_error( execution_exception::system_error,
+                      "signal: generated by the the arrival of a message on an empty message queue" );
+        break;
+
+    default:
+        break;
+    }
+
+    switch( m_sig_info->si_signo ) {
+    case 4:
+        switch( m_sig_info->si_code ) {
+
+        case ILL_ILLOPC:
+            report_error( execution_exception::system_fatal_error,
+                          "signal: illegal opcode; address of failing instruction: 0x%08lx",
+                          (uintptr_t) m_sig_info->_sifields._sigfault.si_addr );
+            break;
+        case ILL_ILLTRP:
+            report_error( execution_exception::system_fatal_error,
+                          "signal: illegal trap; address of failing instruction: 0x%08lx",
+                          (uintptr_t) m_sig_info->_sifields._sigfault.si_addr );
+            break;
+        case ILL_PRVREG:
+            report_error( execution_exception::system_fatal_error,
+                          "signal: privileged register; address of failing instruction: 0x%08lx",
+                          (uintptr_t) m_sig_info->_sifields._sigfault.si_addr );
+            break;
+        case ILL_BADSTK:
+            report_error( execution_exception::system_fatal_error,
+                          "signal: internal stack error; address of failing instruction: 0x%08lx",
+                          (uintptr_t) m_sig_info->_sifields._sigfault.si_addr );
+            break;
+
+        case ILL_ILLOPN:
+            report_error( execution_exception::system_fatal_error,
+                          "signal: illegal operand; address of failing instruction: 0x%08lx",
+                          (uintptr_t) m_sig_info->_sifields._sigfault.si_addr );
+            break;
+        case ILL_ILLADR:
+            report_error( execution_exception::system_fatal_error,
+                          "signal: illegal addressing mode; address of failing instruction: 0x%08lx",
+                          (uintptr_t) m_sig_info->_sifields._sigfault.si_addr );
+            break;
+        case ILL_PRVOPC:
+            report_error( execution_exception::system_fatal_error,
+                          "signal: privileged opcode; address of failing instruction: 0x%08lx",
+                          (uintptr_t) m_sig_info->_sifields._sigfault.si_addr );
+            break;
+        case ILL_COPROC:
+            report_error( execution_exception::system_fatal_error,
+                          "signal: co-processor error; address of failing instruction: 0x%08lx",
+                          (uintptr_t) m_sig_info->_sifields._sigfault.si_addr );
+            break;
+        default:
+            report_error( execution_exception::system_fatal_error,
+                          "signal: SIGILL, si_code: %d (illegal instruction; address of failing instruction: 0x%08lx)",
+                          m_sig_info->si_code, (uintptr_t) m_sig_info->_sifields._sigfault.si_addr );
+            break;
+        }
+        break;
+
+    case 8:
+        switch( m_sig_info->si_code ) {
+        case FPE_INTDIV:
+            report_error( execution_exception::system_error,
+                          "signal: integer divide by zero; address of failing instruction: 0x%08lx",
+                          (uintptr_t) m_sig_info->_sifields._sigfault.si_addr );
+            break;
+        case FPE_INTOVF:
+            report_error( execution_exception::system_error,
+                          "signal: integer overflow; address of failing instruction: 0x%08lx",
+                          (uintptr_t) m_sig_info->_sifields._sigfault.si_addr );
+            break;
+        case FPE_FLTDIV:
+            report_error( execution_exception::system_error,
+                          "signal: floating point divide by zero; address of failing instruction: 0x%08lx",
+                          (uintptr_t) m_sig_info->_sifields._sigfault.si_addr );
+            break;
+        case FPE_FLTOVF:
+            report_error( execution_exception::system_error,
+                          "signal: floating point overflow; address of failing instruction: 0x%08lx",
+                          (uintptr_t) m_sig_info->_sifields._sigfault.si_addr );
+            break;
+        case FPE_FLTUND:
+            report_error( execution_exception::system_error,
+                          "signal: floating point underflow; address of failing instruction: 0x%08lx",
+                          (uintptr_t) m_sig_info->_sifields._sigfault.si_addr );
+            break;
+        case FPE_FLTRES:
+            report_error( execution_exception::system_error,
+                          "signal: floating point inexact result; address of failing instruction: 0x%08lx",
+                          (uintptr_t) m_sig_info->_sifields._sigfault.si_addr );
+            break;
+        case FPE_FLTINV:
+            report_error( execution_exception::system_error,
+                          "signal: invalid floating point operation; address of failing instruction: 0x%08lx",
+                          (uintptr_t) m_sig_info->_sifields._sigfault.si_addr );
+            break;
+        case FPE_FLTSUB:
+            report_error( execution_exception::system_error,
+                          "signal: subscript out of range; address of failing instruction: 0x%08lx",
+                          (uintptr_t) m_sig_info->_sifields._sigfault.si_addr );
+            break;
+        default:
+            report_error( execution_exception::system_error,
+                          "signal: SIGFPE, si_code: %d (errnoneous arithmetic operations; address of failing instruction: 0x%08lx)",
+                          m_sig_info->si_code, (uintptr_t) m_sig_info->_sifields._sigfault.si_addr );
+            break;
+        }
+        break;
+
+    case 11:
+        switch( m_sig_info->si_code ) {
+
+        case SEGV_MAPERR:
+            report_error( execution_exception::system_fatal_error,
+                          "memory access violation at address: 0x%08lx: no mapping at fault address",
+                          (uintptr_t) m_sig_info->_sifields._sigfault.si_addr );
+            break;
+        case SEGV_ACCERR:
+            report_error( execution_exception::system_fatal_error,
+                          "memory access violation at address: 0x%08lx: invalid permissions",
+                          (uintptr_t) m_sig_info->_sifields._sigfault.si_addr );
+            break;
+
+        default:
+            report_error( execution_exception::system_fatal_error,
+                          "signal: SIGSEGV, si_code: %d (memory access violation at address: 0x%08lx)",
+                          m_sig_info->si_code, (uintptr_t) m_sig_info->_sifields._sigfault.si_addr );
+            break;
+        }
+        break;
+
+    case 7:
+        switch( m_sig_info->si_code ) {
+
+        case BUS_ADRALN:
+            report_error( execution_exception::system_fatal_error,
+                          "memory access violation at address: 0x%08lx: invalid address alignment",
+                          (uintptr_t) m_sig_info->_sifields._sigfault.si_addr );
+            break;
+        case BUS_ADRERR:
+            report_error( execution_exception::system_fatal_error,
+                          "memory access violation at address: 0x%08lx: non-existent physical address",
+                          (uintptr_t) m_sig_info->_sifields._sigfault.si_addr );
+            break;
+        case BUS_OBJERR:
+            report_error( execution_exception::system_fatal_error,
+                          "memory access violation at address: 0x%08lx: object specific hardware error",
+                          (uintptr_t) m_sig_info->_sifields._sigfault.si_addr );
+            break;
+
+        default:
+            report_error( execution_exception::system_fatal_error,
+                          "signal: SIGSEGV, si_code: %d (memory access violation at address: 0x%08lx)",
+                          m_sig_info->si_code, (uintptr_t) m_sig_info->_sifields._sigfault.si_addr );
+            break;
+        }
+        break;
+
+
+
+    case 29:
+        switch( m_sig_info->si_code ) {
+
+        case POLL_IN:
+            report_error( execution_exception::system_error,
+                          "data input available; band event %d",
+                          (int)m_sig_info->_sifields._sigpoll.si_band );
+            break;
+        case POLL_OUT:
+            report_error( execution_exception::system_error,
+                          "output buffers available; band event %d",
+                          (int)m_sig_info->_sifields._sigpoll.si_band );
+            break;
+        case POLL_MSG:
+            report_error( execution_exception::system_error,
+                          "input message available; band event %d",
+                          (int)m_sig_info->_sifields._sigpoll.si_band );
+            break;
+        case POLL_ERR:
+            report_error( execution_exception::system_error,
+                          "i/o error; band event %d",
+                          (int)m_sig_info->_sifields._sigpoll.si_band );
+            break;
+        case POLL_PRI:
+            report_error( execution_exception::system_error,
+                          "high priority input available; band event %d",
+                          (int)m_sig_info->_sifields._sigpoll.si_band );
+            break;
+# 610 "/usr/include/boost/test/impl/execution_monitor.ipp" 3 4
+        default:
+            report_error( execution_exception::system_error,
+                          "signal: SIGPOLL, si_code: %d (asynchronous I/O event occurred; band event %d)",
+                          m_sig_info->si_code, (int)m_sig_info->_sifields._sigpoll.si_band );
+            break;
+        }
+        break;
+
+
+
+    case 6:
+        report_error( execution_exception::system_error,
+                      "signal: SIGABRT (application abort requested)" );
+        break;
+
+    case 14:
+        report_error( execution_exception::timeout_error,
+                      "signal: SIGALRM (timeout while executing function)" );
+        break;
+
+    default:
+        report_error( execution_exception::system_error,
+                      "unrecognized signal %d", m_sig_info->si_signo );
+    }
+}
+# 643 "/usr/include/boost/test/impl/execution_monitor.ipp" 3 4
+extern "C" {
+static void boost_execution_monitor_jumping_signal_handler( int sig, siginfo_t* info, void* context );
+static void boost_execution_monitor_attaching_signal_handler( int sig, siginfo_t* info, void* context );
+}
+
+class signal_action {
+    typedef struct sigaction* sigaction_ptr;
+public:
+
+    signal_action();
+    signal_action( int sig, bool install, bool attach_dbg, char* alt_stack );
+    ~signal_action();
+
+private:
+
+    int m_sig;
+    bool m_installed;
+    struct sigaction m_new_action;
+    struct sigaction m_old_action;
+};
+
+
+
+signal_action::signal_action()
+: m_installed( false )
+{}
+
+
+
+signal_action::signal_action( int sig, bool install, bool attach_dbg, char* alt_stack )
+: m_sig( sig )
+, m_installed( install )
+{
+    if( !install )
+        return;
+
+    std::memset( &m_new_action, 0, sizeof(struct sigaction) );
+
+    if( ::sigaction( m_sig , sigaction_ptr(), &m_new_action ) != -1 ) {} else unit_test::ut_detail::throw_exception( ::boost::system_error( "exp" ) );
+
+    if( m_new_action.__sigaction_handler.sa_sigaction || m_new_action.__sigaction_handler.sa_handler ) {
+        m_installed = false;
+        return;
+    }
+
+    m_new_action.sa_flags |= 4;
+    m_new_action.__sigaction_handler.sa_sigaction = attach_dbg ? &boost_execution_monitor_attaching_signal_handler
+                                            : &boost_execution_monitor_jumping_signal_handler;
+    if( sigemptyset( &m_new_action.sa_mask ) != -1 ) {} else unit_test::ut_detail::throw_exception( ::boost::system_error( "exp" ) );
+
+
+    if( alt_stack )
+        m_new_action.sa_flags |= 0x08000000;
+
+
+    if( ::sigaction( m_sig, &m_new_action, &m_old_action ) != -1 ) {} else unit_test::ut_detail::throw_exception( ::boost::system_error( "exp" ) );
+}
+
+
+
+signal_action::~signal_action()
+{
+    if( m_installed )
+        ::sigaction( m_sig, &m_old_action , sigaction_ptr() );
+}
+
+
+
+
+
+
+
+class signal_handler {
+public:
+
+    explicit signal_handler( bool catch_system_errors, bool detect_fpe, unsigned timeout_microseconds, bool attach_dbg, char* alt_stack );
+
+
+    ~signal_handler();
+
+
+    static sigjmp_buf& jump_buffer()
+    {
+        (static_cast <bool> (!!s_active_handler) ? void (0) : __assert_fail ("!!s_active_handler", "/usr/include/boost/test/impl/execution_monitor.ipp", 726, __extension__ __PRETTY_FUNCTION__));
+
+        return s_active_handler->m_sigjmp_buf;
+    }
+
+    static system_signal_exception& sys_sig()
+    {
+        (static_cast <bool> (!!s_active_handler) ? void (0) : __assert_fail ("!!s_active_handler", "/usr/include/boost/test/impl/execution_monitor.ipp", 733, __extension__ __PRETTY_FUNCTION__));
+
+        return s_active_handler->m_sys_sig;
+    }
+
+private:
+
+    signal_handler* m_prev_handler;
+    unsigned m_timeout_microseconds;
+
+
+    signal_action m_ILL_action;
+    signal_action m_FPE_action;
+    signal_action m_SEGV_action;
+    signal_action m_BUS_action;
+    signal_action m_CHLD_action;
+    signal_action m_POLL_action;
+    signal_action m_ABRT_action;
+    signal_action m_ALRM_action;
+
+    sigjmp_buf m_sigjmp_buf;
+    system_signal_exception m_sys_sig;
+
+    static signal_handler* s_active_handler;
+};
+
+
+typedef signal_handler* signal_handler_ptr;
+signal_handler* signal_handler::s_active_handler = signal_handler_ptr();
+
+
+
+signal_handler::signal_handler( bool catch_system_errors, bool detect_fpe, unsigned timeout_microseconds, bool attach_dbg, char* alt_stack )
+: m_prev_handler( s_active_handler )
+, m_timeout_microseconds( timeout_microseconds )
+, m_ILL_action ( 4 , catch_system_errors, attach_dbg, alt_stack )
+, m_FPE_action ( 8 , detect_fpe , attach_dbg, alt_stack )
+, m_SEGV_action( 11, catch_system_errors, attach_dbg, alt_stack )
+, m_BUS_action ( 7 , catch_system_errors, attach_dbg, alt_stack )
+
+, m_POLL_action( 29, catch_system_errors, attach_dbg, alt_stack )
+
+, m_ABRT_action( 6, catch_system_errors, attach_dbg, alt_stack )
+, m_ALRM_action( 14, timeout_microseconds > 0, attach_dbg, alt_stack )
+{
+    s_active_handler = this;
+
+    if( m_timeout_microseconds > 0 ) {
+        ::alarm( 0 );
+        ::alarm( static_cast<unsigned int>(std::ceil(timeout_microseconds / 1E6) ));
+    }
+
+
+    if( alt_stack ) {
+        stack_t sigstk;
+        std::memset( &sigstk, 0, sizeof(stack_t) );
+
+        if( ::sigaltstack( 0, &sigstk ) != -1 ) {} else unit_test::ut_detail::throw_exception( ::boost::system_error( "exp" ) );
+
+        if( sigstk.ss_flags & SS_DISABLE ) {
+            sigstk.ss_sp = alt_stack;
+            sigstk.ss_size = 8192;
+            sigstk.ss_flags = 0;
+            if( ::sigaltstack( &sigstk, 0 ) != -1 ) {} else unit_test::ut_detail::throw_exception( ::boost::system_error( "exp" ) );
+        }
+    }
+
+}
+
+
+
+signal_handler::~signal_handler()
+{
+    (static_cast <bool> (s_active_handler == this) ? void (0) : __assert_fail ("s_active_handler == this", "/usr/include/boost/test/impl/execution_monitor.ipp", 806, __extension__ __PRETTY_FUNCTION__));
+
+    if( m_timeout_microseconds > 0 )
+        ::alarm( 0 );
+
+
+
+
+
+
+    stack_t sigstk = { 0, 0, 0 };
+
+
+
+
+    sigstk.ss_size = 2048;
+    sigstk.ss_flags = SS_DISABLE;
+    if( ::sigaltstack( &sigstk, 0 ) == -1 ) {
+        int error_n = (*__errno_location ());
+        std::cerr << "******** errors disabling the alternate stack:" << std::endl
+                  << "\t#error:" << error_n << std::endl
+                  << "\t" << std::strerror( error_n ) << std::endl;
+    }
+
+
+    s_active_handler = m_prev_handler;
+}
+
+
+
+
+
+
+
+extern "C" {
+
+static void boost_execution_monitor_jumping_signal_handler( int sig, siginfo_t* info, void* context )
+{
+    signal_handler::sys_sig()( info, context );
+
+    siglongjmp( signal_handler::jump_buffer(), sig );
+}
+
+
+
+static void boost_execution_monitor_attaching_signal_handler( int sig, siginfo_t* info, void* context )
+{
+    if( !debug::attach_debugger( false ) )
+        boost_execution_monitor_jumping_signal_handler( sig, info, context );
+
+
+    if( ::signal( sig, ((__sighandler_t) 0) ) != ((__sighandler_t) -1) ) {} else unit_test::ut_detail::throw_exception( ::boost::system_error( "exp" ) );
+}
+
+
+
+}
+
+}
+
+
+
+
+
+int
+execution_monitor::catch_signals( boost::function<int ()> const& F )
+{
+    using namespace detail;
+
+
+
+
+
+
+    if( !!p_use_alt_stack && !m_alt_stack )
+        m_alt_stack.reset( new char[8192] );
+
+
+
+
+    signal_handler local_signal_handler( p_catch_system_errors,
+                                         p_catch_system_errors || (p_detect_fp_exceptions != fpe::BOOST_FPE_OFF),
+                                         p_timeout,
+                                         p_auto_start_dbg,
+                                         !p_use_alt_stack ? 0 : m_alt_stack.get() );
+
+    if( !__sigsetjmp (signal_handler::jump_buffer(), 1) )
+        return detail::do_invoke( m_custom_translators , F );
+    else
+        unit_test::ut_detail::throw_exception( local_signal_handler.sys_sig() );
+}
+# 1271 "/usr/include/boost/test/impl/execution_monitor.ipp" 3 4
+execution_monitor::execution_monitor()
+: p_catch_system_errors( true )
+, p_auto_start_dbg( false )
+, p_timeout( 0 )
+, p_use_alt_stack( true )
+, p_detect_fp_exceptions( fpe::BOOST_FPE_OFF )
+{}
+
+
+
+int
+execution_monitor::execute( boost::function<int ()> const& F )
+{
+    if( debug::under_debugger() )
+        p_catch_system_errors.value = false;
+
+    try {
+        detail::fpe_except_guard G( p_detect_fp_exceptions );
+        boost::ignore_unused( G );
+
+        return catch_signals( F );
+    }
+# 1301 "/usr/include/boost/test/impl/execution_monitor.ipp" 3 4
+    catch( char const* ex )
+      { detail::report_error( execution_exception::cpp_exception_error,
+                              "C string: %s", ex ); }
+    catch( std::string const& ex )
+      { detail::report_error( execution_exception::cpp_exception_error,
+                              "std::string: %s", ex.c_str() ); }
+
+
+    catch( boost::exception const& ex )
+      { detail::report_error( execution_exception::cpp_exception_error,
+                              &ex,
+                              "%s", boost::diagnostic_information(ex).c_str() ); }
+# 1323 "/usr/include/boost/test/impl/execution_monitor.ipp" 3 4
+#define CATCH_AND_REPORT_STD_EXCEPTION(ex_name) catch( ex_name const& ex ) { detail::report_error( execution_exception::cpp_exception_error, current_exception_cast<boost::exception const>(), "%s: %s", detail::typeid_name(ex).c_str(), ex.what() ); }
+
+
+
+
+
+
+
+    catch( std::bad_alloc const& ex ) { detail::report_error( execution_exception::cpp_exception_error, current_exception_cast<boost::exception const>(), "%s: %s", detail::typeid_name(ex).c_str(), ex.what() ); }
+    catch( std::bad_cast const& ex ) { detail::report_error( execution_exception::cpp_exception_error, current_exception_cast<boost::exception const>(), "%s: %s", detail::typeid_name(ex).c_str(), ex.what() ); }
+    catch( std::bad_typeid const& ex ) { detail::report_error( execution_exception::cpp_exception_error, current_exception_cast<boost::exception const>(), "%s: %s", detail::typeid_name(ex).c_str(), ex.what() ); }
+    catch( std::bad_exception const& ex ) { detail::report_error( execution_exception::cpp_exception_error, current_exception_cast<boost::exception const>(), "%s: %s", detail::typeid_name(ex).c_str(), ex.what() ); }
+    catch( std::domain_error const& ex ) { detail::report_error( execution_exception::cpp_exception_error, current_exception_cast<boost::exception const>(), "%s: %s", detail::typeid_name(ex).c_str(), ex.what() ); }
+    catch( std::invalid_argument const& ex ) { detail::report_error( execution_exception::cpp_exception_error, current_exception_cast<boost::exception const>(), "%s: %s", detail::typeid_name(ex).c_str(), ex.what() ); }
+    catch( std::length_error const& ex ) { detail::report_error( execution_exception::cpp_exception_error, current_exception_cast<boost::exception const>(), "%s: %s", detail::typeid_name(ex).c_str(), ex.what() ); }
+    catch( std::out_of_range const& ex ) { detail::report_error( execution_exception::cpp_exception_error, current_exception_cast<boost::exception const>(), "%s: %s", detail::typeid_name(ex).c_str(), ex.what() ); }
+    catch( std::range_error const& ex ) { detail::report_error( execution_exception::cpp_exception_error, current_exception_cast<boost::exception const>(), "%s: %s", detail::typeid_name(ex).c_str(), ex.what() ); }
+    catch( std::overflow_error const& ex ) { detail::report_error( execution_exception::cpp_exception_error, current_exception_cast<boost::exception const>(), "%s: %s", detail::typeid_name(ex).c_str(), ex.what() ); }
+    catch( std::underflow_error const& ex ) { detail::report_error( execution_exception::cpp_exception_error, current_exception_cast<boost::exception const>(), "%s: %s", detail::typeid_name(ex).c_str(), ex.what() ); }
+    catch( std::logic_error const& ex ) { detail::report_error( execution_exception::cpp_exception_error, current_exception_cast<boost::exception const>(), "%s: %s", detail::typeid_name(ex).c_str(), ex.what() ); }
+    catch( std::runtime_error const& ex ) { detail::report_error( execution_exception::cpp_exception_error, current_exception_cast<boost::exception const>(), "%s: %s", detail::typeid_name(ex).c_str(), ex.what() ); }
+    catch( std::exception const& ex ) { detail::report_error( execution_exception::cpp_exception_error, current_exception_cast<boost::exception const>(), "%s: %s", detail::typeid_name(ex).c_str(), ex.what() ); }
+#undef CATCH_AND_REPORT_STD_EXCEPTION
+
+
+    catch( system_error const& ex )
+      { detail::report_error( execution_exception::cpp_exception_error,
+                              "system_error produced by: %s: %s", ex.p_failed_exp, std::strerror( ex.p_errno ) ); }
+    catch( detail::system_signal_exception const& ex )
+      { ex.report(); }
+
+
+    catch( execution_aborted const& )
+      { return 0; }
+
+
+    catch( execution_exception const& )
+      { throw; }
+
+
+    catch( ... )
+      { detail::report_error( execution_exception::cpp_exception_error, "unknown type" ); }
+
+
+
+    return 0;
+}
+
+
+
+namespace detail {
+
+struct forward {
+    explicit forward( boost::function<void ()> const& F ) : m_F( F ) {}
+
+    int operator()() { m_F(); return 0; }
+
+    boost::function<void ()> const& m_F;
+};
+
+}
+void
+execution_monitor::vexecute( boost::function<void ()> const& F )
+{
+    execute( detail::forward( F ) );
+}
+
+
+
+
+
+system_error::system_error( char const* exp )
+
+
+
+: p_errno( (*__errno_location ()) )
+
+, p_failed_exp( exp )
+{}
+
+
+
+
+
+
+
+execution_exception::execution_exception( error_code ec_, const_string what_msg_, location const& location_ )
+: m_error_code( ec_ )
+, m_what( what_msg_.empty() ? ::boost::unit_test::const_string( "uncaught exception, system error or abort requested", sizeof( "uncaught exception, system error or abort requested" ) - 1 ) : what_msg_ )
+, m_location( location_ )
+{}
+
+
+
+execution_exception::location::location( char const* file_name, size_t line_num, char const* func )
+: m_file_name( file_name ? file_name : "unknown location" )
+, m_line_num( line_num )
+, m_function( func )
+{}
+
+execution_exception::location::location(const_string file_name, size_t line_num, char const* func )
+: m_file_name( file_name )
+, m_line_num( line_num )
+, m_function( func )
+{}
+
+
+
+
+
+
+
+namespace fpe {
+
+unsigned
+enable( unsigned mask )
+{
+    boost::ignore_unused(mask);
+# 1460 "/usr/include/boost/test/impl/execution_monitor.ipp" 3 4
+    if (BOOST_FPE_ALL == BOOST_FPE_OFF)
+
+        return BOOST_FPE_OFF;
+    feclearexcept(BOOST_FPE_ALL);
+    int res = feenableexcept( mask );
+    return res == -1 ? (unsigned)BOOST_FPE_INV : (unsigned)res;
+
+
+
+
+}
+
+
+
+unsigned
+disable( unsigned mask )
+{
+    boost::ignore_unused(mask);
+# 1496 "/usr/include/boost/test/impl/execution_monitor.ipp" 3 4
+    if (BOOST_FPE_ALL == BOOST_FPE_OFF)
+
+        return BOOST_FPE_INV;
+    feclearexcept(BOOST_FPE_ALL);
+    int res = fedisableexcept( mask );
+    return res == -1 ? (unsigned)BOOST_FPE_INV : (unsigned)res;
+
+
+
+
+}
+
+
+
+}
+
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 1515 "/usr/include/boost/test/impl/execution_monitor.ipp" 2 3 4
+# 24 "/usr/include/boost/test/included/unit_test.hpp" 2 3 4
+# 1 "/usr/include/boost/test/impl/plain_report_formatter.ipp" 1 3 4
+# 16 "/usr/include/boost/test/impl/plain_report_formatter.ipp" 3 4
+#define BOOST_TEST_PLAIN_REPORT_FORMATTER_IPP_020105GER 
+
+
+# 1 "/usr/include/boost/test/output/plain_report_formatter.hpp" 1 3 4
+# 16 "/usr/include/boost/test/output/plain_report_formatter.hpp" 3 4
+#define BOOST_TEST_PLAIN_REPORT_FORMATTER_HPP_020105GER 
+
+
+
+
+
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 23 "/usr/include/boost/test/output/plain_report_formatter.hpp" 2 3 4
+
+
+
+namespace boost {
+namespace unit_test {
+namespace output {
+
+
+
+
+
+class plain_report_formatter : public results_reporter::format {
+public:
+    plain_report_formatter() : m_indent( 0 ), m_color_output( false ) {}
+
+
+    void results_report_start( std::ostream& ostr );
+    void results_report_finish( std::ostream& ostr );
+
+    void test_unit_report_start( test_unit const&, std::ostream& ostr );
+    void test_unit_report_finish( test_unit const&, std::ostream& ostr );
+
+    void do_confirmation_report( test_unit const&, std::ostream& ostr );
+
+private:
+
+    counter_t m_indent;
+    bool m_color_output;
+};
+
+}
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 58 "/usr/include/boost/test/output/plain_report_formatter.hpp" 2 3 4
+# 20 "/usr/include/boost/test/impl/plain_report_formatter.ipp" 2 3 4
+# 31 "/usr/include/boost/test/impl/plain_report_formatter.ipp" 3 4
+# 1 "/usr/include/boost/config/no_tr1/cmath.hpp" 1 3 4
+# 14 "/usr/include/boost/config/no_tr1/cmath.hpp" 3 4
+#define BOOST_CONFIG_CMATH 
+
+
+#define BOOST_TR1_NO_RECURSION 
+#define BOOST_CONFIG_NO_CMATH_RECURSION 
+
+
+# 1 "/usr/include/c++/10.2.0/cmath" 1 3 4
+# 39 "/usr/include/c++/10.2.0/cmath" 3 4
+       
+# 40 "/usr/include/c++/10.2.0/cmath" 3
+
+
+
+
+#define _GLIBCXX_INCLUDE_NEXT_C_HEADERS 
+
+#undef _GLIBCXX_INCLUDE_NEXT_C_HEADERS
+# 22 "/usr/include/boost/config/no_tr1/cmath.hpp" 2 3 4
+
+
+#undef BOOST_TR1_NO_RECURSION
+#undef BOOST_CONFIG_NO_CMATH_RECURSION
+# 32 "/usr/include/boost/test/impl/plain_report_formatter.ipp" 2 3 4
+
+
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 35 "/usr/include/boost/test/impl/plain_report_formatter.ipp" 2 3 4
+
+
+
+
+
+
+
+namespace boost {
+namespace unit_test {
+namespace output {
+
+namespace {
+
+typedef utils::custom_manip<struct quote_t> quote;
+
+template<typename T>
+inline std::ostream&
+operator<<( utils::custom_printer<quote> const& p, T const& value )
+{
+    *p << '"' << value << '"';
+
+    return *p;
+}
+
+
+
+void
+print_stat_value( std::ostream& ostr, counter_t v, counter_t indent, counter_t total, const_string name, const_string res )
+{
+    if( v == 0 )
+        return;
+
+    if( total > 0 )
+        ostr << std::setw( static_cast<int>(indent) ) << "" << v << ' ' << name << ( v != 1 ? "s" : "" )
+             << " out of " << total << ' ' << res << '\n';
+    else
+        ostr << std::setw( static_cast<int>(indent) ) << "" << v << ' ' << res << ' ' << name << ( v != 1 ? "s" : "" ) << '\n';
+}
+
+
+
+}
+
+
+
+
+
+void
+plain_report_formatter::results_report_start( std::ostream& ostr )
+{
+    m_indent = 0;
+    m_color_output = runtime_config::get<bool>( runtime_config::btrt_color_output );
+    ostr << '\n';
+}
+
+
+
+void
+plain_report_formatter::results_report_finish( std::ostream& ostr )
+{
+    ostr.flush();
+}
+
+
+
+void
+plain_report_formatter::test_unit_report_start( test_unit const& tu, std::ostream& ostr )
+{
+    test_results const& tr = results_collector.results( tu.p_id );
+
+    const_string descr;
+
+    if( tr.passed() )
+        descr = "has passed";
+    else if( tr.p_skipped )
+        descr = "was skipped";
+    else if( tr.p_timed_out )
+        descr = "has timed out";
+    else if( tr.p_aborted )
+        descr = "was aborted";
+    else
+        descr = "has failed";
+
+    ostr << std::setw( static_cast<int>(m_indent) ) << ""
+         << "Test " << tu.p_type_name << ' ' << quote() << tu.full_name() << ' ' << descr;
+
+    if( tr.p_skipped ) {
+        ostr << "\n";
+        m_indent += 2;
+        return;
+    }
+
+
+    counter_t total_assertions = tr.p_assertions_passed + tr.p_assertions_failed;
+    counter_t total_tc = tr.p_test_cases_passed + tr.p_test_cases_warned + tr.p_test_cases_failed + tr.p_test_cases_skipped + tr.p_test_cases_timed_out;
+
+    if( total_assertions > 0 || total_tc > 0 || tr.p_warnings_failed > 0)
+        ostr << " with:";
+
+    ostr << '\n';
+    m_indent += 2;
+
+    print_stat_value( ostr, tr.p_test_cases_passed , m_indent, total_tc , "test case", "passed" );
+    print_stat_value( ostr, tr.p_test_cases_warned , m_indent, total_tc , "test case", "passed with warnings" );
+    print_stat_value( ostr, tr.p_test_cases_failed , m_indent, total_tc , "test case", "failed" );
+    print_stat_value( ostr, tr.p_test_cases_timed_out, m_indent, total_tc , "test case", "timed-out" );
+    print_stat_value( ostr, tr.p_test_suites_timed_out, m_indent, tr.p_test_suites, "test suite", "timed-out" );
+    print_stat_value( ostr, tr.p_test_cases_skipped, m_indent, total_tc , "test case", "skipped" );
+    print_stat_value( ostr, tr.p_test_cases_aborted, m_indent, total_tc , "test case", "aborted" );
+    print_stat_value( ostr, tr.p_assertions_passed , m_indent, total_assertions, "assertion", "passed" );
+    print_stat_value( ostr, tr.p_assertions_failed , m_indent, total_assertions, "assertion", "failed" );
+    print_stat_value( ostr, tr.p_warnings_failed , m_indent, 0 , "warning" , "failed" );
+    print_stat_value( ostr, tr.p_expected_failures , m_indent, 0 , "failure" , "expected" );
+
+    ostr << '\n';
+}
+
+
+
+void
+plain_report_formatter::test_unit_report_finish( test_unit const&, std::ostream& )
+{
+    m_indent -= 2;
+}
+
+
+
+void
+plain_report_formatter::do_confirmation_report( test_unit const& tu, std::ostream& ostr )
+{
+    test_results const& tr = results_collector.results( tu.p_id );
+
+    if( tr.passed() ) {
+        utils::scope_setcolor const sc(m_color_output, ostr, utils::term_attr::BRIGHT, utils::term_color::GREEN); boost::ignore_unused( sc );
+
+        ostr << "*** No errors detected\n";
+        return;
+    }
+
+    utils::scope_setcolor const sc(m_color_output, ostr, utils::term_attr::BRIGHT, utils::term_color::RED); boost::ignore_unused( sc );
+
+    if( tr.p_skipped ) {
+        ostr << "*** The test " << tu.p_type_name << ' ' << quote() << tu.full_name() << " was skipped"
+             << "; see standard output for details\n";
+        return;
+    }
+
+    if( tr.p_timed_out ) {
+        ostr << "*** The test " << tu.p_type_name << ' ' << quote() << tu.full_name() << " has timed out"
+             << "; see standard output for details\n";
+        return;
+    }
+
+    if( tr.p_aborted ) {
+        ostr << "*** The test " << tu.p_type_name << ' ' << quote() << tu.full_name() << " was aborted"
+             << "; see standard output for details\n";
+    }
+
+    if( tr.p_assertions_failed == 0 ) {
+        if( !tr.p_aborted )
+            ostr << "*** Errors were detected in the test " << tu.p_type_name << ' ' << quote() << tu.full_name()
+                 << "; see standard output for details\n";
+        return;
+    }
+
+    counter_t num_failures = tr.p_assertions_failed;
+
+    ostr << "*** " << num_failures << " failure" << ( num_failures != 1 ? "s are" : " is" ) << " detected";
+
+    if( tr.p_expected_failures > 0 )
+        ostr << " (" << tr.p_expected_failures << " failure" << ( tr.p_expected_failures != 1 ? "s are" : " is" ) << " expected)";
+
+    ostr << " in the test " << tu.p_type_name << " " << quote() << tu.full_name() << "\n";
+}
+
+
+
+}
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 217 "/usr/include/boost/test/impl/plain_report_formatter.ipp" 2 3 4
+# 25 "/usr/include/boost/test/included/unit_test.hpp" 2 3 4
+# 1 "/usr/include/boost/test/impl/progress_monitor.ipp" 1 3 4
+# 16 "/usr/include/boost/test/impl/progress_monitor.ipp" 3 4
+#define BOOST_TEST_PROGRESS_MONITOR_IPP_020105GER 
+# 31 "/usr/include/boost/test/impl/progress_monitor.ipp" 3 4
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 32 "/usr/include/boost/test/impl/progress_monitor.ipp" 2 3 4
+
+
+
+namespace boost {
+namespace unit_test {
+
+
+
+
+
+struct progress_display {
+    progress_display( counter_t expected_count, std::ostream& os )
+    : m_os(os)
+    , m_count( 0 )
+    , m_expected_count( expected_count )
+    , m_next_tic_count( 0 )
+    , m_tic( 0 )
+    {
+
+        m_os << "\n0%   10   20   30   40   50   60   70   80   90   100%"
+             << "\n|----|----|----|----|----|----|----|----|----|----|"
+             << std::endl;
+
+        if( !m_expected_count )
+            m_expected_count = 1;
+    }
+
+    unsigned long operator+=( unsigned long increment )
+    {
+        if( (m_count += increment) < m_next_tic_count )
+            return m_count;
+
+
+
+
+        unsigned int tics_needed = static_cast<unsigned int>(
+            (static_cast<double>(m_count)/m_expected_count)*50.0 );
+
+        do {
+            m_os << '*' << std::flush;
+        } while( ++m_tic < tics_needed );
+
+        m_next_tic_count = static_cast<unsigned long>((m_tic/50.0) * m_expected_count);
+
+        if( m_count == m_expected_count ) {
+            if( m_tic < 51 )
+                m_os << '*';
+
+            m_os << std::endl;
+        }
+
+        return m_count;
+    }
+    unsigned long operator++() { return operator+=( 1 ); }
+    unsigned long count() const { return m_count; }
+
+private:
+    progress_display(progress_display const&) = delete;
+    progress_display& operator=(progress_display const&) = delete;
+
+    std::ostream& m_os;
+
+    unsigned long m_count;
+    unsigned long m_expected_count;
+    unsigned long m_next_tic_count;
+    unsigned int m_tic;
+};
+
+namespace {
+
+struct progress_monitor_impl {
+
+    progress_monitor_impl()
+    : m_stream( &std::cout )
+    , m_color_output( false )
+    {
+    }
+
+    std::ostream* m_stream;
+    scoped_ptr<progress_display> m_progress_display;
+    bool m_color_output;
+};
+
+progress_monitor_impl& s_pm_impl() { static progress_monitor_impl the_inst; return the_inst; }
+
+#define PM_SCOPED_COLOR() BOOST_TEST_SCOPE_SETCOLOR( s_pm_impl().m_color_output, *s_pm_impl().m_stream, term_attr::BRIGHT, term_color::MAGENTA )
+
+
+}
+
+
+
+progress_monitor_t& progress_monitor_t::instance() { static progress_monitor_t the_inst; return the_inst; }
+
+
+
+void
+progress_monitor_t::test_start( counter_t test_cases_amount )
+{
+    s_pm_impl().m_color_output = runtime_config::get<bool>( runtime_config::btrt_color_output );
+
+    utils::scope_setcolor const sc(s_pm_impl().m_color_output, *s_pm_impl().m_stream, utils::term_attr::BRIGHT, utils::term_color::MAGENTA); boost::ignore_unused( sc );
+
+    s_pm_impl().m_progress_display.reset( new progress_display( test_cases_amount, *s_pm_impl().m_stream ) );
+}
+
+
+
+void
+progress_monitor_t::test_aborted()
+{
+    utils::scope_setcolor const sc(s_pm_impl().m_color_output, *s_pm_impl().m_stream, utils::term_attr::BRIGHT, utils::term_color::MAGENTA); boost::ignore_unused( sc );
+
+    (*s_pm_impl().m_progress_display) += s_pm_impl().m_progress_display->count();
+}
+
+
+
+void
+progress_monitor_t::test_unit_finish( test_unit const& tu, unsigned long )
+{
+    utils::scope_setcolor const sc(s_pm_impl().m_color_output, *s_pm_impl().m_stream, utils::term_attr::BRIGHT, utils::term_color::MAGENTA); boost::ignore_unused( sc );
+
+    if( tu.p_type == TUT_CASE )
+        ++(*s_pm_impl().m_progress_display);
+}
+
+
+
+void
+progress_monitor_t::test_unit_skipped( test_unit const& tu, const_string )
+{
+    utils::scope_setcolor const sc(s_pm_impl().m_color_output, *s_pm_impl().m_stream, utils::term_attr::BRIGHT, utils::term_color::MAGENTA); boost::ignore_unused( sc );
+
+    test_case_counter tcc;
+    traverse_test_tree( tu, tcc );
+
+    (*s_pm_impl().m_progress_display) += tcc.p_count;
+}
+
+
+
+void
+progress_monitor_t::set_stream( std::ostream& ostr )
+{
+    s_pm_impl().m_stream = &ostr;
+}
+
+
+
+#undef PM_SCOPED_COLOR
+
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 188 "/usr/include/boost/test/impl/progress_monitor.ipp" 2 3 4
+# 26 "/usr/include/boost/test/included/unit_test.hpp" 2 3 4
+# 1 "/usr/include/boost/test/impl/results_collector.ipp" 1 3 4
+# 14 "/usr/include/boost/test/impl/results_collector.ipp" 3 4
+#define BOOST_TEST_RESULTS_COLLECTOR_IPP_021105GER 
+# 33 "/usr/include/boost/test/impl/results_collector.ipp" 3 4
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 34 "/usr/include/boost/test/impl/results_collector.ipp" 2 3 4
+
+
+
+namespace boost {
+namespace unit_test {
+
+
+
+
+
+test_results::test_results()
+{
+    clear();
+}
+
+
+
+bool
+test_results::passed() const
+{
+
+
+    return !p_skipped &&
+            p_test_cases_failed == 0 &&
+            p_assertions_failed <= p_expected_failures &&
+
+            !p_timed_out &&
+            p_test_cases_timed_out == 0 &&
+            !aborted();
+}
+
+
+
+bool
+test_results::aborted() const
+{
+    return p_aborted;
+}
+
+
+
+bool
+test_results::skipped() const
+{
+    return p_skipped;
+}
+
+
+
+int
+test_results::result_code() const
+{
+    return passed() ? exit_success
+           : ( (p_assertions_failed > p_expected_failures || p_skipped || p_timed_out || p_test_cases_timed_out )
+                    ? exit_test_failure
+                    : exit_exception_failure );
+}
+
+
+
+void
+test_results::operator+=( test_results const& tr )
+{
+    p_test_suites.value += tr.p_test_suites;
+    p_assertions_passed.value += tr.p_assertions_passed;
+    p_assertions_failed.value += tr.p_assertions_failed;
+    p_warnings_failed.value += tr.p_warnings_failed;
+    p_test_cases_passed.value += tr.p_test_cases_passed;
+    p_test_cases_warned.value += tr.p_test_cases_warned;
+    p_test_cases_failed.value += tr.p_test_cases_failed;
+    p_test_cases_skipped.value += tr.p_test_cases_skipped;
+    p_test_cases_aborted.value += tr.p_test_cases_aborted;
+    p_test_cases_timed_out.value += tr.p_test_cases_timed_out;
+    p_test_suites_timed_out.value += tr.p_test_suites_timed_out;
+    p_duration_microseconds.value += tr.p_duration_microseconds;
+}
+
+
+
+void
+test_results::clear()
+{
+    p_test_suites.value = 0;
+    p_assertions_passed.value = 0;
+    p_assertions_failed.value = 0;
+    p_warnings_failed.value = 0;
+    p_expected_failures.value = 0;
+    p_test_cases_passed.value = 0;
+    p_test_cases_warned.value = 0;
+    p_test_cases_failed.value = 0;
+    p_test_cases_skipped.value = 0;
+    p_test_cases_aborted.value = 0;
+    p_test_cases_timed_out.value = 0;
+    p_test_suites_timed_out.value = 0;
+    p_duration_microseconds.value= 0;
+    p_aborted.value = false;
+    p_skipped.value = false;
+    p_timed_out.value = false;
+}
+
+
+
+
+
+
+
+namespace {
+
+struct results_collector_impl {
+    std::map<test_unit_id,test_results> m_results_store;
+};
+
+results_collector_impl& s_rc_impl() { static results_collector_impl the_inst; return the_inst; }
+
+}
+
+
+
+results_collector_t& results_collector_t::instance() { static results_collector_t the_inst; return the_inst; }
+
+
+
+void
+results_collector_t::test_start( counter_t )
+{
+    s_rc_impl().m_results_store.clear();
+}
+
+
+
+void
+results_collector_t::test_unit_start( test_unit const& tu )
+{
+
+    test_results& tr = s_rc_impl().m_results_store[tu.p_id];
+
+    tr.clear();
+
+    tr.p_expected_failures.value = tu.p_expected_failures;
+}
+
+
+
+class results_collect_helper : public test_tree_visitor {
+public:
+    explicit results_collect_helper( test_results& tr, test_unit const& ts ) : m_tr( tr ), m_ts( ts ) {}
+
+    void visit( test_case const& tc )
+    {
+        test_results const& tr = results_collector.results( tc.p_id );
+        m_tr += tr;
+
+        if( tr.passed() ) {
+            if( tr.p_warnings_failed )
+                m_tr.p_test_cases_warned.value++;
+            else
+                m_tr.p_test_cases_passed.value++;
+        }
+        else if( tr.p_timed_out ) {
+            m_tr.p_test_cases_timed_out.value++;
+        }
+        else if( tr.p_skipped || !tc.is_enabled() ) {
+            m_tr.p_test_cases_skipped.value++;
+        }
+        else {
+            if( tr.p_aborted )
+                m_tr.p_test_cases_aborted.value++;
+
+            m_tr.p_test_cases_failed.value++;
+        }
+    }
+    bool test_suite_start( test_suite const& ts )
+    {
+        if( m_ts.p_id == ts.p_id )
+            return true;
+
+        m_tr += results_collector.results( ts.p_id );
+        m_tr.p_test_suites.value++;
+
+        if( results_collector.results( ts.p_id ).p_timed_out )
+            m_tr.p_test_suites_timed_out.value++;
+        return false;
+    }
+
+private:
+
+    test_results& m_tr;
+    test_unit const& m_ts;
+};
+
+
+
+void
+results_collector_t::test_unit_finish( test_unit const& tu, unsigned long elapsed_in_microseconds )
+{
+    test_results & tr = s_rc_impl().m_results_store[tu.p_id];
+    if( tu.p_type == TUT_SUITE ) {
+        results_collect_helper ch( tr, tu );
+        traverse_test_tree( tu, ch, true );
+    }
+    else {
+        bool num_failures_match = tr.p_aborted || tr.p_assertions_failed >= tr.p_expected_failures;
+        if( !num_failures_match )
+            (::boost::unit_test::unit_test_log << ::boost::unit_test::log::begin( "boost.test framework", 0 )) ( ::boost::unit_test::log_messages ) << (::boost::unit_test::lazy_ostream::instance() << "Test case " << tu.full_name() << " has fewer failures than expected");
+
+        bool check_any_assertions = tr.p_aborted || (tr.p_assertions_failed != 0) || (tr.p_assertions_passed != 0);
+        if( !check_any_assertions )
+            (::boost::unit_test::unit_test_log << ::boost::unit_test::log::begin( "boost.test framework", 0 )) ( ::boost::unit_test::log_messages ) << (::boost::unit_test::lazy_ostream::instance() << "Test case " << tu.full_name() << " did not check any assertions");
+    }
+    tr.p_duration_microseconds.value = elapsed_in_microseconds;
+}
+
+
+
+void
+results_collector_t::test_unit_skipped( test_unit const& tu, const_string )
+{
+    test_results& tr = s_rc_impl().m_results_store[tu.p_id];
+    tr.clear();
+
+    tr.p_skipped.value = true;
+
+    if( tu.p_type == TUT_SUITE ) {
+        test_case_counter tcc(true);
+        traverse_test_tree( tu, tcc, true );
+
+        tr.p_test_cases_skipped.value = tcc.p_count;
+    }
+}
+
+
+
+void
+results_collector_t::test_unit_timed_out(test_unit const& tu)
+{
+    test_results& tr = s_rc_impl().m_results_store[tu.p_id];
+    tr.p_timed_out.value = true;
+}
+
+
+
+void
+results_collector_t::assertion_result( unit_test::assertion_result ar )
+{
+    test_results& tr = s_rc_impl().m_results_store[framework::current_test_case_id()];
+
+    switch( ar ) {
+    case AR_PASSED: tr.p_assertions_passed.value++; break;
+    case AR_FAILED: tr.p_assertions_failed.value++; break;
+    case AR_TRIGGERED: tr.p_warnings_failed.value++; break;
+    }
+
+    if( tr.p_assertions_failed == 1 )
+        first_failed_assertion();
+}
+
+
+
+void
+results_collector_t::exception_caught( execution_exception const& ex)
+{
+    test_results& tr = s_rc_impl().m_results_store[framework::current_test_case_id()];
+
+    tr.p_assertions_failed.value++;
+    if( ex.code() == execution_exception::timeout_error ) {
+        tr.p_timed_out.value = true;
+    }
+}
+
+
+
+void
+results_collector_t::test_unit_aborted( test_unit const& tu )
+{
+    s_rc_impl().m_results_store[tu.p_id].p_aborted.value = true;
+}
+
+
+
+test_results const&
+results_collector_t::results( test_unit_id id ) const
+{
+    return s_rc_impl().m_results_store[id];
+}
+
+
+
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 325 "/usr/include/boost/test/impl/results_collector.ipp" 2 3 4
+# 27 "/usr/include/boost/test/included/unit_test.hpp" 2 3 4
+# 1 "/usr/include/boost/test/impl/results_reporter.ipp" 1 3 4
+# 16 "/usr/include/boost/test/impl/results_reporter.ipp" 3 4
+#define BOOST_TEST_RESULTS_REPORTER_IPP_020105GER 
+
+
+
+
+
+
+
+# 1 "/usr/include/boost/test/output/xml_report_formatter.hpp" 1 3 4
+# 16 "/usr/include/boost/test/output/xml_report_formatter.hpp" 3 4
+#define BOOST_TEST_XML_REPORT_FORMATTER_HPP_020105GER 
+
+
+
+
+
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 23 "/usr/include/boost/test/output/xml_report_formatter.hpp" 2 3 4
+
+
+
+namespace boost {
+namespace unit_test {
+namespace output {
+
+
+
+
+
+class xml_report_formatter : public results_reporter::format {
+public:
+
+    void results_report_start( std::ostream& ostr );
+    void results_report_finish( std::ostream& ostr );
+
+    void test_unit_report_start( test_unit const&, std::ostream& ostr );
+    void test_unit_report_finish( test_unit const&, std::ostream& ostr );
+
+    void do_confirmation_report( test_unit const&, std::ostream& ostr );
+};
+
+}
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 51 "/usr/include/boost/test/output/xml_report_formatter.hpp" 2 3 4
+# 25 "/usr/include/boost/test/impl/results_reporter.ipp" 2 3 4
+
+
+
+
+
+
+
+# 1 "/usr/include/boost/io/ios_state.hpp" 1 3 4
+# 10 "/usr/include/boost/io/ios_state.hpp" 3 4
+#define BOOST_IO_IOS_STATE_HPP 
+
+# 1 "/usr/include/boost/io_fwd.hpp" 1 3 4
+# 10 "/usr/include/boost/io_fwd.hpp" 3 4
+#define BOOST_IO_FWD_HPP 
+
+
+
+
+namespace boost
+{
+namespace io
+{
+
+
+
+
+class ios_flags_saver;
+class ios_precision_saver;
+class ios_width_saver;
+class ios_base_all_saver;
+
+template < typename Ch, class Tr = ::std::char_traits<Ch> >
+    class basic_ios_iostate_saver;
+template < typename Ch, class Tr = ::std::char_traits<Ch> >
+    class basic_ios_exception_saver;
+template < typename Ch, class Tr = ::std::char_traits<Ch> >
+    class basic_ios_tie_saver;
+template < typename Ch, class Tr = ::std::char_traits<Ch> >
+    class basic_ios_rdbuf_saver;
+template < typename Ch, class Tr = ::std::char_traits<Ch> >
+    class basic_ios_fill_saver;
+template < typename Ch, class Tr = ::std::char_traits<Ch> >
+    class basic_ios_locale_saver;
+template < typename Ch, class Tr = ::std::char_traits<Ch> >
+    class basic_ios_all_saver;
+
+typedef basic_ios_iostate_saver<char> ios_iostate_saver;
+typedef basic_ios_iostate_saver<wchar_t> wios_iostate_saver;
+typedef basic_ios_exception_saver<char> ios_exception_saver;
+typedef basic_ios_exception_saver<wchar_t> wios_exception_saver;
+typedef basic_ios_tie_saver<char> ios_tie_saver;
+typedef basic_ios_tie_saver<wchar_t> wios_tie_saver;
+typedef basic_ios_rdbuf_saver<char> ios_rdbuf_saver;
+typedef basic_ios_rdbuf_saver<wchar_t> wios_rdbuf_saver;
+typedef basic_ios_fill_saver<char> ios_fill_saver;
+typedef basic_ios_fill_saver<wchar_t> wios_fill_saver;
+typedef basic_ios_locale_saver<char> ios_locale_saver;
+typedef basic_ios_locale_saver<wchar_t> wios_locale_saver;
+typedef basic_ios_all_saver<char> ios_all_saver;
+typedef basic_ios_all_saver<wchar_t> wios_all_saver;
+
+class ios_iword_saver;
+class ios_pword_saver;
+class ios_all_word_saver;
+
+
+}
+}
+# 13 "/usr/include/boost/io/ios_state.hpp" 2 3 4
+# 24 "/usr/include/boost/io/ios_state.hpp" 3 4
+namespace boost
+{
+namespace io
+{
+
+
+
+
+class ios_flags_saver
+{
+public:
+    typedef ::std::ios_base state_type;
+    typedef ::std::ios_base::fmtflags aspect_type;
+
+    explicit ios_flags_saver( state_type &s )
+        : s_save_( s ), a_save_( s.flags() )
+        {}
+    ios_flags_saver( state_type &s, aspect_type const &a )
+        : s_save_( s ), a_save_( s.flags(a) )
+        {}
+    ~ios_flags_saver()
+        { this->restore(); }
+
+    void restore()
+        { s_save_.flags( a_save_ ); }
+
+private:
+    state_type & s_save_;
+    aspect_type const a_save_;
+
+    ios_flags_saver& operator=(const ios_flags_saver&);
+};
+
+class ios_precision_saver
+{
+public:
+    typedef ::std::ios_base state_type;
+    typedef ::std::streamsize aspect_type;
+
+    explicit ios_precision_saver( state_type &s )
+        : s_save_( s ), a_save_( s.precision() )
+        {}
+    ios_precision_saver( state_type &s, aspect_type const &a )
+        : s_save_( s ), a_save_( s.precision(a) )
+        {}
+    ~ios_precision_saver()
+        { this->restore(); }
+
+    void restore()
+        { s_save_.precision( a_save_ ); }
+
+private:
+    state_type & s_save_;
+    aspect_type const a_save_;
+
+    ios_precision_saver& operator=(const ios_precision_saver&);
+};
+
+class ios_width_saver
+{
+public:
+    typedef ::std::ios_base state_type;
+    typedef ::std::streamsize aspect_type;
+
+    explicit ios_width_saver( state_type &s )
+        : s_save_( s ), a_save_( s.width() )
+        {}
+    ios_width_saver( state_type &s, aspect_type const &a )
+        : s_save_( s ), a_save_( s.width(a) )
+        {}
+    ~ios_width_saver()
+        { this->restore(); }
+
+    void restore()
+        { s_save_.width( a_save_ ); }
+
+private:
+    state_type & s_save_;
+    aspect_type const a_save_;
+    ios_width_saver& operator=(const ios_width_saver&);
+};
+
+
+
+
+template < typename Ch, class Tr >
+class basic_ios_iostate_saver
+{
+public:
+    typedef ::std::basic_ios<Ch, Tr> state_type;
+    typedef ::std::ios_base::iostate aspect_type;
+
+    explicit basic_ios_iostate_saver( state_type &s )
+        : s_save_( s ), a_save_( s.rdstate() )
+        {}
+    basic_ios_iostate_saver( state_type &s, aspect_type const &a )
+        : s_save_( s ), a_save_( s.rdstate() )
+        { s.clear(a); }
+    ~basic_ios_iostate_saver()
+        { this->restore(); }
+
+    void restore()
+        { s_save_.clear( a_save_ ); }
+
+private:
+    state_type & s_save_;
+    aspect_type const a_save_;
+    basic_ios_iostate_saver& operator=(const basic_ios_iostate_saver&);
+};
+
+template < typename Ch, class Tr >
+class basic_ios_exception_saver
+{
+public:
+    typedef ::std::basic_ios<Ch, Tr> state_type;
+    typedef ::std::ios_base::iostate aspect_type;
+
+    explicit basic_ios_exception_saver( state_type &s )
+        : s_save_( s ), a_save_( s.exceptions() )
+        {}
+
+
+
+    basic_ios_exception_saver( state_type &s, aspect_type const &a )
+
+        : s_save_( s ), a_save_( s.exceptions() )
+        { s.exceptions(a); }
+    ~basic_ios_exception_saver()
+        { this->restore(); }
+
+    void restore()
+        { s_save_.exceptions( a_save_ ); }
+
+private:
+    state_type & s_save_;
+    aspect_type const a_save_;
+    basic_ios_exception_saver& operator=(const basic_ios_exception_saver&);
+};
+
+template < typename Ch, class Tr >
+class basic_ios_tie_saver
+{
+public:
+    typedef ::std::basic_ios<Ch, Tr> state_type;
+    typedef ::std::basic_ostream<Ch, Tr> * aspect_type;
+
+    explicit basic_ios_tie_saver( state_type &s )
+        : s_save_( s ), a_save_( s.tie() )
+        {}
+    basic_ios_tie_saver( state_type &s, aspect_type const &a )
+        : s_save_( s ), a_save_( s.tie(a) )
+        {}
+    ~basic_ios_tie_saver()
+        { this->restore(); }
+
+    void restore()
+        { s_save_.tie( a_save_ ); }
+
+private:
+    state_type & s_save_;
+    aspect_type const a_save_;
+    basic_ios_tie_saver& operator=(const basic_ios_tie_saver&);
+};
+
+template < typename Ch, class Tr >
+class basic_ios_rdbuf_saver
+{
+public:
+    typedef ::std::basic_ios<Ch, Tr> state_type;
+    typedef ::std::basic_streambuf<Ch, Tr> * aspect_type;
+
+    explicit basic_ios_rdbuf_saver( state_type &s )
+        : s_save_( s ), a_save_( s.rdbuf() )
+        {}
+    basic_ios_rdbuf_saver( state_type &s, aspect_type const &a )
+        : s_save_( s ), a_save_( s.rdbuf(a) )
+        {}
+    ~basic_ios_rdbuf_saver()
+        { this->restore(); }
+
+    void restore()
+        { s_save_.rdbuf( a_save_ ); }
+
+private:
+    state_type & s_save_;
+    aspect_type const a_save_;
+    basic_ios_rdbuf_saver& operator=(const basic_ios_rdbuf_saver&);
+};
+
+template < typename Ch, class Tr >
+class basic_ios_fill_saver
+{
+public:
+    typedef ::std::basic_ios<Ch, Tr> state_type;
+    typedef typename state_type::char_type aspect_type;
+
+    explicit basic_ios_fill_saver( state_type &s )
+        : s_save_( s ), a_save_( s.fill() )
+        {}
+    basic_ios_fill_saver( state_type &s, aspect_type const &a )
+        : s_save_( s ), a_save_( s.fill(a) )
+        {}
+    ~basic_ios_fill_saver()
+        { this->restore(); }
+
+    void restore()
+        { s_save_.fill( a_save_ ); }
+
+private:
+    state_type & s_save_;
+    aspect_type const a_save_;
+    basic_ios_fill_saver& operator=(const basic_ios_fill_saver&);
+};
+
+
+template < typename Ch, class Tr >
+class basic_ios_locale_saver
+{
+public:
+    typedef ::std::basic_ios<Ch, Tr> state_type;
+    typedef ::std::locale aspect_type;
+
+    explicit basic_ios_locale_saver( state_type &s )
+        : s_save_( s ), a_save_( s.getloc() )
+        {}
+    basic_ios_locale_saver( state_type &s, aspect_type const &a )
+        : s_save_( s ), a_save_( s.imbue(a) )
+        {}
+    ~basic_ios_locale_saver()
+        { this->restore(); }
+
+    void restore()
+        { s_save_.imbue( a_save_ ); }
+
+private:
+    state_type & s_save_;
+    aspect_type const a_save_;
+    basic_ios_locale_saver& operator=(const basic_ios_locale_saver&);
+};
+
+
+
+
+
+class ios_iword_saver
+{
+public:
+    typedef ::std::ios_base state_type;
+    typedef int index_type;
+    typedef long aspect_type;
+
+    explicit ios_iword_saver( state_type &s, index_type i )
+        : s_save_( s ), a_save_( s.iword(i) ), i_save_( i )
+        {}
+    ios_iword_saver( state_type &s, index_type i, aspect_type const &a )
+        : s_save_( s ), a_save_( s.iword(i) ), i_save_( i )
+        { s.iword(i) = a; }
+    ~ios_iword_saver()
+        { this->restore(); }
+
+    void restore()
+        { s_save_.iword( i_save_ ) = a_save_; }
+
+private:
+    state_type & s_save_;
+    aspect_type const a_save_;
+    index_type const i_save_;
+
+    ios_iword_saver& operator=(const ios_iword_saver&);
+};
+
+class ios_pword_saver
+{
+public:
+    typedef ::std::ios_base state_type;
+    typedef int index_type;
+    typedef void * aspect_type;
+
+    explicit ios_pword_saver( state_type &s, index_type i )
+        : s_save_( s ), a_save_( s.pword(i) ), i_save_( i )
+        {}
+    ios_pword_saver( state_type &s, index_type i, aspect_type const &a )
+        : s_save_( s ), a_save_( s.pword(i) ), i_save_( i )
+        { s.pword(i) = a; }
+    ~ios_pword_saver()
+        { this->restore(); }
+
+    void restore()
+        { s_save_.pword( i_save_ ) = a_save_; }
+
+private:
+    state_type & s_save_;
+    aspect_type const a_save_;
+    index_type const i_save_;
+
+    ios_pword_saver operator=(const ios_pword_saver&);
+};
+
+
+
+
+class ios_base_all_saver
+{
+public:
+    typedef ::std::ios_base state_type;
+
+    explicit ios_base_all_saver( state_type &s )
+        : s_save_( s ), a1_save_( s.flags() ), a2_save_( s.precision() )
+        , a3_save_( s.width() )
+        {}
+
+    ~ios_base_all_saver()
+        { this->restore(); }
+
+    void restore()
+    {
+        s_save_.width( a3_save_ );
+        s_save_.precision( a2_save_ );
+        s_save_.flags( a1_save_ );
+    }
+
+private:
+    state_type & s_save_;
+    state_type::fmtflags const a1_save_;
+    ::std::streamsize const a2_save_;
+    ::std::streamsize const a3_save_;
+
+    ios_base_all_saver& operator=(const ios_base_all_saver&);
+};
+
+template < typename Ch, class Tr >
+class basic_ios_all_saver
+{
+public:
+    typedef ::std::basic_ios<Ch, Tr> state_type;
+
+    explicit basic_ios_all_saver( state_type &s )
+        : s_save_( s ), a1_save_( s.flags() ), a2_save_( s.precision() )
+        , a3_save_( s.width() ), a4_save_( s.rdstate() )
+        , a5_save_( s.exceptions() ), a6_save_( s.tie() )
+        , a7_save_( s.rdbuf() ), a8_save_( s.fill() )
+
+        , a9_save_( s.getloc() )
+
+        {}
+
+    ~basic_ios_all_saver()
+        { this->restore(); }
+
+    void restore()
+    {
+
+        s_save_.imbue( a9_save_ );
+
+        s_save_.fill( a8_save_ );
+        s_save_.rdbuf( a7_save_ );
+        s_save_.tie( a6_save_ );
+        s_save_.exceptions( a5_save_ );
+        s_save_.clear( a4_save_ );
+        s_save_.width( a3_save_ );
+        s_save_.precision( a2_save_ );
+        s_save_.flags( a1_save_ );
+    }
+
+private:
+    state_type & s_save_;
+    typename state_type::fmtflags const a1_save_;
+    ::std::streamsize const a2_save_;
+    ::std::streamsize const a3_save_;
+    typename state_type::iostate const a4_save_;
+    typename state_type::iostate const a5_save_;
+    ::std::basic_ostream<Ch, Tr> * const a6_save_;
+    ::std::basic_streambuf<Ch, Tr> * const a7_save_;
+    typename state_type::char_type const a8_save_;
+
+    ::std::locale const a9_save_;
+
+
+    basic_ios_all_saver& operator=(const basic_ios_all_saver&);
+};
+
+class ios_all_word_saver
+{
+public:
+    typedef ::std::ios_base state_type;
+    typedef int index_type;
+
+    ios_all_word_saver( state_type &s, index_type i )
+        : s_save_( s ), i_save_( i ), a1_save_( s.iword(i) )
+        , a2_save_( s.pword(i) )
+        {}
+
+    ~ios_all_word_saver()
+        { this->restore(); }
+
+    void restore()
+    {
+        s_save_.pword( i_save_ ) = a2_save_;
+        s_save_.iword( i_save_ ) = a1_save_;
+    }
+
+private:
+    state_type & s_save_;
+    index_type const i_save_;
+    long const a1_save_;
+    void * const a2_save_;
+
+    ios_all_word_saver& operator=(const ios_all_word_saver&);
+};
+
+
+}
+}
+# 33 "/usr/include/boost/test/impl/results_reporter.ipp" 2 3 4
+typedef ::boost::io::ios_base_all_saver io_saver_type;
+
+
+
+
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 39 "/usr/include/boost/test/impl/results_reporter.ipp" 2 3 4
+
+
+
+namespace boost {
+namespace unit_test {
+namespace results_reporter {
+
+
+
+
+
+namespace {
+
+struct results_reporter_impl : test_tree_visitor {
+
+    results_reporter_impl()
+    : m_stream( &std::cerr )
+    , m_stream_state_saver( new io_saver_type( std::cerr ) )
+    , m_report_level( CONFIRMATION_REPORT )
+    , m_formatter( new output::plain_report_formatter )
+    {}
+
+
+    void visit( test_case const& tc )
+    {
+        m_formatter->test_unit_report_start( tc, *m_stream );
+        m_formatter->test_unit_report_finish( tc, *m_stream );
+    }
+    bool test_suite_start( test_suite const& ts )
+    {
+        m_formatter->test_unit_report_start( ts, *m_stream );
+
+        if( m_report_level == DETAILED_REPORT && !results_collector.results( ts.p_id ).p_skipped )
+            return true;
+
+        m_formatter->test_unit_report_finish( ts, *m_stream );
+        return false;
+    }
+    void test_suite_finish( test_suite const& ts )
+    {
+        m_formatter->test_unit_report_finish( ts, *m_stream );
+    }
+
+    typedef scoped_ptr<io_saver_type> saver_ptr;
+
+
+    std::ostream* m_stream;
+    saver_ptr m_stream_state_saver;
+    report_level m_report_level;
+    scoped_ptr<format> m_formatter;
+};
+
+results_reporter_impl& s_rr_impl() { static results_reporter_impl the_inst; return the_inst; }
+
+}
+
+
+
+
+
+void
+set_level( report_level l )
+{
+    if( l != INV_REPORT_LEVEL )
+        s_rr_impl().m_report_level = l;
+}
+
+
+
+void
+set_stream( std::ostream& ostr )
+{
+    s_rr_impl().m_stream = &ostr;
+    s_rr_impl().m_stream_state_saver.reset( new io_saver_type( ostr ) );
+}
+
+
+
+std::ostream&
+get_stream()
+{
+    return *s_rr_impl().m_stream;
+}
+
+
+
+void
+set_format( output_format rf )
+{
+    switch( rf ) {
+    default:
+    case OF_CLF:
+        set_format( new output::plain_report_formatter );
+        break;
+    case OF_XML:
+        set_format( new output::xml_report_formatter );
+        break;
+    }
+}
+
+
+
+void
+set_format( results_reporter::format* f )
+{
+    if( f )
+        s_rr_impl().m_formatter.reset( f );
+}
+
+
+
+
+
+
+
+void
+make_report( report_level l, test_unit_id id )
+{
+    if( l == INV_REPORT_LEVEL )
+        l = s_rr_impl().m_report_level;
+
+    if( l == NO_REPORT )
+        return;
+
+    if( id == INV_TEST_UNIT_ID )
+        id = framework::master_test_suite().p_id;
+
+    s_rr_impl().m_stream_state_saver->restore();
+
+    report_level bkup = s_rr_impl().m_report_level;
+    s_rr_impl().m_report_level = l;
+
+    s_rr_impl().m_formatter->results_report_start( *s_rr_impl().m_stream );
+
+    switch( l ) {
+    case CONFIRMATION_REPORT:
+        s_rr_impl().m_formatter->do_confirmation_report( framework::get<test_unit>( id ), *s_rr_impl().m_stream );
+        break;
+    case SHORT_REPORT:
+    case DETAILED_REPORT:
+        traverse_test_tree( id, s_rr_impl() );
+        break;
+    default:
+        break;
+    }
+
+    s_rr_impl().m_formatter->results_report_finish( *s_rr_impl().m_stream );
+    s_rr_impl().m_report_level = bkup;
+}
+
+
+
+}
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 196 "/usr/include/boost/test/impl/results_reporter.ipp" 2 3 4
+# 28 "/usr/include/boost/test/included/unit_test.hpp" 2 3 4
+# 1 "/usr/include/boost/test/impl/test_framework_init_observer.ipp" 1 3 4
+# 13 "/usr/include/boost/test/impl/test_framework_init_observer.ipp" 3 4
+#define BOOST_TEST_FRAMEWORK_INIT_OBSERVER_IPP_021105GER 
+
+
+
+
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 19 "/usr/include/boost/test/impl/test_framework_init_observer.ipp" 2 3 4
+
+
+
+namespace boost {
+namespace unit_test {
+# 32 "/usr/include/boost/test/impl/test_framework_init_observer.ipp" 3 4
+namespace {
+
+struct test_init_observer_check {
+    bool has_failure;
+
+    void clear()
+    {
+      has_failure = false;
+    }
+};
+
+
+test_init_observer_check& s_tioc_impl() { static test_init_observer_check the_inst; return the_inst; }
+
+}
+
+
+
+
+
+framework_init_observer_t& framework_init_observer_t::instance() { static framework_init_observer_t the_inst; return the_inst; }
+
+
+
+void
+framework_init_observer_t::clear()
+{
+    if(!framework::test_in_progress())
+        s_tioc_impl().clear();
+}
+
+
+
+void
+framework_init_observer_t::test_start( counter_t )
+{
+    clear();
+}
+
+
+
+void
+framework_init_observer_t::assertion_result( unit_test::assertion_result ar )
+{
+    test_init_observer_check& tr = s_tioc_impl();
+    switch( ar ) {
+    case AR_TRIGGERED: break;
+    case AR_PASSED: break;
+    case AR_FAILED: tr.has_failure = true; break;
+    default:
+        break;
+    }
+}
+
+
+
+void
+framework_init_observer_t::exception_caught( execution_exception const& )
+{
+    test_init_observer_check& tr = s_tioc_impl();
+    tr.has_failure = true;
+}
+
+void
+framework_init_observer_t::test_aborted()
+{
+    s_tioc_impl().has_failure = true;
+}
+
+
+
+
+bool
+framework_init_observer_t::has_failed() const
+{
+    return s_tioc_impl().has_failure;
+}
+
+
+
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 116 "/usr/include/boost/test/impl/test_framework_init_observer.ipp" 2 3 4
+# 29 "/usr/include/boost/test/included/unit_test.hpp" 2 3 4
+# 1 "/usr/include/boost/test/impl/test_tools.ipp" 1 3 4
+# 16 "/usr/include/boost/test/impl/test_tools.ipp" 3 4
+#define BOOST_TEST_TEST_TOOLS_IPP_012205GER 
+
+
+# 1 "/usr/include/boost/test/test_tools.hpp" 1 3 4
+# 15 "/usr/include/boost/test/test_tools.hpp" 3 4
+#define BOOST_TEST_TOOLS_HPP_111812GER 
+# 42 "/usr/include/boost/test/test_tools.hpp" 3 4
+# 1 "/usr/include/boost/test/tools/context.hpp" 1 3 4
+# 16 "/usr/include/boost/test/tools/context.hpp" 3 4
+#define BOOST_TEST_TOOLS_CONTEXT_HPP_111712GER 
+
+
+
+# 1 "/usr/include/boost/test/detail/pp_variadic.hpp" 1 3 4
+# 13 "/usr/include/boost/test/detail/pp_variadic.hpp" 3 4
+#define BOOST_TEST_PP_VARIADIC_HPP_021515GER 
+
+
+
+# 1 "/usr/include/boost/preprocessor/comparison/equal.hpp" 1 3 4
+# 15 "/usr/include/boost/preprocessor/comparison/equal.hpp" 3 4
+#define BOOST_PREPROCESSOR_COMPARISON_EQUAL_HPP 
+
+# 1 "/usr/include/boost/preprocessor/comparison/not_equal.hpp" 1 3 4
+# 15 "/usr/include/boost/preprocessor/comparison/not_equal.hpp" 3 4
+#define BOOST_PREPROCESSOR_COMPARISON_NOT_EQUAL_HPP 
+# 24 "/usr/include/boost/preprocessor/comparison/not_equal.hpp" 3 4
+#define BOOST_PP_NOT_EQUAL(x,y) BOOST_PP_NOT_EQUAL_I(x, y)
+
+
+
+
+
+#define BOOST_PP_NOT_EQUAL_I(x,y) BOOST_PP_CAT(BOOST_PP_NOT_EQUAL_CHECK_, BOOST_PP_NOT_EQUAL_ ## x(0, BOOST_PP_NOT_EQUAL_ ## y))
+
+
+
+#define BOOST_PP_NOT_EQUAL_D(d,x,y) BOOST_PP_NOT_EQUAL(x, y)
+
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NIL 1
+
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_0(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_1(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_2(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_3(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_4(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_5(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_6(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_7(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_8(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_9(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_10(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_11(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_12(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_13(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_14(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_15(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_16(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_17(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_18(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_19(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_20(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_21(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_22(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_23(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_24(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_25(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_26(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_27(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_28(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_29(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_30(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_31(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_32(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_33(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_34(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_35(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_36(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_37(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_38(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_39(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_40(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_41(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_42(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_43(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_44(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_45(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_46(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_47(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_48(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_49(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_50(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_51(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_52(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_53(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_54(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_55(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_56(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_57(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_58(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_59(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_60(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_61(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_62(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_63(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_64(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_65(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_66(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_67(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_68(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_69(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_70(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_71(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_72(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_73(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_74(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_75(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_76(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_77(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_78(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_79(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_80(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_81(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_82(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_83(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_84(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_85(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_86(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_87(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_88(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_89(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_90(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_91(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_92(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_93(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_94(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_95(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_96(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_97(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_98(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_99(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_100(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_101(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_102(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_103(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_104(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_105(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_106(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_107(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_108(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_109(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_110(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_111(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_112(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_113(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_114(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_115(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_116(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_117(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_118(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_119(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_120(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_121(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_122(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_123(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_124(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_125(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_126(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_127(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_128(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_129(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_130(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_131(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_132(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_133(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_134(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_135(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_136(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_137(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_138(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_139(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_140(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_141(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_142(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_143(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_144(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_145(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_146(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_147(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_148(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_149(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_150(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_151(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_152(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_153(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_154(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_155(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_156(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_157(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_158(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_159(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_160(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_161(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_162(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_163(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_164(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_165(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_166(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_167(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_168(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_169(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_170(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_171(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_172(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_173(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_174(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_175(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_176(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_177(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_178(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_179(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_180(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_181(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_182(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_183(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_184(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_185(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_186(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_187(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_188(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_189(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_190(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_191(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_192(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_193(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_194(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_195(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_196(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_197(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_198(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_199(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_200(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_201(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_202(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_203(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_204(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_205(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_206(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_207(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_208(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_209(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_210(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_211(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_212(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_213(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_214(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_215(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_216(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_217(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_218(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_219(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_220(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_221(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_222(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_223(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_224(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_225(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_226(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_227(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_228(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_229(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_230(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_231(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_232(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_233(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_234(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_235(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_236(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_237(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_238(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_239(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_240(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_241(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_242(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_243(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_244(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_245(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_246(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_247(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_248(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_249(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_250(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_251(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_252(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_253(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_254(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_255(c,y) 0
+#define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_256(c,y) 0
+
+
+#define BOOST_PP_NOT_EQUAL_0(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_1(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_2(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_3(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_4(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_5(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_6(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_7(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_8(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_9(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_10(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_11(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_12(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_13(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_14(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_15(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_16(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_17(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_18(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_19(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_20(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_21(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_22(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_23(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_24(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_25(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_26(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_27(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_28(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_29(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_30(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_31(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_32(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_33(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_34(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_35(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_36(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_37(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_38(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_39(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_40(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_41(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_42(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_43(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_44(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_45(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_46(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_47(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_48(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_49(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_50(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_51(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_52(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_53(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_54(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_55(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_56(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_57(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_58(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_59(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_60(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_61(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_62(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_63(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_64(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_65(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_66(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_67(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_68(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_69(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_70(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_71(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_72(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_73(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_74(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_75(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_76(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_77(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_78(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_79(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_80(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_81(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_82(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_83(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_84(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_85(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_86(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_87(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_88(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_89(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_90(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_91(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_92(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_93(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_94(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_95(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_96(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_97(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_98(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_99(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_100(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_101(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_102(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_103(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_104(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_105(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_106(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_107(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_108(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_109(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_110(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_111(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_112(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_113(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_114(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_115(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_116(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_117(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_118(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_119(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_120(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_121(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_122(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_123(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_124(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_125(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_126(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_127(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_128(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_129(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_130(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_131(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_132(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_133(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_134(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_135(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_136(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_137(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_138(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_139(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_140(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_141(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_142(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_143(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_144(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_145(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_146(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_147(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_148(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_149(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_150(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_151(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_152(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_153(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_154(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_155(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_156(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_157(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_158(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_159(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_160(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_161(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_162(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_163(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_164(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_165(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_166(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_167(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_168(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_169(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_170(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_171(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_172(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_173(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_174(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_175(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_176(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_177(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_178(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_179(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_180(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_181(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_182(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_183(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_184(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_185(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_186(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_187(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_188(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_189(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_190(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_191(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_192(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_193(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_194(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_195(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_196(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_197(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_198(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_199(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_200(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_201(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_202(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_203(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_204(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_205(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_206(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_207(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_208(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_209(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_210(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_211(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_212(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_213(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_214(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_215(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_216(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_217(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_218(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_219(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_220(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_221(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_222(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_223(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_224(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_225(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_226(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_227(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_228(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_229(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_230(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_231(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_232(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_233(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_234(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_235(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_236(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_237(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_238(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_239(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_240(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_241(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_242(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_243(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_244(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_245(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_246(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_247(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_248(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_249(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_250(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_251(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_252(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_253(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_254(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_255(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+#define BOOST_PP_NOT_EQUAL_256(c,y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL))
+# 18 "/usr/include/boost/preprocessor/comparison/equal.hpp" 2 3 4
+
+
+
+
+
+
+#define BOOST_PP_EQUAL(x,y) BOOST_PP_COMPL(BOOST_PP_NOT_EQUAL(x, y))
+
+
+
+
+
+
+
+#define BOOST_PP_EQUAL_D(d,x,y) BOOST_PP_EQUAL(x, y)
+# 18 "/usr/include/boost/test/detail/pp_variadic.hpp" 2 3 4
+# 27 "/usr/include/boost/test/detail/pp_variadic.hpp" 3 4
+#define BOOST_TEST_INVOKE_VARIADIC(tool,...) tool (__VA_ARGS__)
+
+
+
+
+
+
+#define BOOST_TEST_INVOKE_IF_N_ARGS(N,F1,F2,...) BOOST_TEST_INVOKE_VARIADIC( BOOST_PP_IIF( BOOST_PP_EQUAL(BOOST_PP_VARIADIC_SIZE(__VA_ARGS__), N), F1, F2), __VA_ARGS__ )
+# 21 "/usr/include/boost/test/tools/context.hpp" 2 3 4
+
+
+# 1 "/usr/include/boost/preprocessor/repetition/enum_binary_params.hpp" 1 3 4
+# 13 "/usr/include/boost/preprocessor/repetition/enum_binary_params.hpp" 3 4
+#define BOOST_PREPROCESSOR_REPETITION_ENUM_BINARY_PARAMS_HPP 
+# 25 "/usr/include/boost/preprocessor/repetition/enum_binary_params.hpp" 3 4
+#define BOOST_PP_ENUM_BINARY_PARAMS(count,p1,p2) BOOST_PP_REPEAT(count, BOOST_PP_ENUM_BINARY_PARAMS_M, (p1, p2))
+
+
+
+
+
+
+#define BOOST_PP_ENUM_BINARY_PARAMS_M(z,n,pp) BOOST_PP_ENUM_BINARY_PARAMS_M_IM(z, n, BOOST_PP_TUPLE_REM_2 pp)
+#define BOOST_PP_ENUM_BINARY_PARAMS_M_IM(z,n,im) BOOST_PP_ENUM_BINARY_PARAMS_M_I(z, n, im)
+
+
+
+
+
+#define BOOST_PP_ENUM_BINARY_PARAMS_M_I(z,n,p1,p2) BOOST_PP_ENUM_BINARY_PARAMS_M_II(z, n, p1, p2)
+#define BOOST_PP_ENUM_BINARY_PARAMS_M_II(z,n,p1,p2) BOOST_PP_COMMA_IF(n) p1 ## n p2 ## n
+
+
+
+
+
+
+
+#define BOOST_PP_ENUM_BINARY_PARAMS_Z(z,count,p1,p2) BOOST_PP_REPEAT_ ## z(count, BOOST_PP_ENUM_BINARY_PARAMS_M, (p1, p2))
+# 24 "/usr/include/boost/test/tools/context.hpp" 2 3 4
+# 1 "/usr/include/boost/preprocessor/repetition/repeat_from_to.hpp" 1 3 4
+# 15 "/usr/include/boost/preprocessor/repetition/repeat_from_to.hpp" 3 4
+#define BOOST_PREPROCESSOR_REPETITION_REPEAT_FROM_TO_HPP 
+
+
+
+
+
+
+
+# 1 "/usr/include/boost/preprocessor/detail/auto_rec.hpp" 1 3 4
+# 24 "/usr/include/boost/preprocessor/repetition/repeat_from_to.hpp" 2 3 4
+# 34 "/usr/include/boost/preprocessor/repetition/repeat_from_to.hpp" 3 4
+#define BOOST_PP_REPEAT_FROM_TO BOOST_PP_CAT(BOOST_PP_REPEAT_FROM_TO_, BOOST_PP_AUTO_REC(BOOST_PP_REPEAT_P, 4))
+
+#define BOOST_PP_REPEAT_FROM_TO_1(f,l,m,dt) BOOST_PP_REPEAT_FROM_TO_D_1(BOOST_PP_AUTO_REC(BOOST_PP_WHILE_P, 256), f, l, m, dt)
+#define BOOST_PP_REPEAT_FROM_TO_2(f,l,m,dt) BOOST_PP_REPEAT_FROM_TO_D_2(BOOST_PP_AUTO_REC(BOOST_PP_WHILE_P, 256), f, l, m, dt)
+#define BOOST_PP_REPEAT_FROM_TO_3(f,l,m,dt) BOOST_PP_REPEAT_FROM_TO_D_3(BOOST_PP_AUTO_REC(BOOST_PP_WHILE_P, 256), f, l, m, dt)
+#define BOOST_PP_REPEAT_FROM_TO_4(f,l,m,dt) BOOST_PP_ERROR(0x0003)
+
+#define BOOST_PP_REPEAT_FROM_TO_1ST BOOST_PP_REPEAT_FROM_TO_1
+#define BOOST_PP_REPEAT_FROM_TO_2ND BOOST_PP_REPEAT_FROM_TO_2
+#define BOOST_PP_REPEAT_FROM_TO_3RD BOOST_PP_REPEAT_FROM_TO_3
+
+
+
+
+
+
+
+#define BOOST_PP_REPEAT_FROM_TO_D BOOST_PP_CAT(BOOST_PP_REPEAT_FROM_TO_D_, BOOST_PP_AUTO_REC(BOOST_PP_REPEAT_P, 4))
+
+
+#define BOOST_PP_REPEAT_FROM_TO_D_1(d,f,l,m,dt) BOOST_PP_REPEAT_1(BOOST_PP_SUB_D(d, l, f), BOOST_PP_REPEAT_FROM_TO_M_1, (d, f, m, dt))
+#define BOOST_PP_REPEAT_FROM_TO_D_2(d,f,l,m,dt) BOOST_PP_REPEAT_2(BOOST_PP_SUB_D(d, l, f), BOOST_PP_REPEAT_FROM_TO_M_2, (d, f, m, dt))
+#define BOOST_PP_REPEAT_FROM_TO_D_3(d,f,l,m,dt) BOOST_PP_REPEAT_3(BOOST_PP_SUB_D(d, l, f), BOOST_PP_REPEAT_FROM_TO_M_3, (d, f, m, dt))
+# 67 "/usr/include/boost/preprocessor/repetition/repeat_from_to.hpp" 3 4
+#define BOOST_PP_REPEAT_FROM_TO_M_1(z,n,dfmd) BOOST_PP_REPEAT_FROM_TO_M_1_IM(z, n, BOOST_PP_TUPLE_REM_4 dfmd)
+#define BOOST_PP_REPEAT_FROM_TO_M_2(z,n,dfmd) BOOST_PP_REPEAT_FROM_TO_M_2_IM(z, n, BOOST_PP_TUPLE_REM_4 dfmd)
+#define BOOST_PP_REPEAT_FROM_TO_M_3(z,n,dfmd) BOOST_PP_REPEAT_FROM_TO_M_3_IM(z, n, BOOST_PP_TUPLE_REM_4 dfmd)
+#define BOOST_PP_REPEAT_FROM_TO_M_1_IM(z,n,im) BOOST_PP_REPEAT_FROM_TO_M_1_I(z, n, im)
+#define BOOST_PP_REPEAT_FROM_TO_M_2_IM(z,n,im) BOOST_PP_REPEAT_FROM_TO_M_2_I(z, n, im)
+#define BOOST_PP_REPEAT_FROM_TO_M_3_IM(z,n,im) BOOST_PP_REPEAT_FROM_TO_M_3_I(z, n, im)
+
+
+
+
+
+
+#define BOOST_PP_REPEAT_FROM_TO_M_1_I(z,n,d,f,m,dt) BOOST_PP_REPEAT_FROM_TO_M_1_II(z, BOOST_PP_ADD_D(d, n, f), m, dt)
+#define BOOST_PP_REPEAT_FROM_TO_M_2_I(z,n,d,f,m,dt) BOOST_PP_REPEAT_FROM_TO_M_2_II(z, BOOST_PP_ADD_D(d, n, f), m, dt)
+#define BOOST_PP_REPEAT_FROM_TO_M_3_I(z,n,d,f,m,dt) BOOST_PP_REPEAT_FROM_TO_M_3_II(z, BOOST_PP_ADD_D(d, n, f), m, dt)
+
+#define BOOST_PP_REPEAT_FROM_TO_M_1_II(z,n,m,dt) m(z, n, dt)
+#define BOOST_PP_REPEAT_FROM_TO_M_2_II(z,n,m,dt) m(z, n, dt)
+#define BOOST_PP_REPEAT_FROM_TO_M_3_II(z,n,m,dt) m(z, n, dt)
+# 25 "/usr/include/boost/test/tools/context.hpp" 2 3 4
+
+# 1 "/usr/include/boost/preprocessor/variadic/to_seq.hpp" 1 3 4
+# 14 "/usr/include/boost/preprocessor/variadic/to_seq.hpp" 3 4
+#define BOOST_PREPROCESSOR_VARIADIC_TO_SEQ_HPP 
+
+
+# 1 "/usr/include/boost/preprocessor/tuple/to_seq.hpp" 1 3 4
+# 14 "/usr/include/boost/preprocessor/tuple/to_seq.hpp" 3 4
+#define BOOST_PREPROCESSOR_TUPLE_TO_SEQ_HPP 
+
+
+
+
+# 1 "/usr/include/boost/preprocessor/tuple/size.hpp" 1 3 4
+# 14 "/usr/include/boost/preprocessor/tuple/size.hpp" 3 4
+#define BOOST_PREPROCESSOR_TUPLE_SIZE_HPP 
+# 24 "/usr/include/boost/preprocessor/tuple/size.hpp" 3 4
+#define BOOST_PP_TUPLE_SIZE(tuple) BOOST_PP_VARIADIC_SIZE tuple
+# 20 "/usr/include/boost/preprocessor/tuple/to_seq.hpp" 2 3 4
+# 31 "/usr/include/boost/preprocessor/tuple/to_seq.hpp" 3 4
+#define BOOST_PP_TUPLE_TO_SEQ(...) BOOST_PP_OVERLOAD(BOOST_PP_TUPLE_TO_SEQ_O_, __VA_ARGS__)(__VA_ARGS__)
+#define BOOST_PP_TUPLE_TO_SEQ_O_1(tuple) BOOST_PP_CAT(BOOST_PP_TUPLE_TO_SEQ_, BOOST_PP_VARIADIC_SIZE tuple) tuple
+
+#define BOOST_PP_TUPLE_TO_SEQ_O_2(size,tuple) BOOST_PP_TUPLE_TO_SEQ_O_1(tuple)
+# 52 "/usr/include/boost/preprocessor/tuple/to_seq.hpp" 3 4
+#define BOOST_PP_TUPLE_TO_SEQ_0() ()
+
+#define BOOST_PP_TUPLE_TO_SEQ_1(e0) (e0)
+#define BOOST_PP_TUPLE_TO_SEQ_2(e0,e1) (e0)(e1)
+#define BOOST_PP_TUPLE_TO_SEQ_3(e0,e1,e2) (e0)(e1)(e2)
+#define BOOST_PP_TUPLE_TO_SEQ_4(e0,e1,e2,e3) (e0)(e1)(e2)(e3)
+#define BOOST_PP_TUPLE_TO_SEQ_5(e0,e1,e2,e3,e4) (e0)(e1)(e2)(e3)(e4)
+#define BOOST_PP_TUPLE_TO_SEQ_6(e0,e1,e2,e3,e4,e5) (e0)(e1)(e2)(e3)(e4)(e5)
+#define BOOST_PP_TUPLE_TO_SEQ_7(e0,e1,e2,e3,e4,e5,e6) (e0)(e1)(e2)(e3)(e4)(e5)(e6)
+#define BOOST_PP_TUPLE_TO_SEQ_8(e0,e1,e2,e3,e4,e5,e6,e7) (e0)(e1)(e2)(e3)(e4)(e5)(e6)(e7)
+#define BOOST_PP_TUPLE_TO_SEQ_9(e0,e1,e2,e3,e4,e5,e6,e7,e8) (e0)(e1)(e2)(e3)(e4)(e5)(e6)(e7)(e8)
+#define BOOST_PP_TUPLE_TO_SEQ_10(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9) (e0)(e1)(e2)(e3)(e4)(e5)(e6)(e7)(e8)(e9)
+#define BOOST_PP_TUPLE_TO_SEQ_11(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10) (e0)(e1)(e2)(e3)(e4)(e5)(e6)(e7)(e8)(e9)(e10)
+#define BOOST_PP_TUPLE_TO_SEQ_12(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11) (e0)(e1)(e2)(e3)(e4)(e5)(e6)(e7)(e8)(e9)(e10)(e11)
+#define BOOST_PP_TUPLE_TO_SEQ_13(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12) (e0)(e1)(e2)(e3)(e4)(e5)(e6)(e7)(e8)(e9)(e10)(e11)(e12)
+#define BOOST_PP_TUPLE_TO_SEQ_14(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13) (e0)(e1)(e2)(e3)(e4)(e5)(e6)(e7)(e8)(e9)(e10)(e11)(e12)(e13)
+#define BOOST_PP_TUPLE_TO_SEQ_15(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14) (e0)(e1)(e2)(e3)(e4)(e5)(e6)(e7)(e8)(e9)(e10)(e11)(e12)(e13)(e14)
+#define BOOST_PP_TUPLE_TO_SEQ_16(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15) (e0)(e1)(e2)(e3)(e4)(e5)(e6)(e7)(e8)(e9)(e10)(e11)(e12)(e13)(e14)(e15)
+#define BOOST_PP_TUPLE_TO_SEQ_17(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16) (e0)(e1)(e2)(e3)(e4)(e5)(e6)(e7)(e8)(e9)(e10)(e11)(e12)(e13)(e14)(e15)(e16)
+#define BOOST_PP_TUPLE_TO_SEQ_18(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17) (e0)(e1)(e2)(e3)(e4)(e5)(e6)(e7)(e8)(e9)(e10)(e11)(e12)(e13)(e14)(e15)(e16)(e17)
+#define BOOST_PP_TUPLE_TO_SEQ_19(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18) (e0)(e1)(e2)(e3)(e4)(e5)(e6)(e7)(e8)(e9)(e10)(e11)(e12)(e13)(e14)(e15)(e16)(e17)(e18)
+#define BOOST_PP_TUPLE_TO_SEQ_20(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19) (e0)(e1)(e2)(e3)(e4)(e5)(e6)(e7)(e8)(e9)(e10)(e11)(e12)(e13)(e14)(e15)(e16)(e17)(e18)(e19)
+#define BOOST_PP_TUPLE_TO_SEQ_21(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20) (e0)(e1)(e2)(e3)(e4)(e5)(e6)(e7)(e8)(e9)(e10)(e11)(e12)(e13)(e14)(e15)(e16)(e17)(e18)(e19)(e20)
+#define BOOST_PP_TUPLE_TO_SEQ_22(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21) (e0)(e1)(e2)(e3)(e4)(e5)(e6)(e7)(e8)(e9)(e10)(e11)(e12)(e13)(e14)(e15)(e16)(e17)(e18)(e19)(e20)(e21)
+#define BOOST_PP_TUPLE_TO_SEQ_23(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22) (e0)(e1)(e2)(e3)(e4)(e5)(e6)(e7)(e8)(e9)(e10)(e11)(e12)(e13)(e14)(e15)(e16)(e17)(e18)(e19)(e20)(e21)(e22)
+#define BOOST_PP_TUPLE_TO_SEQ_24(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23) (e0)(e1)(e2)(e3)(e4)(e5)(e6)(e7)(e8)(e9)(e10)(e11)(e12)(e13)(e14)(e15)(e16)(e17)(e18)(e19)(e20)(e21)(e22)(e23)
+#define BOOST_PP_TUPLE_TO_SEQ_25(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24) (e0)(e1)(e2)(e3)(e4)(e5)(e6)(e7)(e8)(e9)(e10)(e11)(e12)(e13)(e14)(e15)(e16)(e17)(e18)(e19)(e20)(e21)(e22)(e23)(e24)
+#define BOOST_PP_TUPLE_TO_SEQ_26(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25) (e0)(e1)(e2)(e3)(e4)(e5)(e6)(e7)(e8)(e9)(e10)(e11)(e12)(e13)(e14)(e15)(e16)(e17)(e18)(e19)(e20)(e21)(e22)(e23)(e24)(e25)
+#define BOOST_PP_TUPLE_TO_SEQ_27(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26) (e0)(e1)(e2)(e3)(e4)(e5)(e6)(e7)(e8)(e9)(e10)(e11)(e12)(e13)(e14)(e15)(e16)(e17)(e18)(e19)(e20)(e21)(e22)(e23)(e24)(e25)(e26)
+#define BOOST_PP_TUPLE_TO_SEQ_28(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27) (e0)(e1)(e2)(e3)(e4)(e5)(e6)(e7)(e8)(e9)(e10)(e11)(e12)(e13)(e14)(e15)(e16)(e17)(e18)(e19)(e20)(e21)(e22)(e23)(e24)(e25)(e26)(e27)
+#define BOOST_PP_TUPLE_TO_SEQ_29(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28) (e0)(e1)(e2)(e3)(e4)(e5)(e6)(e7)(e8)(e9)(e10)(e11)(e12)(e13)(e14)(e15)(e16)(e17)(e18)(e19)(e20)(e21)(e22)(e23)(e24)(e25)(e26)(e27)(e28)
+#define BOOST_PP_TUPLE_TO_SEQ_30(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29) (e0)(e1)(e2)(e3)(e4)(e5)(e6)(e7)(e8)(e9)(e10)(e11)(e12)(e13)(e14)(e15)(e16)(e17)(e18)(e19)(e20)(e21)(e22)(e23)(e24)(e25)(e26)(e27)(e28)(e29)
+#define BOOST_PP_TUPLE_TO_SEQ_31(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30) (e0)(e1)(e2)(e3)(e4)(e5)(e6)(e7)(e8)(e9)(e10)(e11)(e12)(e13)(e14)(e15)(e16)(e17)(e18)(e19)(e20)(e21)(e22)(e23)(e24)(e25)(e26)(e27)(e28)(e29)(e30)
+#define BOOST_PP_TUPLE_TO_SEQ_32(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31) (e0)(e1)(e2)(e3)(e4)(e5)(e6)(e7)(e8)(e9)(e10)(e11)(e12)(e13)(e14)(e15)(e16)(e17)(e18)(e19)(e20)(e21)(e22)(e23)(e24)(e25)(e26)(e27)(e28)(e29)(e30)(e31)
+#define BOOST_PP_TUPLE_TO_SEQ_33(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32) (e0)(e1)(e2)(e3)(e4)(e5)(e6)(e7)(e8)(e9)(e10)(e11)(e12)(e13)(e14)(e15)(e16)(e17)(e18)(e19)(e20)(e21)(e22)(e23)(e24)(e25)(e26)(e27)(e28)(e29)(e30)(e31)(e32)
+#define BOOST_PP_TUPLE_TO_SEQ_34(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33) (e0)(e1)(e2)(e3)(e4)(e5)(e6)(e7)(e8)(e9)(e10)(e11)(e12)(e13)(e14)(e15)(e16)(e17)(e18)(e19)(e20)(e21)(e22)(e23)(e24)(e25)(e26)(e27)(e28)(e29)(e30)(e31)(e32)(e33)
+#define BOOST_PP_TUPLE_TO_SEQ_35(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34) (e0)(e1)(e2)(e3)(e4)(e5)(e6)(e7)(e8)(e9)(e10)(e11)(e12)(e13)(e14)(e15)(e16)(e17)(e18)(e19)(e20)(e21)(e22)(e23)(e24)(e25)(e26)(e27)(e28)(e29)(e30)(e31)(e32)(e33)(e34)
+#define BOOST_PP_TUPLE_TO_SEQ_36(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35) (e0)(e1)(e2)(e3)(e4)(e5)(e6)(e7)(e8)(e9)(e10)(e11)(e12)(e13)(e14)(e15)(e16)(e17)(e18)(e19)(e20)(e21)(e22)(e23)(e24)(e25)(e26)(e27)(e28)(e29)(e30)(e31)(e32)(e33)(e34)(e35)
+#define BOOST_PP_TUPLE_TO_SEQ_37(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36) (e0)(e1)(e2)(e3)(e4)(e5)(e6)(e7)(e8)(e9)(e10)(e11)(e12)(e13)(e14)(e15)(e16)(e17)(e18)(e19)(e20)(e21)(e22)(e23)(e24)(e25)(e26)(e27)(e28)(e29)(e30)(e31)(e32)(e33)(e34)(e35)(e36)
+#define BOOST_PP_TUPLE_TO_SEQ_38(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37) (e0)(e1)(e2)(e3)(e4)(e5)(e6)(e7)(e8)(e9)(e10)(e11)(e12)(e13)(e14)(e15)(e16)(e17)(e18)(e19)(e20)(e21)(e22)(e23)(e24)(e25)(e26)(e27)(e28)(e29)(e30)(e31)(e32)(e33)(e34)(e35)(e36)(e37)
+#define BOOST_PP_TUPLE_TO_SEQ_39(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38) (e0)(e1)(e2)(e3)(e4)(e5)(e6)(e7)(e8)(e9)(e10)(e11)(e12)(e13)(e14)(e15)(e16)(e17)(e18)(e19)(e20)(e21)(e22)(e23)(e24)(e25)(e26)(e27)(e28)(e29)(e30)(e31)(e32)(e33)(e34)(e35)(e36)(e37)(e38)
+#define BOOST_PP_TUPLE_TO_SEQ_40(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39) (e0)(e1)(e2)(e3)(e4)(e5)(e6)(e7)(e8)(e9)(e10)(e11)(e12)(e13)(e14)(e15)(e16)(e17)(e18)(e19)(e20)(e21)(e22)(e23)(e24)(e25)(e26)(e27)(e28)(e29)(e30)(e31)(e32)(e33)(e34)(e35)(e36)(e37)(e38)(e39)
+#define BOOST_PP_TUPLE_TO_SEQ_41(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40) (e0)(e1)(e2)(e3)(e4)(e5)(e6)(e7)(e8)(e9)(e10)(e11)(e12)(e13)(e14)(e15)(e16)(e17)(e18)(e19)(e20)(e21)(e22)(e23)(e24)(e25)(e26)(e27)(e28)(e29)(e30)(e31)(e32)(e33)(e34)(e35)(e36)(e37)(e38)(e39)(e40)
+#define BOOST_PP_TUPLE_TO_SEQ_42(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41) (e0)(e1)(e2)(e3)(e4)(e5)(e6)(e7)(e8)(e9)(e10)(e11)(e12)(e13)(e14)(e15)(e16)(e17)(e18)(e19)(e20)(e21)(e22)(e23)(e24)(e25)(e26)(e27)(e28)(e29)(e30)(e31)(e32)(e33)(e34)(e35)(e36)(e37)(e38)(e39)(e40)(e41)
+#define BOOST_PP_TUPLE_TO_SEQ_43(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42) (e0)(e1)(e2)(e3)(e4)(e5)(e6)(e7)(e8)(e9)(e10)(e11)(e12)(e13)(e14)(e15)(e16)(e17)(e18)(e19)(e20)(e21)(e22)(e23)(e24)(e25)(e26)(e27)(e28)(e29)(e30)(e31)(e32)(e33)(e34)(e35)(e36)(e37)(e38)(e39)(e40)(e41)(e42)
+#define BOOST_PP_TUPLE_TO_SEQ_44(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43) (e0)(e1)(e2)(e3)(e4)(e5)(e6)(e7)(e8)(e9)(e10)(e11)(e12)(e13)(e14)(e15)(e16)(e17)(e18)(e19)(e20)(e21)(e22)(e23)(e24)(e25)(e26)(e27)(e28)(e29)(e30)(e31)(e32)(e33)(e34)(e35)(e36)(e37)(e38)(e39)(e40)(e41)(e42)(e43)
+#define BOOST_PP_TUPLE_TO_SEQ_45(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44) (e0)(e1)(e2)(e3)(e4)(e5)(e6)(e7)(e8)(e9)(e10)(e11)(e12)(e13)(e14)(e15)(e16)(e17)(e18)(e19)(e20)(e21)(e22)(e23)(e24)(e25)(e26)(e27)(e28)(e29)(e30)(e31)(e32)(e33)(e34)(e35)(e36)(e37)(e38)(e39)(e40)(e41)(e42)(e43)(e44)
+#define BOOST_PP_TUPLE_TO_SEQ_46(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45) (e0)(e1)(e2)(e3)(e4)(e5)(e6)(e7)(e8)(e9)(e10)(e11)(e12)(e13)(e14)(e15)(e16)(e17)(e18)(e19)(e20)(e21)(e22)(e23)(e24)(e25)(e26)(e27)(e28)(e29)(e30)(e31)(e32)(e33)(e34)(e35)(e36)(e37)(e38)(e39)(e40)(e41)(e42)(e43)(e44)(e45)
+#define BOOST_PP_TUPLE_TO_SEQ_47(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46) (e0)(e1)(e2)(e3)(e4)(e5)(e6)(e7)(e8)(e9)(e10)(e11)(e12)(e13)(e14)(e15)(e16)(e17)(e18)(e19)(e20)(e21)(e22)(e23)(e24)(e25)(e26)(e27)(e28)(e29)(e30)(e31)(e32)(e33)(e34)(e35)(e36)(e37)(e38)(e39)(e40)(e41)(e42)(e43)(e44)(e45)(e46)
+#define BOOST_PP_TUPLE_TO_SEQ_48(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47) (e0)(e1)(e2)(e3)(e4)(e5)(e6)(e7)(e8)(e9)(e10)(e11)(e12)(e13)(e14)(e15)(e16)(e17)(e18)(e19)(e20)(e21)(e22)(e23)(e24)(e25)(e26)(e27)(e28)(e29)(e30)(e31)(e32)(e33)(e34)(e35)(e36)(e37)(e38)(e39)(e40)(e41)(e42)(e43)(e44)(e45)(e46)(e47)
+#define BOOST_PP_TUPLE_TO_SEQ_49(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48) (e0)(e1)(e2)(e3)(e4)(e5)(e6)(e7)(e8)(e9)(e10)(e11)(e12)(e13)(e14)(e15)(e16)(e17)(e18)(e19)(e20)(e21)(e22)(e23)(e24)(e25)(e26)(e27)(e28)(e29)(e30)(e31)(e32)(e33)(e34)(e35)(e36)(e37)(e38)(e39)(e40)(e41)(e42)(e43)(e44)(e45)(e46)(e47)(e48)
+#define BOOST_PP_TUPLE_TO_SEQ_50(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49) (e0)(e1)(e2)(e3)(e4)(e5)(e6)(e7)(e8)(e9)(e10)(e11)(e12)(e13)(e14)(e15)(e16)(e17)(e18)(e19)(e20)(e21)(e22)(e23)(e24)(e25)(e26)(e27)(e28)(e29)(e30)(e31)(e32)(e33)(e34)(e35)(e36)(e37)(e38)(e39)(e40)(e41)(e42)(e43)(e44)(e45)(e46)(e47)(e48)(e49)
+#define BOOST_PP_TUPLE_TO_SEQ_51(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50) (e0)(e1)(e2)(e3)(e4)(e5)(e6)(e7)(e8)(e9)(e10)(e11)(e12)(e13)(e14)(e15)(e16)(e17)(e18)(e19)(e20)(e21)(e22)(e23)(e24)(e25)(e26)(e27)(e28)(e29)(e30)(e31)(e32)(e33)(e34)(e35)(e36)(e37)(e38)(e39)(e40)(e41)(e42)(e43)(e44)(e45)(e46)(e47)(e48)(e49)(e50)
+#define BOOST_PP_TUPLE_TO_SEQ_52(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51) (e0)(e1)(e2)(e3)(e4)(e5)(e6)(e7)(e8)(e9)(e10)(e11)(e12)(e13)(e14)(e15)(e16)(e17)(e18)(e19)(e20)(e21)(e22)(e23)(e24)(e25)(e26)(e27)(e28)(e29)(e30)(e31)(e32)(e33)(e34)(e35)(e36)(e37)(e38)(e39)(e40)(e41)(e42)(e43)(e44)(e45)(e46)(e47)(e48)(e49)(e50)(e51)
+#define BOOST_PP_TUPLE_TO_SEQ_53(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52) (e0)(e1)(e2)(e3)(e4)(e5)(e6)(e7)(e8)(e9)(e10)(e11)(e12)(e13)(e14)(e15)(e16)(e17)(e18)(e19)(e20)(e21)(e22)(e23)(e24)(e25)(e26)(e27)(e28)(e29)(e30)(e31)(e32)(e33)(e34)(e35)(e36)(e37)(e38)(e39)(e40)(e41)(e42)(e43)(e44)(e45)(e46)(e47)(e48)(e49)(e50)(e51)(e52)
+#define BOOST_PP_TUPLE_TO_SEQ_54(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53) (e0)(e1)(e2)(e3)(e4)(e5)(e6)(e7)(e8)(e9)(e10)(e11)(e12)(e13)(e14)(e15)(e16)(e17)(e18)(e19)(e20)(e21)(e22)(e23)(e24)(e25)(e26)(e27)(e28)(e29)(e30)(e31)(e32)(e33)(e34)(e35)(e36)(e37)(e38)(e39)(e40)(e41)(e42)(e43)(e44)(e45)(e46)(e47)(e48)(e49)(e50)(e51)(e52)(e53)
+#define BOOST_PP_TUPLE_TO_SEQ_55(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54) (e0)(e1)(e2)(e3)(e4)(e5)(e6)(e7)(e8)(e9)(e10)(e11)(e12)(e13)(e14)(e15)(e16)(e17)(e18)(e19)(e20)(e21)(e22)(e23)(e24)(e25)(e26)(e27)(e28)(e29)(e30)(e31)(e32)(e33)(e34)(e35)(e36)(e37)(e38)(e39)(e40)(e41)(e42)(e43)(e44)(e45)(e46)(e47)(e48)(e49)(e50)(e51)(e52)(e53)(e54)
+#define BOOST_PP_TUPLE_TO_SEQ_56(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55) (e0)(e1)(e2)(e3)(e4)(e5)(e6)(e7)(e8)(e9)(e10)(e11)(e12)(e13)(e14)(e15)(e16)(e17)(e18)(e19)(e20)(e21)(e22)(e23)(e24)(e25)(e26)(e27)(e28)(e29)(e30)(e31)(e32)(e33)(e34)(e35)(e36)(e37)(e38)(e39)(e40)(e41)(e42)(e43)(e44)(e45)(e46)(e47)(e48)(e49)(e50)(e51)(e52)(e53)(e54)(e55)
+#define BOOST_PP_TUPLE_TO_SEQ_57(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56) (e0)(e1)(e2)(e3)(e4)(e5)(e6)(e7)(e8)(e9)(e10)(e11)(e12)(e13)(e14)(e15)(e16)(e17)(e18)(e19)(e20)(e21)(e22)(e23)(e24)(e25)(e26)(e27)(e28)(e29)(e30)(e31)(e32)(e33)(e34)(e35)(e36)(e37)(e38)(e39)(e40)(e41)(e42)(e43)(e44)(e45)(e46)(e47)(e48)(e49)(e50)(e51)(e52)(e53)(e54)(e55)(e56)
+#define BOOST_PP_TUPLE_TO_SEQ_58(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57) (e0)(e1)(e2)(e3)(e4)(e5)(e6)(e7)(e8)(e9)(e10)(e11)(e12)(e13)(e14)(e15)(e16)(e17)(e18)(e19)(e20)(e21)(e22)(e23)(e24)(e25)(e26)(e27)(e28)(e29)(e30)(e31)(e32)(e33)(e34)(e35)(e36)(e37)(e38)(e39)(e40)(e41)(e42)(e43)(e44)(e45)(e46)(e47)(e48)(e49)(e50)(e51)(e52)(e53)(e54)(e55)(e56)(e57)
+#define BOOST_PP_TUPLE_TO_SEQ_59(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58) (e0)(e1)(e2)(e3)(e4)(e5)(e6)(e7)(e8)(e9)(e10)(e11)(e12)(e13)(e14)(e15)(e16)(e17)(e18)(e19)(e20)(e21)(e22)(e23)(e24)(e25)(e26)(e27)(e28)(e29)(e30)(e31)(e32)(e33)(e34)(e35)(e36)(e37)(e38)(e39)(e40)(e41)(e42)(e43)(e44)(e45)(e46)(e47)(e48)(e49)(e50)(e51)(e52)(e53)(e54)(e55)(e56)(e57)(e58)
+#define BOOST_PP_TUPLE_TO_SEQ_60(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59) (e0)(e1)(e2)(e3)(e4)(e5)(e6)(e7)(e8)(e9)(e10)(e11)(e12)(e13)(e14)(e15)(e16)(e17)(e18)(e19)(e20)(e21)(e22)(e23)(e24)(e25)(e26)(e27)(e28)(e29)(e30)(e31)(e32)(e33)(e34)(e35)(e36)(e37)(e38)(e39)(e40)(e41)(e42)(e43)(e44)(e45)(e46)(e47)(e48)(e49)(e50)(e51)(e52)(e53)(e54)(e55)(e56)(e57)(e58)(e59)
+#define BOOST_PP_TUPLE_TO_SEQ_61(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59,e60) (e0)(e1)(e2)(e3)(e4)(e5)(e6)(e7)(e8)(e9)(e10)(e11)(e12)(e13)(e14)(e15)(e16)(e17)(e18)(e19)(e20)(e21)(e22)(e23)(e24)(e25)(e26)(e27)(e28)(e29)(e30)(e31)(e32)(e33)(e34)(e35)(e36)(e37)(e38)(e39)(e40)(e41)(e42)(e43)(e44)(e45)(e46)(e47)(e48)(e49)(e50)(e51)(e52)(e53)(e54)(e55)(e56)(e57)(e58)(e59)(e60)
+#define BOOST_PP_TUPLE_TO_SEQ_62(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59,e60,e61) (e0)(e1)(e2)(e3)(e4)(e5)(e6)(e7)(e8)(e9)(e10)(e11)(e12)(e13)(e14)(e15)(e16)(e17)(e18)(e19)(e20)(e21)(e22)(e23)(e24)(e25)(e26)(e27)(e28)(e29)(e30)(e31)(e32)(e33)(e34)(e35)(e36)(e37)(e38)(e39)(e40)(e41)(e42)(e43)(e44)(e45)(e46)(e47)(e48)(e49)(e50)(e51)(e52)(e53)(e54)(e55)(e56)(e57)(e58)(e59)(e60)(e61)
+#define BOOST_PP_TUPLE_TO_SEQ_63(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59,e60,e61,e62) (e0)(e1)(e2)(e3)(e4)(e5)(e6)(e7)(e8)(e9)(e10)(e11)(e12)(e13)(e14)(e15)(e16)(e17)(e18)(e19)(e20)(e21)(e22)(e23)(e24)(e25)(e26)(e27)(e28)(e29)(e30)(e31)(e32)(e33)(e34)(e35)(e36)(e37)(e38)(e39)(e40)(e41)(e42)(e43)(e44)(e45)(e46)(e47)(e48)(e49)(e50)(e51)(e52)(e53)(e54)(e55)(e56)(e57)(e58)(e59)(e60)(e61)(e62)
+#define BOOST_PP_TUPLE_TO_SEQ_64(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51,e52,e53,e54,e55,e56,e57,e58,e59,e60,e61,e62,e63) (e0)(e1)(e2)(e3)(e4)(e5)(e6)(e7)(e8)(e9)(e10)(e11)(e12)(e13)(e14)(e15)(e16)(e17)(e18)(e19)(e20)(e21)(e22)(e23)(e24)(e25)(e26)(e27)(e28)(e29)(e30)(e31)(e32)(e33)(e34)(e35)(e36)(e37)(e38)(e39)(e40)(e41)(e42)(e43)(e44)(e45)(e46)(e47)(e48)(e49)(e50)(e51)(e52)(e53)(e54)(e55)(e56)(e57)(e58)(e59)(e60)(e61)(e62)(e63)
+# 18 "/usr/include/boost/preprocessor/variadic/to_seq.hpp" 2 3 4
+
+
+
+
+#define BOOST_PP_VARIADIC_TO_SEQ(...) BOOST_PP_TUPLE_TO_SEQ((__VA_ARGS__))
+# 27 "/usr/include/boost/test/tools/context.hpp" 2 3 4
+
+
+# 1 "/usr/include/boost/preprocessor/seq/for_each_i.hpp" 1 3 4
+# 13 "/usr/include/boost/preprocessor/seq/for_each_i.hpp" 3 4
+#define BOOST_PREPROCESSOR_SEQ_FOR_EACH_I_HPP 
+# 30 "/usr/include/boost/preprocessor/seq/for_each_i.hpp" 3 4
+#define BOOST_PP_SEQ_FOR_EACH_I(macro,data,seq) BOOST_PP_SEQ_FOR_EACH_I_DETAIL_CHECK(macro, data, seq)
+
+
+
+
+
+#define BOOST_PP_SEQ_FOR_EACH_I_DETAIL_CHECK_EXEC(macro,data,seq) BOOST_PP_FOR((macro, data, seq, 0, BOOST_PP_SEQ_SIZE(seq)), BOOST_PP_SEQ_FOR_EACH_I_P, BOOST_PP_SEQ_FOR_EACH_I_O, BOOST_PP_SEQ_FOR_EACH_I_M)
+#define BOOST_PP_SEQ_FOR_EACH_I_DETAIL_CHECK_EMPTY(macro,data,seq) 
+
+#define BOOST_PP_SEQ_FOR_EACH_I_DETAIL_CHECK(macro,data,seq) BOOST_PP_IIF ( BOOST_PP_SEQ_DETAIL_IS_NOT_EMPTY(seq), BOOST_PP_SEQ_FOR_EACH_I_DETAIL_CHECK_EXEC, BOOST_PP_SEQ_FOR_EACH_I_DETAIL_CHECK_EMPTY ) (macro, data, seq)
+# 49 "/usr/include/boost/preprocessor/seq/for_each_i.hpp" 3 4
+#define BOOST_PP_SEQ_FOR_EACH_I_P(r,x) BOOST_PP_TUPLE_ELEM(5, 4, x)
+
+
+#define BOOST_PP_SEQ_FOR_EACH_I_O(r,x) BOOST_PP_SEQ_FOR_EACH_I_O_I x
+
+
+
+
+#define BOOST_PP_SEQ_FOR_EACH_I_O_I(macro,data,seq,i,sz) BOOST_PP_SEQ_FOR_EACH_I_O_I_DEC(macro, data, seq, i, BOOST_PP_DEC(sz))
+
+
+#define BOOST_PP_SEQ_FOR_EACH_I_O_I_DEC(macro,data,seq,i,sz) ( macro, data, BOOST_PP_IF ( sz, BOOST_PP_SEQ_FOR_EACH_I_O_I_TAIL, BOOST_PP_SEQ_FOR_EACH_I_O_I_NIL ) (seq), BOOST_PP_INC(i), sz )
+# 75 "/usr/include/boost/preprocessor/seq/for_each_i.hpp" 3 4
+#define BOOST_PP_SEQ_FOR_EACH_I_O_I_TAIL(seq) BOOST_PP_SEQ_TAIL(seq)
+#define BOOST_PP_SEQ_FOR_EACH_I_O_I_NIL(seq) BOOST_PP_NIL
+
+
+#define BOOST_PP_SEQ_FOR_EACH_I_M(r,x) BOOST_PP_SEQ_FOR_EACH_I_M_IM(r, BOOST_PP_TUPLE_REM_5 x)
+#define BOOST_PP_SEQ_FOR_EACH_I_M_IM(r,im) BOOST_PP_SEQ_FOR_EACH_I_M_I(r, im)
+
+
+
+
+#define BOOST_PP_SEQ_FOR_EACH_I_M_I(r,macro,data,seq,i,sz) macro(r, data, i, BOOST_PP_SEQ_HEAD(seq))
+
+
+
+
+#define BOOST_PP_SEQ_FOR_EACH_I_R(r,macro,data,seq) BOOST_PP_SEQ_FOR_EACH_I_R_DETAIL_CHECK(r, macro, data, seq)
+
+
+
+
+
+#define BOOST_PP_SEQ_FOR_EACH_I_R_DETAIL_CHECK_EXEC(r,macro,data,seq) BOOST_PP_FOR_ ## r((macro, data, seq, 0, BOOST_PP_SEQ_SIZE(seq)), BOOST_PP_SEQ_FOR_EACH_I_P, BOOST_PP_SEQ_FOR_EACH_I_O, BOOST_PP_SEQ_FOR_EACH_I_M)
+#define BOOST_PP_SEQ_FOR_EACH_I_R_DETAIL_CHECK_EMPTY(r,macro,data,seq) 
+
+#define BOOST_PP_SEQ_FOR_EACH_I_R_DETAIL_CHECK(r,macro,data,seq) BOOST_PP_IIF ( BOOST_PP_SEQ_DETAIL_IS_NOT_EMPTY(seq), BOOST_PP_SEQ_FOR_EACH_I_R_DETAIL_CHECK_EXEC, BOOST_PP_SEQ_FOR_EACH_I_R_DETAIL_CHECK_EMPTY ) (r, macro, data, seq)
+# 30 "/usr/include/boost/test/tools/context.hpp" 2 3 4
+
+# 1 "/usr/include/boost/preprocessor/seq/enum.hpp" 1 3 4
+# 13 "/usr/include/boost/preprocessor/seq/enum.hpp" 3 4
+#define BOOST_PREPROCESSOR_SEQ_ENUM_HPP 
+# 28 "/usr/include/boost/preprocessor/seq/enum.hpp" 3 4
+#define BOOST_PP_SEQ_ENUM(seq) BOOST_PP_CAT(BOOST_PP_SEQ_ENUM_, BOOST_PP_SEQ_SIZE(seq)) seq
+
+
+#define BOOST_PP_SEQ_ENUM_1(x) x
+#define BOOST_PP_SEQ_ENUM_2(x) x, BOOST_PP_SEQ_ENUM_1
+#define BOOST_PP_SEQ_ENUM_3(x) x, BOOST_PP_SEQ_ENUM_2
+#define BOOST_PP_SEQ_ENUM_4(x) x, BOOST_PP_SEQ_ENUM_3
+#define BOOST_PP_SEQ_ENUM_5(x) x, BOOST_PP_SEQ_ENUM_4
+#define BOOST_PP_SEQ_ENUM_6(x) x, BOOST_PP_SEQ_ENUM_5
+#define BOOST_PP_SEQ_ENUM_7(x) x, BOOST_PP_SEQ_ENUM_6
+#define BOOST_PP_SEQ_ENUM_8(x) x, BOOST_PP_SEQ_ENUM_7
+#define BOOST_PP_SEQ_ENUM_9(x) x, BOOST_PP_SEQ_ENUM_8
+#define BOOST_PP_SEQ_ENUM_10(x) x, BOOST_PP_SEQ_ENUM_9
+#define BOOST_PP_SEQ_ENUM_11(x) x, BOOST_PP_SEQ_ENUM_10
+#define BOOST_PP_SEQ_ENUM_12(x) x, BOOST_PP_SEQ_ENUM_11
+#define BOOST_PP_SEQ_ENUM_13(x) x, BOOST_PP_SEQ_ENUM_12
+#define BOOST_PP_SEQ_ENUM_14(x) x, BOOST_PP_SEQ_ENUM_13
+#define BOOST_PP_SEQ_ENUM_15(x) x, BOOST_PP_SEQ_ENUM_14
+#define BOOST_PP_SEQ_ENUM_16(x) x, BOOST_PP_SEQ_ENUM_15
+#define BOOST_PP_SEQ_ENUM_17(x) x, BOOST_PP_SEQ_ENUM_16
+#define BOOST_PP_SEQ_ENUM_18(x) x, BOOST_PP_SEQ_ENUM_17
+#define BOOST_PP_SEQ_ENUM_19(x) x, BOOST_PP_SEQ_ENUM_18
+#define BOOST_PP_SEQ_ENUM_20(x) x, BOOST_PP_SEQ_ENUM_19
+#define BOOST_PP_SEQ_ENUM_21(x) x, BOOST_PP_SEQ_ENUM_20
+#define BOOST_PP_SEQ_ENUM_22(x) x, BOOST_PP_SEQ_ENUM_21
+#define BOOST_PP_SEQ_ENUM_23(x) x, BOOST_PP_SEQ_ENUM_22
+#define BOOST_PP_SEQ_ENUM_24(x) x, BOOST_PP_SEQ_ENUM_23
+#define BOOST_PP_SEQ_ENUM_25(x) x, BOOST_PP_SEQ_ENUM_24
+#define BOOST_PP_SEQ_ENUM_26(x) x, BOOST_PP_SEQ_ENUM_25
+#define BOOST_PP_SEQ_ENUM_27(x) x, BOOST_PP_SEQ_ENUM_26
+#define BOOST_PP_SEQ_ENUM_28(x) x, BOOST_PP_SEQ_ENUM_27
+#define BOOST_PP_SEQ_ENUM_29(x) x, BOOST_PP_SEQ_ENUM_28
+#define BOOST_PP_SEQ_ENUM_30(x) x, BOOST_PP_SEQ_ENUM_29
+#define BOOST_PP_SEQ_ENUM_31(x) x, BOOST_PP_SEQ_ENUM_30
+#define BOOST_PP_SEQ_ENUM_32(x) x, BOOST_PP_SEQ_ENUM_31
+#define BOOST_PP_SEQ_ENUM_33(x) x, BOOST_PP_SEQ_ENUM_32
+#define BOOST_PP_SEQ_ENUM_34(x) x, BOOST_PP_SEQ_ENUM_33
+#define BOOST_PP_SEQ_ENUM_35(x) x, BOOST_PP_SEQ_ENUM_34
+#define BOOST_PP_SEQ_ENUM_36(x) x, BOOST_PP_SEQ_ENUM_35
+#define BOOST_PP_SEQ_ENUM_37(x) x, BOOST_PP_SEQ_ENUM_36
+#define BOOST_PP_SEQ_ENUM_38(x) x, BOOST_PP_SEQ_ENUM_37
+#define BOOST_PP_SEQ_ENUM_39(x) x, BOOST_PP_SEQ_ENUM_38
+#define BOOST_PP_SEQ_ENUM_40(x) x, BOOST_PP_SEQ_ENUM_39
+#define BOOST_PP_SEQ_ENUM_41(x) x, BOOST_PP_SEQ_ENUM_40
+#define BOOST_PP_SEQ_ENUM_42(x) x, BOOST_PP_SEQ_ENUM_41
+#define BOOST_PP_SEQ_ENUM_43(x) x, BOOST_PP_SEQ_ENUM_42
+#define BOOST_PP_SEQ_ENUM_44(x) x, BOOST_PP_SEQ_ENUM_43
+#define BOOST_PP_SEQ_ENUM_45(x) x, BOOST_PP_SEQ_ENUM_44
+#define BOOST_PP_SEQ_ENUM_46(x) x, BOOST_PP_SEQ_ENUM_45
+#define BOOST_PP_SEQ_ENUM_47(x) x, BOOST_PP_SEQ_ENUM_46
+#define BOOST_PP_SEQ_ENUM_48(x) x, BOOST_PP_SEQ_ENUM_47
+#define BOOST_PP_SEQ_ENUM_49(x) x, BOOST_PP_SEQ_ENUM_48
+#define BOOST_PP_SEQ_ENUM_50(x) x, BOOST_PP_SEQ_ENUM_49
+#define BOOST_PP_SEQ_ENUM_51(x) x, BOOST_PP_SEQ_ENUM_50
+#define BOOST_PP_SEQ_ENUM_52(x) x, BOOST_PP_SEQ_ENUM_51
+#define BOOST_PP_SEQ_ENUM_53(x) x, BOOST_PP_SEQ_ENUM_52
+#define BOOST_PP_SEQ_ENUM_54(x) x, BOOST_PP_SEQ_ENUM_53
+#define BOOST_PP_SEQ_ENUM_55(x) x, BOOST_PP_SEQ_ENUM_54
+#define BOOST_PP_SEQ_ENUM_56(x) x, BOOST_PP_SEQ_ENUM_55
+#define BOOST_PP_SEQ_ENUM_57(x) x, BOOST_PP_SEQ_ENUM_56
+#define BOOST_PP_SEQ_ENUM_58(x) x, BOOST_PP_SEQ_ENUM_57
+#define BOOST_PP_SEQ_ENUM_59(x) x, BOOST_PP_SEQ_ENUM_58
+#define BOOST_PP_SEQ_ENUM_60(x) x, BOOST_PP_SEQ_ENUM_59
+#define BOOST_PP_SEQ_ENUM_61(x) x, BOOST_PP_SEQ_ENUM_60
+#define BOOST_PP_SEQ_ENUM_62(x) x, BOOST_PP_SEQ_ENUM_61
+#define BOOST_PP_SEQ_ENUM_63(x) x, BOOST_PP_SEQ_ENUM_62
+#define BOOST_PP_SEQ_ENUM_64(x) x, BOOST_PP_SEQ_ENUM_63
+#define BOOST_PP_SEQ_ENUM_65(x) x, BOOST_PP_SEQ_ENUM_64
+#define BOOST_PP_SEQ_ENUM_66(x) x, BOOST_PP_SEQ_ENUM_65
+#define BOOST_PP_SEQ_ENUM_67(x) x, BOOST_PP_SEQ_ENUM_66
+#define BOOST_PP_SEQ_ENUM_68(x) x, BOOST_PP_SEQ_ENUM_67
+#define BOOST_PP_SEQ_ENUM_69(x) x, BOOST_PP_SEQ_ENUM_68
+#define BOOST_PP_SEQ_ENUM_70(x) x, BOOST_PP_SEQ_ENUM_69
+#define BOOST_PP_SEQ_ENUM_71(x) x, BOOST_PP_SEQ_ENUM_70
+#define BOOST_PP_SEQ_ENUM_72(x) x, BOOST_PP_SEQ_ENUM_71
+#define BOOST_PP_SEQ_ENUM_73(x) x, BOOST_PP_SEQ_ENUM_72
+#define BOOST_PP_SEQ_ENUM_74(x) x, BOOST_PP_SEQ_ENUM_73
+#define BOOST_PP_SEQ_ENUM_75(x) x, BOOST_PP_SEQ_ENUM_74
+#define BOOST_PP_SEQ_ENUM_76(x) x, BOOST_PP_SEQ_ENUM_75
+#define BOOST_PP_SEQ_ENUM_77(x) x, BOOST_PP_SEQ_ENUM_76
+#define BOOST_PP_SEQ_ENUM_78(x) x, BOOST_PP_SEQ_ENUM_77
+#define BOOST_PP_SEQ_ENUM_79(x) x, BOOST_PP_SEQ_ENUM_78
+#define BOOST_PP_SEQ_ENUM_80(x) x, BOOST_PP_SEQ_ENUM_79
+#define BOOST_PP_SEQ_ENUM_81(x) x, BOOST_PP_SEQ_ENUM_80
+#define BOOST_PP_SEQ_ENUM_82(x) x, BOOST_PP_SEQ_ENUM_81
+#define BOOST_PP_SEQ_ENUM_83(x) x, BOOST_PP_SEQ_ENUM_82
+#define BOOST_PP_SEQ_ENUM_84(x) x, BOOST_PP_SEQ_ENUM_83
+#define BOOST_PP_SEQ_ENUM_85(x) x, BOOST_PP_SEQ_ENUM_84
+#define BOOST_PP_SEQ_ENUM_86(x) x, BOOST_PP_SEQ_ENUM_85
+#define BOOST_PP_SEQ_ENUM_87(x) x, BOOST_PP_SEQ_ENUM_86
+#define BOOST_PP_SEQ_ENUM_88(x) x, BOOST_PP_SEQ_ENUM_87
+#define BOOST_PP_SEQ_ENUM_89(x) x, BOOST_PP_SEQ_ENUM_88
+#define BOOST_PP_SEQ_ENUM_90(x) x, BOOST_PP_SEQ_ENUM_89
+#define BOOST_PP_SEQ_ENUM_91(x) x, BOOST_PP_SEQ_ENUM_90
+#define BOOST_PP_SEQ_ENUM_92(x) x, BOOST_PP_SEQ_ENUM_91
+#define BOOST_PP_SEQ_ENUM_93(x) x, BOOST_PP_SEQ_ENUM_92
+#define BOOST_PP_SEQ_ENUM_94(x) x, BOOST_PP_SEQ_ENUM_93
+#define BOOST_PP_SEQ_ENUM_95(x) x, BOOST_PP_SEQ_ENUM_94
+#define BOOST_PP_SEQ_ENUM_96(x) x, BOOST_PP_SEQ_ENUM_95
+#define BOOST_PP_SEQ_ENUM_97(x) x, BOOST_PP_SEQ_ENUM_96
+#define BOOST_PP_SEQ_ENUM_98(x) x, BOOST_PP_SEQ_ENUM_97
+#define BOOST_PP_SEQ_ENUM_99(x) x, BOOST_PP_SEQ_ENUM_98
+#define BOOST_PP_SEQ_ENUM_100(x) x, BOOST_PP_SEQ_ENUM_99
+#define BOOST_PP_SEQ_ENUM_101(x) x, BOOST_PP_SEQ_ENUM_100
+#define BOOST_PP_SEQ_ENUM_102(x) x, BOOST_PP_SEQ_ENUM_101
+#define BOOST_PP_SEQ_ENUM_103(x) x, BOOST_PP_SEQ_ENUM_102
+#define BOOST_PP_SEQ_ENUM_104(x) x, BOOST_PP_SEQ_ENUM_103
+#define BOOST_PP_SEQ_ENUM_105(x) x, BOOST_PP_SEQ_ENUM_104
+#define BOOST_PP_SEQ_ENUM_106(x) x, BOOST_PP_SEQ_ENUM_105
+#define BOOST_PP_SEQ_ENUM_107(x) x, BOOST_PP_SEQ_ENUM_106
+#define BOOST_PP_SEQ_ENUM_108(x) x, BOOST_PP_SEQ_ENUM_107
+#define BOOST_PP_SEQ_ENUM_109(x) x, BOOST_PP_SEQ_ENUM_108
+#define BOOST_PP_SEQ_ENUM_110(x) x, BOOST_PP_SEQ_ENUM_109
+#define BOOST_PP_SEQ_ENUM_111(x) x, BOOST_PP_SEQ_ENUM_110
+#define BOOST_PP_SEQ_ENUM_112(x) x, BOOST_PP_SEQ_ENUM_111
+#define BOOST_PP_SEQ_ENUM_113(x) x, BOOST_PP_SEQ_ENUM_112
+#define BOOST_PP_SEQ_ENUM_114(x) x, BOOST_PP_SEQ_ENUM_113
+#define BOOST_PP_SEQ_ENUM_115(x) x, BOOST_PP_SEQ_ENUM_114
+#define BOOST_PP_SEQ_ENUM_116(x) x, BOOST_PP_SEQ_ENUM_115
+#define BOOST_PP_SEQ_ENUM_117(x) x, BOOST_PP_SEQ_ENUM_116
+#define BOOST_PP_SEQ_ENUM_118(x) x, BOOST_PP_SEQ_ENUM_117
+#define BOOST_PP_SEQ_ENUM_119(x) x, BOOST_PP_SEQ_ENUM_118
+#define BOOST_PP_SEQ_ENUM_120(x) x, BOOST_PP_SEQ_ENUM_119
+#define BOOST_PP_SEQ_ENUM_121(x) x, BOOST_PP_SEQ_ENUM_120
+#define BOOST_PP_SEQ_ENUM_122(x) x, BOOST_PP_SEQ_ENUM_121
+#define BOOST_PP_SEQ_ENUM_123(x) x, BOOST_PP_SEQ_ENUM_122
+#define BOOST_PP_SEQ_ENUM_124(x) x, BOOST_PP_SEQ_ENUM_123
+#define BOOST_PP_SEQ_ENUM_125(x) x, BOOST_PP_SEQ_ENUM_124
+#define BOOST_PP_SEQ_ENUM_126(x) x, BOOST_PP_SEQ_ENUM_125
+#define BOOST_PP_SEQ_ENUM_127(x) x, BOOST_PP_SEQ_ENUM_126
+#define BOOST_PP_SEQ_ENUM_128(x) x, BOOST_PP_SEQ_ENUM_127
+#define BOOST_PP_SEQ_ENUM_129(x) x, BOOST_PP_SEQ_ENUM_128
+#define BOOST_PP_SEQ_ENUM_130(x) x, BOOST_PP_SEQ_ENUM_129
+#define BOOST_PP_SEQ_ENUM_131(x) x, BOOST_PP_SEQ_ENUM_130
+#define BOOST_PP_SEQ_ENUM_132(x) x, BOOST_PP_SEQ_ENUM_131
+#define BOOST_PP_SEQ_ENUM_133(x) x, BOOST_PP_SEQ_ENUM_132
+#define BOOST_PP_SEQ_ENUM_134(x) x, BOOST_PP_SEQ_ENUM_133
+#define BOOST_PP_SEQ_ENUM_135(x) x, BOOST_PP_SEQ_ENUM_134
+#define BOOST_PP_SEQ_ENUM_136(x) x, BOOST_PP_SEQ_ENUM_135
+#define BOOST_PP_SEQ_ENUM_137(x) x, BOOST_PP_SEQ_ENUM_136
+#define BOOST_PP_SEQ_ENUM_138(x) x, BOOST_PP_SEQ_ENUM_137
+#define BOOST_PP_SEQ_ENUM_139(x) x, BOOST_PP_SEQ_ENUM_138
+#define BOOST_PP_SEQ_ENUM_140(x) x, BOOST_PP_SEQ_ENUM_139
+#define BOOST_PP_SEQ_ENUM_141(x) x, BOOST_PP_SEQ_ENUM_140
+#define BOOST_PP_SEQ_ENUM_142(x) x, BOOST_PP_SEQ_ENUM_141
+#define BOOST_PP_SEQ_ENUM_143(x) x, BOOST_PP_SEQ_ENUM_142
+#define BOOST_PP_SEQ_ENUM_144(x) x, BOOST_PP_SEQ_ENUM_143
+#define BOOST_PP_SEQ_ENUM_145(x) x, BOOST_PP_SEQ_ENUM_144
+#define BOOST_PP_SEQ_ENUM_146(x) x, BOOST_PP_SEQ_ENUM_145
+#define BOOST_PP_SEQ_ENUM_147(x) x, BOOST_PP_SEQ_ENUM_146
+#define BOOST_PP_SEQ_ENUM_148(x) x, BOOST_PP_SEQ_ENUM_147
+#define BOOST_PP_SEQ_ENUM_149(x) x, BOOST_PP_SEQ_ENUM_148
+#define BOOST_PP_SEQ_ENUM_150(x) x, BOOST_PP_SEQ_ENUM_149
+#define BOOST_PP_SEQ_ENUM_151(x) x, BOOST_PP_SEQ_ENUM_150
+#define BOOST_PP_SEQ_ENUM_152(x) x, BOOST_PP_SEQ_ENUM_151
+#define BOOST_PP_SEQ_ENUM_153(x) x, BOOST_PP_SEQ_ENUM_152
+#define BOOST_PP_SEQ_ENUM_154(x) x, BOOST_PP_SEQ_ENUM_153
+#define BOOST_PP_SEQ_ENUM_155(x) x, BOOST_PP_SEQ_ENUM_154
+#define BOOST_PP_SEQ_ENUM_156(x) x, BOOST_PP_SEQ_ENUM_155
+#define BOOST_PP_SEQ_ENUM_157(x) x, BOOST_PP_SEQ_ENUM_156
+#define BOOST_PP_SEQ_ENUM_158(x) x, BOOST_PP_SEQ_ENUM_157
+#define BOOST_PP_SEQ_ENUM_159(x) x, BOOST_PP_SEQ_ENUM_158
+#define BOOST_PP_SEQ_ENUM_160(x) x, BOOST_PP_SEQ_ENUM_159
+#define BOOST_PP_SEQ_ENUM_161(x) x, BOOST_PP_SEQ_ENUM_160
+#define BOOST_PP_SEQ_ENUM_162(x) x, BOOST_PP_SEQ_ENUM_161
+#define BOOST_PP_SEQ_ENUM_163(x) x, BOOST_PP_SEQ_ENUM_162
+#define BOOST_PP_SEQ_ENUM_164(x) x, BOOST_PP_SEQ_ENUM_163
+#define BOOST_PP_SEQ_ENUM_165(x) x, BOOST_PP_SEQ_ENUM_164
+#define BOOST_PP_SEQ_ENUM_166(x) x, BOOST_PP_SEQ_ENUM_165
+#define BOOST_PP_SEQ_ENUM_167(x) x, BOOST_PP_SEQ_ENUM_166
+#define BOOST_PP_SEQ_ENUM_168(x) x, BOOST_PP_SEQ_ENUM_167
+#define BOOST_PP_SEQ_ENUM_169(x) x, BOOST_PP_SEQ_ENUM_168
+#define BOOST_PP_SEQ_ENUM_170(x) x, BOOST_PP_SEQ_ENUM_169
+#define BOOST_PP_SEQ_ENUM_171(x) x, BOOST_PP_SEQ_ENUM_170
+#define BOOST_PP_SEQ_ENUM_172(x) x, BOOST_PP_SEQ_ENUM_171
+#define BOOST_PP_SEQ_ENUM_173(x) x, BOOST_PP_SEQ_ENUM_172
+#define BOOST_PP_SEQ_ENUM_174(x) x, BOOST_PP_SEQ_ENUM_173
+#define BOOST_PP_SEQ_ENUM_175(x) x, BOOST_PP_SEQ_ENUM_174
+#define BOOST_PP_SEQ_ENUM_176(x) x, BOOST_PP_SEQ_ENUM_175
+#define BOOST_PP_SEQ_ENUM_177(x) x, BOOST_PP_SEQ_ENUM_176
+#define BOOST_PP_SEQ_ENUM_178(x) x, BOOST_PP_SEQ_ENUM_177
+#define BOOST_PP_SEQ_ENUM_179(x) x, BOOST_PP_SEQ_ENUM_178
+#define BOOST_PP_SEQ_ENUM_180(x) x, BOOST_PP_SEQ_ENUM_179
+#define BOOST_PP_SEQ_ENUM_181(x) x, BOOST_PP_SEQ_ENUM_180
+#define BOOST_PP_SEQ_ENUM_182(x) x, BOOST_PP_SEQ_ENUM_181
+#define BOOST_PP_SEQ_ENUM_183(x) x, BOOST_PP_SEQ_ENUM_182
+#define BOOST_PP_SEQ_ENUM_184(x) x, BOOST_PP_SEQ_ENUM_183
+#define BOOST_PP_SEQ_ENUM_185(x) x, BOOST_PP_SEQ_ENUM_184
+#define BOOST_PP_SEQ_ENUM_186(x) x, BOOST_PP_SEQ_ENUM_185
+#define BOOST_PP_SEQ_ENUM_187(x) x, BOOST_PP_SEQ_ENUM_186
+#define BOOST_PP_SEQ_ENUM_188(x) x, BOOST_PP_SEQ_ENUM_187
+#define BOOST_PP_SEQ_ENUM_189(x) x, BOOST_PP_SEQ_ENUM_188
+#define BOOST_PP_SEQ_ENUM_190(x) x, BOOST_PP_SEQ_ENUM_189
+#define BOOST_PP_SEQ_ENUM_191(x) x, BOOST_PP_SEQ_ENUM_190
+#define BOOST_PP_SEQ_ENUM_192(x) x, BOOST_PP_SEQ_ENUM_191
+#define BOOST_PP_SEQ_ENUM_193(x) x, BOOST_PP_SEQ_ENUM_192
+#define BOOST_PP_SEQ_ENUM_194(x) x, BOOST_PP_SEQ_ENUM_193
+#define BOOST_PP_SEQ_ENUM_195(x) x, BOOST_PP_SEQ_ENUM_194
+#define BOOST_PP_SEQ_ENUM_196(x) x, BOOST_PP_SEQ_ENUM_195
+#define BOOST_PP_SEQ_ENUM_197(x) x, BOOST_PP_SEQ_ENUM_196
+#define BOOST_PP_SEQ_ENUM_198(x) x, BOOST_PP_SEQ_ENUM_197
+#define BOOST_PP_SEQ_ENUM_199(x) x, BOOST_PP_SEQ_ENUM_198
+#define BOOST_PP_SEQ_ENUM_200(x) x, BOOST_PP_SEQ_ENUM_199
+#define BOOST_PP_SEQ_ENUM_201(x) x, BOOST_PP_SEQ_ENUM_200
+#define BOOST_PP_SEQ_ENUM_202(x) x, BOOST_PP_SEQ_ENUM_201
+#define BOOST_PP_SEQ_ENUM_203(x) x, BOOST_PP_SEQ_ENUM_202
+#define BOOST_PP_SEQ_ENUM_204(x) x, BOOST_PP_SEQ_ENUM_203
+#define BOOST_PP_SEQ_ENUM_205(x) x, BOOST_PP_SEQ_ENUM_204
+#define BOOST_PP_SEQ_ENUM_206(x) x, BOOST_PP_SEQ_ENUM_205
+#define BOOST_PP_SEQ_ENUM_207(x) x, BOOST_PP_SEQ_ENUM_206
+#define BOOST_PP_SEQ_ENUM_208(x) x, BOOST_PP_SEQ_ENUM_207
+#define BOOST_PP_SEQ_ENUM_209(x) x, BOOST_PP_SEQ_ENUM_208
+#define BOOST_PP_SEQ_ENUM_210(x) x, BOOST_PP_SEQ_ENUM_209
+#define BOOST_PP_SEQ_ENUM_211(x) x, BOOST_PP_SEQ_ENUM_210
+#define BOOST_PP_SEQ_ENUM_212(x) x, BOOST_PP_SEQ_ENUM_211
+#define BOOST_PP_SEQ_ENUM_213(x) x, BOOST_PP_SEQ_ENUM_212
+#define BOOST_PP_SEQ_ENUM_214(x) x, BOOST_PP_SEQ_ENUM_213
+#define BOOST_PP_SEQ_ENUM_215(x) x, BOOST_PP_SEQ_ENUM_214
+#define BOOST_PP_SEQ_ENUM_216(x) x, BOOST_PP_SEQ_ENUM_215
+#define BOOST_PP_SEQ_ENUM_217(x) x, BOOST_PP_SEQ_ENUM_216
+#define BOOST_PP_SEQ_ENUM_218(x) x, BOOST_PP_SEQ_ENUM_217
+#define BOOST_PP_SEQ_ENUM_219(x) x, BOOST_PP_SEQ_ENUM_218
+#define BOOST_PP_SEQ_ENUM_220(x) x, BOOST_PP_SEQ_ENUM_219
+#define BOOST_PP_SEQ_ENUM_221(x) x, BOOST_PP_SEQ_ENUM_220
+#define BOOST_PP_SEQ_ENUM_222(x) x, BOOST_PP_SEQ_ENUM_221
+#define BOOST_PP_SEQ_ENUM_223(x) x, BOOST_PP_SEQ_ENUM_222
+#define BOOST_PP_SEQ_ENUM_224(x) x, BOOST_PP_SEQ_ENUM_223
+#define BOOST_PP_SEQ_ENUM_225(x) x, BOOST_PP_SEQ_ENUM_224
+#define BOOST_PP_SEQ_ENUM_226(x) x, BOOST_PP_SEQ_ENUM_225
+#define BOOST_PP_SEQ_ENUM_227(x) x, BOOST_PP_SEQ_ENUM_226
+#define BOOST_PP_SEQ_ENUM_228(x) x, BOOST_PP_SEQ_ENUM_227
+#define BOOST_PP_SEQ_ENUM_229(x) x, BOOST_PP_SEQ_ENUM_228
+#define BOOST_PP_SEQ_ENUM_230(x) x, BOOST_PP_SEQ_ENUM_229
+#define BOOST_PP_SEQ_ENUM_231(x) x, BOOST_PP_SEQ_ENUM_230
+#define BOOST_PP_SEQ_ENUM_232(x) x, BOOST_PP_SEQ_ENUM_231
+#define BOOST_PP_SEQ_ENUM_233(x) x, BOOST_PP_SEQ_ENUM_232
+#define BOOST_PP_SEQ_ENUM_234(x) x, BOOST_PP_SEQ_ENUM_233
+#define BOOST_PP_SEQ_ENUM_235(x) x, BOOST_PP_SEQ_ENUM_234
+#define BOOST_PP_SEQ_ENUM_236(x) x, BOOST_PP_SEQ_ENUM_235
+#define BOOST_PP_SEQ_ENUM_237(x) x, BOOST_PP_SEQ_ENUM_236
+#define BOOST_PP_SEQ_ENUM_238(x) x, BOOST_PP_SEQ_ENUM_237
+#define BOOST_PP_SEQ_ENUM_239(x) x, BOOST_PP_SEQ_ENUM_238
+#define BOOST_PP_SEQ_ENUM_240(x) x, BOOST_PP_SEQ_ENUM_239
+#define BOOST_PP_SEQ_ENUM_241(x) x, BOOST_PP_SEQ_ENUM_240
+#define BOOST_PP_SEQ_ENUM_242(x) x, BOOST_PP_SEQ_ENUM_241
+#define BOOST_PP_SEQ_ENUM_243(x) x, BOOST_PP_SEQ_ENUM_242
+#define BOOST_PP_SEQ_ENUM_244(x) x, BOOST_PP_SEQ_ENUM_243
+#define BOOST_PP_SEQ_ENUM_245(x) x, BOOST_PP_SEQ_ENUM_244
+#define BOOST_PP_SEQ_ENUM_246(x) x, BOOST_PP_SEQ_ENUM_245
+#define BOOST_PP_SEQ_ENUM_247(x) x, BOOST_PP_SEQ_ENUM_246
+#define BOOST_PP_SEQ_ENUM_248(x) x, BOOST_PP_SEQ_ENUM_247
+#define BOOST_PP_SEQ_ENUM_249(x) x, BOOST_PP_SEQ_ENUM_248
+#define BOOST_PP_SEQ_ENUM_250(x) x, BOOST_PP_SEQ_ENUM_249
+#define BOOST_PP_SEQ_ENUM_251(x) x, BOOST_PP_SEQ_ENUM_250
+#define BOOST_PP_SEQ_ENUM_252(x) x, BOOST_PP_SEQ_ENUM_251
+#define BOOST_PP_SEQ_ENUM_253(x) x, BOOST_PP_SEQ_ENUM_252
+#define BOOST_PP_SEQ_ENUM_254(x) x, BOOST_PP_SEQ_ENUM_253
+#define BOOST_PP_SEQ_ENUM_255(x) x, BOOST_PP_SEQ_ENUM_254
+#define BOOST_PP_SEQ_ENUM_256(x) x, BOOST_PP_SEQ_ENUM_255
+# 32 "/usr/include/boost/test/tools/context.hpp" 2 3 4
+
+
+
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 36 "/usr/include/boost/test/tools/context.hpp" 2 3 4
+
+
+
+namespace boost {
+namespace test_tools {
+namespace tt_detail {
+
+
+
+
+
+struct __attribute__((__visibility__("default"))) context_frame {
+    explicit context_frame( ::boost::unit_test::lazy_ostream const& context_descr );
+    ~context_frame();
+
+    operator bool();
+
+private:
+
+    int m_frame_id;
+};
+
+
+
+#define BOOST_TEST_INFO(context_descr) ::boost::unit_test::framework::add_context( BOOST_TEST_LAZY_MSG( context_descr ) , false )
+
+
+
+#define BOOST_TEST_INFO_SCOPE(context_descr) ::boost::test_tools::tt_detail::context_frame BOOST_JOIN( context_frame_, __LINE__ ) = ::boost::test_tools::tt_detail::context_frame(BOOST_TEST_LAZY_MSG( context_descr ) )
+
+
+
+
+
+
+
+#define BOOST_CONTEXT_PARAM(r,ctx,i,context_descr) if( ::boost::test_tools::tt_detail::context_frame BOOST_PP_CAT(ctx, i) = ::boost::test_tools::tt_detail::context_frame(BOOST_TEST_LAZY_MSG( context_descr ) ) )
+
+
+
+
+#define BOOST_CONTEXT_PARAMS(params) BOOST_PP_SEQ_FOR_EACH_I(BOOST_CONTEXT_PARAM, BOOST_JOIN( context_frame_, __LINE__ ), params)
+
+
+
+
+
+#define BOOST_TEST_CONTEXT(...) BOOST_CONTEXT_PARAMS( BOOST_PP_VARIADIC_TO_SEQ(__VA_ARGS__) )
+
+
+
+
+
+
+}
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 95 "/usr/include/boost/test/tools/context.hpp" 2 3 4
+# 43 "/usr/include/boost/test/test_tools.hpp" 2 3 4
+
+
+# 1 "/usr/include/boost/test/tools/old/interface.hpp" 1 3 4
+# 16 "/usr/include/boost/test/tools/old/interface.hpp" 3 4
+#define BOOST_TEST_TOOLS_OLD_INTERFACE_HPP_111712GER 
+
+
+
+
+# 1 "/usr/include/boost/preprocessor/seq/to_tuple.hpp" 1 3 4
+# 13 "/usr/include/boost/preprocessor/seq/to_tuple.hpp" 3 4
+#define BOOST_PREPROCESSOR_SEQ_TO_TUPLE_HPP 
+
+
+
+
+
+
+
+#define BOOST_PP_SEQ_TO_TUPLE(seq) (BOOST_PP_SEQ_ENUM(seq))
+# 22 "/usr/include/boost/test/tools/old/interface.hpp" 2 3 4
+
+
+
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 26 "/usr/include/boost/test/tools/old/interface.hpp" 2 3 4
+# 49 "/usr/include/boost/test/tools/old/interface.hpp" 3 4
+#define BOOST_TEST_TOOL_PASS_PRED0(P,ARGS) P
+#define BOOST_TEST_TOOL_PASS_PRED1(P,ARGS) P BOOST_PP_SEQ_TO_TUPLE(ARGS)
+#define BOOST_TEST_TOOL_PASS_PRED2(P,ARGS) P
+
+#define BOOST_TEST_TOOL_PASS_ARG(r,_,arg) , arg, BOOST_STRINGIZE( arg )
+#define BOOST_TEST_TOOL_PASS_ARG_DSCR(r,_,arg) , BOOST_STRINGIZE( arg )
+
+#define BOOST_TEST_TOOL_PASS_ARGS0(ARGS) BOOST_PP_SEQ_FOR_EACH( BOOST_TEST_TOOL_PASS_ARG, _, ARGS )
+
+#define BOOST_TEST_TOOL_PASS_ARGS1(ARGS) , BOOST_PP_SEQ_SIZE(ARGS) BOOST_PP_SEQ_FOR_EACH( BOOST_TEST_TOOL_PASS_ARG_DSCR, _, ARGS )
+
+#define BOOST_TEST_TOOL_PASS_ARGS2(ARGS) , 0
+
+
+#define BOOST_TEST_TOOL_IMPL(frwd_type,P,assertion_descr,TL,CT,ARGS) do { BOOST_TEST_PASSPOINT(); ::boost::test_tools::tt_detail:: BOOST_PP_IF( frwd_type, report_assertion, check_frwd ) ( BOOST_JOIN( BOOST_TEST_TOOL_PASS_PRED, frwd_type )( P, ARGS ), BOOST_TEST_LAZY_MSG( assertion_descr ), BOOST_TEST_L(__FILE__), static_cast<std::size_t>(__LINE__), ::boost::test_tools::tt_detail::TL, ::boost::test_tools::tt_detail::CT BOOST_JOIN( BOOST_TEST_TOOL_PASS_ARGS, frwd_type )( ARGS ) ); } while( ::boost::test_tools::tt_detail::dummy_cond() )
+# 80 "/usr/include/boost/test/tools/old/interface.hpp" 3 4
+#define BOOST_WARN(P) BOOST_TEST_TOOL_IMPL( 2, (P), BOOST_TEST_STRINGIZE( P ), WARN, CHECK_PRED, _ )
+
+#define BOOST_CHECK(P) BOOST_TEST_TOOL_IMPL( 2, (P), BOOST_TEST_STRINGIZE( P ), CHECK, CHECK_PRED, _ )
+
+#define BOOST_REQUIRE(P) BOOST_TEST_TOOL_IMPL( 2, (P), BOOST_TEST_STRINGIZE( P ), REQUIRE, CHECK_PRED, _ )
+
+
+
+
+#define BOOST_WARN_MESSAGE(P,M) BOOST_TEST_TOOL_IMPL( 2, (P), M, WARN, CHECK_MSG, _ )
+#define BOOST_CHECK_MESSAGE(P,M) BOOST_TEST_TOOL_IMPL( 2, (P), M, CHECK, CHECK_MSG, _ )
+#define BOOST_REQUIRE_MESSAGE(P,M) BOOST_TEST_TOOL_IMPL( 2, (P), M, REQUIRE, CHECK_MSG, _ )
+
+
+
+#define BOOST_ERROR(M) BOOST_CHECK_MESSAGE( false, M )
+#define BOOST_FAIL(M) BOOST_REQUIRE_MESSAGE( false, M )
+
+
+
+#define BOOST_CHECK_THROW_IMPL(S,E,P,postfix,TL) do { try { BOOST_TEST_PASSPOINT(); S; BOOST_TEST_TOOL_IMPL( 2, false, "exception " BOOST_STRINGIZE(E) " expected but not raised", TL, CHECK_MSG, _ ); } catch( E const& ex ) { boost::ignore_unused( ex ); BOOST_TEST_TOOL_IMPL( 2, P, "exception \"" BOOST_STRINGIZE( E )"\" raised as expected" postfix, TL, CHECK_MSG, _ ); } } while( ::boost::test_tools::tt_detail::dummy_cond() )
+# 118 "/usr/include/boost/test/tools/old/interface.hpp" 3 4
+#define BOOST_WARN_THROW(S,E) BOOST_CHECK_THROW_IMPL( S, E, true, "", WARN )
+#define BOOST_CHECK_THROW(S,E) BOOST_CHECK_THROW_IMPL( S, E, true, "", CHECK )
+#define BOOST_REQUIRE_THROW(S,E) BOOST_CHECK_THROW_IMPL( S, E, true, "", REQUIRE )
+
+
+
+#define BOOST_WARN_EXCEPTION(S,E,P) BOOST_CHECK_THROW_IMPL( S, E, P( ex ), ": validation on the raised exception through predicate \"" BOOST_STRINGIZE(P) "\"", WARN )
+
+#define BOOST_CHECK_EXCEPTION(S,E,P) BOOST_CHECK_THROW_IMPL( S, E, P( ex ), ": validation on the raised exception through predicate \"" BOOST_STRINGIZE(P) "\"", CHECK )
+
+#define BOOST_REQUIRE_EXCEPTION(S,E,P) BOOST_CHECK_THROW_IMPL( S, E, P( ex ), ": validation on the raised exception through predicate \"" BOOST_STRINGIZE(P) "\"", REQUIRE )
+
+
+
+
+#define BOOST_CHECK_NO_THROW_IMPL(S,TL) do { try { S; BOOST_TEST_TOOL_IMPL( 2, true, "no exceptions thrown by " BOOST_STRINGIZE( S ), TL, CHECK_MSG, _ ); } catch( ... ) { BOOST_TEST_TOOL_IMPL( 2, false, "unexpected exception thrown by " BOOST_STRINGIZE( S ), TL, CHECK_MSG, _ ); } } while( ::boost::test_tools::tt_detail::dummy_cond() )
+# 146 "/usr/include/boost/test/tools/old/interface.hpp" 3 4
+#define BOOST_WARN_NO_THROW(S) BOOST_CHECK_NO_THROW_IMPL( S, WARN )
+#define BOOST_CHECK_NO_THROW(S) BOOST_CHECK_NO_THROW_IMPL( S, CHECK )
+#define BOOST_REQUIRE_NO_THROW(S) BOOST_CHECK_NO_THROW_IMPL( S, REQUIRE )
+
+
+
+#define BOOST_WARN_EQUAL(L,R) BOOST_TEST_TOOL_IMPL( 0, ::boost::test_tools::tt_detail::equal_impl_frwd(), "", WARN, CHECK_EQUAL, (L)(R) )
+
+#define BOOST_CHECK_EQUAL(L,R) BOOST_TEST_TOOL_IMPL( 0, ::boost::test_tools::tt_detail::equal_impl_frwd(), "", CHECK, CHECK_EQUAL, (L)(R) )
+
+#define BOOST_REQUIRE_EQUAL(L,R) BOOST_TEST_TOOL_IMPL( 0, ::boost::test_tools::tt_detail::equal_impl_frwd(), "", REQUIRE, CHECK_EQUAL, (L)(R) )
+
+
+
+
+#define BOOST_WARN_NE(L,R) BOOST_TEST_TOOL_IMPL( 0, ::boost::test_tools::tt_detail::ne_impl(), "", WARN, CHECK_NE, (L)(R) )
+
+#define BOOST_CHECK_NE(L,R) BOOST_TEST_TOOL_IMPL( 0, ::boost::test_tools::tt_detail::ne_impl(), "", CHECK, CHECK_NE, (L)(R) )
+
+#define BOOST_REQUIRE_NE(L,R) BOOST_TEST_TOOL_IMPL( 0, ::boost::test_tools::tt_detail::ne_impl(), "", REQUIRE, CHECK_NE, (L)(R) )
+
+
+
+
+#define BOOST_WARN_LT(L,R) BOOST_TEST_TOOL_IMPL( 0, ::boost::test_tools::tt_detail::lt_impl(), "", WARN, CHECK_LT, (L)(R) )
+
+#define BOOST_CHECK_LT(L,R) BOOST_TEST_TOOL_IMPL( 0, ::boost::test_tools::tt_detail::lt_impl(), "", CHECK, CHECK_LT, (L)(R) )
+
+#define BOOST_REQUIRE_LT(L,R) BOOST_TEST_TOOL_IMPL( 0, ::boost::test_tools::tt_detail::lt_impl(), "", REQUIRE, CHECK_LT, (L)(R) )
+
+
+
+
+#define BOOST_WARN_LE(L,R) BOOST_TEST_TOOL_IMPL( 0, ::boost::test_tools::tt_detail::le_impl(), "", WARN, CHECK_LE, (L)(R) )
+
+#define BOOST_CHECK_LE(L,R) BOOST_TEST_TOOL_IMPL( 0, ::boost::test_tools::tt_detail::le_impl(), "", CHECK, CHECK_LE, (L)(R) )
+
+#define BOOST_REQUIRE_LE(L,R) BOOST_TEST_TOOL_IMPL( 0, ::boost::test_tools::tt_detail::le_impl(), "", REQUIRE, CHECK_LE, (L)(R) )
+
+
+
+
+#define BOOST_WARN_GT(L,R) BOOST_TEST_TOOL_IMPL( 0, ::boost::test_tools::tt_detail::gt_impl(), "", WARN, CHECK_GT, (L)(R) )
+
+#define BOOST_CHECK_GT(L,R) BOOST_TEST_TOOL_IMPL( 0, ::boost::test_tools::tt_detail::gt_impl(), "", CHECK, CHECK_GT, (L)(R) )
+
+#define BOOST_REQUIRE_GT(L,R) BOOST_TEST_TOOL_IMPL( 0, ::boost::test_tools::tt_detail::gt_impl(), "", REQUIRE, CHECK_GT, (L)(R) )
+
+
+
+
+#define BOOST_WARN_GE(L,R) BOOST_TEST_TOOL_IMPL( 0, ::boost::test_tools::tt_detail::ge_impl(), "", WARN, CHECK_GE, (L)(R) )
+
+#define BOOST_CHECK_GE(L,R) BOOST_TEST_TOOL_IMPL( 0, ::boost::test_tools::tt_detail::ge_impl(), "", CHECK, CHECK_GE, (L)(R) )
+
+#define BOOST_REQUIRE_GE(L,R) BOOST_TEST_TOOL_IMPL( 0, ::boost::test_tools::tt_detail::ge_impl(), "", REQUIRE, CHECK_GE, (L)(R) )
+
+
+
+
+#define BOOST_WARN_CLOSE(L,R,T) BOOST_TEST_TOOL_IMPL( 0, ::boost::test_tools::check_is_close_t(), "", WARN, CHECK_CLOSE, (L)(R)(::boost::math::fpc::percent_tolerance(T)) )
+
+#define BOOST_CHECK_CLOSE(L,R,T) BOOST_TEST_TOOL_IMPL( 0, ::boost::test_tools::check_is_close_t(), "", CHECK, CHECK_CLOSE, (L)(R)(::boost::math::fpc::percent_tolerance(T)) )
+
+#define BOOST_REQUIRE_CLOSE(L,R,T) BOOST_TEST_TOOL_IMPL( 0, ::boost::test_tools::check_is_close_t(), "", REQUIRE, CHECK_CLOSE, (L)(R)(::boost::math::fpc::percent_tolerance(T)) )
+
+
+
+
+#define BOOST_WARN_CLOSE_FRACTION(L,R,T) BOOST_TEST_TOOL_IMPL( 0, ::boost::test_tools::check_is_close_t(), "", WARN, CHECK_CLOSE_FRACTION, (L)(R)(T) )
+
+#define BOOST_CHECK_CLOSE_FRACTION(L,R,T) BOOST_TEST_TOOL_IMPL( 0, ::boost::test_tools::check_is_close_t(), "", CHECK, CHECK_CLOSE_FRACTION, (L)(R)(T) )
+
+#define BOOST_REQUIRE_CLOSE_FRACTION(L,R,T) BOOST_TEST_TOOL_IMPL( 0, ::boost::test_tools::check_is_close_t(), "", REQUIRE, CHECK_CLOSE_FRACTION, (L)(R)(T) )
+
+
+
+
+#define BOOST_WARN_SMALL(FPV,T) BOOST_TEST_TOOL_IMPL( 0, ::boost::test_tools::check_is_small_t(), "", WARN, CHECK_SMALL, (FPV)(T) )
+
+#define BOOST_CHECK_SMALL(FPV,T) BOOST_TEST_TOOL_IMPL( 0, ::boost::test_tools::check_is_small_t(), "", CHECK, CHECK_SMALL, (FPV)(T) )
+
+#define BOOST_REQUIRE_SMALL(FPV,T) BOOST_TEST_TOOL_IMPL( 0, ::boost::test_tools::check_is_small_t(), "", REQUIRE, CHECK_SMALL, (FPV)(T) )
+
+
+
+
+#define BOOST_WARN_PREDICATE(P,ARGS) BOOST_TEST_TOOL_IMPL( 0, P, BOOST_TEST_STRINGIZE( P ), WARN, CHECK_PRED_WITH_ARGS, ARGS )
+
+#define BOOST_CHECK_PREDICATE(P,ARGS) BOOST_TEST_TOOL_IMPL( 0, P, BOOST_TEST_STRINGIZE( P ), CHECK, CHECK_PRED_WITH_ARGS, ARGS )
+
+#define BOOST_REQUIRE_PREDICATE(P,ARGS) BOOST_TEST_TOOL_IMPL( 0, P, BOOST_TEST_STRINGIZE( P ), REQUIRE, CHECK_PRED_WITH_ARGS, ARGS )
+
+
+
+
+#define BOOST_WARN_EQUAL_COLLECTIONS(L_begin,L_end,R_begin,R_end) BOOST_TEST_TOOL_IMPL( 1, ::boost::test_tools::tt_detail::equal_coll_impl(), "", WARN, CHECK_EQUAL_COLL, (L_begin)(L_end)(R_begin)(R_end) )
+
+
+
+#define BOOST_CHECK_EQUAL_COLLECTIONS(L_begin,L_end,R_begin,R_end) BOOST_TEST_TOOL_IMPL( 1, ::boost::test_tools::tt_detail::equal_coll_impl(), "", CHECK, CHECK_EQUAL_COLL, (L_begin)(L_end)(R_begin)(R_end) )
+
+
+
+#define BOOST_REQUIRE_EQUAL_COLLECTIONS(L_begin,L_end,R_begin,R_end) BOOST_TEST_TOOL_IMPL( 1, ::boost::test_tools::tt_detail::equal_coll_impl(), "", REQUIRE, CHECK_EQUAL_COLL, (L_begin)(L_end)(R_begin)(R_end) )
+
+
+
+
+
+
+#define BOOST_WARN_BITWISE_EQUAL(L,R) BOOST_TEST_TOOL_IMPL( 1, ::boost::test_tools::tt_detail::bitwise_equal_impl(), "", WARN, CHECK_BITWISE_EQUAL, (L)(R) )
+
+#define BOOST_CHECK_BITWISE_EQUAL(L,R) BOOST_TEST_TOOL_IMPL( 1, ::boost::test_tools::tt_detail::bitwise_equal_impl(), "", CHECK, CHECK_BITWISE_EQUAL, (L)(R) )
+
+#define BOOST_REQUIRE_BITWISE_EQUAL(L,R) BOOST_TEST_TOOL_IMPL( 1, ::boost::test_tools::tt_detail::bitwise_equal_impl(), "", REQUIRE, CHECK_BITWISE_EQUAL, (L)(R) )
+
+
+
+
+#define BOOST_IS_DEFINED(symb) ::boost::test_tools::tt_detail::is_defined_impl( #symb, BOOST_STRINGIZE(= symb) )
+# 282 "/usr/include/boost/test/tools/old/interface.hpp" 3 4
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 283 "/usr/include/boost/test/tools/old/interface.hpp" 2 3 4
+# 46 "/usr/include/boost/test/test_tools.hpp" 2 3 4
+# 1 "/usr/include/boost/test/tools/old/impl.hpp" 1 3 4
+# 16 "/usr/include/boost/test/tools/old/impl.hpp" 3 4
+#define BOOST_TEST_TOOLS_OLD_IMPL_HPP_012705GER 
+
+
+
+
+# 1 "/usr/include/boost/test/tools/floating_point_comparison.hpp" 1 3 4
+# 13 "/usr/include/boost/test/tools/floating_point_comparison.hpp" 3 4
+#define BOOST_TEST_FLOATING_POINT_COMPARISON_HPP_071894GER 
+# 22 "/usr/include/boost/test/tools/floating_point_comparison.hpp" 3 4
+# 1 "/usr/include/boost/assert.hpp" 1 3 4
+# 32 "/usr/include/boost/assert.hpp" 3 4
+#undef BOOST_ASSERT
+#undef BOOST_ASSERT_MSG
+#undef BOOST_ASSERT_IS_VOID
+# 58 "/usr/include/boost/assert.hpp" 3 4
+# 1 "/usr/include/assert.h" 1 3 4
+# 24 "/usr/include/assert.h" 3 4
+#undef _ASSERT_H
+#undef assert
+#undef __ASSERT_VOID_CAST
+
+
+#undef assert_perror
+
+
+
+
+#define _ASSERT_H 1
+
+
+
+#define __ASSERT_VOID_CAST static_cast<void>
+# 64 "/usr/include/assert.h" 3 4
+extern "C" {
+
+
+extern void __assert_fail (const char *__assertion, const char *__file,
+      unsigned int __line, const char *__function)
+     throw () __attribute__ ((__noreturn__));
+
+
+extern void __assert_perror_fail (int __errnum, const char *__file,
+      unsigned int __line, const char *__function)
+     throw () __attribute__ ((__noreturn__));
+
+
+
+
+extern void __assert (const char *__assertion, const char *__file, int __line)
+     throw () __attribute__ ((__noreturn__));
+
+
+}
+
+
+
+
+
+#define assert(expr) (static_cast <bool> (expr) ? void (0) : __assert_fail (#expr, __FILE__, __LINE__, __ASSERT_FUNCTION))
+# 114 "/usr/include/assert.h" 3 4
+#define assert_perror(errnum) (!(errnum) ? __ASSERT_VOID_CAST (0) : __assert_perror_fail ((errnum), __FILE__, __LINE__, __ASSERT_FUNCTION))
+# 126 "/usr/include/assert.h" 3 4
+#define __ASSERT_FUNCTION __extension__ __PRETTY_FUNCTION__
+# 59 "/usr/include/boost/assert.hpp" 2 3 4
+
+#define BOOST_ASSERT(expr) assert(expr)
+#define BOOST_ASSERT_MSG(expr,msg) assert((expr)&&(msg))
+# 72 "/usr/include/boost/assert.hpp" 3 4
+#undef BOOST_VERIFY
+#undef BOOST_VERIFY_MSG
+# 82 "/usr/include/boost/assert.hpp" 3 4
+#define BOOST_VERIFY(expr) BOOST_ASSERT(expr)
+#define BOOST_VERIFY_MSG(expr,msg) BOOST_ASSERT_MSG(expr,msg)
+# 23 "/usr/include/boost/test/tools/floating_point_comparison.hpp" 2 3 4
+# 34 "/usr/include/boost/test/tools/floating_point_comparison.hpp" 3 4
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 35 "/usr/include/boost/test/tools/floating_point_comparison.hpp" 2 3 4
+
+
+
+namespace boost {
+namespace math {
+namespace fpc {
+# 49 "/usr/include/boost/test/tools/floating_point_comparison.hpp" 3 4
+template <typename T, bool enabled>
+struct tolerance_based_delegate;
+
+template <typename T>
+struct tolerance_based_delegate<T, false> : mpl::false_ {};
+
+
+template<typename T>
+class is_abstract_class_or_function
+{
+    typedef char (&Two)[2];
+    template<typename U> static char test(U(*)[1]);
+    template<typename U> static Two test(...);
+
+public:
+    static const bool value =
+           !is_reference<T>::value
+        && !is_void<T>::value
+        && (sizeof(test<T>(0)) == sizeof(Two));
+};
+
+
+
+template <typename T>
+struct tolerance_based_delegate<T, true>
+: mpl::bool_<
+    is_floating_point<T>::value ||
+    (!std::numeric_limits<T>::is_integer && std::numeric_limits<T>::is_specialized && !std::numeric_limits<T>::is_exact)>
+{};
+# 89 "/usr/include/boost/test/tools/floating_point_comparison.hpp" 3 4
+template <typename T>
+struct tolerance_based : tolerance_based_delegate<T, !is_array<T>::value && !is_abstract_class_or_function<T>::value>::type {};
+
+
+
+
+
+
+enum strength {
+    FPC_STRONG,
+    FPC_WEAK
+};
+
+
+
+
+
+
+template<typename FPT>
+struct percent_tolerance_t {
+    explicit percent_tolerance_t( FPT v ) : m_value( v ) {}
+
+    FPT m_value;
+};
+
+
+
+template<typename FPT>
+inline std::ostream& operator<<( std::ostream& out, percent_tolerance_t<FPT> t )
+{
+    return out << t.m_value;
+}
+
+
+
+template<typename FPT>
+inline percent_tolerance_t<FPT>
+percent_tolerance( FPT v )
+{
+    return percent_tolerance_t<FPT>( v );
+}
+
+
+
+
+
+
+
+namespace fpc_detail {
+
+
+template<typename FPT>
+inline FPT
+fpt_abs( FPT fpv )
+{
+    return fpv < static_cast<FPT>(0) ? -fpv : fpv;
+}
+
+
+
+template<typename FPT>
+struct fpt_specialized_limits
+{
+  static FPT min_value() { return (std::numeric_limits<FPT>::min)(); }
+  static FPT max_value() { return (std::numeric_limits<FPT>::max)(); }
+};
+
+template<typename FPT>
+struct fpt_non_specialized_limits
+{
+  static FPT min_value() { return static_cast<FPT>(0); }
+  static FPT max_value() { return static_cast<FPT>(1000000); }
+};
+
+template<typename FPT>
+struct fpt_limits : boost::conditional<std::numeric_limits<FPT>::is_specialized,
+                                       fpt_specialized_limits<FPT>,
+                                       fpt_non_specialized_limits<FPT>
+                                      >::type
+{};
+
+
+
+
+template<typename FPT>
+inline FPT
+safe_fpt_division( FPT f1, FPT f2 )
+{
+
+    if( (f2 < static_cast<FPT>(1)) && (f1 > f2*fpt_limits<FPT>::max_value()) )
+        return fpt_limits<FPT>::max_value();
+
+
+    if( (f1 == static_cast<FPT>(0)) ||
+        ((f2 > static_cast<FPT>(1)) && (f1 < f2*fpt_limits<FPT>::min_value())) )
+        return static_cast<FPT>(0);
+
+    return f1/f2;
+}
+
+
+
+template<typename FPT, typename ToleranceType>
+inline FPT
+fraction_tolerance( ToleranceType tolerance )
+{
+  return static_cast<FPT>(tolerance);
+}
+
+
+
+template<typename FPT2, typename FPT>
+inline FPT2
+fraction_tolerance( percent_tolerance_t<FPT> tolerance )
+{
+    return FPT2(tolerance.m_value)*FPT2(0.01);
+}
+
+
+
+}
+# 225 "/usr/include/boost/test/tools/floating_point_comparison.hpp" 3 4
+template<typename FPT>
+class close_at_tolerance {
+public:
+
+    typedef bool result_type;
+
+
+    template<typename ToleranceType>
+    explicit close_at_tolerance( ToleranceType tolerance, fpc::strength fpc_strength = FPC_STRONG )
+    : m_fraction_tolerance( fpc_detail::fraction_tolerance<FPT>( tolerance ) )
+    , m_strength( fpc_strength )
+    , m_tested_rel_diff( 0 )
+    {
+        (static_cast <bool> ((m_fraction_tolerance >= FPT(0))&&("tolerance must not be negative!")) ? void (0) : __assert_fail ("(m_fraction_tolerance >= FPT(0))&&(\"tolerance must not be negative!\")", "/usr/include/boost/test/tools/floating_point_comparison.hpp", 238, __extension__ __PRETTY_FUNCTION__));
+    }
+
+
+
+    FPT fraction_tolerance() const { return m_fraction_tolerance; }
+
+
+    fpc::strength strength() const { return m_strength; }
+
+
+    FPT tested_rel_diff() const { return m_tested_rel_diff; }
+# 262 "/usr/include/boost/test/tools/floating_point_comparison.hpp" 3 4
+    bool operator()( FPT left, FPT right ) const
+    {
+        FPT diff = fpc_detail::fpt_abs<FPT>( left - right );
+        FPT fraction_of_right = fpc_detail::safe_fpt_division( diff, fpc_detail::fpt_abs( right ) );
+        FPT fraction_of_left = fpc_detail::safe_fpt_division( diff, fpc_detail::fpt_abs( left ) );
+
+        FPT max_rel_diff = (std::max)( fraction_of_left, fraction_of_right );
+        FPT min_rel_diff = (std::min)( fraction_of_left, fraction_of_right );
+
+        m_tested_rel_diff = m_strength == FPC_STRONG ? max_rel_diff : min_rel_diff;
+
+        return m_tested_rel_diff <= m_fraction_tolerance;
+    }
+
+private:
+
+    FPT m_fraction_tolerance;
+    fpc::strength m_strength;
+    mutable FPT m_tested_rel_diff;
+};
+# 293 "/usr/include/boost/test/tools/floating_point_comparison.hpp" 3 4
+template<typename FPT>
+class small_with_tolerance {
+public:
+
+    typedef bool result_type;
+
+
+    explicit small_with_tolerance( FPT tolerance )
+    : m_tolerance( tolerance )
+    {
+        (static_cast <bool> (m_tolerance >= FPT(0)) ? void (0) : __assert_fail ("m_tolerance >= FPT(0)", "/usr/include/boost/test/tools/floating_point_comparison.hpp", 303, __extension__ __PRETTY_FUNCTION__));
+    }
+
+
+    bool operator()( FPT fpv ) const
+    {
+        return fpc::fpc_detail::fpt_abs( fpv ) <= m_tolerance;
+    }
+
+private:
+
+    FPT m_tolerance;
+};
+
+
+
+
+
+template<typename FPT>
+inline bool
+is_small( FPT fpv, FPT tolerance )
+{
+    return small_with_tolerance<FPT>( tolerance )( fpv );
+}
+
+
+
+}
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 335 "/usr/include/boost/test/tools/floating_point_comparison.hpp" 2 3 4
+# 22 "/usr/include/boost/test/tools/old/impl.hpp" 2 3 4
+
+# 1 "/usr/include/boost/test/tools/detail/fwd.hpp" 1 3 4
+# 16 "/usr/include/boost/test/tools/detail/fwd.hpp" 3 4
+#define BOOST_TEST_TOOLS_DETAIL_FWD_HPP_012705GER 
+# 25 "/usr/include/boost/test/tools/detail/fwd.hpp" 3 4
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 26 "/usr/include/boost/test/tools/detail/fwd.hpp" 2 3 4
+
+
+
+namespace boost {
+namespace unit_test {
+
+class lazy_ostream;
+
+}
+
+namespace test_tools {
+
+using unit_test::const_string;
+class assertion_result;
+
+
+
+namespace tt_detail {
+
+inline bool dummy_cond() { return false; }
+
+
+
+
+
+
+
+enum check_type {
+    CHECK_PRED,
+    CHECK_MSG,
+    CHECK_EQUAL,
+    CHECK_NE,
+    CHECK_LT,
+    CHECK_LE,
+    CHECK_GT,
+    CHECK_GE,
+    CHECK_CLOSE,
+    CHECK_CLOSE_FRACTION,
+    CHECK_SMALL,
+    CHECK_BITWISE_EQUAL,
+    CHECK_PRED_WITH_ARGS,
+    CHECK_EQUAL_COLL,
+    CHECK_BUILT_ASSERTION
+};
+
+
+
+
+
+
+
+enum tool_level {
+    WARN, CHECK, REQUIRE, PASS
+};
+
+
+
+
+
+
+
+__attribute__((__visibility__("default"))) bool
+report_assertion( assertion_result const& pr, unit_test::lazy_ostream const& assertion_descr,
+                  const_string file_name, std::size_t line_num,
+                  tool_level tl, check_type ct,
+                  std::size_t num_args, ... );
+
+
+
+__attribute__((__visibility__("default"))) assertion_result
+format_assertion_result( const_string expr_val, const_string details );
+
+
+
+__attribute__((__visibility__("default"))) assertion_result
+format_fpc_report( const_string expr_val, const_string details );
+
+
+
+__attribute__((__visibility__("default"))) bool
+is_defined_impl( const_string symbol_name, const_string symbol_value );
+
+
+
+__attribute__((__visibility__("default"))) assertion_result
+equal_impl( char const* left, char const* right );
+
+
+
+}
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 120 "/usr/include/boost/test/tools/detail/fwd.hpp" 2 3 4
+# 24 "/usr/include/boost/test/tools/old/impl.hpp" 2 3 4
+# 1 "/usr/include/boost/test/tools/detail/print_helper.hpp" 1 3 4
+# 16 "/usr/include/boost/test/tools/detail/print_helper.hpp" 3 4
+#define BOOST_TEST_TOOLS_IMPL_COMMON_HPP_012705GER 
+# 28 "/usr/include/boost/test/tools/detail/print_helper.hpp" 3 4
+# 1 "/usr/include/boost/type_traits/has_left_shift.hpp" 1 3 4
+# 10 "/usr/include/boost/type_traits/has_left_shift.hpp" 3 4
+#define BOOST_TT_HAS_LEFT_SHIFT_HPP_INCLUDED 
+
+#define BOOST_TT_TRAIT_NAME has_left_shift
+#define BOOST_TT_TRAIT_OP <<
+#define BOOST_TT_FORBIDDEN_IF ( ( ::boost::is_fundamental< Lhs_nocv >::value && ::boost::is_fundamental< Rhs_nocv >::value && ( (! ::boost::is_integral< Lhs_noref >::value ) || (! ::boost::is_integral< Rhs_noref >::value ) ) )|| ( ::boost::is_fundamental< Lhs_nocv >::value && ::boost::is_pointer< Rhs_noref >::value )|| ( ::boost::is_fundamental< Rhs_nocv >::value && ::boost::is_pointer< Lhs_noref >::value )|| ( ::boost::is_pointer< Lhs_noref >::value && ::boost::is_pointer< Rhs_noref >::value ) )
+# 43 "/usr/include/boost/type_traits/has_left_shift.hpp" 3 4
+# 1 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 1 3 4
+# 25 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3 4
+          
+# 26 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
+# 37 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
+# 1 "/usr/include/boost/type_traits/make_void.hpp" 1 3 4
+# 11 "/usr/include/boost/type_traits/make_void.hpp" 3 4
+#define BOOST_TT_MAKE_VOID_HPP_INCLUDED 
+
+
+
+namespace boost {
+
+
+template<class...>
+struct make_void {
+    typedef void type;
+};
+
+
+template<class... Ts>
+using void_t = typename make_void<Ts...>::type;
+# 50 "/usr/include/boost/type_traits/make_void.hpp" 3 4
+}
+# 38 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3
+
+
+
+
+
+namespace boost
+{
+
+   namespace binary_op_detail {
+
+      struct dont_care;
+
+      template <class T, class U, class Ret, class = void>
+      struct has_left_shift_ret_imp : public boost::false_type {};
+
+      template <class T, class U, class Ret>
+      struct has_left_shift_ret_imp<T, U, Ret, typename boost::make_void<decltype(std::declval<typename add_reference<T>::type>() << std::declval<typename add_reference<U>::type>())>::type>
+         : public boost::integral_constant<bool, ::boost::is_convertible<decltype(std::declval<typename add_reference<T>::type>() << std::declval<typename add_reference<U>::type>()), Ret>::value> {};
+
+      template <class T, class U, class = void >
+      struct has_left_shift_void_imp : public boost::false_type {};
+
+      template <class T, class U>
+      struct has_left_shift_void_imp<T, U, typename boost::make_void<decltype(std::declval<typename add_reference<T>::type>() << std::declval<typename add_reference<U>::type>())>::type>
+         : public boost::integral_constant<bool, ::boost::is_void<decltype(std::declval<typename add_reference<T>::type>() << std::declval<typename add_reference<U>::type>())>::value> {};
+
+      template <class T, class U, class = void>
+      struct has_left_shift_dc_imp : public boost::false_type {};
+
+      template <class T, class U>
+      struct has_left_shift_dc_imp<T, U, typename boost::make_void<decltype(std::declval<typename add_reference<T>::type>() << std::declval<typename add_reference<U>::type>())>::type>
+         : public boost::true_type {};
+
+   }
+
+   template <class T, class U = T, class Ret = boost::binary_op_detail::dont_care>
+   struct has_left_shift : public boost::binary_op_detail:: has_left_shift_ret_imp <T, U, Ret> {};
+   template <class T, class U>
+   struct has_left_shift<T, U, void> : public boost::binary_op_detail:: has_left_shift_void_imp <T, U> {};
+   template <class T, class U>
+   struct has_left_shift<T, U, boost::binary_op_detail::dont_care> : public boost::binary_op_detail:: has_left_shift_dc_imp <T, U> {};
+
+
+}
+# 44 "/usr/include/boost/type_traits/has_left_shift.hpp" 2 3 4
+
+#undef BOOST_TT_TRAIT_NAME
+#undef BOOST_TT_TRAIT_OP
+#undef BOOST_TT_FORBIDDEN_IF
+# 29 "/usr/include/boost/test/tools/detail/print_helper.hpp" 2 3 4
+# 38 "/usr/include/boost/test/tools/detail/print_helper.hpp" 3 4
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 39 "/usr/include/boost/test/tools/detail/print_helper.hpp" 2 3 4
+
+
+
+namespace boost {
+namespace test_tools {
+namespace tt_detail {
+
+
+
+
+
+    namespace impl {
+        template <class T>
+        std::ostream& boost_test_print_type(std::ostream& ostr, T const& t) {
+            static_assert((boost::has_left_shift<std::ostream,T>::value), "Type has to implement operator<< to be printable")
+                                                                                       ;
+            ostr << t;
+            return ostr;
+        }
+
+        struct boost_test_print_type_impl {
+            template <class R>
+            std::ostream& operator()(std::ostream& ostr, R const& r) const {
+                return boost_test_print_type(ostr, r);
+            }
+        };
+    }
+
+
+    template <class T> struct static_const { static const T value; };
+    template <class T> const T static_const<T>::value = T();
+
+    namespace {
+        static const impl::boost_test_print_type_impl& boost_test_print_type =
+            static_const<impl::boost_test_print_type_impl>::value;
+    }
+
+
+
+
+
+
+template<typename T>
+struct print_log_value {
+    void operator()( std::ostream& ostr, T const& t )
+    {
+        typedef typename mpl::or_<is_array<T>,is_function<T>,is_abstract<T> >::type cant_use_nl;
+
+        std::streamsize old_precision = set_precision( ostr, cant_use_nl() );
+
+
+        using boost::test_tools::tt_detail::boost_test_print_type;
+        boost_test_print_type(ostr, t);
+
+        if( old_precision != (std::streamsize)-1 )
+            ostr.precision( old_precision );
+    }
+
+    std::streamsize set_precision( std::ostream& ostr, mpl::false_ )
+    {
+        if( std::numeric_limits<T>::is_specialized && std::numeric_limits<T>::radix == 2 )
+            return ostr.precision( 2 + std::numeric_limits<T>::digits * 301/1000 );
+        else if ( std::numeric_limits<T>::is_specialized && std::numeric_limits<T>::radix == 10 ) {
+# 110 "/usr/include/boost/test/tools/detail/print_helper.hpp" 3 4
+            return ostr.precision( std::numeric_limits<T>::max_digits10 );
+
+        }
+
+
+        return (std::streamsize)-1;
+    }
+
+    std::streamsize set_precision( std::ostream&, mpl::true_ ) { return (std::streamsize)-1; }
+};
+# 135 "/usr/include/boost/test/tools/detail/print_helper.hpp" 3 4
+template<>
+struct __attribute__((__visibility__("default"))) print_log_value<bool> {
+    void operator()( std::ostream& ostr, bool t );
+};
+
+
+
+template<>
+struct __attribute__((__visibility__("default"))) print_log_value<char> {
+    void operator()( std::ostream& ostr, char t );
+};
+
+
+
+template<>
+struct __attribute__((__visibility__("default"))) print_log_value<unsigned char> {
+    void operator()( std::ostream& ostr, unsigned char t );
+};
+
+
+
+template<>
+struct __attribute__((__visibility__("default"))) print_log_value<char const*> {
+    void operator()( std::ostream& ostr, char const* t );
+};
+
+
+
+template<>
+struct __attribute__((__visibility__("default"))) print_log_value<wchar_t const*> {
+    void operator()( std::ostream& ostr, wchar_t const* t );
+};
+
+
+template<>
+struct print_log_value<std::nullptr_t> {
+
+    void operator()( std::ostream& ostr, std::nullptr_t ) {
+        ostr << "nullptr";
+    }
+};
+# 186 "/usr/include/boost/test/tools/detail/print_helper.hpp" 3 4
+template<typename T>
+struct print_helper_t {
+    explicit print_helper_t( T const& t ) : m_t( t ) {}
+
+    T const& m_t;
+};
+# 207 "/usr/include/boost/test/tools/detail/print_helper.hpp" 3 4
+template<typename T>
+inline print_helper_t<T>
+print_helper( T const& t )
+{
+    return print_helper_t<T>( t );
+}
+
+
+
+template<typename T>
+inline std::ostream&
+operator<<( std::ostream& ostr, print_helper_t<T> const& ph )
+{
+    print_log_value<T>()( ostr, ph.m_t );
+
+    return ostr;
+}
+
+
+
+}
+
+
+
+
+
+#define BOOST_TEST_DONT_PRINT_LOG_VALUE(the_type) namespace boost{ namespace test_tools{ namespace tt_detail{ template<> struct print_log_value<the_type > { void operator()( std::ostream&, the_type const& ) {} }; }}}
+# 242 "/usr/include/boost/test/tools/detail/print_helper.hpp" 3 4
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 246 "/usr/include/boost/test/tools/detail/print_helper.hpp" 2 3 4
+# 25 "/usr/include/boost/test/tools/old/impl.hpp" 2 3 4
+
+
+
+# 1 "/usr/include/boost/numeric/conversion/conversion_traits.hpp" 1 3 4
+# 11 "/usr/include/boost/numeric/conversion/conversion_traits.hpp" 3 4
+#define BOOST_NUMERIC_CONVERSION_CONVERSION_TRAITS_FLC_12NOV2002_HPP 
+
+# 1 "/usr/include/boost/numeric/conversion/detail/conversion_traits.hpp" 1 3 4
+# 11 "/usr/include/boost/numeric/conversion/detail/conversion_traits.hpp" 3 4
+#define BOOST_NUMERIC_CONVERSION_DETAIL_CONVERSION_TRAITS_FLC_12NOV2002_HPP 
+
+
+
+
+
+# 1 "/usr/include/boost/numeric/conversion/detail/meta.hpp" 1 3 4
+# 11 "/usr/include/boost/numeric/conversion/detail/meta.hpp" 3 4
+#define BOOST_NUMERIC_CONVERSION_DETAIL_META_FLC_12NOV2002_HPP 
+
+
+
+
+
+# 1 "/usr/include/boost/mpl/equal_to.hpp" 1 3 4
+
+
+#define BOOST_MPL_EQUAL_TO_HPP_INCLUDED 
+# 17 "/usr/include/boost/mpl/equal_to.hpp" 3 4
+#define AUX778076_OP_NAME equal_to
+#define AUX778076_OP_TOKEN ==
+# 1 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 1 3 4
+# 22 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 3 4
+#define AUX778076_OP_PREFIX AUX778076_OP_NAME
+
+
+#define AUX778076_OP_ARITY 2
+
+# 1 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 1 3 4
+# 21 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 3 4
+# 1 "/usr/include/boost/mpl/numeric_cast.hpp" 1 3 4
+
+
+#define BOOST_MPL_NUMERIC_CAST_HPP_INCLUDED 
+# 27 "/usr/include/boost/mpl/numeric_cast.hpp" 3 4
+#define BOOST_MPL_AUX_NUMERIC_CAST numeric_cast
+
+
+namespace boost { namespace mpl {
+
+
+
+template< typename SourceTag, typename TargetTag > struct numeric_cast
+{
+    template< typename N > struct apply;
+};
+
+}}
+# 22 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 2 3 4
+# 1 "/usr/include/boost/mpl/apply_wrap.hpp" 1 3 4
+# 23 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 2 3 4
+
+# 1 "/usr/include/boost/mpl/tag.hpp" 1 3 4
+
+
+#define BOOST_MPL_TAG_HPP_INCLUDED 
+# 19 "/usr/include/boost/mpl/tag.hpp" 3 4
+# 1 "/usr/include/boost/mpl/aux_/has_tag.hpp" 1 3 4
+
+
+#define BOOST_MPL_AUX_HAS_TAG_HPP_INCLUDED 
+# 19 "/usr/include/boost/mpl/aux_/has_tag.hpp" 3 4
+namespace boost { namespace mpl { namespace aux {
+template< typename T, typename fallback_ = boost::mpl::bool_<false> > struct has_tag { struct gcc_3_2_wknd { template< typename U > static boost::mpl::aux::yes_tag test( boost::mpl::aux::type_wrapper<U> const volatile* , boost::mpl::aux::type_wrapper<typename U::tag>* = 0 ); static boost::mpl::aux::no_tag test(...); }; typedef boost::mpl::aux::type_wrapper<T> t_; static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::aux::yes_tag); typedef boost::mpl::bool_<value> type; };
+}}}
+# 20 "/usr/include/boost/mpl/tag.hpp" 2 3 4
+
+
+namespace boost { namespace mpl {
+
+namespace aux {
+template< typename T > struct tag_impl
+{
+    typedef typename T::tag type;
+};
+}
+
+template< typename T, typename Default = void_ > struct tag
+
+    : if_<
+          aux::has_tag<T>
+        , aux::tag_impl<T>
+        , Default
+        >::type
+{
+# 48 "/usr/include/boost/mpl/tag.hpp" 3 4
+};
+
+}}
+# 25 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 2 3 4
+# 1 "/usr/include/boost/mpl/aux_/numeric_cast_utils.hpp" 1 3 4
+
+
+#define BOOST_MPL_AUX_NUMERIC_CAST_HPP_INCLUDED 
+# 18 "/usr/include/boost/mpl/aux_/numeric_cast_utils.hpp" 3 4
+# 1 "/usr/include/boost/mpl/apply_wrap.hpp" 1 3 4
+# 19 "/usr/include/boost/mpl/aux_/numeric_cast_utils.hpp" 2 3 4
+# 1 "/usr/include/boost/mpl/aux_/config/forwarding.hpp" 1 3 4
+
+
+#define BOOST_MPL_AUX_CONFIG_FORWARDING_HPP_INCLUDED 
+# 20 "/usr/include/boost/mpl/aux_/numeric_cast_utils.hpp" 2 3 4
+
+namespace boost { namespace mpl { namespace aux {
+
+template<
+      typename F
+    , typename Tag1
+    , typename Tag2
+    >
+struct cast1st_impl
+{
+    template< typename N1, typename N2 > struct apply
+
+        : apply_wrap2<
+              F
+            , typename apply_wrap1< numeric_cast<Tag1,Tag2>,N1 >::type
+            , N2
+            >
+    {
+# 46 "/usr/include/boost/mpl/aux_/numeric_cast_utils.hpp" 3 4
+    };
+};
+
+template<
+      typename F
+    , typename Tag1
+    , typename Tag2
+    >
+struct cast2nd_impl
+{
+    template< typename N1, typename N2 > struct apply
+
+        : apply_wrap2<
+              F
+            , N1
+            , typename apply_wrap1< numeric_cast<Tag2,Tag1>,N2 >::type
+            >
+    {
+# 72 "/usr/include/boost/mpl/aux_/numeric_cast_utils.hpp" 3 4
+    };
+};
+
+}}}
+# 26 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 2 3 4
+
+
+
+# 1 "/usr/include/boost/mpl/aux_/msvc_eti_base.hpp" 1 3 4
+
+
+#define BOOST_MPL_AUX_MSVC_ETI_BASE_HPP_INCLUDED 
+# 17 "/usr/include/boost/mpl/aux_/msvc_eti_base.hpp" 3 4
+# 1 "/usr/include/boost/mpl/aux_/is_msvc_eti_arg.hpp" 1 3 4
+
+
+#define BOOST_MPL_AUX_IS_MSVC_ETI_ARG_HPP_INCLUDED 
+# 21 "/usr/include/boost/mpl/aux_/is_msvc_eti_arg.hpp" 3 4
+namespace boost { namespace mpl { namespace aux {
+# 62 "/usr/include/boost/mpl/aux_/is_msvc_eti_arg.hpp" 3 4
+}}}
+# 18 "/usr/include/boost/mpl/aux_/msvc_eti_base.hpp" 2 3 4
+
+
+
+
+namespace boost { namespace mpl { namespace aux {
+# 55 "/usr/include/boost/mpl/aux_/msvc_eti_base.hpp" 3 4
+template< typename T > struct msvc_eti_base
+    : T
+{
+
+    msvc_eti_base();
+
+    typedef T type;
+};
+
+
+
+template<> struct msvc_eti_base<int>
+{
+    typedef msvc_eti_base type;
+    typedef msvc_eti_base first;
+    typedef msvc_eti_base second;
+    typedef msvc_eti_base tag;
+    enum { value = 0 };
+};
+
+}}}
+# 30 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 2 3 4
+# 28 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 2 3 4
+
+
+
+
+
+
+#define BOOST_MPL_PREPROCESSED_HEADER AUX778076_OP_PREFIX.hpp
+# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
+# 23 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
+#define AUX778076_PREPROCESSED_HEADER BOOST_MPL_CFG_COMPILER_DIR/BOOST_MPL_PREPROCESSED_HEADER
+# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
+# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/equal_to.hpp" 1 3 4
+# 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/equal_to.hpp" 3 4
+namespace boost { namespace mpl {
+
+template<
+      typename Tag1
+    , typename Tag2
+    >
+struct equal_to_impl
+    : if_c<
+          ( Tag1::value
+              > Tag2::value
+            )
+
+        , aux::cast2nd_impl< equal_to_impl< Tag1,Tag1 >,Tag1, Tag2 >
+        , aux::cast1st_impl< equal_to_impl< Tag2,Tag2 >,Tag1, Tag2 >
+        >::type
+{
+};
+
+
+template<> struct equal_to_impl< na,na >
+{
+    template< typename U1, typename U2 > struct apply
+    {
+        typedef apply type;
+        static const int value = 0;
+    };
+};
+
+template< typename Tag > struct equal_to_impl< na,Tag >
+{
+    template< typename U1, typename U2 > struct apply
+    {
+        typedef apply type;
+        static const int value = 0;
+    };
+};
+
+template< typename Tag > struct equal_to_impl< Tag,na >
+{
+    template< typename U1, typename U2 > struct apply
+    {
+        typedef apply type;
+        static const int value = 0;
+    };
+};
+
+template< typename T > struct equal_to_tag
+{
+    typedef typename T::tag type;
+};
+
+template<
+      typename N1 = na
+    , typename N2 = na
+    >
+struct equal_to
+
+    : equal_to_impl<
+          typename equal_to_tag<N1>::type
+        , typename equal_to_tag<N2>::type
+        >::template apply< N1,N2 >::type
+{
+   
+
+};
+
+template<> struct equal_to< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : equal_to< T1 , T2 > { }; }; template< typename Tag > struct lambda< equal_to< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef equal_to< na , na > result_; typedef equal_to< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< equal_to< T1 , T2 > > : int_<2> { }; template<> struct template_arity< equal_to< na , na > > : int_<-1> { }; }
+
+}}
+
+namespace boost { namespace mpl {
+
+template<>
+struct equal_to_impl< integral_c_tag,integral_c_tag >
+{
+    template< typename N1, typename N2 > struct apply
+
+        : bool_< ( N1::value == N2::value ) >
+    {
+    };
+};
+
+}}
+# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
+
+
+#undef AUX778076_PREPROCESSED_HEADER
+
+#undef BOOST_MPL_PREPROCESSED_HEADER
+# 36 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 2 3 4
+# 78 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 3 4
+#undef AUX778076_OP_TAG_NAME
+#undef AUX778076_OP_IMPL_NAME
+#undef AUX778076_OP_ARITY
+#undef AUX778076_OP_PREFIX
+#undef AUX778076_OP_NAME
+#undef AUX778076_OP_TOKEN
+# 20 "/usr/include/boost/mpl/equal_to.hpp" 2 3 4
+# 18 "/usr/include/boost/numeric/conversion/detail/meta.hpp" 2 3 4
+
+
+
+
+
+namespace boost { namespace numeric { namespace convdetail
+{
+   template< class T1, class T2>
+   struct equal_to
+   {
+
+
+       enum { x = ( T1::value == T2::value ) };
+
+       static const bool value = x;
+
+       typedef mpl::bool_<value> type;
+# 48 "/usr/include/boost/numeric/conversion/detail/meta.hpp" 3 4
+   };
+# 59 "/usr/include/boost/numeric/conversion/detail/meta.hpp" 3 4
+  template<class Value,
+           class Case0Val,
+           class Case1Val,
+           class Case2Val,
+           class Case0Type,
+           class Case1Type,
+           class Case2Type,
+           class DefaultType
+          >
+  struct ct_switch4
+  {
+    typedef mpl::identity<Case0Type> Case0TypeQ ;
+    typedef mpl::identity<Case1Type> Case1TypeQ ;
+
+    typedef equal_to<Value,Case0Val> is_case0 ;
+    typedef equal_to<Value,Case1Val> is_case1 ;
+    typedef equal_to<Value,Case2Val> is_case2 ;
+
+    typedef mpl::if_<is_case2,Case2Type,DefaultType> choose_2_3Q ;
+    typedef mpl::eval_if<is_case1,Case1TypeQ,choose_2_3Q> choose_1_2_3Q ;
+
+    typedef typename
+      mpl::eval_if<is_case0,Case0TypeQ,choose_1_2_3Q>::type
+        type ;
+  } ;
+# 97 "/usr/include/boost/numeric/conversion/detail/meta.hpp" 3 4
+  template<class expr0, class expr1, class TT, class TF, class FT, class FF>
+  struct for_both
+  {
+    typedef mpl::identity<TF> TF_Q ;
+    typedef mpl::identity<TT> TT_Q ;
+
+    typedef typename mpl::not_<expr0>::type not_expr0 ;
+    typedef typename mpl::not_<expr1>::type not_expr1 ;
+
+    typedef typename mpl::and_<expr0,expr1>::type caseTT ;
+    typedef typename mpl::and_<expr0,not_expr1>::type caseTF ;
+    typedef typename mpl::and_<not_expr0,expr1>::type caseFT ;
+
+    typedef mpl::if_<caseFT,FT,FF> choose_FT_FF_Q ;
+    typedef mpl::eval_if<caseTF,TF_Q,choose_FT_FF_Q> choose_TF_FT_FF_Q ;
+
+    typedef typename mpl::eval_if<caseTT,TT_Q,choose_TF_FT_FF_Q>::type type ;
+  } ;
+
+} } }
+# 18 "/usr/include/boost/numeric/conversion/detail/conversion_traits.hpp" 2 3 4
+# 1 "/usr/include/boost/numeric/conversion/detail/int_float_mixture.hpp" 1 3 4
+# 11 "/usr/include/boost/numeric/conversion/detail/int_float_mixture.hpp" 3 4
+#define BOOST_NUMERIC_CONVERSION_DETAIL_INT_FLOAT_MIXTURE_FLC_12NOV2002_HPP 
+
+
+
+
+# 1 "/usr/include/boost/numeric/conversion/int_float_mixture_enum.hpp" 1 3 4
+# 11 "/usr/include/boost/numeric/conversion/int_float_mixture_enum.hpp" 3 4
+#define BOOST_NUMERIC_CONVERSION_INT_FLOAT_MIXTURE_ENUM_FLC_12NOV2002_HPP 
+
+namespace boost { namespace numeric
+{
+  enum int_float_mixture_enum
+  {
+     integral_to_integral
+    ,integral_to_float
+    ,float_to_integral
+    ,float_to_float
+  } ;
+
+} }
+# 17 "/usr/include/boost/numeric/conversion/detail/int_float_mixture.hpp" 2 3 4
+
+
+# 1 "/usr/include/boost/mpl/integral_c.hpp" 1 3 4
+
+
+#define BOOST_MPL_INTEGRAL_C_HPP_INCLUDED 
+# 17 "/usr/include/boost/mpl/integral_c.hpp" 3 4
+# 1 "/usr/include/boost/mpl/integral_c_fwd.hpp" 1 3 4
+
+
+#define BOOST_MPL_INTEGRAL_C_FWD_HPP_INCLUDED 
+# 20 "/usr/include/boost/mpl/integral_c_fwd.hpp" 3 4
+namespace mpl_ {
+
+
+
+
+
+template< typename T, T N > struct integral_c;
+
+
+}
+namespace boost { namespace mpl { using ::mpl_::integral_c; } }
+# 18 "/usr/include/boost/mpl/integral_c.hpp" 2 3 4
+# 26 "/usr/include/boost/mpl/integral_c.hpp" 3 4
+#define AUX_WRAPPER_PARAMS(N) typename T, T N
+
+
+#define AUX_WRAPPER_NAME integral_c
+#define AUX_WRAPPER_VALUE_TYPE T
+#define AUX_WRAPPER_INST(value) AUX_WRAPPER_NAME< T, value >
+# 1 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 1 3 4
+# 40 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 3 4
+namespace mpl_ {
+
+template< typename T, T N >
+struct integral_c
+{
+    static const T value = N;
+
+
+
+
+
+    typedef integral_c type;
+
+    typedef T value_type;
+    typedef integral_c_tag tag;
+# 72 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 3 4
+    typedef integral_c< T, static_cast<T>((value + 1)) > next;
+    typedef integral_c< T, static_cast<T>((value - 1)) > prior;
+
+
+
+
+
+
+    constexpr operator T() const { return static_cast<T>(this->value); }
+};
+
+
+template< typename T, T N >
+T const integral_c< T, N >::value;
+
+
+}
+
+#undef AUX_WRAPPER_NAME
+#undef AUX_WRAPPER_PARAMS
+#undef AUX_WRAPPER_INST
+#undef AUX_WRAPPER_VALUE_TYPE
+# 33 "/usr/include/boost/mpl/integral_c.hpp" 2 3 4
+
+
+
+
+namespace mpl_ {
+
+template< bool C >
+struct integral_c<bool, C>
+{
+    static const bool value = C;
+    typedef integral_c_tag tag;
+    typedef integral_c type;
+    typedef bool value_type;
+    operator bool() const { return this->value; }
+};
+}
+# 20 "/usr/include/boost/numeric/conversion/detail/int_float_mixture.hpp" 2 3 4
+
+namespace boost { namespace numeric { namespace convdetail
+{
+
+  typedef mpl::integral_c<int_float_mixture_enum, integral_to_integral> int2int_c ;
+  typedef mpl::integral_c<int_float_mixture_enum, integral_to_float> int2float_c ;
+  typedef mpl::integral_c<int_float_mixture_enum, float_to_integral> float2int_c ;
+  typedef mpl::integral_c<int_float_mixture_enum, float_to_float> float2float_c ;
+
+
+
+
+
+
+
+  template<class T,class S>
+  struct get_int_float_mixture
+  {
+    typedef mpl::bool_< ::std::numeric_limits<S>::is_integer > S_int ;
+    typedef mpl::bool_< ::std::numeric_limits<T>::is_integer > T_int ;
+
+    typedef typename
+      for_both<S_int, T_int, int2int_c, int2float_c, float2int_c, float2float_c>::type
+        type ;
+  } ;
+# 55 "/usr/include/boost/numeric/conversion/detail/int_float_mixture.hpp" 3 4
+  template<class IntFloatMixture, class Int2Int, class Int2Float, class Float2Int, class Float2Float>
+  struct for_int_float_mixture
+  {
+    typedef typename
+      ct_switch4<IntFloatMixture
+                 ,int2int_c, int2float_c, float2int_c
+                 ,Int2Int , Int2Float , Float2Int , Float2Float
+                >::type
+        type ;
+  } ;
+
+} } }
+# 19 "/usr/include/boost/numeric/conversion/detail/conversion_traits.hpp" 2 3 4
+# 1 "/usr/include/boost/numeric/conversion/detail/sign_mixture.hpp" 1 3 4
+# 11 "/usr/include/boost/numeric/conversion/detail/sign_mixture.hpp" 3 4
+#define BOOST_NUMERIC_CONVERSION_DETAIL_SIGN_MIXTURE_FLC_12NOV2002_HPP 
+
+
+
+
+# 1 "/usr/include/boost/numeric/conversion/sign_mixture_enum.hpp" 1 3 4
+# 11 "/usr/include/boost/numeric/conversion/sign_mixture_enum.hpp" 3 4
+#define BOOST_NUMERIC_CONVERSION_SIGN_MIXTURE_ENUM_FLC_12NOV2002_HPP 
+
+namespace boost { namespace numeric
+{
+  enum sign_mixture_enum
+  {
+     unsigned_to_unsigned
+    ,signed_to_signed
+    ,signed_to_unsigned
+    ,unsigned_to_signed
+  } ;
+
+} }
+# 17 "/usr/include/boost/numeric/conversion/detail/sign_mixture.hpp" 2 3 4
+
+
+
+
+namespace boost { namespace numeric { namespace convdetail
+{
+
+  typedef mpl::integral_c<sign_mixture_enum, unsigned_to_unsigned> unsig2unsig_c ;
+  typedef mpl::integral_c<sign_mixture_enum, signed_to_signed> sig2sig_c ;
+  typedef mpl::integral_c<sign_mixture_enum, signed_to_unsigned> sig2unsig_c ;
+  typedef mpl::integral_c<sign_mixture_enum, unsigned_to_signed> unsig2sig_c ;
+
+
+
+
+
+
+
+  template<class T,class S>
+  struct get_sign_mixture
+  {
+    typedef mpl::bool_< ::std::numeric_limits<S>::is_signed > S_signed ;
+    typedef mpl::bool_< ::std::numeric_limits<T>::is_signed > T_signed ;
+
+    typedef typename
+      for_both<S_signed, T_signed, sig2sig_c, sig2unsig_c, unsig2sig_c, unsig2unsig_c>::type
+        type ;
+  } ;
+# 55 "/usr/include/boost/numeric/conversion/detail/sign_mixture.hpp" 3 4
+  template<class SignMixture, class Sig2Sig, class Sig2Unsig, class Unsig2Sig, class Unsig2Unsig>
+  struct for_sign_mixture
+  {
+    typedef typename
+      ct_switch4<SignMixture
+                 , sig2sig_c, sig2unsig_c, unsig2sig_c
+                 , Sig2Sig , Sig2Unsig , Unsig2Sig , Unsig2Unsig
+                >::type
+        type ;
+  } ;
+
+} } }
+# 20 "/usr/include/boost/numeric/conversion/detail/conversion_traits.hpp" 2 3 4
+# 1 "/usr/include/boost/numeric/conversion/detail/udt_builtin_mixture.hpp" 1 3 4
+# 11 "/usr/include/boost/numeric/conversion/detail/udt_builtin_mixture.hpp" 3 4
+#define BOOST_NUMERIC_CONVERSION_DETAIL_UDT_BUILTIN_MIXTURE_FLC_12NOV2002_HPP 
+
+
+
+# 1 "/usr/include/boost/numeric/conversion/udt_builtin_mixture_enum.hpp" 1 3 4
+# 11 "/usr/include/boost/numeric/conversion/udt_builtin_mixture_enum.hpp" 3 4
+#define BOOST_NUMERIC_CONVERSION_UDT_BUILTIN_MIXTURE_ENUM_FLC_12NOV2002_HPP 
+
+namespace boost { namespace numeric
+{
+  enum udt_builtin_mixture_enum
+  {
+     builtin_to_builtin
+    ,builtin_to_udt
+    ,udt_to_builtin
+    ,udt_to_udt
+  } ;
+
+} }
+# 16 "/usr/include/boost/numeric/conversion/detail/udt_builtin_mixture.hpp" 2 3 4
+
+
+
+
+namespace boost { namespace numeric { namespace convdetail
+{
+
+  typedef mpl::integral_c<udt_builtin_mixture_enum, builtin_to_builtin> builtin2builtin_c ;
+  typedef mpl::integral_c<udt_builtin_mixture_enum, builtin_to_udt> builtin2udt_c ;
+  typedef mpl::integral_c<udt_builtin_mixture_enum, udt_to_builtin> udt2builtin_c ;
+  typedef mpl::integral_c<udt_builtin_mixture_enum, udt_to_udt> udt2udt_c ;
+# 37 "/usr/include/boost/numeric/conversion/detail/udt_builtin_mixture.hpp" 3 4
+  template<class UdtMixture, class BuiltIn2BuiltIn, class BuiltIn2Udt, class Udt2BuiltIn, class Udt2Udt>
+  struct for_udt_builtin_mixture
+  {
+    typedef typename
+      ct_switch4<UdtMixture
+                 , builtin2builtin_c, builtin2udt_c, udt2builtin_c
+                 , BuiltIn2BuiltIn , BuiltIn2Udt , Udt2BuiltIn , Udt2Udt
+                >::type
+        type ;
+  } ;
+
+
+
+
+
+
+
+  template<class T,class S>
+  struct get_udt_builtin_mixture
+  {
+    typedef is_arithmetic<S> S_builtin ;
+    typedef is_arithmetic<T> T_builtin ;
+
+    typedef typename
+      for_both<S_builtin, T_builtin, builtin2builtin_c, builtin2udt_c, udt2builtin_c, udt2udt_c>::type
+        type ;
+  } ;
+
+} } }
+# 21 "/usr/include/boost/numeric/conversion/detail/conversion_traits.hpp" 2 3 4
+# 1 "/usr/include/boost/numeric/conversion/detail/is_subranged.hpp" 1 3 4
+# 11 "/usr/include/boost/numeric/conversion/detail/is_subranged.hpp" 3 4
+#define BOOST_NUMERIC_CONVERSION_DETAIL_IS_SUBRANGED_FLC_12NOV2002_HPP 
+
+
+
+
+
+# 1 "/usr/include/boost/mpl/multiplies.hpp" 1 3 4
+
+
+#define BOOST_MPL_MULTIPLIES_HPP_INCLUDED 
+# 17 "/usr/include/boost/mpl/multiplies.hpp" 3 4
+# 1 "/usr/include/boost/mpl/times.hpp" 1 3 4
+
+
+#define BOOST_MPL_TIMES_HPP_INCLUDED 
+# 17 "/usr/include/boost/mpl/times.hpp" 3 4
+#define AUX778076_OP_NAME times
+#define AUX778076_OP_TOKEN *
+# 1 "/usr/include/boost/mpl/aux_/arithmetic_op.hpp" 1 3 4
+# 18 "/usr/include/boost/mpl/aux_/arithmetic_op.hpp" 3 4
+# 1 "/usr/include/boost/mpl/aux_/largest_int.hpp" 1 3 4
+
+
+#define BOOST_MPL_AUX_LARGEST_INT_HPP_INCLUDED 
+# 22 "/usr/include/boost/mpl/aux_/largest_int.hpp" 3 4
+namespace boost { namespace mpl { namespace aux {
+
+template< typename T > struct integral_rank;
+
+template<> struct integral_rank<bool> : int_<1> {};
+template<> struct integral_rank<signed char> : int_<2> {};
+template<> struct integral_rank<char> : int_<3> {};
+template<> struct integral_rank<unsigned char> : int_<4> {};
+
+template<> struct integral_rank<wchar_t> : int_<5> {};
+
+template<> struct integral_rank<short> : int_<6> {};
+template<> struct integral_rank<unsigned short> : int_<7> {};
+template<> struct integral_rank<int> : int_<8> {};
+template<> struct integral_rank<unsigned int> : int_<9> {};
+template<> struct integral_rank<long> : int_<10> {};
+template<> struct integral_rank<unsigned long> : int_<11> {};
+
+
+template<> struct integral_rank<long_long_type> : int_<12> {};
+template<> struct integral_rank<ulong_long_type>: int_<13> {};
+
+
+template< typename T1, typename T2 > struct largest_int
+
+    : if_c<
+          ( integral_rank<T1>::value >= integral_rank<T2>::value )
+        , T1
+        , T2
+        >
+{
+
+
+
+
+
+
+};
+
+}}}
+# 19 "/usr/include/boost/mpl/aux_/arithmetic_op.hpp" 2 3 4
+
+
+
+
+#define AUX778076_OP_PREFIX AUX778076_OP_NAME
+
+
+# 1 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 1 3 4
+# 22 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 3 4
+# 1 "/usr/include/boost/mpl/apply_wrap.hpp" 1 3 4
+# 23 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 2 3 4
+# 27 "/usr/include/boost/mpl/aux_/arithmetic_op.hpp" 2 3 4
+
+
+
+
+
+
+#define BOOST_MPL_PREPROCESSED_HEADER AUX778076_OP_PREFIX.hpp
+# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
+# 23 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
+#define AUX778076_PREPROCESSED_HEADER BOOST_MPL_CFG_COMPILER_DIR/BOOST_MPL_PREPROCESSED_HEADER
+# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
+# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/times.hpp" 1 3 4
+# 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/times.hpp" 3 4
+namespace boost { namespace mpl {
+
+template<
+      typename Tag1
+    , typename Tag2
+    >
+struct times_impl
+    : if_c<
+          ( Tag1::value
+              > Tag2::value
+            )
+
+        , aux::cast2nd_impl< times_impl< Tag1,Tag1 >,Tag1, Tag2 >
+        , aux::cast1st_impl< times_impl< Tag2,Tag2 >,Tag1, Tag2 >
+        >::type
+{
+};
+
+
+template<> struct times_impl< na,na >
+{
+    template< typename U1, typename U2 > struct apply
+    {
+        typedef apply type;
+        static const int value = 0;
+    };
+};
+
+template< typename Tag > struct times_impl< na,Tag >
+{
+    template< typename U1, typename U2 > struct apply
+    {
+        typedef apply type;
+        static const int value = 0;
+    };
+};
+
+template< typename Tag > struct times_impl< Tag,na >
+{
+    template< typename U1, typename U2 > struct apply
+    {
+        typedef apply type;
+        static const int value = 0;
+    };
+};
+
+template< typename T > struct times_tag
+{
+    typedef typename T::tag type;
+};
+
+template<
+      typename N1 = na
+    , typename N2 = na
+    , typename N3 = na, typename N4 = na, typename N5 = na
+    >
+struct times
+    : times< times< times< times< N1,N2 >, N3>, N4>, N5>
+{
+   
+
+
+
+
+};
+
+template<
+      typename N1, typename N2, typename N3, typename N4
+    >
+struct times< N1,N2,N3,N4,na >
+
+    : times< times< times< N1,N2 >, N3>, N4>
+{
+   
+
+
+
+
+};
+
+template<
+      typename N1, typename N2, typename N3
+    >
+struct times< N1,N2,N3,na,na >
+
+    : times< times< N1,N2 >, N3>
+{
+   
+
+
+
+
+};
+
+template<
+      typename N1, typename N2
+    >
+struct times< N1,N2,na,na,na >
+    : times_impl<
+          typename times_tag<N1>::type
+        , typename times_tag<N2>::type
+        >::template apply< N1,N2 >::type
+{
+   
+
+
+
+
+
+};
+
+template<> struct times< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : times< T1 , T2 > { }; }; template< typename Tag > struct lambda< times< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef times< na , na > result_; typedef times< na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > struct template_arity< times< T1 , T2 , T3 , T4 , T5 > > : int_<5> { }; template<> struct template_arity< times< na , na > > : int_<-1> { }; }
+
+}}
+
+namespace boost { namespace mpl {
+template<>
+struct times_impl< integral_c_tag,integral_c_tag >
+{
+    template< typename N1, typename N2 > struct apply
+
+        : integral_c<
+              typename aux::largest_int<
+                  typename N1::value_type
+                , typename N2::value_type
+                >::type
+            , ( N1::value
+                  * N2::value
+                )
+            >
+    {
+    };
+};
+
+}}
+# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
+
+
+#undef AUX778076_PREPROCESSED_HEADER
+
+#undef BOOST_MPL_PREPROCESSED_HEADER
+# 35 "/usr/include/boost/mpl/aux_/arithmetic_op.hpp" 2 3 4
+# 87 "/usr/include/boost/mpl/aux_/arithmetic_op.hpp" 3 4
+#undef AUX778076_OP_TAG_NAME
+#undef AUX778076_OP_IMPL_NAME
+#undef AUX778076_OP_ARITY
+#undef AUX778076_OP_PREFIX
+#undef AUX778076_OP_NAME
+#undef AUX778076_OP_TOKEN
+# 20 "/usr/include/boost/mpl/times.hpp" 2 3 4
+# 18 "/usr/include/boost/mpl/multiplies.hpp" 2 3 4
+# 26 "/usr/include/boost/mpl/multiplies.hpp" 3 4
+namespace boost { namespace mpl {
+
+
+#define AUX778076_OP_ARITY BOOST_MPL_LIMIT_METAFUNCTION_ARITY
+
+
+
+
+template<
+      typename N1 = na , typename N2 = na , typename N3 = na , typename N4 = na , typename N5 = na
+    >
+struct multiplies
+    : times< N1 , N2 , N3 , N4 , N5 >
+{
+   
+
+
+
+
+};
+
+template<> struct multiplies< na , na , na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > struct apply : multiplies< T1 , T2 , T3 , T4 , T5 > { }; }; template< typename Tag > struct lambda< multiplies< na , na , na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef multiplies< na , na , na , na , na > result_; typedef multiplies< na , na , na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > struct template_arity< multiplies< T1 , T2 , T3 , T4 , T5 > > : int_<5> { }; template<> struct template_arity< multiplies< na , na , na , na , na > > : int_<-1> { }; }
+
+#undef AUX778076_OP_ARITY
+
+}}
+# 18 "/usr/include/boost/numeric/conversion/detail/is_subranged.hpp" 2 3 4
+# 1 "/usr/include/boost/mpl/less.hpp" 1 3 4
+
+
+#define BOOST_MPL_LESS_HPP_INCLUDED 
+# 17 "/usr/include/boost/mpl/less.hpp" 3 4
+#define AUX778076_OP_NAME less
+#define AUX778076_OP_TOKEN <
+# 1 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 1 3 4
+# 22 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 3 4
+#define AUX778076_OP_PREFIX AUX778076_OP_NAME
+
+
+#define AUX778076_OP_ARITY 2
+
+# 1 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 1 3 4
+# 22 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 3 4
+# 1 "/usr/include/boost/mpl/apply_wrap.hpp" 1 3 4
+# 23 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 2 3 4
+# 28 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 2 3 4
+
+
+
+
+
+
+#define BOOST_MPL_PREPROCESSED_HEADER AUX778076_OP_PREFIX.hpp
+# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
+# 23 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
+#define AUX778076_PREPROCESSED_HEADER BOOST_MPL_CFG_COMPILER_DIR/BOOST_MPL_PREPROCESSED_HEADER
+# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
+# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/less.hpp" 1 3 4
+# 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/less.hpp" 3 4
+namespace boost { namespace mpl {
+
+template<
+      typename Tag1
+    , typename Tag2
+    >
+struct less_impl
+    : if_c<
+          ( Tag1::value
+              > Tag2::value
+            )
+
+        , aux::cast2nd_impl< less_impl< Tag1,Tag1 >,Tag1, Tag2 >
+        , aux::cast1st_impl< less_impl< Tag2,Tag2 >,Tag1, Tag2 >
+        >::type
+{
+};
+
+
+template<> struct less_impl< na,na >
+{
+    template< typename U1, typename U2 > struct apply
+    {
+        typedef apply type;
+        static const int value = 0;
+    };
+};
+
+template< typename Tag > struct less_impl< na,Tag >
+{
+    template< typename U1, typename U2 > struct apply
+    {
+        typedef apply type;
+        static const int value = 0;
+    };
+};
+
+template< typename Tag > struct less_impl< Tag,na >
+{
+    template< typename U1, typename U2 > struct apply
+    {
+        typedef apply type;
+        static const int value = 0;
+    };
+};
+
+template< typename T > struct less_tag
+{
+    typedef typename T::tag type;
+};
+
+template<
+      typename N1 = na
+    , typename N2 = na
+    >
+struct less
+
+    : less_impl<
+          typename less_tag<N1>::type
+        , typename less_tag<N2>::type
+        >::template apply< N1,N2 >::type
+{
+   
+
+};
+
+template<> struct less< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : less< T1 , T2 > { }; }; template< typename Tag > struct lambda< less< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef less< na , na > result_; typedef less< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< less< T1 , T2 > > : int_<2> { }; template<> struct template_arity< less< na , na > > : int_<-1> { }; }
+
+}}
+
+namespace boost { namespace mpl {
+
+template<>
+struct less_impl< integral_c_tag,integral_c_tag >
+{
+    template< typename N1, typename N2 > struct apply
+
+        : bool_< ( N2::value > N1::value ) >
+    {
+    };
+};
+
+}}
+# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
+
+
+#undef AUX778076_PREPROCESSED_HEADER
+
+#undef BOOST_MPL_PREPROCESSED_HEADER
+# 36 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 2 3 4
+# 78 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 3 4
+#undef AUX778076_OP_TAG_NAME
+#undef AUX778076_OP_IMPL_NAME
+#undef AUX778076_OP_ARITY
+#undef AUX778076_OP_PREFIX
+#undef AUX778076_OP_NAME
+#undef AUX778076_OP_TOKEN
+# 20 "/usr/include/boost/mpl/less.hpp" 2 3 4
+# 19 "/usr/include/boost/numeric/conversion/detail/is_subranged.hpp" 2 3 4
+# 28 "/usr/include/boost/numeric/conversion/detail/is_subranged.hpp" 3 4
+namespace boost { namespace numeric { namespace convdetail
+{
+
+
+
+
+
+    template<class T,class S>
+    struct subranged_Sig2Unsig
+    {
+
+
+      typedef mpl::true_ type ;
+    } ;
+
+
+    template<class T,class S>
+    struct subranged_Unsig2Sig
+    {
+# 62 "/usr/include/boost/numeric/conversion/detail/is_subranged.hpp" 3 4
+       typedef mpl::int_< ::std::numeric_limits<S>::digits > S_digits ;
+       typedef mpl::int_< ::std::numeric_limits<T>::digits > T_digits ;
+
+
+       typedef typename T_digits::next u_T_digits ;
+
+       typedef mpl::int_<2> Two ;
+
+       typedef typename mpl::multiplies<S_digits,Two>::type S_digits_times_2 ;
+
+       typedef typename mpl::less<u_T_digits,S_digits_times_2>::type type ;
+    } ;
+
+
+    template<class T,class S>
+    struct subranged_SameSign
+    {
+
+
+       typedef mpl::int_< ::std::numeric_limits<S>::digits > S_digits ;
+       typedef mpl::int_< ::std::numeric_limits<T>::digits > T_digits ;
+
+       typedef typename mpl::less<T_digits,S_digits>::type type ;
+    } ;
+
+
+    template<class T,class S>
+    struct subranged_Int2Float
+    {
+      typedef mpl::false_ type ;
+    } ;
+
+
+    template<class T,class S>
+    struct subranged_Float2Int
+    {
+      typedef mpl::true_ type ;
+    } ;
+
+
+    template<class T,class S>
+    struct subranged_Float2Float
+    {
+
+
+
+      typedef mpl::int_< ::std::numeric_limits<S>::digits > S_mantisa ;
+      typedef mpl::int_< ::std::numeric_limits<T>::digits > T_mantisa ;
+
+      typedef mpl::int_< ::std::numeric_limits<S>::max_exponent > S_exponent ;
+      typedef mpl::int_< ::std::numeric_limits<T>::max_exponent > T_exponent ;
+
+      typedef typename mpl::less<T_exponent,S_exponent>::type T_smaller_exponent ;
+
+      typedef typename mpl::equal_to<T_exponent,S_exponent>::type equal_exponents ;
+
+      typedef mpl::less<T_mantisa,S_mantisa> T_smaller_mantisa ;
+
+      typedef mpl::eval_if<equal_exponents,T_smaller_mantisa,mpl::false_> not_bigger_exponent_case ;
+
+      typedef typename
+        mpl::eval_if<T_smaller_exponent,mpl::true_,not_bigger_exponent_case>::type
+          type ;
+    } ;
+
+
+    template<class T,class S>
+    struct subranged_Udt2BuiltIn
+    {
+      typedef mpl::true_ type ;
+    } ;
+
+
+    template<class T,class S>
+    struct subranged_BuiltIn2Udt
+    {
+      typedef mpl::false_ type ;
+    } ;
+
+
+    template<class T,class S>
+    struct subranged_Udt2Udt
+    {
+      typedef mpl::false_ type ;
+    } ;
+
+
+
+
+
+    template<class T,class S>
+    struct get_subranged_Int2Int
+    {
+      typedef subranged_SameSign<T,S> Sig2Sig ;
+      typedef subranged_Sig2Unsig<T,S> Sig2Unsig ;
+      typedef subranged_Unsig2Sig<T,S> Unsig2Sig ;
+      typedef Sig2Sig Unsig2Unsig ;
+
+      typedef typename get_sign_mixture<T,S>::type sign_mixture ;
+
+      typedef typename
+        for_sign_mixture<sign_mixture, Sig2Sig, Sig2Unsig, Unsig2Sig, Unsig2Unsig>::type
+           type ;
+    } ;
+
+    template<class T,class S>
+    struct get_subranged_BuiltIn2BuiltIn
+    {
+      typedef get_subranged_Int2Int<T,S> Int2IntQ ;
+
+      typedef subranged_Int2Float <T,S> Int2Float ;
+      typedef subranged_Float2Int <T,S> Float2Int ;
+      typedef subranged_Float2Float<T,S> Float2Float ;
+
+      typedef mpl::identity<Int2Float > Int2FloatQ ;
+      typedef mpl::identity<Float2Int > Float2IntQ ;
+      typedef mpl::identity<Float2Float> Float2FloatQ ;
+
+      typedef typename get_int_float_mixture<T,S>::type int_float_mixture ;
+
+      typedef for_int_float_mixture<int_float_mixture, Int2IntQ, Int2FloatQ, Float2IntQ, Float2FloatQ> for_ ;
+
+      typedef typename for_::type selected ;
+
+      typedef typename selected::type type ;
+    } ;
+
+    template<class T,class S>
+    struct get_subranged
+    {
+      typedef get_subranged_BuiltIn2BuiltIn<T,S> BuiltIn2BuiltInQ ;
+
+      typedef subranged_BuiltIn2Udt<T,S> BuiltIn2Udt ;
+      typedef subranged_Udt2BuiltIn<T,S> Udt2BuiltIn ;
+      typedef subranged_Udt2Udt<T,S> Udt2Udt ;
+
+      typedef mpl::identity<BuiltIn2Udt> BuiltIn2UdtQ ;
+      typedef mpl::identity<Udt2BuiltIn> Udt2BuiltInQ ;
+      typedef mpl::identity<Udt2Udt > Udt2UdtQ ;
+
+      typedef typename get_udt_builtin_mixture<T,S>::type udt_builtin_mixture ;
+
+      typedef typename
+        for_udt_builtin_mixture<udt_builtin_mixture, BuiltIn2BuiltInQ, BuiltIn2UdtQ, Udt2BuiltInQ, Udt2UdtQ>::type
+          selected ;
+
+      typedef typename selected::type selected2 ;
+
+      typedef typename selected2::type type ;
+    } ;
+
+
+
+
+
+  template<class T, class S>
+  struct get_is_subranged
+  {
+    typedef get_subranged<T,S> non_trivial_case ;
+    typedef mpl::identity<mpl::false_> trivial_case ;
+
+    typedef is_same<T,S> is_trivial ;
+
+    typedef typename mpl::if_<is_trivial,trivial_case,non_trivial_case>::type selected ;
+
+    typedef typename selected::type type ;
+  } ;
+
+} } }
+# 22 "/usr/include/boost/numeric/conversion/detail/conversion_traits.hpp" 2 3 4
+
+namespace boost { namespace numeric { namespace convdetail
+{
+
+
+
+
+
+  template<class T,class S>
+  struct non_trivial_traits_impl
+  {
+    typedef typename get_int_float_mixture <T,S>::type int_float_mixture ;
+    typedef typename get_sign_mixture <T,S>::type sign_mixture ;
+    typedef typename get_udt_builtin_mixture <T,S>::type udt_builtin_mixture ;
+
+    typedef typename get_is_subranged<T,S>::type subranged ;
+
+    typedef mpl::false_ trivial ;
+
+    typedef T target_type ;
+    typedef S source_type ;
+    typedef T result_type ;
+
+    typedef typename mpl::if_< is_arithmetic<S>, S, S const&>::type argument_type ;
+
+    typedef typename mpl::if_<subranged,S,T>::type supertype ;
+    typedef typename mpl::if_<subranged,T,S>::type subtype ;
+  } ;
+
+
+
+
+
+
+  template<class N>
+  struct trivial_traits_impl
+  {
+    typedef typename get_int_float_mixture <N,N>::type int_float_mixture ;
+    typedef typename get_sign_mixture <N,N>::type sign_mixture ;
+    typedef typename get_udt_builtin_mixture<N,N>::type udt_builtin_mixture ;
+
+    typedef mpl::false_ subranged ;
+    typedef mpl::true_ trivial ;
+
+    typedef N target_type ;
+    typedef N source_type ;
+    typedef N const& result_type ;
+    typedef N const& argument_type ;
+
+    typedef N supertype ;
+    typedef N subtype ;
+
+  } ;
+
+
+
+
+  template<class T, class S>
+  struct get_conversion_traits
+  {
+    typedef typename remove_cv<T>::type target_type ;
+    typedef typename remove_cv<S>::type source_type ;
+
+    typedef typename is_same<target_type,source_type>::type is_trivial ;
+
+    typedef trivial_traits_impl <target_type> trivial_imp ;
+    typedef non_trivial_traits_impl<target_type,source_type> non_trivial_imp ;
+
+    typedef typename mpl::if_<is_trivial,trivial_imp,non_trivial_imp>::type type ;
+  } ;
+
+} } }
+# 14 "/usr/include/boost/numeric/conversion/conversion_traits.hpp" 2 3 4
+
+
+
+namespace boost { namespace numeric
+{
+
+template<class T, class S>
+struct conversion_traits
+    : convdetail::get_conversion_traits<T,S>::type
+{
+} ;
+
+} }
+# 29 "/usr/include/boost/test/tools/old/impl.hpp" 2 3 4
+
+
+
+
+
+
+
+# 1 "/usr/include/c++/10.2.0/climits" 1 3 4
+# 39 "/usr/include/c++/10.2.0/climits" 3 4
+       
+# 40 "/usr/include/c++/10.2.0/climits" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include-fixed/limits.h" 1 3 4
+# 43 "/usr/include/c++/10.2.0/climits" 2 3
+# 37 "/usr/include/boost/test/tools/old/impl.hpp" 2 3 4
+
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 39 "/usr/include/boost/test/tools/old/impl.hpp" 2 3 4
+
+
+
+namespace boost {
+namespace test_tools {
+namespace tt_detail {
+# 54 "/usr/include/boost/test/tools/old/impl.hpp" 3 4
+#define TEMPL_PARAMS(z,m,dummy) , typename BOOST_JOIN( Arg, m )
+
+#define FUNC_PARAMS(z,m,dummy) , BOOST_JOIN( Arg, m ) const& BOOST_JOIN( arg, m ) , char const* BOOST_JOIN( BOOST_JOIN( arg, m ), _descr )
+
+
+
+
+#define PRED_PARAMS(z,m,dummy) BOOST_PP_COMMA_IF( m ) BOOST_JOIN( arg, m )
+
+#define ARG_INFO(z,m,dummy) , BOOST_JOIN( BOOST_JOIN( arg, m ), _descr ) , &static_cast<const unit_test::lazy_ostream&>(unit_test::lazy_ostream::instance() << ::boost::test_tools::tt_detail::print_helper( BOOST_JOIN( arg, m ) ))
+
+
+
+
+
+#define IMPL_FRWD(z,n,dummy) template<typename Pred BOOST_PP_REPEAT_ ## z( BOOST_PP_ADD( n, 1 ), TEMPL_PARAMS, _ )> inline bool check_frwd( Pred P, unit_test::lazy_ostream const& assertion_descr, const_string file_name, std::size_t line_num, tool_level tl, check_type ct BOOST_PP_REPEAT_ ## z( BOOST_PP_ADD( n, 1 ), FUNC_PARAMS, _ ) ) { return report_assertion( P( BOOST_PP_REPEAT_ ## z(BOOST_PP_ADD(n, 1), PRED_PARAMS,_) ), assertion_descr, file_name, line_num, tl, ct, BOOST_PP_ADD( n, 1 ) BOOST_PP_REPEAT_ ## z( BOOST_PP_ADD( n, 1 ), ARG_INFO, _ ) ); }
+# 89 "/usr/include/boost/test/tools/old/impl.hpp" 3 4
+#define BOOST_TEST_MAX_PREDICATE_ARITY 5
+
+
+template<typename Pred , typename Arg0> inline bool check_frwd( Pred P, unit_test::lazy_ostream const& assertion_descr, const_string file_name, std::size_t line_num, tool_level tl, check_type ct , Arg0 const& arg0 , char const* arg0_descr ) { return report_assertion( P( arg0 ), assertion_descr, file_name, line_num, tl, ct, 1 , arg0_descr , &static_cast<const unit_test::lazy_ostream&>(unit_test::lazy_ostream::instance() << ::boost::test_tools::tt_detail::print_helper( arg0 )) ); } template<typename Pred , typename Arg0 , typename Arg1> inline bool check_frwd( Pred P, unit_test::lazy_ostream const& assertion_descr, const_string file_name, std::size_t line_num, tool_level tl, check_type ct , Arg0 const& arg0 , char const* arg0_descr , Arg1 const& arg1 , char const* arg1_descr ) { return report_assertion( P( arg0 , arg1 ), assertion_descr, file_name, line_num, tl, ct, 2 , arg0_descr , &static_cast<const unit_test::lazy_ostream&>(unit_test::lazy_ostream::instance() << ::boost::test_tools::tt_detail::print_helper( arg0 )) , arg1_descr , &static_cast<const unit_test::lazy_ostream&>(unit_test::lazy_ostream::instance() << ::boost::test_tools::tt_detail::print_helper( arg1 )) ); } template<typename Pred , typename Arg0 , typename Arg1 , typename Arg2> inline bool check_frwd( Pred P, unit_test::lazy_ostream const& assertion_descr, const_string file_name, std::size_t line_num, tool_level tl, check_type ct , Arg0 const& arg0 , char const* arg0_descr , Arg1 const& arg1 , char const* arg1_descr , Arg2 const& arg2 , char const* arg2_descr ) { return report_assertion( P( arg0 , arg1 , arg2 ), assertion_descr, file_name, line_num, tl, ct, 3 , arg0_descr , &static_cast<const unit_test::lazy_ostream&>(unit_test::lazy_ostream::instance() << ::boost::test_tools::tt_detail::print_helper( arg0 )) , arg1_descr , &static_cast<const unit_test::lazy_ostream&>(unit_test::lazy_ostream::instance() << ::boost::test_tools::tt_detail::print_helper( arg1 )) , arg2_descr , &static_cast<const unit_test::lazy_ostream&>(unit_test::lazy_ostream::instance() << ::boost::test_tools::tt_detail::print_helper( arg2 )) ); } template<typename Pred , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3> inline bool check_frwd( Pred P, unit_test::lazy_ostream const& assertion_descr, const_string file_name, std::size_t line_num, tool_level tl, check_type ct , Arg0 const& arg0 , char const* arg0_descr , Arg1 const& arg1 , char const* arg1_descr , Arg2 const& arg2 , char const* arg2_descr , Arg3 const& arg3 , char const* arg3_descr ) { return report_assertion( P( arg0 , arg1 , arg2 , arg3 ), assertion_descr, file_name, line_num, tl, ct, 4 , arg0_descr , &static_cast<const unit_test::lazy_ostream&>(unit_test::lazy_ostream::instance() << ::boost::test_tools::tt_detail::print_helper( arg0 )) , arg1_descr , &static_cast<const unit_test::lazy_ostream&>(unit_test::lazy_ostream::instance() << ::boost::test_tools::tt_detail::print_helper( arg1 )) , arg2_descr , &static_cast<const unit_test::lazy_ostream&>(unit_test::lazy_ostream::instance() << ::boost::test_tools::tt_detail::print_helper( arg2 )) , arg3_descr , &static_cast<const unit_test::lazy_ostream&>(unit_test::lazy_ostream::instance() << ::boost::test_tools::tt_detail::print_helper( arg3 )) ); } template<typename Pred , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4> inline bool check_frwd( Pred P, unit_test::lazy_ostream const& assertion_descr, const_string file_name, std::size_t line_num, tool_level tl, check_type ct , Arg0 const& arg0 , char const* arg0_descr , Arg1 const& arg1 , char const* arg1_descr , Arg2 const& arg2 , char const* arg2_descr , Arg3 const& arg3 , char const* arg3_descr , Arg4 const& arg4 , char const* arg4_descr ) { return report_assertion( P( arg0 , arg1 , arg2 , arg3 , arg4 ), assertion_descr, file_name, line_num, tl, ct, 5 , arg0_descr , &static_cast<const unit_test::lazy_ostream&>(unit_test::lazy_ostream::instance() << ::boost::test_tools::tt_detail::print_helper( arg0 )) , arg1_descr , &static_cast<const unit_test::lazy_ostream&>(unit_test::lazy_ostream::instance() << ::boost::test_tools::tt_detail::print_helper( arg1 )) , arg2_descr , &static_cast<const unit_test::lazy_ostream&>(unit_test::lazy_ostream::instance() << ::boost::test_tools::tt_detail::print_helper( arg2 )) , arg3_descr , &static_cast<const unit_test::lazy_ostream&>(unit_test::lazy_ostream::instance() << ::boost::test_tools::tt_detail::print_helper( arg3 )) , arg4_descr , &static_cast<const unit_test::lazy_ostream&>(unit_test::lazy_ostream::instance() << ::boost::test_tools::tt_detail::print_helper( arg4 )) ); }
+
+#undef TEMPL_PARAMS
+#undef FUNC_PARAMS
+#undef PRED_INFO
+#undef ARG_INFO
+#undef IMPL_FRWD
+
+
+
+
+
+template <class Left, class Right>
+inline assertion_result equal_impl( Left const& left, Right const& right )
+{
+    return left == right;
+}
+
+
+
+inline assertion_result equal_impl( char* left, char const* right ) { return equal_impl( static_cast<char const*>(left), static_cast<char const*>(right) ); }
+inline assertion_result equal_impl( char const* left, char* right ) { return equal_impl( static_cast<char const*>(left), static_cast<char const*>(right) ); }
+inline assertion_result equal_impl( char* left, char* right ) { return equal_impl( static_cast<char const*>(left), static_cast<char const*>(right) ); }
+
+
+__attribute__((__visibility__("default"))) assertion_result equal_impl( wchar_t const* left, wchar_t const* right );
+inline assertion_result equal_impl( wchar_t* left, wchar_t const* right ) { return equal_impl( static_cast<wchar_t const*>(left), static_cast<wchar_t const*>(right) ); }
+inline assertion_result equal_impl( wchar_t const* left, wchar_t* right ) { return equal_impl( static_cast<wchar_t const*>(left), static_cast<wchar_t const*>(right) ); }
+inline assertion_result equal_impl( wchar_t* left, wchar_t* right ) { return equal_impl( static_cast<wchar_t const*>(left), static_cast<wchar_t const*>(right) ); }
+
+
+
+
+struct equal_impl_frwd {
+    template <typename Left, typename Right>
+    inline assertion_result
+    call_impl( Left const& left, Right const& right, mpl::false_ ) const
+    {
+        return equal_impl( left, right );
+    }
+
+    template <typename Left, typename Right>
+    inline assertion_result
+    call_impl( Left const& left, Right const& right, mpl::true_ ) const
+    {
+        return (*this)( right, &left[0] );
+    }
+
+    template <typename Left, typename Right>
+    inline assertion_result
+    operator()( Left const& left, Right const& right ) const
+    {
+        typedef typename is_array<Left>::type left_is_array;
+        return call_impl( left, right, left_is_array() );
+    }
+};
+
+
+
+struct ne_impl {
+    template <class Left, class Right>
+    assertion_result operator()( Left const& left, Right const& right )
+    {
+        return !equal_impl_frwd()( left, right );
+    }
+};
+
+
+
+struct lt_impl {
+    template <class Left, class Right>
+    assertion_result operator()( Left const& left, Right const& right )
+    {
+        return left < right;
+    }
+};
+
+
+
+struct le_impl {
+    template <class Left, class Right>
+    assertion_result operator()( Left const& left, Right const& right )
+    {
+        return left <= right;
+    }
+};
+
+
+
+struct gt_impl {
+    template <class Left, class Right>
+    assertion_result operator()( Left const& left, Right const& right )
+    {
+        return left > right;
+    }
+};
+
+
+
+struct ge_impl {
+    template <class Left, class Right>
+    assertion_result operator()( Left const& left, Right const& right )
+    {
+        return left >= right;
+    }
+};
+
+
+
+struct equal_coll_impl {
+    template <typename Left, typename Right>
+    assertion_result operator()( Left left_begin, Left left_end, Right right_begin, Right right_end )
+    {
+        assertion_result pr( true );
+        std::size_t pos = 0;
+
+        for( ; left_begin != left_end && right_begin != right_end; ++left_begin, ++right_begin, ++pos ) {
+            if( *left_begin != *right_begin ) {
+                pr = false;
+                pr.message() << "\nMismatch at position " << pos << ": "
+                  << ::boost::test_tools::tt_detail::print_helper(*left_begin)
+                  << " != "
+                  << ::boost::test_tools::tt_detail::print_helper(*right_begin);
+            }
+        }
+
+        if( left_begin != left_end ) {
+            std::size_t r_size = pos;
+            while( left_begin != left_end ) {
+                ++pos;
+                ++left_begin;
+            }
+
+            pr = false;
+            pr.message() << "\nCollections size mismatch: " << pos << " != " << r_size;
+        }
+
+        if( right_begin != right_end ) {
+            std::size_t l_size = pos;
+            while( right_begin != right_end ) {
+                ++pos;
+                ++right_begin;
+            }
+
+            pr = false;
+            pr.message() << "\nCollections size mismatch: " << l_size << " != " << pos;
+        }
+
+        return pr;
+    }
+};
+
+
+
+struct bitwise_equal_impl {
+    template <class Left, class Right>
+    assertion_result operator()( Left const& left, Right const& right )
+    {
+        assertion_result pr( true );
+
+        std::size_t left_bit_size = sizeof(Left)*8;
+        std::size_t right_bit_size = sizeof(Right)*8;
+
+        static Left const leftOne( 1 );
+        static Right const rightOne( 1 );
+
+        std::size_t total_bits = left_bit_size < right_bit_size ? left_bit_size : right_bit_size;
+
+        for( std::size_t counter = 0; counter < total_bits; ++counter ) {
+            if( ( left & ( leftOne << counter ) ) != ( right & ( rightOne << counter ) ) ) {
+                pr = false;
+                pr.message() << "\nMismatch at position " << counter;
+            }
+        }
+
+        if( left_bit_size != right_bit_size ) {
+            pr = false;
+            pr.message() << "\nOperands bit sizes mismatch: " << left_bit_size << " != " << right_bit_size;
+        }
+
+        return pr;
+    }
+};
+
+
+
+template<typename FPT1, typename FPT2>
+struct comp_supertype {
+
+
+
+
+    typedef typename numeric::conversion_traits<FPT1,FPT2>::supertype type;
+    static_assert(!is_integral<type>::value, "Only floating-point types can be compared!");
+};
+
+}
+
+namespace fpc = math::fpc;
+
+
+
+
+
+struct __attribute__((__visibility__("default"))) check_is_close_t {
+
+    typedef assertion_result result_type;
+
+    template<typename FPT1, typename FPT2, typename ToleranceType>
+    assertion_result
+    operator()( FPT1 left, FPT2 right, ToleranceType tolerance ) const
+    {
+        fpc::close_at_tolerance<typename tt_detail::comp_supertype<FPT1,FPT2>::type> pred( tolerance, fpc::FPC_STRONG );
+
+        assertion_result ar( pred( left, right ) );
+
+        if( !ar )
+            ar.message() << pred.tested_rel_diff();
+
+        return ar;
+    }
+};
+
+
+
+template<typename FPT1, typename FPT2, typename ToleranceType>
+inline assertion_result
+check_is_close( FPT1 left, FPT2 right, ToleranceType tolerance )
+{
+    return check_is_close_t()( left, right, tolerance );
+}
+
+
+
+
+
+
+
+struct __attribute__((__visibility__("default"))) check_is_small_t {
+
+    typedef bool result_type;
+
+    template<typename FPT>
+    bool
+    operator()( FPT fpv, FPT tolerance ) const
+    {
+        return fpc::is_small( fpv, tolerance );
+    }
+};
+
+
+
+template<typename FPT>
+inline bool
+check_is_small( FPT fpv, FPT tolerance )
+{
+    return fpc::is_small( fpv, tolerance );
+}
+
+
+
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 357 "/usr/include/boost/test/tools/old/impl.hpp" 2 3 4
+# 47 "/usr/include/boost/test/test_tools.hpp" 2 3 4
+
+
+
+
+
+# 1 "/usr/include/boost/test/tools/interface.hpp" 1 3 4
+# 16 "/usr/include/boost/test/tools/interface.hpp" 3 4
+#define BOOST_TEST_TOOLS_INTERFACE_HPP_111712GER 
+# 35 "/usr/include/boost/test/tools/interface.hpp" 3 4
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 36 "/usr/include/boost/test/tools/interface.hpp" 2 3 4
+
+
+
+
+
+
+
+#define BOOST_TEST_BUILD_ASSERTION(P) (::boost::test_tools::assertion::seed()->*P)
+
+
+
+
+
+
+#define BOOST_TEST_TOOL_DIRECT_IMPL(P,level,M) do { ::boost::test_tools::assertion_result res = (P); report_assertion( res, BOOST_TEST_LAZY_MSG( M ), BOOST_TEST_L(__FILE__), static_cast<std::size_t>(__LINE__), ::boost::test_tools::tt_detail::level, ::boost::test_tools::tt_detail::CHECK_MSG, 0 ); } while( ::boost::test_tools::tt_detail::dummy_cond() )
+# 67 "/usr/include/boost/test/tools/interface.hpp" 3 4
+#define BOOST_TEST_TOOL_ET_IMPL(P,level) do { BOOST_TEST_PASSPOINT(); ::boost::test_tools::tt_detail:: report_assertion( BOOST_TEST_BUILD_ASSERTION( P ).evaluate(), BOOST_TEST_LAZY_MSG( BOOST_TEST_STRINGIZE( P ) ), BOOST_TEST_L(__FILE__), static_cast<std::size_t>(__LINE__), ::boost::test_tools::tt_detail::level, ::boost::test_tools::tt_detail::CHECK_BUILT_ASSERTION, 0 ); } while( ::boost::test_tools::tt_detail::dummy_cond() )
+# 86 "/usr/include/boost/test/tools/interface.hpp" 3 4
+#define BOOST_TEST_TOOL_ET_IMPL_EX(P,level,arg) do { BOOST_TEST_PASSPOINT(); ::boost::test_tools::tt_detail:: report_assertion( ::boost::test_tools::tt_detail::assertion_evaluate( BOOST_TEST_BUILD_ASSERTION( P ) ) << arg, ::boost::test_tools::tt_detail::assertion_text( BOOST_TEST_LAZY_MSG( BOOST_TEST_STRINGIZE(P) ), BOOST_TEST_LAZY_MSG( arg ) ), BOOST_TEST_L(__FILE__), static_cast<std::size_t>(__LINE__), ::boost::test_tools::tt_detail::level, ::boost::test_tools::tt_detail::assertion_type() << arg, 0 ); } while( ::boost::test_tools::tt_detail::dummy_cond() )
+# 136 "/usr/include/boost/test/tools/interface.hpp" 3 4
+#define BOOST_TEST_TOOL_UNIV(level,P) BOOST_TEST_TOOL_ET_IMPL( P, level )
+
+
+
+#define BOOST_TEST_TOOL_UNIV_EX(level,P,...) BOOST_TEST_TOOL_ET_IMPL_EX( P, level, __VA_ARGS__ )
+
+
+
+
+
+
+
+#define BOOST_TEST_WARN(...) BOOST_TEST_INVOKE_IF_N_ARGS( 2, BOOST_TEST_TOOL_UNIV, BOOST_TEST_TOOL_UNIV_EX, WARN, __VA_ARGS__ )
+
+
+#define BOOST_TEST_CHECK(...) BOOST_TEST_INVOKE_IF_N_ARGS( 2, BOOST_TEST_TOOL_UNIV, BOOST_TEST_TOOL_UNIV_EX, CHECK, __VA_ARGS__ )
+
+
+#define BOOST_TEST_REQUIRE(...) BOOST_TEST_INVOKE_IF_N_ARGS( 2, BOOST_TEST_TOOL_UNIV, BOOST_TEST_TOOL_UNIV_EX, REQUIRE, __VA_ARGS__ )
+
+
+
+#define BOOST_TEST(...) BOOST_TEST_INVOKE_IF_N_ARGS( 2, BOOST_TEST_TOOL_UNIV, BOOST_TEST_TOOL_UNIV_EX, CHECK, __VA_ARGS__ )
+
+
+
+
+
+#define BOOST_TEST_ERROR(M) BOOST_CHECK_MESSAGE( false, M )
+#define BOOST_TEST_FAIL(M) BOOST_REQUIRE_MESSAGE( false, M )
+
+
+
+#define BOOST_TEST_IS_DEFINED(symb) ::boost::test_tools::tt_detail::is_defined_impl( symb, BOOST_STRINGIZE(= symb) )
+# 367 "/usr/include/boost/test/tools/interface.hpp" 3 4
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 368 "/usr/include/boost/test/tools/interface.hpp" 2 3 4
+# 53 "/usr/include/boost/test/test_tools.hpp" 2 3 4
+# 1 "/usr/include/boost/test/tools/assertion.hpp" 1 3 4
+# 13 "/usr/include/boost/test/tools/assertion.hpp" 3 4
+#define BOOST_TEST_TOOLS_ASSERTION_HPP_100911GER 
+# 22 "/usr/include/boost/test/tools/assertion.hpp" 3 4
+# 1 "/usr/include/boost/type_traits/decay.hpp" 1 3 4
+# 10 "/usr/include/boost/type_traits/decay.hpp" 3 4
+#define BOOST_TT_DECAY_HPP_INCLUDED 
+
+
+
+# 1 "/usr/include/boost/type_traits/remove_bounds.hpp" 1 3 4
+# 10 "/usr/include/boost/type_traits/remove_bounds.hpp" 3 4
+#define BOOST_TT_REMOVE_BOUNDS_HPP_INCLUDED 
+
+
+
+namespace boost
+{
+
+template <class T> struct remove_bounds : public remove_extent<T> {};
+
+
+
+template <class T> using remove_bounds_t = typename remove_bounds<T>::type;
+
+
+
+
+}
+# 15 "/usr/include/boost/type_traits/decay.hpp" 2 3 4
+
+
+
+
+namespace boost
+{
+
+   namespace detail
+   {
+
+      template <class T, bool Array, bool Function> struct decay_imp { typedef typename remove_cv<T>::type type; };
+      template <class T> struct decay_imp<T, true, false> { typedef typename remove_bounds<T>::type* type; };
+      template <class T> struct decay_imp<T, false, true> { typedef T* type; };
+
+   }
+
+    template< class T >
+    struct decay
+    {
+    private:
+        typedef typename remove_reference<T>::type Ty;
+    public:
+       typedef typename boost::detail::decay_imp<Ty, boost::is_array<Ty>::value, boost::is_function<Ty>::value>::type type;
+    };
+
+
+
+   template <class T> using decay_t = typename decay<T>::type;
+
+
+
+}
+# 23 "/usr/include/boost/test/tools/assertion.hpp" 2 3 4
+# 33 "/usr/include/boost/test/tools/assertion.hpp" 3 4
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 34 "/usr/include/boost/test/tools/assertion.hpp" 2 3 4
+
+
+
+namespace boost {
+namespace test_tools {
+namespace assertion {
+# 65 "/usr/include/boost/test/tools/assertion.hpp" 3 4
+namespace op {
+
+#define BOOST_TEST_FOR_EACH_COMP_OP(action) action( < , LT, >= ) action( <=, LE, > ) action( > , GT, <= ) action( >=, GE, < ) action( ==, EQ, != ) action( !=, NE, == )
+# 80 "/usr/include/boost/test/tools/assertion.hpp" 3 4
+#define BOOST_TEST_FOR_EACH_CONST_OP(action) action(->*, MEMP, ->* ) action( * , MUL, * ) action( / , DIV, / ) action( % , MOD, % ) action( + , ADD, + ) action( - , SUB, - ) action( <<, LSH, << ) action( >>, RSH, >> ) BOOST_TEST_FOR_EACH_COMP_OP(action) action( & , BAND, & ) action( ^ , XOR, ^ ) action( | , BOR, | )
+# 110 "/usr/include/boost/test/tools/assertion.hpp" 3 4
+#define BOOST_TEST_FOR_EACH_MUT_OP(action) action( = , SET , = ) action( +=, IADD, += ) action( -=, ISUB, -= ) action( *=, IMUL, *= ) action( /=, IDIV, /= ) action( %=, IMOD, %= ) action(<<=, ILSH, <<=) action(>>=, IRSH, >>=) action( &=, IAND, &= ) action( ^=, IXOR, ^= ) action( |=, IOR , |= )
+# 127 "/usr/include/boost/test/tools/assertion.hpp" 3 4
+#define DEDUCE_RESULT_TYPE(oper) decltype(boost::declval<Lhs>() oper boost::declval<Rhs>() ) optype; typedef typename boost::remove_reference<optype>::type
+
+
+
+
+
+
+
+#define DEFINE_CONST_OPER(oper,name,rev) template<typename Lhs, typename Rhs, typename Enabler=void> struct name { typedef DEDUCE_RESULT_TYPE( oper ) result_type; static result_type eval( Lhs const& lhs, Rhs const& rhs ) { return lhs oper rhs; } template<typename PrevExprType> static void report( std::ostream& ostr, PrevExprType const& lhs, Rhs const& rhs) { lhs.report( ostr ); ostr << revert() << tt_detail::print_helper( rhs ); } static char const* revert() { return " " #rev " "; } };
+# 163 "/usr/include/boost/test/tools/assertion.hpp" 3 4
+template<typename Lhs, typename Rhs, typename Enabler=void> struct MEMP { typedef decltype(boost::declval<Lhs>() ->* boost::declval<Rhs>() ) optype; typedef typename boost::remove_reference<optype>::type result_type; static result_type eval( Lhs const& lhs, Rhs const& rhs ) { return lhs ->* rhs; } template<typename PrevExprType> static void report( std::ostream& ostr, PrevExprType const& lhs, Rhs const& rhs) { lhs.report( ostr ); ostr << revert() << tt_detail::print_helper( rhs ); } static char const* revert() { return " " "->*" " "; } }; template<typename Lhs, typename Rhs, typename Enabler=void> struct MUL { typedef decltype(boost::declval<Lhs>() * boost::declval<Rhs>() ) optype; typedef typename boost::remove_reference<optype>::type result_type; static result_type eval( Lhs const& lhs, Rhs const& rhs ) { return lhs * rhs; } template<typename PrevExprType> static void report( std::ostream& ostr, PrevExprType const& lhs, Rhs const& rhs) { lhs.report( ostr ); ostr << revert() << tt_detail::print_helper( rhs ); } static char const* revert() { return " " "*" " "; } }; template<typename Lhs, typename Rhs, typename Enabler=void> struct DIV { typedef decltype(boost::declval<Lhs>() / boost::declval<Rhs>() ) optype; typedef typename boost::remove_reference<optype>::type result_type; static result_type eval( Lhs const& lhs, Rhs const& rhs ) { return lhs / rhs; } template<typename PrevExprType> static void report( std::ostream& ostr, PrevExprType const& lhs, Rhs const& rhs) { lhs.report( ostr ); ostr << revert() << tt_detail::print_helper( rhs ); } static char const* revert() { return " " "/" " "; } }; template<typename Lhs, typename Rhs, typename Enabler=void> struct MOD { typedef decltype(boost::declval<Lhs>() % boost::declval<Rhs>() ) optype; typedef typename boost::remove_reference<optype>::type result_type; static result_type eval( Lhs const& lhs, Rhs const& rhs ) { return lhs % rhs; } template<typename PrevExprType> static void report( std::ostream& ostr, PrevExprType const& lhs, Rhs const& rhs) { lhs.report( ostr ); ostr << revert() << tt_detail::print_helper( rhs ); } static char const* revert() { return " " "%" " "; } }; template<typename Lhs, typename Rhs, typename Enabler=void> struct ADD { typedef decltype(boost::declval<Lhs>() + boost::declval<Rhs>() ) optype; typedef typename boost::remove_reference<optype>::type result_type; static result_type eval( Lhs const& lhs, Rhs const& rhs ) { return lhs + rhs; } template<typename PrevExprType> static void report( std::ostream& ostr, PrevExprType const& lhs, Rhs const& rhs) { lhs.report( ostr ); ostr << revert() << tt_detail::print_helper( rhs ); } static char const* revert() { return " " "+" " "; } }; template<typename Lhs, typename Rhs, typename Enabler=void> struct SUB { typedef decltype(boost::declval<Lhs>() - boost::declval<Rhs>() ) optype; typedef typename boost::remove_reference<optype>::type result_type; static result_type eval( Lhs const& lhs, Rhs const& rhs ) { return lhs - rhs; } template<typename PrevExprType> static void report( std::ostream& ostr, PrevExprType const& lhs, Rhs const& rhs) { lhs.report( ostr ); ostr << revert() << tt_detail::print_helper( rhs ); } static char const* revert() { return " " "-" " "; } }; template<typename Lhs, typename Rhs, typename Enabler=void> struct LSH { typedef decltype(boost::declval<Lhs>() << boost::declval<Rhs>() ) optype; typedef typename boost::remove_reference<optype>::type result_type; static result_type eval( Lhs const& lhs, Rhs const& rhs ) { return lhs << rhs; } template<typename PrevExprType> static void report( std::ostream& ostr, PrevExprType const& lhs, Rhs const& rhs) { lhs.report( ostr ); ostr << revert() << tt_detail::print_helper( rhs ); } static char const* revert() { return " " "<<" " "; } }; template<typename Lhs, typename Rhs, typename Enabler=void> struct RSH { typedef decltype(boost::declval<Lhs>() >> boost::declval<Rhs>() ) optype; typedef typename boost::remove_reference<optype>::type result_type; static result_type eval( Lhs const& lhs, Rhs const& rhs ) { return lhs >> rhs; } template<typename PrevExprType> static void report( std::ostream& ostr, PrevExprType const& lhs, Rhs const& rhs) { lhs.report( ostr ); ostr << revert() << tt_detail::print_helper( rhs ); } static char const* revert() { return " " ">>" " "; } }; template<typename Lhs, typename Rhs, typename Enabler=void> struct LT { typedef decltype(boost::declval<Lhs>() < boost::declval<Rhs>() ) optype; typedef typename boost::remove_reference<optype>::type result_type; static result_type eval( Lhs const& lhs, Rhs const& rhs ) { return lhs < rhs; } template<typename PrevExprType> static void report( std::ostream& ostr, PrevExprType const& lhs, Rhs const& rhs) { lhs.report( ostr ); ostr << revert() << tt_detail::print_helper( rhs ); } static char const* revert() { return " " ">=" " "; } }; template<typename Lhs, typename Rhs, typename Enabler=void> struct LE { typedef decltype(boost::declval<Lhs>() <= boost::declval<Rhs>() ) optype; typedef typename boost::remove_reference<optype>::type result_type; static result_type eval( Lhs const& lhs, Rhs const& rhs ) { return lhs <= rhs; } template<typename PrevExprType> static void report( std::ostream& ostr, PrevExprType const& lhs, Rhs const& rhs) { lhs.report( ostr ); ostr << revert() << tt_detail::print_helper( rhs ); } static char const* revert() { return " " ">" " "; } }; template<typename Lhs, typename Rhs, typename Enabler=void> struct GT { typedef decltype(boost::declval<Lhs>() > boost::declval<Rhs>() ) optype; typedef typename boost::remove_reference<optype>::type result_type; static result_type eval( Lhs const& lhs, Rhs const& rhs ) { return lhs > rhs; } template<typename PrevExprType> static void report( std::ostream& ostr, PrevExprType const& lhs, Rhs const& rhs) { lhs.report( ostr ); ostr << revert() << tt_detail::print_helper( rhs ); } static char const* revert() { return " " "<=" " "; } }; template<typename Lhs, typename Rhs, typename Enabler=void> struct GE { typedef decltype(boost::declval<Lhs>() >= boost::declval<Rhs>() ) optype; typedef typename boost::remove_reference<optype>::type result_type; static result_type eval( Lhs const& lhs, Rhs const& rhs ) { return lhs >= rhs; } template<typename PrevExprType> static void report( std::ostream& ostr, PrevExprType const& lhs, Rhs const& rhs) { lhs.report( ostr ); ostr << revert() << tt_detail::print_helper( rhs ); } static char const* revert() { return " " "<" " "; } }; template<typename Lhs, typename Rhs, typename Enabler=void> struct EQ { typedef decltype(boost::declval<Lhs>() == boost::declval<Rhs>() ) optype; typedef typename boost::remove_reference<optype>::type result_type; static result_type eval( Lhs const& lhs, Rhs const& rhs ) { return lhs == rhs; } template<typename PrevExprType> static void report( std::ostream& ostr, PrevExprType const& lhs, Rhs const& rhs) { lhs.report( ostr ); ostr << revert() << tt_detail::print_helper( rhs ); } static char const* revert() { return " " "!=" " "; } }; template<typename Lhs, typename Rhs, typename Enabler=void> struct NE { typedef decltype(boost::declval<Lhs>() != boost::declval<Rhs>() ) optype; typedef typename boost::remove_reference<optype>::type result_type; static result_type eval( Lhs const& lhs, Rhs const& rhs ) { return lhs != rhs; } template<typename PrevExprType> static void report( std::ostream& ostr, PrevExprType const& lhs, Rhs const& rhs) { lhs.report( ostr ); ostr << revert() << tt_detail::print_helper( rhs ); } static char const* revert() { return " " "==" " "; } }; template<typename Lhs, typename Rhs, typename Enabler=void> struct BAND { typedef decltype(boost::declval<Lhs>() & boost::declval<Rhs>() ) optype; typedef typename boost::remove_reference<optype>::type result_type; static result_type eval( Lhs const& lhs, Rhs const& rhs ) { return lhs & rhs; } template<typename PrevExprType> static void report( std::ostream& ostr, PrevExprType const& lhs, Rhs const& rhs) { lhs.report( ostr ); ostr << revert() << tt_detail::print_helper( rhs ); } static char const* revert() { return " " "&" " "; } }; template<typename Lhs, typename Rhs, typename Enabler=void> struct XOR { typedef decltype(boost::declval<Lhs>() ^ boost::declval<Rhs>() ) optype; typedef typename boost::remove_reference<optype>::type result_type; static result_type eval( Lhs const& lhs, Rhs const& rhs ) { return lhs ^ rhs; } template<typename PrevExprType> static void report( std::ostream& ostr, PrevExprType const& lhs, Rhs const& rhs) { lhs.report( ostr ); ostr << revert() << tt_detail::print_helper( rhs ); } static char const* revert() { return " " "^" " "; } }; template<typename Lhs, typename Rhs, typename Enabler=void> struct BOR { typedef decltype(boost::declval<Lhs>() | boost::declval<Rhs>() ) optype; typedef typename boost::remove_reference<optype>::type result_type; static result_type eval( Lhs const& lhs, Rhs const& rhs ) { return lhs | rhs; } template<typename PrevExprType> static void report( std::ostream& ostr, PrevExprType const& lhs, Rhs const& rhs) { lhs.report( ostr ); ostr << revert() << tt_detail::print_helper( rhs ); } static char const* revert() { return " " "|" " "; } };
+
+#undef DEDUCE_RESULT_TYPE
+#undef DEFINE_CONST_OPER
+
+
+
+}
+
+
+
+
+
+
+template<typename Lhs, typename Rhs, typename OP> class binary_expr;
+
+template<typename ExprType,typename ValType>
+class expression_base {
+public:
+
+
+    template<typename T>
+    struct RhsT : remove_const<typename remove_reference<T>::type> {};
+
+#define ADD_OP_SUPPORT(oper,name,_) template<typename T> binary_expr<ExprType,T, op::name<ValType,typename RhsT<T>::type> > operator oper( T&& rhs ) { return binary_expr<ExprType,T, op::name<ValType,typename RhsT<T>::type> > ( std::forward<ExprType>( *static_cast<ExprType*>(this) ), std::forward<T>(rhs) ); }
+# 216 "/usr/include/boost/test/tools/assertion.hpp" 3 4
+    template<typename T> binary_expr<ExprType,T, op::MEMP<ValType,typename RhsT<T>::type> > operator ->*( T&& rhs ) { return binary_expr<ExprType,T, op::MEMP<ValType,typename RhsT<T>::type> > ( std::forward<ExprType>( *static_cast<ExprType*>(this) ), std::forward<T>(rhs) ); } template<typename T> binary_expr<ExprType,T, op::MUL<ValType,typename RhsT<T>::type> > operator *( T&& rhs ) { return binary_expr<ExprType,T, op::MUL<ValType,typename RhsT<T>::type> > ( std::forward<ExprType>( *static_cast<ExprType*>(this) ), std::forward<T>(rhs) ); } template<typename T> binary_expr<ExprType,T, op::DIV<ValType,typename RhsT<T>::type> > operator /( T&& rhs ) { return binary_expr<ExprType,T, op::DIV<ValType,typename RhsT<T>::type> > ( std::forward<ExprType>( *static_cast<ExprType*>(this) ), std::forward<T>(rhs) ); } template<typename T> binary_expr<ExprType,T, op::MOD<ValType,typename RhsT<T>::type> > operator %( T&& rhs ) { return binary_expr<ExprType,T, op::MOD<ValType,typename RhsT<T>::type> > ( std::forward<ExprType>( *static_cast<ExprType*>(this) ), std::forward<T>(rhs) ); } template<typename T> binary_expr<ExprType,T, op::ADD<ValType,typename RhsT<T>::type> > operator +( T&& rhs ) { return binary_expr<ExprType,T, op::ADD<ValType,typename RhsT<T>::type> > ( std::forward<ExprType>( *static_cast<ExprType*>(this) ), std::forward<T>(rhs) ); } template<typename T> binary_expr<ExprType,T, op::SUB<ValType,typename RhsT<T>::type> > operator -( T&& rhs ) { return binary_expr<ExprType,T, op::SUB<ValType,typename RhsT<T>::type> > ( std::forward<ExprType>( *static_cast<ExprType*>(this) ), std::forward<T>(rhs) ); } template<typename T> binary_expr<ExprType,T, op::LSH<ValType,typename RhsT<T>::type> > operator <<( T&& rhs ) { return binary_expr<ExprType,T, op::LSH<ValType,typename RhsT<T>::type> > ( std::forward<ExprType>( *static_cast<ExprType*>(this) ), std::forward<T>(rhs) ); } template<typename T> binary_expr<ExprType,T, op::RSH<ValType,typename RhsT<T>::type> > operator >>( T&& rhs ) { return binary_expr<ExprType,T, op::RSH<ValType,typename RhsT<T>::type> > ( std::forward<ExprType>( *static_cast<ExprType*>(this) ), std::forward<T>(rhs) ); } template<typename T> binary_expr<ExprType,T, op::LT<ValType,typename RhsT<T>::type> > operator <( T&& rhs ) { return binary_expr<ExprType,T, op::LT<ValType,typename RhsT<T>::type> > ( std::forward<ExprType>( *static_cast<ExprType*>(this) ), std::forward<T>(rhs) ); } template<typename T> binary_expr<ExprType,T, op::LE<ValType,typename RhsT<T>::type> > operator <=( T&& rhs ) { return binary_expr<ExprType,T, op::LE<ValType,typename RhsT<T>::type> > ( std::forward<ExprType>( *static_cast<ExprType*>(this) ), std::forward<T>(rhs) ); } template<typename T> binary_expr<ExprType,T, op::GT<ValType,typename RhsT<T>::type> > operator >( T&& rhs ) { return binary_expr<ExprType,T, op::GT<ValType,typename RhsT<T>::type> > ( std::forward<ExprType>( *static_cast<ExprType*>(this) ), std::forward<T>(rhs) ); } template<typename T> binary_expr<ExprType,T, op::GE<ValType,typename RhsT<T>::type> > operator >=( T&& rhs ) { return binary_expr<ExprType,T, op::GE<ValType,typename RhsT<T>::type> > ( std::forward<ExprType>( *static_cast<ExprType*>(this) ), std::forward<T>(rhs) ); } template<typename T> binary_expr<ExprType,T, op::EQ<ValType,typename RhsT<T>::type> > operator ==( T&& rhs ) { return binary_expr<ExprType,T, op::EQ<ValType,typename RhsT<T>::type> > ( std::forward<ExprType>( *static_cast<ExprType*>(this) ), std::forward<T>(rhs) ); } template<typename T> binary_expr<ExprType,T, op::NE<ValType,typename RhsT<T>::type> > operator !=( T&& rhs ) { return binary_expr<ExprType,T, op::NE<ValType,typename RhsT<T>::type> > ( std::forward<ExprType>( *static_cast<ExprType*>(this) ), std::forward<T>(rhs) ); } template<typename T> binary_expr<ExprType,T, op::BAND<ValType,typename RhsT<T>::type> > operator &( T&& rhs ) { return binary_expr<ExprType,T, op::BAND<ValType,typename RhsT<T>::type> > ( std::forward<ExprType>( *static_cast<ExprType*>(this) ), std::forward<T>(rhs) ); } template<typename T> binary_expr<ExprType,T, op::XOR<ValType,typename RhsT<T>::type> > operator ^( T&& rhs ) { return binary_expr<ExprType,T, op::XOR<ValType,typename RhsT<T>::type> > ( std::forward<ExprType>( *static_cast<ExprType*>(this) ), std::forward<T>(rhs) ); } template<typename T> binary_expr<ExprType,T, op::BOR<ValType,typename RhsT<T>::type> > operator |( T&& rhs ) { return binary_expr<ExprType,T, op::BOR<ValType,typename RhsT<T>::type> > ( std::forward<ExprType>( *static_cast<ExprType*>(this) ), std::forward<T>(rhs) ); }
+#undef ADD_OP_SUPPORT
+
+
+
+    template<typename T>
+    ExprType&
+    operator ||( T const& )
+    {
+        struct CANT_USE_LOGICAL_OPERATOR_OR_WITHIN_THIS_TESTING_TOOL; typedef struct CANT_USE_LOGICAL_OPERATOR_OR_WITHIN_THIS_TESTING_TOOL225 : boost::mpl::assert_ { static boost::mpl::failed ************ (CANT_USE_LOGICAL_OPERATOR_OR_WITHIN_THIS_TESTING_TOOL::************ assert_arg()) () { return 0; } } mpl_assert_arg225; enum { mpl_assertion_in_line_225 = sizeof( boost::mpl::assertion_failed<(false)>( mpl_assert_arg225::assert_arg() ) ) };
+
+        return *static_cast<ExprType*>(this);
+    }
+
+    template<typename T>
+    ExprType&
+    operator &&( T const& )
+    {
+        struct CANT_USE_LOGICAL_OPERATOR_AND_WITHIN_THIS_TESTING_TOOL; typedef struct CANT_USE_LOGICAL_OPERATOR_AND_WITHIN_THIS_TESTING_TOOL234 : boost::mpl::assert_ { static boost::mpl::failed ************ (CANT_USE_LOGICAL_OPERATOR_AND_WITHIN_THIS_TESTING_TOOL::************ assert_arg()) () { return 0; } } mpl_assert_arg234; enum { mpl_assertion_in_line_234 = sizeof( boost::mpl::assertion_failed<(false)>( mpl_assert_arg234::assert_arg() ) ) };
+
+        return *static_cast<ExprType*>(this);
+    }
+
+    operator bool()
+    {
+        struct CANT_USE_TERNARY_OPERATOR_WITHIN_THIS_TESTING_TOOL; typedef struct CANT_USE_TERNARY_OPERATOR_WITHIN_THIS_TESTING_TOOL241 : boost::mpl::assert_ { static boost::mpl::failed ************ (CANT_USE_TERNARY_OPERATOR_WITHIN_THIS_TESTING_TOOL::************ assert_arg()) () { return 0; } } mpl_assert_arg241; enum { mpl_assertion_in_line_241 = sizeof( boost::mpl::assertion_failed<(false)>( mpl_assert_arg241::assert_arg() ) ) };
+
+        return false;
+    }
+
+};
+
+
+
+
+
+
+template<typename T>
+class value_expr : public expression_base<value_expr<T>,typename remove_const<typename remove_reference<T>::type>::type> {
+public:
+
+    typedef T result_type;
+
+
+
+    value_expr( value_expr&& ve )
+    : m_value( std::forward<T>(ve.m_value) )
+    {}
+    explicit value_expr( T&& val )
+    : m_value( std::forward<T>(val) )
+    {}
+
+
+
+
+
+
+
+    T const& value() const
+    {
+        return m_value;
+    }
+    void report( std::ostream& ostr ) const
+    {
+        ostr << tt_detail::print_helper( value() );
+    }
+
+
+#define ADD_OP_SUPPORT(OPER,ID,_) template<typename U> value_expr<T>& operator OPER( U const& rhs ) { m_value OPER rhs; return *this; }
+# 295 "/usr/include/boost/test/tools/assertion.hpp" 3 4
+    template<typename U> value_expr<T>& operator =( U const& rhs ) { m_value = rhs; return *this; } template<typename U> value_expr<T>& operator +=( U const& rhs ) { m_value += rhs; return *this; } template<typename U> value_expr<T>& operator -=( U const& rhs ) { m_value -= rhs; return *this; } template<typename U> value_expr<T>& operator *=( U const& rhs ) { m_value *= rhs; return *this; } template<typename U> value_expr<T>& operator /=( U const& rhs ) { m_value /= rhs; return *this; } template<typename U> value_expr<T>& operator %=( U const& rhs ) { m_value %= rhs; return *this; } template<typename U> value_expr<T>& operator <<=( U const& rhs ) { m_value <<= rhs; return *this; } template<typename U> value_expr<T>& operator >>=( U const& rhs ) { m_value >>= rhs; return *this; } template<typename U> value_expr<T>& operator &=( U const& rhs ) { m_value &= rhs; return *this; } template<typename U> value_expr<T>& operator ^=( U const& rhs ) { m_value ^= rhs; return *this; } template<typename U> value_expr<T>& operator |=( U const& rhs ) { m_value |= rhs; return *this; }
+#undef ADD_OP_SUPPORT
+
+
+    assertion_result evaluate( bool no_message = false ) const
+    {
+        assertion_result res( value() );
+        if( no_message || res )
+            return res;
+
+        format_message( res.message(), value() );
+
+        return tt_detail::format_assertion_result( "", res.message().str() );
+    }
+
+private:
+    template<typename U>
+    static void format_message( wrap_stringstream& ostr, U const& v )
+    {
+        ostr << "['" << tt_detail::print_helper(v) << "' evaluates to false]";
+    }
+    static void format_message( wrap_stringstream& , bool ) {}
+    static void format_message( wrap_stringstream& , assertion_result const& ) {}
+
+
+    T m_value;
+};
+
+
+
+
+
+
+template<typename LExpr, typename Rhs, typename OP>
+class binary_expr : public expression_base<binary_expr<LExpr,Rhs,OP>,typename OP::result_type> {
+public:
+
+    typedef typename OP::result_type result_type;
+
+
+
+    binary_expr( binary_expr&& be )
+    : m_lhs( std::forward<LExpr>(be.m_lhs) )
+    , m_rhs( std::forward<Rhs>(be.m_rhs) )
+    {}
+    binary_expr( LExpr&& lhs, Rhs&& rhs )
+    : m_lhs( std::forward<LExpr>(lhs) )
+    , m_rhs( std::forward<Rhs>(rhs) )
+    {}
+# 352 "/usr/include/boost/test/tools/assertion.hpp" 3 4
+    result_type value() const
+    {
+        return OP::eval( m_lhs.value(), m_rhs );
+    }
+    void report( std::ostream& ostr ) const
+    {
+        return OP::report( ostr, m_lhs, m_rhs );
+    }
+
+    assertion_result evaluate( bool no_message = false ) const
+    {
+        assertion_result const expr_res( value() );
+        if( no_message || expr_res )
+            return expr_res;
+
+        wrap_stringstream buff;
+        report( buff.stream() );
+
+        return tt_detail::format_assertion_result( buff.stream().str(), expr_res.message() );
+    }
+
+
+    LExpr const& lhs() const { return m_lhs; }
+    Rhs const& rhs() const { return m_rhs; }
+private:
+
+    LExpr m_lhs;
+    Rhs m_rhs;
+};
+
+
+
+
+
+
+class seed {
+public:
+
+    template<typename T>
+    value_expr<T>
+
+    operator->*( T&& v ) const
+    {
+        return value_expr<T>( std::forward<T>( v ) );
+    }
+
+
+
+
+
+
+};
+
+#undef BOOST_TEST_FOR_EACH_CONST_OP
+
+}
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 412 "/usr/include/boost/test/tools/assertion.hpp" 2 3 4
+# 54 "/usr/include/boost/test/test_tools.hpp" 2 3 4
+# 1 "/usr/include/boost/test/tools/fpc_op.hpp" 1 3 4
+# 13 "/usr/include/boost/test/tools/fpc_op.hpp" 3 4
+#define BOOST_TEST_TOOLS_FPC_OP_HPP_050915GER 
+
+
+
+
+
+# 1 "/usr/include/boost/test/tools/fpc_tolerance.hpp" 1 3 4
+# 16 "/usr/include/boost/test/tools/fpc_tolerance.hpp" 3 4
+#define BOOST_TEST_TOOLS_FPC_TOLERANCE_HPP_121612GER 
+
+
+
+
+
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 23 "/usr/include/boost/test/tools/fpc_tolerance.hpp" 2 3 4
+
+
+
+namespace boost {
+namespace test_tools {
+
+namespace fpc = math::fpc;
+
+
+
+
+
+template<typename FPT>
+inline FPT&
+fpc_tolerance()
+{
+    static FPT s_value = 0;
+    return s_value;
+}
+
+
+
+template<typename FPT>
+struct local_fpc_tolerance {
+    local_fpc_tolerance( FPT fraction_tolerance ) : m_old_tolerance( fpc_tolerance<FPT>() )
+    {
+        fpc_tolerance<FPT>() = fraction_tolerance;
+    }
+
+    ~local_fpc_tolerance()
+    {
+        if( m_old_tolerance != (FPT)-1 )
+            fpc_tolerance<FPT>() = m_old_tolerance;
+    }
+
+private:
+
+    FPT m_old_tolerance;
+};
+
+
+
+}
+
+
+
+
+
+namespace unit_test {
+namespace decorator {
+
+template<typename FPT>
+inline fixture_t
+tolerance( FPT v )
+{
+    return fixture_t( test_unit_fixture_ptr(
+        new unit_test::class_based_fixture<test_tools::local_fpc_tolerance<FPT>,FPT>( v ) ) );
+}
+
+
+
+template<typename FPT>
+inline fixture_t
+tolerance( test_tools::fpc::percent_tolerance_t<FPT> v )
+{
+    return fixture_t( test_unit_fixture_ptr(
+        new unit_test::class_based_fixture<test_tools::local_fpc_tolerance<FPT>,FPT>( boost::math::fpc::fpc_detail::fraction_tolerance<FPT>( v ) ) ) );
+}
+
+
+
+}
+
+using decorator::tolerance;
+
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 102 "/usr/include/boost/test/tools/fpc_tolerance.hpp" 2 3 4
+# 20 "/usr/include/boost/test/tools/fpc_op.hpp" 2 3 4
+
+
+# 1 "/usr/include/boost/type_traits/common_type.hpp" 1 3 4
+
+#define BOOST_TYPE_TRAITS_COMMON_TYPE_HPP_INCLUDED 
+# 26 "/usr/include/boost/type_traits/common_type.hpp" 3 4
+# 1 "/usr/include/boost/type_traits/detail/mp_defer.hpp" 1 3 4
+
+#define BOOST_TYPE_TRAITS_DETAIL_MP_DEFER_HPP_INCLUDED 
+# 15 "/usr/include/boost/type_traits/detail/mp_defer.hpp" 3 4
+namespace boost
+{
+
+namespace type_traits_detail
+{
+
+
+
+
+template<template<class...> class F, class... T>
+struct mp_valid_impl
+{
+    template<template<class...> class G, class = G<T...>>
+    static boost::true_type check_s(int);
+
+    template<template<class...> class>
+    static boost::false_type check_s(...);
+
+    using type = decltype(check_s<F>(0));
+};
+
+template<template<class...> class F, class... T>
+using mp_valid = typename mp_valid_impl<F, T...>::type;
+
+
+
+struct mp_empty
+{
+};
+
+template<template<class...> class F, class... T> struct mp_defer_impl
+{
+    using type = F<T...>;
+};
+
+template<template<class...> class F, class... T> using mp_defer = typename boost::conditional<mp_valid<F, T...>::value, mp_defer_impl<F, T...>, mp_empty>::type;
+
+}
+
+}
+# 27 "/usr/include/boost/type_traits/common_type.hpp" 2 3 4
+
+
+namespace boost
+{
+
+
+
+
+
+template<class... T> struct common_type
+{
+};
+
+
+
+template<class... T> using common_type_t = typename common_type<T...>::type;
+
+namespace type_traits_detail
+{
+
+template<class T1, class T2, class... T> using common_type_fold = common_type_t<common_type_t<T1, T2>, T...>;
+
+}
+
+template<class T1, class T2, class... T>
+struct common_type<T1, T2, T...>: type_traits_detail::mp_defer<type_traits_detail::common_type_fold, T1, T2, T...>
+{
+};
+# 80 "/usr/include/boost/type_traits/common_type.hpp" 3 4
+template<class T> struct common_type<T>: boost::decay<T>
+{
+   static_assert(::boost::is_complete<T>::value || ::boost::is_void<T>::value || ::boost::is_array<T>::value, "Arguments to common_type must both be complete types");
+};
+
+
+
+namespace type_traits_detail
+{
+# 100 "/usr/include/boost/type_traits/common_type.hpp" 3 4
+template<class T1, class T2> using builtin_common_type = typename boost::decay<decltype( boost::declval<bool>()? boost::declval<T1>(): boost::declval<T2>() )>::type;
+
+template<class T1, class T2> struct common_type_impl: mp_defer<builtin_common_type, T1, T2>
+{
+};
+# 134 "/usr/include/boost/type_traits/common_type.hpp" 3 4
+template<class T1, class T2, class T1d = typename boost::decay<T1>::type, class T2d = typename boost::decay<T2>::type> struct common_type_decay_helper: boost::common_type<T1d, T2d>
+{
+};
+
+template<class T1, class T2> struct common_type_decay_helper<T1, T2, T1, T2>: common_type_impl<T1, T2>
+{
+};
+
+}
+
+template<class T1, class T2> struct common_type<T1, T2>: type_traits_detail::common_type_decay_helper<T1, T2>
+{
+   static_assert(::boost::is_complete<T1>::value || ::boost::is_void<T1>::value || ::boost::is_array<T1>::value, "Arguments to common_type must both be complete types");
+   static_assert(::boost::is_complete<T2>::value || ::boost::is_void<T2>::value || ::boost::is_array<T2>::value, "Arguments to common_type must both be complete types");
+};
+
+}
+# 23 "/usr/include/boost/test/tools/fpc_op.hpp" 2 3 4
+
+
+
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 27 "/usr/include/boost/test/tools/fpc_op.hpp" 2 3 4
+
+
+
+namespace boost {
+namespace test_tools {
+namespace assertion {
+namespace op {
+
+
+
+
+
+
+template<typename OP>
+struct fpctraits {
+
+
+    static const bool equality_logical_disjunction = true;
+};
+
+template <typename Lhs, typename Rhs>
+struct fpctraits<op::LT<Lhs,Rhs> > {
+    static const bool equality_logical_disjunction = false;
+};
+
+template <typename Lhs, typename Rhs>
+struct fpctraits<op::GT<Lhs,Rhs> > {
+    static const bool equality_logical_disjunction = false;
+};
+# 65 "/usr/include/boost/test/tools/fpc_op.hpp" 3 4
+template <typename FPT, typename Lhs, typename Rhs, typename OP>
+inline assertion_result
+compare_fpv( Lhs const& lhs, Rhs const& rhs, OP* cmp_operator)
+{
+    bool result = cmp_operator->eval_direct(lhs, rhs);
+    if(fpctraits<OP>::equality_logical_disjunction) {
+        return result || compare_fpv<FPT>(lhs, rhs, (op::EQ<Lhs, Rhs>*)0);
+    }
+    return result && compare_fpv<FPT>(lhs, rhs, (op::NE<Lhs, Rhs>*)0);
+}
+
+
+
+template <typename FPT, typename Lhs, typename Rhs>
+inline assertion_result
+compare_fpv_near_zero( FPT const& fpv, op::EQ<Lhs,Rhs>* )
+{
+    fpc::small_with_tolerance<FPT> P( fpc_tolerance<FPT>() );
+
+    assertion_result ar( P( fpv ) );
+    if( !ar )
+        ar.message() << "Absolute value exceeds tolerance [|" << fpv << "| > "<< fpc_tolerance<FPT>() << ']';
+
+    return ar;
+}
+
+
+
+template <typename FPT, typename Lhs, typename Rhs>
+inline assertion_result
+compare_fpv_near_zero( FPT const& fpv, op::NE<Lhs,Rhs>* )
+{
+    fpc::small_with_tolerance<FPT> P( fpc_tolerance<FPT>() );
+
+    assertion_result ar( !P( fpv ) );
+    if( !ar )
+        ar.message() << "Absolute value is within tolerance [|" << fpv << "| < "<< fpc_tolerance<FPT>() << ']';
+    return ar;
+}
+
+
+
+template <typename FPT, typename Lhs, typename Rhs>
+inline assertion_result
+compare_fpv( Lhs const& lhs, Rhs const& rhs, op::EQ<Lhs,Rhs>* )
+{
+    if( lhs == 0 ) {
+        return compare_fpv_near_zero<FPT>( rhs, (op::EQ<Lhs,Rhs>*)0 );
+    }
+    else if( rhs == 0) {
+        return compare_fpv_near_zero<FPT>( lhs, (op::EQ<Lhs,Rhs>*)0 );
+    }
+    else {
+        fpc::close_at_tolerance<FPT> P( fpc_tolerance<FPT>(), fpc::FPC_STRONG );
+
+        assertion_result ar( P( lhs, rhs ) );
+        if( !ar )
+            ar.message() << "Relative difference exceeds tolerance ["
+                         << P.tested_rel_diff() << " > " << P.fraction_tolerance() << ']';
+        return ar;
+    }
+}
+
+
+
+template <typename FPT, typename Lhs, typename Rhs>
+inline assertion_result
+compare_fpv( Lhs const& lhs, Rhs const& rhs, op::NE<Lhs,Rhs>* )
+{
+    if( lhs == 0 ) {
+        return compare_fpv_near_zero<FPT>( rhs, (op::NE<Lhs,Rhs>*)0 );
+    }
+    else if( rhs == 0 ) {
+        return compare_fpv_near_zero<FPT>( lhs, (op::NE<Lhs,Rhs>*)0 );
+    }
+    else {
+        fpc::close_at_tolerance<FPT> P( fpc_tolerance<FPT>(), fpc::FPC_WEAK );
+
+        assertion_result ar( !P( lhs, rhs ) );
+        if( !ar )
+            ar.message() << "Relative difference is within tolerance ["
+                         << P.tested_rel_diff() << " < " << fpc_tolerance<FPT>() << ']';
+
+        return ar;
+    }
+}
+
+
+
+#define DEFINE_FPV_COMPARISON(oper,name,rev) template<typename Lhs,typename Rhs> struct name<Lhs,Rhs,typename boost::enable_if_c< (fpc::tolerance_based<Lhs>::value && fpc::tolerance_based<Rhs>::value) || (fpc::tolerance_based<Lhs>::value && boost::is_arithmetic<Rhs>::value) || (boost::is_arithmetic<Lhs>::value && fpc::tolerance_based<Rhs>::value) >::type> { public: typedef typename common_type<Lhs,Rhs>::type FPT; typedef name<Lhs,Rhs> OP; typedef assertion_result result_type; static bool eval_direct( Lhs const& lhs, Rhs const& rhs ) { return lhs oper rhs; } static assertion_result eval( Lhs const& lhs, Rhs const& rhs ) { if( fpc_tolerance<FPT>() == FPT(0) || (std::numeric_limits<Lhs>::has_infinity && (lhs == std::numeric_limits<Lhs>::infinity())) || (std::numeric_limits<Rhs>::has_infinity && (rhs == std::numeric_limits<Rhs>::infinity()))) { return eval_direct( lhs, rhs ); } return compare_fpv<FPT>( lhs, rhs, (OP*)0 ); } template<typename PrevExprType> static void report( std::ostream& ostr, PrevExprType const& lhs, Rhs const& rhs ) { lhs.report( ostr ); ostr << revert() << tt_detail::print_helper( rhs ); } static char const* revert() { return " " #rev " "; } };
+# 207 "/usr/include/boost/test/tools/fpc_op.hpp" 3 4
+template<typename Lhs,typename Rhs> struct LT<Lhs,Rhs,typename boost::enable_if_c< (fpc::tolerance_based<Lhs>::value && fpc::tolerance_based<Rhs>::value) || (fpc::tolerance_based<Lhs>::value && boost::is_arithmetic<Rhs>::value) || (boost::is_arithmetic<Lhs>::value && fpc::tolerance_based<Rhs>::value) >::type> { public: typedef typename common_type<Lhs,Rhs>::type FPT; typedef LT<Lhs,Rhs> OP; typedef assertion_result result_type; static bool eval_direct( Lhs const& lhs, Rhs const& rhs ) { return lhs < rhs; } static assertion_result eval( Lhs const& lhs, Rhs const& rhs ) { if( fpc_tolerance<FPT>() == FPT(0) || (std::numeric_limits<Lhs>::has_infinity && (lhs == std::numeric_limits<Lhs>::infinity())) || (std::numeric_limits<Rhs>::has_infinity && (rhs == std::numeric_limits<Rhs>::infinity()))) { return eval_direct( lhs, rhs ); } return compare_fpv<FPT>( lhs, rhs, (OP*)0 ); } template<typename PrevExprType> static void report( std::ostream& ostr, PrevExprType const& lhs, Rhs const& rhs ) { lhs.report( ostr ); ostr << revert() << tt_detail::print_helper( rhs ); } static char const* revert() { return " " ">=" " "; } }; template<typename Lhs,typename Rhs> struct LE<Lhs,Rhs,typename boost::enable_if_c< (fpc::tolerance_based<Lhs>::value && fpc::tolerance_based<Rhs>::value) || (fpc::tolerance_based<Lhs>::value && boost::is_arithmetic<Rhs>::value) || (boost::is_arithmetic<Lhs>::value && fpc::tolerance_based<Rhs>::value) >::type> { public: typedef typename common_type<Lhs,Rhs>::type FPT; typedef LE<Lhs,Rhs> OP; typedef assertion_result result_type; static bool eval_direct( Lhs const& lhs, Rhs const& rhs ) { return lhs <= rhs; } static assertion_result eval( Lhs const& lhs, Rhs const& rhs ) { if( fpc_tolerance<FPT>() == FPT(0) || (std::numeric_limits<Lhs>::has_infinity && (lhs == std::numeric_limits<Lhs>::infinity())) || (std::numeric_limits<Rhs>::has_infinity && (rhs == std::numeric_limits<Rhs>::infinity()))) { return eval_direct( lhs, rhs ); } return compare_fpv<FPT>( lhs, rhs, (OP*)0 ); } template<typename PrevExprType> static void report( std::ostream& ostr, PrevExprType const& lhs, Rhs const& rhs ) { lhs.report( ostr ); ostr << revert() << tt_detail::print_helper( rhs ); } static char const* revert() { return " " ">" " "; } }; template<typename Lhs,typename Rhs> struct GT<Lhs,Rhs,typename boost::enable_if_c< (fpc::tolerance_based<Lhs>::value && fpc::tolerance_based<Rhs>::value) || (fpc::tolerance_based<Lhs>::value && boost::is_arithmetic<Rhs>::value) || (boost::is_arithmetic<Lhs>::value && fpc::tolerance_based<Rhs>::value) >::type> { public: typedef typename common_type<Lhs,Rhs>::type FPT; typedef GT<Lhs,Rhs> OP; typedef assertion_result result_type; static bool eval_direct( Lhs const& lhs, Rhs const& rhs ) { return lhs > rhs; } static assertion_result eval( Lhs const& lhs, Rhs const& rhs ) { if( fpc_tolerance<FPT>() == FPT(0) || (std::numeric_limits<Lhs>::has_infinity && (lhs == std::numeric_limits<Lhs>::infinity())) || (std::numeric_limits<Rhs>::has_infinity && (rhs == std::numeric_limits<Rhs>::infinity()))) { return eval_direct( lhs, rhs ); } return compare_fpv<FPT>( lhs, rhs, (OP*)0 ); } template<typename PrevExprType> static void report( std::ostream& ostr, PrevExprType const& lhs, Rhs const& rhs ) { lhs.report( ostr ); ostr << revert() << tt_detail::print_helper( rhs ); } static char const* revert() { return " " "<=" " "; } }; template<typename Lhs,typename Rhs> struct GE<Lhs,Rhs,typename boost::enable_if_c< (fpc::tolerance_based<Lhs>::value && fpc::tolerance_based<Rhs>::value) || (fpc::tolerance_based<Lhs>::value && boost::is_arithmetic<Rhs>::value) || (boost::is_arithmetic<Lhs>::value && fpc::tolerance_based<Rhs>::value) >::type> { public: typedef typename common_type<Lhs,Rhs>::type FPT; typedef GE<Lhs,Rhs> OP; typedef assertion_result result_type; static bool eval_direct( Lhs const& lhs, Rhs const& rhs ) { return lhs >= rhs; } static assertion_result eval( Lhs const& lhs, Rhs const& rhs ) { if( fpc_tolerance<FPT>() == FPT(0) || (std::numeric_limits<Lhs>::has_infinity && (lhs == std::numeric_limits<Lhs>::infinity())) || (std::numeric_limits<Rhs>::has_infinity && (rhs == std::numeric_limits<Rhs>::infinity()))) { return eval_direct( lhs, rhs ); } return compare_fpv<FPT>( lhs, rhs, (OP*)0 ); } template<typename PrevExprType> static void report( std::ostream& ostr, PrevExprType const& lhs, Rhs const& rhs ) { lhs.report( ostr ); ostr << revert() << tt_detail::print_helper( rhs ); } static char const* revert() { return " " "<" " "; } }; template<typename Lhs,typename Rhs> struct EQ<Lhs,Rhs,typename boost::enable_if_c< (fpc::tolerance_based<Lhs>::value && fpc::tolerance_based<Rhs>::value) || (fpc::tolerance_based<Lhs>::value && boost::is_arithmetic<Rhs>::value) || (boost::is_arithmetic<Lhs>::value && fpc::tolerance_based<Rhs>::value) >::type> { public: typedef typename common_type<Lhs,Rhs>::type FPT; typedef EQ<Lhs,Rhs> OP; typedef assertion_result result_type; static bool eval_direct( Lhs const& lhs, Rhs const& rhs ) { return lhs == rhs; } static assertion_result eval( Lhs const& lhs, Rhs const& rhs ) { if( fpc_tolerance<FPT>() == FPT(0) || (std::numeric_limits<Lhs>::has_infinity && (lhs == std::numeric_limits<Lhs>::infinity())) || (std::numeric_limits<Rhs>::has_infinity && (rhs == std::numeric_limits<Rhs>::infinity()))) { return eval_direct( lhs, rhs ); } return compare_fpv<FPT>( lhs, rhs, (OP*)0 ); } template<typename PrevExprType> static void report( std::ostream& ostr, PrevExprType const& lhs, Rhs const& rhs ) { lhs.report( ostr ); ostr << revert() << tt_detail::print_helper( rhs ); } static char const* revert() { return " " "!=" " "; } }; template<typename Lhs,typename Rhs> struct NE<Lhs,Rhs,typename boost::enable_if_c< (fpc::tolerance_based<Lhs>::value && fpc::tolerance_based<Rhs>::value) || (fpc::tolerance_based<Lhs>::value && boost::is_arithmetic<Rhs>::value) || (boost::is_arithmetic<Lhs>::value && fpc::tolerance_based<Rhs>::value) >::type> { public: typedef typename common_type<Lhs,Rhs>::type FPT; typedef NE<Lhs,Rhs> OP; typedef assertion_result result_type; static bool eval_direct( Lhs const& lhs, Rhs const& rhs ) { return lhs != rhs; } static assertion_result eval( Lhs const& lhs, Rhs const& rhs ) { if( fpc_tolerance<FPT>() == FPT(0) || (std::numeric_limits<Lhs>::has_infinity && (lhs == std::numeric_limits<Lhs>::infinity())) || (std::numeric_limits<Rhs>::has_infinity && (rhs == std::numeric_limits<Rhs>::infinity()))) { return eval_direct( lhs, rhs ); } return compare_fpv<FPT>( lhs, rhs, (OP*)0 ); } template<typename PrevExprType> static void report( std::ostream& ostr, PrevExprType const& lhs, Rhs const& rhs ) { lhs.report( ostr ); ostr << revert() << tt_detail::print_helper( rhs ); } static char const* revert() { return " " "==" " "; } };
+#undef DEFINE_FPV_COMPARISON
+
+
+
+}
+}
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 218 "/usr/include/boost/test/tools/fpc_op.hpp" 2 3 4
+# 55 "/usr/include/boost/test/test_tools.hpp" 2 3 4
+# 1 "/usr/include/boost/test/tools/collection_comparison_op.hpp" 1 3 4
+# 13 "/usr/include/boost/test/tools/collection_comparison_op.hpp" 3 4
+#define BOOST_TEST_TOOLS_COLLECTION_COMPARISON_OP_HPP_050815GER 
+
+
+
+
+# 1 "/usr/include/boost/test/utils/is_forward_iterable.hpp" 1 3 4
+# 13 "/usr/include/boost/test/utils/is_forward_iterable.hpp" 3 4
+#define BOOST_TEST_UTILS_IS_FORWARD_ITERABLE_HPP 
+# 43 "/usr/include/boost/test/utils/is_forward_iterable.hpp" 3 4
+# 1 "/usr/include/boost/test/utils/is_cstring.hpp" 1 3 4
+# 13 "/usr/include/boost/test/utils/is_cstring.hpp" 3 4
+#define BOOST_TEST_UTILS_IS_CSTRING_HPP 
+# 32 "/usr/include/boost/test/utils/is_cstring.hpp" 3 4
+namespace boost {
+namespace unit_test {
+
+
+
+
+
+namespace ut_detail {
+
+template<typename T>
+struct is_cstring_impl : public mpl::false_ {};
+
+template<typename T>
+struct is_cstring_impl<T const*> : public is_cstring_impl<T*> {};
+
+template<typename T>
+struct is_cstring_impl<T const* const> : public is_cstring_impl<T*> {};
+
+template<>
+struct is_cstring_impl<char*> : public mpl::true_ {};
+
+template<>
+struct is_cstring_impl<wchar_t*> : public mpl::true_ {};
+
+template <typename T, bool is_cstring = is_cstring_impl<typename boost::decay<T>::type>::value >
+struct deduce_cstring_transform_impl;
+
+template <typename T, bool is_cstring >
+struct deduce_cstring_transform_impl<T&, is_cstring> : public deduce_cstring_transform_impl<T, is_cstring>{};
+
+template <typename T, bool is_cstring >
+struct deduce_cstring_transform_impl<T const, is_cstring> : public deduce_cstring_transform_impl<T, is_cstring>{};
+
+template <typename T>
+struct deduce_cstring_transform_impl<T, true> {
+    typedef typename boost::add_const<
+        typename boost::remove_pointer<
+            typename boost::decay<T>::type
+        >::type
+    >::type U;
+    typedef boost::unit_test::basic_cstring<U> type;
+};
+
+template <typename T>
+struct deduce_cstring_transform_impl< T, false > {
+    typedef typename
+        boost::remove_const<
+            typename boost::remove_reference<T>::type
+        >::type type;
+};
+
+template <typename T>
+struct deduce_cstring_transform_impl< std::basic_string<T, std::char_traits<T> >, false > {
+    typedef boost::unit_test::basic_cstring<typename boost::add_const<T>::type> type;
+};
+
+
+template <typename T>
+struct deduce_cstring_transform_impl< std::basic_string_view<T, std::char_traits<T> >, false > {
+private:
+    using sv_t = std::basic_string_view<T, std::char_traits<T> > ;
+
+public:
+    using type = stringview_cstring_helper<typename boost::add_const<T>::type, sv_t>;
+};
+
+
+}
+
+template<typename T>
+struct is_cstring : public ut_detail::is_cstring_impl<typename decay<T>::type> {};
+
+template<typename T, bool is_cstring = is_cstring<typename boost::decay<T>::type>::value >
+struct is_cstring_comparable: public mpl::false_ {};
+
+template<typename T>
+struct is_cstring_comparable< T, true > : public mpl::true_ {};
+
+template<typename T>
+struct is_cstring_comparable< std::basic_string<T, std::char_traits<T> >, false > : public mpl::true_ {};
+
+
+template<typename T>
+struct is_cstring_comparable< std::basic_string_view<T, std::char_traits<T> >, false > : public mpl::true_ {};
+
+
+template<typename T>
+struct is_cstring_comparable< boost::unit_test::basic_cstring<T>, false > : public mpl::true_ {};
+
+template <class T>
+struct deduce_cstring_transform {
+    typedef typename
+        boost::remove_const<
+            typename boost::remove_reference<T>::type
+        >::type U;
+    typedef typename ut_detail::deduce_cstring_transform_impl<typename boost::decay<U>::type>::type type;
+};
+
+}
+}
+# 44 "/usr/include/boost/test/utils/is_forward_iterable.hpp" 2 3 4
+# 52 "/usr/include/boost/test/utils/is_forward_iterable.hpp" 3 4
+namespace boost {
+namespace unit_test {
+
+template<typename T>
+struct is_forward_iterable;
+# 94 "/usr/include/boost/test/utils/is_forward_iterable.hpp" 3 4
+namespace ut_detail {
+
+
+template<typename T>
+struct is_present : public mpl::true_ {};
+
+
+
+
+
+template <class T>
+struct has_member_size {
+private:
+    struct nil_t {};
+    template<typename U> static auto test( U* ) -> decltype(boost::declval<U>().size());
+    template<typename> static nil_t test( ... );
+
+public:
+    static bool const value = !std::is_same< decltype(test<T>( nullptr )), nil_t>::value;
+};
+
+
+
+template <class T>
+struct has_member_begin {
+private:
+    struct nil_t {};
+    template<typename U> static auto test( U* ) -> decltype(std::begin(boost::declval<U&>()));
+    template<typename> static nil_t test( ... );
+public:
+    static bool const value = !std::is_same< decltype(test<T>( nullptr )), nil_t>::value;
+};
+
+
+
+template <class T>
+struct has_member_end {
+private:
+    struct nil_t {};
+    template<typename U> static auto test( U* ) -> decltype(std::end(boost::declval<U&>()));
+    template<typename> static nil_t test( ... );
+public:
+    static bool const value = !std::is_same< decltype(test<T>( nullptr )), nil_t>::value;
+};
+
+
+
+template <class T, class enabled = void>
+struct is_forward_iterable_impl : std::false_type {
+};
+
+template <class T>
+struct is_forward_iterable_impl<
+    T,
+    typename std::enable_if<
+      has_member_begin<T>::value &&
+      has_member_end<T>::value
+    >::type
+> : std::true_type
+{};
+
+
+
+template <class T, class enabled = void>
+struct is_container_forward_iterable_impl : std::false_type {
+};
+
+template <class T>
+struct is_container_forward_iterable_impl<
+    T,
+    typename std::enable_if<
+      is_present<typename T::const_iterator>::value &&
+      is_present<typename T::value_type>::value &&
+      has_member_size<T>::value &&
+      is_forward_iterable_impl<T>::value
+    >::type
+> : is_forward_iterable_impl<T>
+{};
+
+
+
+}
+
+
+template<typename T>
+struct is_forward_iterable {
+    typedef typename std::remove_reference<T>::type T_ref;
+    typedef ut_detail::is_forward_iterable_impl<T_ref> is_fwd_it_t;
+    typedef mpl::bool_<is_fwd_it_t::value> type;
+    enum { value = is_fwd_it_t::value };
+};
+
+
+template<typename T>
+struct is_container_forward_iterable {
+    typedef typename std::remove_reference<T>::type T_ref;
+    typedef ut_detail::is_container_forward_iterable_impl<T_ref> is_fwd_it_t;
+    typedef mpl::bool_<is_fwd_it_t::value> type;
+    enum { value = is_fwd_it_t::value };
+};
+
+
+
+
+
+template <typename T, bool is_forward_iterable = is_forward_iterable<T>::value >
+struct bt_iterator_traits;
+
+template <typename T>
+struct bt_iterator_traits< T, true >{
+    static_assert((is_forward_iterable<T>::value), "(is_forward_iterable<T>::value)");
+
+
+
+
+
+
+    typedef decltype(boost::declval<
+        typename boost::add_const<
+          typename boost::remove_reference<T>::type
+        >::type>().begin()) const_iterator;
+
+    typedef typename std::iterator_traits<const_iterator>::value_type value_type;
+
+
+    static const_iterator begin(T const& container) {
+        return container.begin();
+    }
+    static const_iterator end(T const& container) {
+        return container.end();
+    }
+# 233 "/usr/include/boost/test/utils/is_forward_iterable.hpp" 3 4
+    static std::size_t
+    size(T const& container) {
+        return size(container,
+                    std::integral_constant<bool, ut_detail::has_member_size<T>::value>());
+    }
+private:
+    static std::size_t
+    size(T const& container, std::true_type) { return container.size(); }
+
+    static std::size_t
+    size(T const& container, std::false_type) { return std::distance(begin(container), end(container)); }
+
+};
+
+template <typename T, std::size_t N>
+struct bt_iterator_traits< T [N], true > {
+    typedef typename boost::add_const<T>::type T_const;
+    typedef typename boost::add_pointer<T_const>::type const_iterator;
+    typedef T value_type;
+
+    static const_iterator begin(T_const (&array)[N]) {
+        return &array[0];
+    }
+    static const_iterator end(T_const (&array)[N]) {
+        return &array[N];
+    }
+    static std::size_t size(T_const (&)[N]) {
+        return N;
+    }
+};
+
+}
+}
+# 19 "/usr/include/boost/test/tools/collection_comparison_op.hpp" 2 3 4
+# 27 "/usr/include/boost/test/tools/collection_comparison_op.hpp" 3 4
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 28 "/usr/include/boost/test/tools/collection_comparison_op.hpp" 2 3 4
+
+
+
+namespace boost {
+namespace test_tools {
+namespace assertion {
+
+
+
+
+
+template<typename T>
+struct specialized_compare : public mpl::false_ {};
+
+template <typename T>
+struct is_c_array : public mpl::false_ {};
+
+template<typename T, std::size_t N>
+struct is_c_array<T [N]> : public mpl::true_ {};
+
+template<typename T, std::size_t N>
+struct is_c_array<T (&)[N]> : public mpl::true_ {};
+
+#define BOOST_TEST_SPECIALIZED_COLLECTION_COMPARE(Col) namespace boost { namespace test_tools { namespace assertion { template<> struct specialized_compare<Col> : public mpl::true_ {}; }}}
+# 62 "/usr/include/boost/test/tools/collection_comparison_op.hpp" 3 4
+namespace op {
+
+template <typename OP, bool can_be_equal, bool prefer_shorter,
+          typename Lhs, typename Rhs>
+inline
+typename boost::enable_if_c<
+       unit_test::is_forward_iterable<Lhs>::value && !unit_test::is_cstring<Lhs>::value
+    && unit_test::is_forward_iterable<Rhs>::value && !unit_test::is_cstring<Rhs>::value,
+    assertion_result>::type
+lexicographic_compare( Lhs const& lhs, Rhs const& rhs )
+{
+    assertion_result ar( true );
+
+    typedef unit_test::bt_iterator_traits<Lhs> t_Lhs_iterator;
+    typedef unit_test::bt_iterator_traits<Rhs> t_Rhs_iterator;
+
+    typename t_Lhs_iterator::const_iterator first1 = t_Lhs_iterator::begin(lhs);
+    typename t_Rhs_iterator::const_iterator first2 = t_Rhs_iterator::begin(rhs);
+    typename t_Lhs_iterator::const_iterator last1 = t_Lhs_iterator::end(lhs);
+    typename t_Rhs_iterator::const_iterator last2 = t_Rhs_iterator::end(rhs);
+    std::size_t pos = 0;
+
+    for( ; (first1 != last1) && (first2 != last2); ++first1, ++first2, ++pos ) {
+        assertion_result const& element_ar = OP::eval(*first1, *first2);
+        if( !can_be_equal && element_ar )
+            return ar;
+
+        assertion_result const& reverse_ar = OP::eval(*first2, *first1);
+        if( element_ar && !reverse_ar )
+            return ar;
+
+        if( element_ar || !reverse_ar )
+            continue;
+
+
+        ar = false;
+        ar.message() << "\nFailure at position " << pos << ": "
+                     << tt_detail::print_helper(*first1)
+                     << OP::revert()
+                     << tt_detail::print_helper(*first2)
+                     << ". " << element_ar.message();
+        return ar;
+    }
+
+    if( first1 != last1 ) {
+        if( prefer_shorter ) {
+            ar = false;
+            ar.message() << "\nFirst collection has extra trailing elements.";
+        }
+    }
+    else if( first2 != last2 ) {
+        if( !prefer_shorter ) {
+            ar = false;
+            ar.message() << "\nSecond collection has extra trailing elements.";
+        }
+    }
+    else if( !can_be_equal ) {
+        ar = false;
+        ar.message() << "\nCollections appear to be equal.";
+    }
+
+    return ar;
+}
+
+template <typename OP, bool can_be_equal, bool prefer_shorter,
+          typename Lhs, typename Rhs>
+inline
+typename boost::enable_if_c<
+    (unit_test::is_cstring<Lhs>::value || unit_test::is_cstring<Rhs>::value),
+    assertion_result>::type
+lexicographic_compare( Lhs const& lhs, Rhs const& rhs )
+{
+    typedef typename unit_test::deduce_cstring_transform<Lhs>::type lhs_char_type;
+    typedef typename unit_test::deduce_cstring_transform<Rhs>::type rhs_char_type;
+
+    return lexicographic_compare<OP, can_be_equal, prefer_shorter>(
+        lhs_char_type(lhs),
+        rhs_char_type(rhs));
+}
+
+
+
+
+
+
+
+template <typename OP, typename Lhs, typename Rhs>
+inline
+typename boost::enable_if_c<
+       unit_test::is_forward_iterable<Lhs>::value && !unit_test::is_cstring<Lhs>::value
+    && unit_test::is_forward_iterable<Rhs>::value && !unit_test::is_cstring<Rhs>::value,
+    assertion_result>::type
+element_compare( Lhs const& lhs, Rhs const& rhs )
+{
+    typedef unit_test::bt_iterator_traits<Lhs> t_Lhs_iterator;
+    typedef unit_test::bt_iterator_traits<Rhs> t_Rhs_iterator;
+
+    assertion_result ar( true );
+
+    if( t_Lhs_iterator::size(lhs) != t_Rhs_iterator::size(rhs) ) {
+        ar = false;
+        ar.message() << "\nCollections size mismatch: " << t_Lhs_iterator::size(lhs) << " != " << t_Rhs_iterator::size(rhs);
+        return ar;
+    }
+
+    typename t_Lhs_iterator::const_iterator left = t_Lhs_iterator::begin(lhs);
+    typename t_Rhs_iterator::const_iterator right = t_Rhs_iterator::begin(rhs);
+    std::size_t pos = 0;
+
+    for( ; pos < t_Lhs_iterator::size(lhs); ++left, ++right, ++pos ) {
+        assertion_result const element_ar = OP::eval( *left, *right );
+        if( element_ar )
+            continue;
+
+        ar = false;
+        ar.message() << "\nMismatch at position " << pos << ": "
+                     << tt_detail::print_helper(*left)
+                     << OP::revert()
+                     << tt_detail::print_helper(*right)
+                     << ". " << element_ar.message();
+    }
+
+    return ar;
+}
+
+
+template <typename OP, typename Lhs, typename Rhs>
+inline
+typename boost::enable_if_c<
+    (unit_test::is_cstring<Lhs>::value || unit_test::is_cstring<Rhs>::value),
+    assertion_result>::type
+element_compare( Lhs const& lhs, Rhs const& rhs )
+{
+    typedef typename unit_test::deduce_cstring_transform<Lhs>::type lhs_char_type;
+    typedef typename unit_test::deduce_cstring_transform<Rhs>::type rhs_char_type;
+
+    return element_compare<OP>(lhs_char_type(lhs),
+                               rhs_char_type(rhs));
+}
+
+
+
+
+
+
+
+template <typename OP, typename Lhs, typename Rhs>
+inline assertion_result
+non_equality_compare( Lhs const& lhs, Rhs const& rhs )
+{
+    typedef unit_test::bt_iterator_traits<Lhs> t_Lhs_iterator;
+    typedef unit_test::bt_iterator_traits<Rhs> t_Rhs_iterator;
+
+    assertion_result ar( true );
+
+    if( t_Lhs_iterator::size(lhs) != t_Rhs_iterator::size(rhs) )
+        return ar;
+
+    typename t_Lhs_iterator::const_iterator left = t_Lhs_iterator::begin(lhs);
+    typename t_Rhs_iterator::const_iterator right = t_Rhs_iterator::begin(rhs);
+    typename t_Lhs_iterator::const_iterator end = t_Lhs_iterator::end(lhs);
+
+    for( ; left != end; ++left, ++right ) {
+        if( OP::eval( *left, *right ) )
+            return ar;
+    }
+
+    ar = false;
+    ar.message() << "\nCollections appear to be equal";
+
+    return ar;
+}
+# 242 "/usr/include/boost/test/tools/collection_comparison_op.hpp" 3 4
+template<typename OP>
+struct cctraits;
+
+template<typename Lhs, typename Rhs>
+struct cctraits<op::EQ<Lhs, Rhs> > {
+    typedef specialized_compare<Lhs> is_specialized;
+};
+
+template<typename Lhs, typename Rhs>
+struct cctraits<op::NE<Lhs, Rhs> > {
+    typedef specialized_compare<Lhs> is_specialized;
+};
+
+template<typename Lhs, typename Rhs>
+struct cctraits<op::LT<Lhs, Rhs> > {
+    static const bool can_be_equal = false;
+    static const bool prefer_short = true;
+
+    typedef specialized_compare<Lhs> is_specialized;
+};
+
+template<typename Lhs, typename Rhs>
+struct cctraits<op::LE<Lhs, Rhs> > {
+    static const bool can_be_equal = true;
+    static const bool prefer_short = true;
+
+    typedef specialized_compare<Lhs> is_specialized;
+};
+
+template<typename Lhs, typename Rhs>
+struct cctraits<op::GT<Lhs, Rhs> > {
+    static const bool can_be_equal = false;
+    static const bool prefer_short = false;
+
+    typedef specialized_compare<Lhs> is_specialized;
+};
+
+template<typename Lhs, typename Rhs>
+struct cctraits<op::GE<Lhs, Rhs> > {
+    static const bool can_be_equal = true;
+    static const bool prefer_short = false;
+
+    typedef specialized_compare<Lhs> is_specialized;
+};
+
+
+
+
+
+
+template <typename Lhs, typename Rhs, typename L, typename R>
+inline assertion_result
+compare_collections( Lhs const& lhs, Rhs const& rhs, boost::type<op::EQ<L, R> >*, mpl::true_ )
+{
+    return assertion::op::element_compare<op::EQ<L, R> >( lhs, rhs );
+}
+
+
+
+template <typename Lhs, typename Rhs, typename L, typename R>
+inline assertion_result
+compare_collections( Lhs const& lhs, Rhs const& rhs, boost::type<op::EQ<L, R> >*, mpl::false_ )
+{
+    return lhs == rhs;
+}
+
+
+
+template <typename Lhs, typename Rhs, typename L, typename R>
+inline assertion_result
+compare_collections( Lhs const& lhs, Rhs const& rhs, boost::type<op::NE<L, R> >*, mpl::true_ )
+{
+    return assertion::op::non_equality_compare<op::NE<L, R> >( lhs, rhs );
+}
+
+
+
+template <typename Lhs, typename Rhs, typename L, typename R>
+inline assertion_result
+compare_collections( Lhs const& lhs, Rhs const& rhs, boost::type<op::NE<L, R> >*, mpl::false_ )
+{
+    return lhs != rhs;
+}
+
+
+
+template <typename OP, typename Lhs, typename Rhs>
+inline assertion_result
+lexicographic_compare( Lhs const& lhs, Rhs const& rhs )
+{
+    return assertion::op::lexicographic_compare<OP, cctraits<OP>::can_be_equal, cctraits<OP>::prefer_short>( lhs, rhs );
+}
+
+
+
+template <typename Lhs, typename Rhs, typename OP>
+inline assertion_result
+compare_collections( Lhs const& lhs, Rhs const& rhs, boost::type<OP>*, mpl::true_ )
+{
+    return lexicographic_compare<OP>( lhs, rhs );
+}
+
+
+
+template <typename Lhs, typename Rhs, typename L, typename R>
+inline assertion_result
+compare_collections( Lhs const& lhs, Rhs const& rhs, boost::type<op::LT<L, R> >*, mpl::false_ )
+{
+    return lhs < rhs;
+}
+
+
+
+template <typename Lhs, typename Rhs, typename L, typename R>
+inline assertion_result
+compare_collections( Lhs const& lhs, Rhs const& rhs, boost::type<op::LE<L, R> >*, mpl::false_ )
+{
+    return lhs <= rhs;
+}
+
+
+
+template <typename Lhs, typename Rhs, typename L, typename R>
+inline assertion_result
+compare_collections( Lhs const& lhs, Rhs const& rhs, boost::type<op::GT<L, R> >*, mpl::false_ )
+{
+    return lhs > rhs;
+}
+
+
+
+template <typename Lhs, typename Rhs, typename L, typename R>
+inline assertion_result
+compare_collections( Lhs const& lhs, Rhs const& rhs, boost::type<op::GE<L, R> >*, mpl::false_ )
+{
+    return lhs >= rhs;
+}
+
+
+
+
+
+
+
+#define DEFINE_COLLECTION_COMPARISON(oper,name,rev) template<typename Lhs,typename Rhs> struct name<Lhs,Rhs,typename boost::enable_if_c< unit_test::is_forward_iterable<Lhs>::value && !unit_test::is_cstring_comparable<Lhs>::value && unit_test::is_forward_iterable<Rhs>::value && !unit_test::is_cstring_comparable<Rhs>::value>::type> { public: typedef assertion_result result_type; typedef unit_test::bt_iterator_traits<Lhs> t_Lhs_iterator_helper; typedef unit_test::bt_iterator_traits<Rhs> t_Rhs_iterator_helper; typedef name<Lhs, Rhs> OP; typedef typename mpl::if_c< mpl::or_< typename is_c_array<Lhs>::type, typename is_c_array<Rhs>::type >::value, mpl::true_, typename mpl::if_c<is_same<typename decay<Lhs>::type, typename decay<Rhs>::type>::value, typename cctraits<OP>::is_specialized, mpl::false_>::type >::type is_specialized; typedef name<typename t_Lhs_iterator_helper::value_type, typename t_Rhs_iterator_helper::value_type > elem_op; static assertion_result eval( Lhs const& lhs, Rhs const& rhs) { return assertion::op::compare_collections( lhs, rhs, (boost::type<elem_op>*)0, is_specialized() ); } template<typename PrevExprType> static void report( std::ostream&, PrevExprType const&, Rhs const& ) {} static char const* revert() { return " " #rev " "; } };
+# 438 "/usr/include/boost/test/tools/collection_comparison_op.hpp" 3 4
+template<typename Lhs,typename Rhs> struct LT<Lhs,Rhs,typename boost::enable_if_c< unit_test::is_forward_iterable<Lhs>::value && !unit_test::is_cstring_comparable<Lhs>::value && unit_test::is_forward_iterable<Rhs>::value && !unit_test::is_cstring_comparable<Rhs>::value>::type> { public: typedef assertion_result result_type; typedef unit_test::bt_iterator_traits<Lhs> t_Lhs_iterator_helper; typedef unit_test::bt_iterator_traits<Rhs> t_Rhs_iterator_helper; typedef LT<Lhs, Rhs> OP; typedef typename mpl::if_c< mpl::or_< typename is_c_array<Lhs>::type, typename is_c_array<Rhs>::type >::value, mpl::true_, typename mpl::if_c<is_same<typename decay<Lhs>::type, typename decay<Rhs>::type>::value, typename cctraits<OP>::is_specialized, mpl::false_>::type >::type is_specialized; typedef LT<typename t_Lhs_iterator_helper::value_type, typename t_Rhs_iterator_helper::value_type > elem_op; static assertion_result eval( Lhs const& lhs, Rhs const& rhs) { return assertion::op::compare_collections( lhs, rhs, (boost::type<elem_op>*)0, is_specialized() ); } template<typename PrevExprType> static void report( std::ostream&, PrevExprType const&, Rhs const& ) {} static char const* revert() { return " " ">=" " "; } }; template<typename Lhs,typename Rhs> struct LE<Lhs,Rhs,typename boost::enable_if_c< unit_test::is_forward_iterable<Lhs>::value && !unit_test::is_cstring_comparable<Lhs>::value && unit_test::is_forward_iterable<Rhs>::value && !unit_test::is_cstring_comparable<Rhs>::value>::type> { public: typedef assertion_result result_type; typedef unit_test::bt_iterator_traits<Lhs> t_Lhs_iterator_helper; typedef unit_test::bt_iterator_traits<Rhs> t_Rhs_iterator_helper; typedef LE<Lhs, Rhs> OP; typedef typename mpl::if_c< mpl::or_< typename is_c_array<Lhs>::type, typename is_c_array<Rhs>::type >::value, mpl::true_, typename mpl::if_c<is_same<typename decay<Lhs>::type, typename decay<Rhs>::type>::value, typename cctraits<OP>::is_specialized, mpl::false_>::type >::type is_specialized; typedef LE<typename t_Lhs_iterator_helper::value_type, typename t_Rhs_iterator_helper::value_type > elem_op; static assertion_result eval( Lhs const& lhs, Rhs const& rhs) { return assertion::op::compare_collections( lhs, rhs, (boost::type<elem_op>*)0, is_specialized() ); } template<typename PrevExprType> static void report( std::ostream&, PrevExprType const&, Rhs const& ) {} static char const* revert() { return " " ">" " "; } }; template<typename Lhs,typename Rhs> struct GT<Lhs,Rhs,typename boost::enable_if_c< unit_test::is_forward_iterable<Lhs>::value && !unit_test::is_cstring_comparable<Lhs>::value && unit_test::is_forward_iterable<Rhs>::value && !unit_test::is_cstring_comparable<Rhs>::value>::type> { public: typedef assertion_result result_type; typedef unit_test::bt_iterator_traits<Lhs> t_Lhs_iterator_helper; typedef unit_test::bt_iterator_traits<Rhs> t_Rhs_iterator_helper; typedef GT<Lhs, Rhs> OP; typedef typename mpl::if_c< mpl::or_< typename is_c_array<Lhs>::type, typename is_c_array<Rhs>::type >::value, mpl::true_, typename mpl::if_c<is_same<typename decay<Lhs>::type, typename decay<Rhs>::type>::value, typename cctraits<OP>::is_specialized, mpl::false_>::type >::type is_specialized; typedef GT<typename t_Lhs_iterator_helper::value_type, typename t_Rhs_iterator_helper::value_type > elem_op; static assertion_result eval( Lhs const& lhs, Rhs const& rhs) { return assertion::op::compare_collections( lhs, rhs, (boost::type<elem_op>*)0, is_specialized() ); } template<typename PrevExprType> static void report( std::ostream&, PrevExprType const&, Rhs const& ) {} static char const* revert() { return " " "<=" " "; } }; template<typename Lhs,typename Rhs> struct GE<Lhs,Rhs,typename boost::enable_if_c< unit_test::is_forward_iterable<Lhs>::value && !unit_test::is_cstring_comparable<Lhs>::value && unit_test::is_forward_iterable<Rhs>::value && !unit_test::is_cstring_comparable<Rhs>::value>::type> { public: typedef assertion_result result_type; typedef unit_test::bt_iterator_traits<Lhs> t_Lhs_iterator_helper; typedef unit_test::bt_iterator_traits<Rhs> t_Rhs_iterator_helper; typedef GE<Lhs, Rhs> OP; typedef typename mpl::if_c< mpl::or_< typename is_c_array<Lhs>::type, typename is_c_array<Rhs>::type >::value, mpl::true_, typename mpl::if_c<is_same<typename decay<Lhs>::type, typename decay<Rhs>::type>::value, typename cctraits<OP>::is_specialized, mpl::false_>::type >::type is_specialized; typedef GE<typename t_Lhs_iterator_helper::value_type, typename t_Rhs_iterator_helper::value_type > elem_op; static assertion_result eval( Lhs const& lhs, Rhs const& rhs) { return assertion::op::compare_collections( lhs, rhs, (boost::type<elem_op>*)0, is_specialized() ); } template<typename PrevExprType> static void report( std::ostream&, PrevExprType const&, Rhs const& ) {} static char const* revert() { return " " "<" " "; } }; template<typename Lhs,typename Rhs> struct EQ<Lhs,Rhs,typename boost::enable_if_c< unit_test::is_forward_iterable<Lhs>::value && !unit_test::is_cstring_comparable<Lhs>::value && unit_test::is_forward_iterable<Rhs>::value && !unit_test::is_cstring_comparable<Rhs>::value>::type> { public: typedef assertion_result result_type; typedef unit_test::bt_iterator_traits<Lhs> t_Lhs_iterator_helper; typedef unit_test::bt_iterator_traits<Rhs> t_Rhs_iterator_helper; typedef EQ<Lhs, Rhs> OP; typedef typename mpl::if_c< mpl::or_< typename is_c_array<Lhs>::type, typename is_c_array<Rhs>::type >::value, mpl::true_, typename mpl::if_c<is_same<typename decay<Lhs>::type, typename decay<Rhs>::type>::value, typename cctraits<OP>::is_specialized, mpl::false_>::type >::type is_specialized; typedef EQ<typename t_Lhs_iterator_helper::value_type, typename t_Rhs_iterator_helper::value_type > elem_op; static assertion_result eval( Lhs const& lhs, Rhs const& rhs) { return assertion::op::compare_collections( lhs, rhs, (boost::type<elem_op>*)0, is_specialized() ); } template<typename PrevExprType> static void report( std::ostream&, PrevExprType const&, Rhs const& ) {} static char const* revert() { return " " "!=" " "; } }; template<typename Lhs,typename Rhs> struct NE<Lhs,Rhs,typename boost::enable_if_c< unit_test::is_forward_iterable<Lhs>::value && !unit_test::is_cstring_comparable<Lhs>::value && unit_test::is_forward_iterable<Rhs>::value && !unit_test::is_cstring_comparable<Rhs>::value>::type> { public: typedef assertion_result result_type; typedef unit_test::bt_iterator_traits<Lhs> t_Lhs_iterator_helper; typedef unit_test::bt_iterator_traits<Rhs> t_Rhs_iterator_helper; typedef NE<Lhs, Rhs> OP; typedef typename mpl::if_c< mpl::or_< typename is_c_array<Lhs>::type, typename is_c_array<Rhs>::type >::value, mpl::true_, typename mpl::if_c<is_same<typename decay<Lhs>::type, typename decay<Rhs>::type>::value, typename cctraits<OP>::is_specialized, mpl::false_>::type >::type is_specialized; typedef NE<typename t_Lhs_iterator_helper::value_type, typename t_Rhs_iterator_helper::value_type > elem_op; static assertion_result eval( Lhs const& lhs, Rhs const& rhs) { return assertion::op::compare_collections( lhs, rhs, (boost::type<elem_op>*)0, is_specialized() ); } template<typename PrevExprType> static void report( std::ostream&, PrevExprType const&, Rhs const& ) {} static char const* revert() { return " " "==" " "; } };
+#undef DEFINE_COLLECTION_COMPARISON
+
+
+
+}
+}
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 449 "/usr/include/boost/test/tools/collection_comparison_op.hpp" 2 3 4
+# 56 "/usr/include/boost/test/test_tools.hpp" 2 3 4
+# 1 "/usr/include/boost/test/tools/cstring_comparison_op.hpp" 1 3 4
+# 13 "/usr/include/boost/test/tools/cstring_comparison_op.hpp" 3 4
+#define BOOST_TEST_TOOLS_CSTRING_COMPARISON_OP_HPP_050815GER 
+# 24 "/usr/include/boost/test/tools/cstring_comparison_op.hpp" 3 4
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 25 "/usr/include/boost/test/tools/cstring_comparison_op.hpp" 2 3 4
+
+
+
+namespace boost {
+namespace test_tools {
+namespace assertion {
+namespace op {
+
+
+
+
+
+#define DEFINE_CSTRING_COMPARISON(oper,name,rev) template<typename Lhs,typename Rhs> struct name<Lhs,Rhs,typename boost::enable_if_c< ( unit_test::is_cstring_comparable<Lhs>::value && unit_test::is_cstring_comparable<Rhs>::value) >::type > { typedef typename unit_test::deduce_cstring_transform<Lhs>::type lhs_char_type; typedef typename unit_test::deduce_cstring_transform<Rhs>::type rhs_char_type; public: typedef assertion_result result_type; typedef name< typename lhs_char_type::value_type, typename rhs_char_type::value_type> elem_op; static bool eval( Lhs const& lhs, Rhs const& rhs) { return lhs_char_type(lhs) oper rhs_char_type(rhs); } template<typename PrevExprType> static void report( std::ostream& ostr, PrevExprType const& lhs, Rhs const& rhs) { lhs.report( ostr ); ostr << revert() << tt_detail::print_helper( rhs ); } static char const* revert() { return " " #rev " "; } };
+# 75 "/usr/include/boost/test/tools/cstring_comparison_op.hpp" 3 4
+template<typename Lhs,typename Rhs> struct LT<Lhs,Rhs,typename boost::enable_if_c< ( unit_test::is_cstring_comparable<Lhs>::value && unit_test::is_cstring_comparable<Rhs>::value) >::type > { typedef typename unit_test::deduce_cstring_transform<Lhs>::type lhs_char_type; typedef typename unit_test::deduce_cstring_transform<Rhs>::type rhs_char_type; public: typedef assertion_result result_type; typedef LT< typename lhs_char_type::value_type, typename rhs_char_type::value_type> elem_op; static bool eval( Lhs const& lhs, Rhs const& rhs) { return lhs_char_type(lhs) < rhs_char_type(rhs); } template<typename PrevExprType> static void report( std::ostream& ostr, PrevExprType const& lhs, Rhs const& rhs) { lhs.report( ostr ); ostr << revert() << tt_detail::print_helper( rhs ); } static char const* revert() { return " " ">=" " "; } }; template<typename Lhs,typename Rhs> struct LE<Lhs,Rhs,typename boost::enable_if_c< ( unit_test::is_cstring_comparable<Lhs>::value && unit_test::is_cstring_comparable<Rhs>::value) >::type > { typedef typename unit_test::deduce_cstring_transform<Lhs>::type lhs_char_type; typedef typename unit_test::deduce_cstring_transform<Rhs>::type rhs_char_type; public: typedef assertion_result result_type; typedef LE< typename lhs_char_type::value_type, typename rhs_char_type::value_type> elem_op; static bool eval( Lhs const& lhs, Rhs const& rhs) { return lhs_char_type(lhs) <= rhs_char_type(rhs); } template<typename PrevExprType> static void report( std::ostream& ostr, PrevExprType const& lhs, Rhs const& rhs) { lhs.report( ostr ); ostr << revert() << tt_detail::print_helper( rhs ); } static char const* revert() { return " " ">" " "; } }; template<typename Lhs,typename Rhs> struct GT<Lhs,Rhs,typename boost::enable_if_c< ( unit_test::is_cstring_comparable<Lhs>::value && unit_test::is_cstring_comparable<Rhs>::value) >::type > { typedef typename unit_test::deduce_cstring_transform<Lhs>::type lhs_char_type; typedef typename unit_test::deduce_cstring_transform<Rhs>::type rhs_char_type; public: typedef assertion_result result_type; typedef GT< typename lhs_char_type::value_type, typename rhs_char_type::value_type> elem_op; static bool eval( Lhs const& lhs, Rhs const& rhs) { return lhs_char_type(lhs) > rhs_char_type(rhs); } template<typename PrevExprType> static void report( std::ostream& ostr, PrevExprType const& lhs, Rhs const& rhs) { lhs.report( ostr ); ostr << revert() << tt_detail::print_helper( rhs ); } static char const* revert() { return " " "<=" " "; } }; template<typename Lhs,typename Rhs> struct GE<Lhs,Rhs,typename boost::enable_if_c< ( unit_test::is_cstring_comparable<Lhs>::value && unit_test::is_cstring_comparable<Rhs>::value) >::type > { typedef typename unit_test::deduce_cstring_transform<Lhs>::type lhs_char_type; typedef typename unit_test::deduce_cstring_transform<Rhs>::type rhs_char_type; public: typedef assertion_result result_type; typedef GE< typename lhs_char_type::value_type, typename rhs_char_type::value_type> elem_op; static bool eval( Lhs const& lhs, Rhs const& rhs) { return lhs_char_type(lhs) >= rhs_char_type(rhs); } template<typename PrevExprType> static void report( std::ostream& ostr, PrevExprType const& lhs, Rhs const& rhs) { lhs.report( ostr ); ostr << revert() << tt_detail::print_helper( rhs ); } static char const* revert() { return " " "<" " "; } }; template<typename Lhs,typename Rhs> struct EQ<Lhs,Rhs,typename boost::enable_if_c< ( unit_test::is_cstring_comparable<Lhs>::value && unit_test::is_cstring_comparable<Rhs>::value) >::type > { typedef typename unit_test::deduce_cstring_transform<Lhs>::type lhs_char_type; typedef typename unit_test::deduce_cstring_transform<Rhs>::type rhs_char_type; public: typedef assertion_result result_type; typedef EQ< typename lhs_char_type::value_type, typename rhs_char_type::value_type> elem_op; static bool eval( Lhs const& lhs, Rhs const& rhs) { return lhs_char_type(lhs) == rhs_char_type(rhs); } template<typename PrevExprType> static void report( std::ostream& ostr, PrevExprType const& lhs, Rhs const& rhs) { lhs.report( ostr ); ostr << revert() << tt_detail::print_helper( rhs ); } static char const* revert() { return " " "!=" " "; } }; template<typename Lhs,typename Rhs> struct NE<Lhs,Rhs,typename boost::enable_if_c< ( unit_test::is_cstring_comparable<Lhs>::value && unit_test::is_cstring_comparable<Rhs>::value) >::type > { typedef typename unit_test::deduce_cstring_transform<Lhs>::type lhs_char_type; typedef typename unit_test::deduce_cstring_transform<Rhs>::type rhs_char_type; public: typedef assertion_result result_type; typedef NE< typename lhs_char_type::value_type, typename rhs_char_type::value_type> elem_op; static bool eval( Lhs const& lhs, Rhs const& rhs) { return lhs_char_type(lhs) != rhs_char_type(rhs); } template<typename PrevExprType> static void report( std::ostream& ostr, PrevExprType const& lhs, Rhs const& rhs) { lhs.report( ostr ); ostr << revert() << tt_detail::print_helper( rhs ); } static char const* revert() { return " " "==" " "; } };
+#undef DEFINE_CSTRING_COMPARISON
+
+
+
+}
+}
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 86 "/usr/include/boost/test/tools/cstring_comparison_op.hpp" 2 3 4
+# 57 "/usr/include/boost/test/test_tools.hpp" 2 3 4
+
+
+
+# 1 "/usr/include/boost/test/tools/detail/it_pair.hpp" 1 3 4
+# 16 "/usr/include/boost/test/tools/detail/it_pair.hpp" 3 4
+#define BOOST_TEST_TOOLS_DETAIL_IT_PAIR_HPP_112812GER 
+# 61 "/usr/include/boost/test/test_tools.hpp" 2 3 4
+
+# 1 "/usr/include/boost/test/tools/detail/bitwise_manip.hpp" 1 3 4
+# 13 "/usr/include/boost/test/tools/detail/bitwise_manip.hpp" 3 4
+#define BOOST_TEST_TOOLS_DETAIL_BITWISE_MANIP_HPP_012705GER 
+
+
+
+# 1 "/usr/include/boost/test/tools/detail/indirections.hpp" 1 3 4
+# 16 "/usr/include/boost/test/tools/detail/indirections.hpp" 3 4
+#define BOOST_TEST_TOOLS_DETAIL_INDIRECTIONS_HPP_112812GER 
+
+
+
+
+
+
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 24 "/usr/include/boost/test/tools/detail/indirections.hpp" 2 3 4
+
+
+
+namespace boost {
+namespace test_tools {
+namespace tt_detail {
+
+
+
+
+
+template<typename E>
+struct assertion_evaluate_t {
+    assertion_evaluate_t( E const& e ) : m_e( e ) {}
+    operator assertion_result() { return m_e.evaluate( true ); }
+
+    E const& m_e;
+};
+
+
+
+template<typename E>
+inline assertion_evaluate_t<E>
+assertion_evaluate( E const& e ) { return assertion_evaluate_t<E>( e ); }
+
+
+
+template<typename E, typename T>
+inline assertion_evaluate_t<E>
+operator<<( assertion_evaluate_t<E> const& ae, T const& ) { return ae; }
+
+
+
+
+
+
+
+template<typename T>
+inline unit_test::lazy_ostream const&
+assertion_text( unit_test::lazy_ostream const& , T const& m ) { return m; }
+
+
+
+inline unit_test::lazy_ostream const&
+assertion_text( unit_test::lazy_ostream const& et, int ) { return et; }
+
+
+
+
+
+
+
+struct assertion_type {
+    operator check_type() { return CHECK_MSG; }
+};
+
+
+
+template<typename T>
+inline assertion_type
+operator<<( assertion_type const& at, T const& ) { return at; }
+
+
+
+}
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 93 "/usr/include/boost/test/tools/detail/indirections.hpp" 2 3 4
+# 18 "/usr/include/boost/test/tools/detail/bitwise_manip.hpp" 2 3 4
+
+
+
+
+
+# 1 "/usr/include/c++/10.2.0/climits" 1 3 4
+# 39 "/usr/include/c++/10.2.0/climits" 3 4
+       
+# 40 "/usr/include/c++/10.2.0/climits" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include-fixed/limits.h" 1 3 4
+# 43 "/usr/include/c++/10.2.0/climits" 2 3
+# 24 "/usr/include/boost/test/tools/detail/bitwise_manip.hpp" 2 3 4
+
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 26 "/usr/include/boost/test/tools/detail/bitwise_manip.hpp" 2 3 4
+
+
+
+namespace boost {
+namespace test_tools {
+
+
+
+
+
+
+struct bitwise {};
+
+
+
+inline int
+operator<<( unit_test::lazy_ostream const&, bitwise ) { return 0; }
+
+
+
+namespace tt_detail {
+
+
+
+
+
+
+template<typename Lhs, typename Rhs, typename E>
+inline assertion_result
+bitwise_compare(Lhs const& lhs, Rhs const& rhs, E const& expr )
+{
+    assertion_result pr( true );
+
+    std::size_t left_bit_size = sizeof(Lhs)*8;
+    std::size_t right_bit_size = sizeof(Rhs)*8;
+
+    static Lhs const leftOne( 1 );
+    static Rhs const rightOne( 1 );
+
+    std::size_t total_bits = left_bit_size < right_bit_size ? left_bit_size : right_bit_size;
+
+    for( std::size_t counter = 0; counter < total_bits; ++counter ) {
+        if( (lhs & ( leftOne << counter )) != (rhs & (rightOne << counter)) ) {
+            if( pr ) {
+                pr.message() << " [";
+                expr.report( pr.message().stream() );
+                pr.message() << "]. Bitwise comparison failed";
+                pr = false;
+            }
+            pr.message() << "\nMismatch at position " << counter;
+        }
+    }
+
+    if( left_bit_size != right_bit_size ) {
+        if( pr ) {
+            pr.message() << " [";
+            expr.report( pr.message().stream() );
+            pr.message() << "]. Bitwise comparison failed";
+            pr = false;
+        }
+        pr.message() << "\nOperands bit sizes mismatch: " << left_bit_size << " != " << right_bit_size;
+    }
+
+    return pr;
+}
+# 100 "/usr/include/boost/test/tools/detail/bitwise_manip.hpp" 3 4
+template<typename T1, typename T2, typename T3, typename T4>
+inline assertion_result
+operator<<(assertion_evaluate_t<assertion::binary_expr<T1,T2,assertion::op::EQ<T3,T4> > > const& ae, bitwise )
+{
+    return bitwise_compare( ae.m_e.lhs().value(), ae.m_e.rhs(), ae.m_e );
+}
+
+
+
+inline check_type
+operator<<( assertion_type const& , bitwise )
+{
+    return CHECK_BUILT_ASSERTION;
+}
+
+
+
+}
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 122 "/usr/include/boost/test/tools/detail/bitwise_manip.hpp" 2 3 4
+# 63 "/usr/include/boost/test/test_tools.hpp" 2 3 4
+# 1 "/usr/include/boost/test/tools/detail/tolerance_manip.hpp" 1 3 4
+# 16 "/usr/include/boost/test/tools/detail/tolerance_manip.hpp" 3 4
+#define BOOST_TEST_TOOLS_DETAIL_TOLERANCE_MANIP_HPP_012705GER 
+# 25 "/usr/include/boost/test/tools/detail/tolerance_manip.hpp" 3 4
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 26 "/usr/include/boost/test/tools/detail/tolerance_manip.hpp" 2 3 4
+
+
+
+namespace boost {
+namespace test_tools {
+namespace tt_detail {
+
+
+
+
+
+template<typename FPT>
+struct tolerance_manip {
+    explicit tolerance_manip( FPT const & tol ) : m_value( tol ) {}
+
+    FPT m_value;
+};
+
+
+
+struct tolerance_manip_delay {};
+
+template<typename FPT>
+inline tolerance_manip<FPT>
+operator%( FPT v, tolerance_manip_delay const& )
+{
+    static_assert((fpc::tolerance_based<FPT>::value), "tolerance should be specified using a floating points type")
+                                                                                           ;
+
+    return tolerance_manip<FPT>( FPT(v / 100) );
+}
+
+
+
+template<typename E, typename FPT>
+inline assertion_result
+operator<<(assertion_evaluate_t<E> const& ae, tolerance_manip<FPT> const& tol)
+{
+    local_fpc_tolerance<FPT> lt( tol.m_value );
+
+    return ae.m_e.evaluate();
+}
+
+
+
+template<typename FPT>
+inline int
+operator<<( unit_test::lazy_ostream const&, tolerance_manip<FPT> const& ) { return 0; }
+
+
+
+template<typename FPT>
+inline check_type
+operator<<( assertion_type const& , tolerance_manip<FPT> const& ) { return CHECK_BUILT_ASSERTION; }
+
+
+
+}
+
+
+
+
+
+
+
+template<typename FPT>
+inline tt_detail::tolerance_manip<FPT>
+tolerance( FPT v )
+{
+    static_assert((fpc::tolerance_based<FPT>::value), "tolerance only for floating points")
+                                                                   ;
+
+    return tt_detail::tolerance_manip<FPT>( v );
+}
+
+
+
+
+template<typename FPT>
+inline tt_detail::tolerance_manip<FPT>
+tolerance( fpc::percent_tolerance_t<FPT> v )
+{
+    static_assert((fpc::tolerance_based<FPT>::value), "tolerance only for floating points")
+                                                                   ;
+
+    return tt_detail::tolerance_manip<FPT>( static_cast<FPT>(v.m_value / 100) );
+}
+
+
+
+
+inline tt_detail::tolerance_manip_delay
+tolerance()
+{
+    return tt_detail::tolerance_manip_delay();
+}
+
+
+
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 129 "/usr/include/boost/test/tools/detail/tolerance_manip.hpp" 2 3 4
+# 64 "/usr/include/boost/test/test_tools.hpp" 2 3 4
+# 1 "/usr/include/boost/test/tools/detail/per_element_manip.hpp" 1 3 4
+# 13 "/usr/include/boost/test/tools/detail/per_element_manip.hpp" 3 4
+#define BOOST_TEST_TOOLS_DETAIL_PER_ELEMENT_MANIP_HPP_050815GER 
+# 22 "/usr/include/boost/test/tools/detail/per_element_manip.hpp" 3 4
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 23 "/usr/include/boost/test/tools/detail/per_element_manip.hpp" 2 3 4
+
+
+
+namespace boost {
+namespace test_tools {
+
+
+
+
+
+
+struct per_element {};
+
+
+
+inline int
+operator<<( unit_test::lazy_ostream const&, per_element ) { return 0; }
+
+
+
+namespace tt_detail {
+
+template<typename T1, typename T2, typename OP>
+inline assertion_result
+operator<<(assertion_evaluate_t<assertion::binary_expr<T1,T2,OP> > const& ae, per_element )
+{
+    typedef typename OP::elem_op elem_op;
+    return assertion::op::element_compare<elem_op>( ae.m_e.lhs().value(), ae.m_e.rhs() );
+}
+
+
+
+inline check_type
+operator<<( assertion_type const&, per_element )
+{
+    return CHECK_BUILT_ASSERTION;
+}
+
+
+
+}
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 68 "/usr/include/boost/test/tools/detail/per_element_manip.hpp" 2 3 4
+# 65 "/usr/include/boost/test/test_tools.hpp" 2 3 4
+# 1 "/usr/include/boost/test/tools/detail/lexicographic_manip.hpp" 1 3 4
+# 13 "/usr/include/boost/test/tools/detail/lexicographic_manip.hpp" 3 4
+#define BOOST_TEST_TOOLS_DETAIL_LEXICOGRAPHIC_MANIP_HPP_050815GER 
+# 22 "/usr/include/boost/test/tools/detail/lexicographic_manip.hpp" 3 4
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 23 "/usr/include/boost/test/tools/detail/lexicographic_manip.hpp" 2 3 4
+
+
+
+namespace boost {
+namespace test_tools {
+
+
+
+
+
+
+struct lexicographic {};
+
+
+
+inline int
+operator<<( unit_test::lazy_ostream const&, lexicographic ) { return 0; }
+
+
+
+namespace tt_detail {
+
+template<typename T1, typename T2, typename OP>
+inline assertion_result
+operator<<(assertion_evaluate_t<assertion::binary_expr<T1,T2,OP> > const& ae, lexicographic )
+{
+    typedef typename OP::elem_op elem_op;
+    return assertion::op::lexicographic_compare<elem_op>( ae.m_e.lhs().value(), ae.m_e.rhs() );
+}
+
+
+
+inline check_type
+operator<<( assertion_type const&, lexicographic )
+{
+    return CHECK_BUILT_ASSERTION;
+}
+
+
+
+}
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 68 "/usr/include/boost/test/tools/detail/lexicographic_manip.hpp" 2 3 4
+# 66 "/usr/include/boost/test/test_tools.hpp" 2 3 4
+# 20 "/usr/include/boost/test/impl/test_tools.ipp" 2 3 4
+
+
+# 1 "/usr/include/boost/test/tools/output_test_stream.hpp" 1 3 4
+# 13 "/usr/include/boost/test/tools/output_test_stream.hpp" 3 4
+#define BOOST_TEST_OUTPUT_TEST_STREAM_HPP_012705GER 
+# 23 "/usr/include/boost/test/tools/output_test_stream.hpp" 3 4
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 24 "/usr/include/boost/test/tools/output_test_stream.hpp" 2 3 4
+# 33 "/usr/include/boost/test/tools/output_test_stream.hpp" 3 4
+namespace boost {
+namespace test_tools {
+
+
+class __attribute__((__visibility__("default"))) output_test_stream : public wrap_stringstream::wrapped_stream {
+    typedef unit_test::const_string const_string;
+public:
+# 49 "/usr/include/boost/test/tools/output_test_stream.hpp" 3 4
+    explicit output_test_stream( const_string pattern_file_name = const_string(),
+                                        bool match_or_save = true,
+                                        bool text_or_binary = true );
+
+
+    virtual ~output_test_stream();
+
+
+
+
+    virtual assertion_result is_empty( bool flush_stream = true );
+
+
+
+
+
+
+    virtual assertion_result check_length( std::size_t length, bool flush_stream = true );
+
+
+
+
+
+    virtual assertion_result is_equal( const_string arg_, bool flush_stream = true );
+
+
+
+
+    virtual assertion_result match_pattern( bool flush_stream = true );
+
+
+    void flush();
+
+protected:
+
+
+
+
+    virtual std::string get_stream_string_representation() const;
+
+private:
+
+
+
+    std::size_t length();
+
+
+    virtual void sync();
+
+    struct Impl;
+    Impl* m_pimpl;
+};
+
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 106 "/usr/include/boost/test/tools/output_test_stream.hpp" 2 3 4
+# 23 "/usr/include/boost/test/impl/test_tools.ipp" 2 3 4
+# 41 "/usr/include/boost/test/impl/test_tools.ipp" 3 4
+# 1 "/usr/include/c++/10.2.0/cstring" 1 3 4
+# 39 "/usr/include/c++/10.2.0/cstring" 3 4
+       
+# 40 "/usr/include/c++/10.2.0/cstring" 3
+# 42 "/usr/include/boost/test/impl/test_tools.ipp" 2 3 4
+# 1 "/usr/include/c++/10.2.0/cctype" 1 3 4
+# 39 "/usr/include/c++/10.2.0/cctype" 3 4
+       
+# 40 "/usr/include/c++/10.2.0/cctype" 3
+# 43 "/usr/include/boost/test/impl/test_tools.ipp" 2 3 4
+# 1 "/usr/include/c++/10.2.0/cwchar" 1 3 4
+# 39 "/usr/include/c++/10.2.0/cwchar" 3 4
+       
+# 40 "/usr/include/c++/10.2.0/cwchar" 3
+# 44 "/usr/include/boost/test/impl/test_tools.ipp" 2 3 4
+# 52 "/usr/include/boost/test/impl/test_tools.ipp" 3 4
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 53 "/usr/include/boost/test/impl/test_tools.ipp" 2 3 4
+# 64 "/usr/include/boost/test/impl/test_tools.ipp" 3 4
+namespace boost {
+namespace unit_test {
+
+  lazy_ostream lazy_ostream::inst = lazy_ostream();
+}}
+
+namespace boost {
+namespace test_tools {
+namespace tt_detail {
+
+
+
+
+
+void
+print_log_value<bool>::operator()( std::ostream& ostr, bool t )
+{
+     ostr << std::boolalpha << t;
+}
+
+void
+print_log_value<char>::operator()( std::ostream& ostr, char t )
+{
+    if( (std::isprint)( static_cast<unsigned char>(t) ) )
+        ostr << '\'' << t << '\'';
+    else
+        ostr << std::hex
+
+        << std::showbase
+
+
+
+        << static_cast<int>(t);
+}
+
+
+
+void
+print_log_value<unsigned char>::operator()( std::ostream& ostr, unsigned char t )
+{
+    ostr << std::hex
+
+
+        << std::showbase
+
+
+
+        << static_cast<int>(t);
+}
+
+
+
+void
+print_log_value<char const*>::operator()( std::ostream& ostr, char const* t )
+{
+    ostr << ( t ? t : "null string" );
+}
+
+
+
+void
+print_log_value<wchar_t const*>::operator()( std::ostream& ostr, wchar_t const* t )
+{
+    ostr << ( t ? t : L"null string" );
+}
+
+
+
+
+
+
+
+using ::boost::unit_test::lazy_ostream;
+
+static char const* check_str [] = { " == ", " != ", " < " , " <= ", " > " , " >= " };
+static char const* rever_str [] = { " != ", " == ", " >= ", " > " , " <= ", " < " };
+
+template<typename OutStream>
+void
+format_report( OutStream& os, assertion_result const& pr, unit_test::lazy_ostream const& assertion_descr,
+               tool_level tl, check_type ct,
+               std::size_t num_args, va_list args,
+               char const* prefix, char const* suffix )
+{
+    using namespace unit_test;
+
+    switch( ct ) {
+    case CHECK_PRED:
+        os << prefix << assertion_descr << suffix;
+
+        if( !pr.has_empty_message() )
+            os << ". " << pr.message();
+        break;
+
+    case CHECK_BUILT_ASSERTION: {
+        os << prefix << assertion_descr << suffix;
+
+        if( tl != PASS ) {
+            const_string details_message = pr.message();
+
+            if( !details_message.is_empty() ) {
+                os << details_message;
+            }
+        }
+        break;
+    }
+
+    case CHECK_MSG:
+        if( tl == PASS )
+            os << prefix << "'" << assertion_descr << "'" << suffix;
+        else
+            os << assertion_descr;
+
+        if( !pr.has_empty_message() )
+            os << ". " << pr.message();
+        break;
+
+    case CHECK_EQUAL:
+    case CHECK_NE:
+    case CHECK_LT:
+    case CHECK_LE:
+    case CHECK_GT:
+    case CHECK_GE: {
+        char const* arg1_descr = __builtin_va_arg(args,char const*);
+        lazy_ostream const* arg1_val = __builtin_va_arg(args,lazy_ostream const*);
+        char const* arg2_descr = __builtin_va_arg(args,char const*);
+        lazy_ostream const* arg2_val = __builtin_va_arg(args,lazy_ostream const*);
+
+        os << prefix << arg1_descr << check_str[ct-CHECK_EQUAL] << arg2_descr << suffix;
+
+        if( tl != PASS )
+            os << " [" << *arg1_val << rever_str[ct-CHECK_EQUAL] << *arg2_val << "]" ;
+
+        if( !pr.has_empty_message() )
+            os << ". " << pr.message();
+        break;
+    }
+
+    case CHECK_CLOSE:
+    case CHECK_CLOSE_FRACTION: {
+        char const* arg1_descr = __builtin_va_arg(args,char const*);
+        lazy_ostream const* arg1_val = __builtin_va_arg(args,lazy_ostream const*);
+        char const* arg2_descr = __builtin_va_arg(args,char const*);
+        lazy_ostream const* arg2_val = __builtin_va_arg(args,lazy_ostream const*);
+                                          __builtin_va_arg(args,char const*);
+        lazy_ostream const* toler_val = __builtin_va_arg(args,lazy_ostream const*);
+
+        os << "difference{" << pr.message()
+                            << "} between " << arg1_descr << "{" << *arg1_val
+                            << "} and " << arg2_descr << "{" << *arg2_val
+                            << ( tl == PASS ? "} doesn't exceed " : "} exceeds " )
+                            << *toler_val;
+        if( ct == CHECK_CLOSE )
+            os << "%";
+        break;
+    }
+    case CHECK_SMALL: {
+        char const* arg1_descr = __builtin_va_arg(args,char const*);
+        lazy_ostream const* arg1_val = __builtin_va_arg(args,lazy_ostream const*);
+                                          __builtin_va_arg(args,char const*);
+        lazy_ostream const* toler_val = __builtin_va_arg(args,lazy_ostream const*);
+
+        os << "absolute value of " << arg1_descr << "{" << *arg1_val << "}"
+                                   << ( tl == PASS ? " doesn't exceed " : " exceeds " )
+                                   << *toler_val;
+
+        if( !pr.has_empty_message() )
+            os << ". " << pr.message();
+        break;
+    }
+
+    case CHECK_PRED_WITH_ARGS: {
+        std::vector< std::pair<char const*, lazy_ostream const*> > args_copy;
+        args_copy.reserve( num_args );
+        for( std::size_t i = 0; i < num_args; ++i ) {
+            char const* desc = __builtin_va_arg(args,char const*);
+            lazy_ostream const* value = __builtin_va_arg(args,lazy_ostream const*);
+            args_copy.push_back( std::make_pair( desc, value ) );
+        }
+
+        os << prefix << assertion_descr;
+
+
+        os << "( ";
+        for( std::size_t i = 0; i < num_args; ++i ) {
+            os << args_copy[i].first;
+
+            if( i != num_args-1 )
+                os << ", ";
+        }
+        os << " )" << suffix;
+
+        if( tl != PASS ) {
+            os << " for ( ";
+            for( std::size_t i = 0; i < num_args; ++i ) {
+                os << *args_copy[i].second;
+
+                if( i != num_args-1 )
+                    os << ", ";
+            }
+            os << " )";
+        }
+
+        if( !pr.has_empty_message() )
+            os << ". " << pr.message();
+        break;
+    }
+
+    case CHECK_EQUAL_COLL: {
+        char const* left_begin_descr = __builtin_va_arg(args,char const*);
+        char const* left_end_descr = __builtin_va_arg(args,char const*);
+        char const* right_begin_descr = __builtin_va_arg(args,char const*);
+        char const* right_end_descr = __builtin_va_arg(args,char const*);
+
+        os << prefix << "{ " << left_begin_descr << ", " << left_end_descr << " } == { "
+                             << right_begin_descr << ", " << right_end_descr << " }"
+           << suffix;
+
+        if( !pr.has_empty_message() )
+            os << ". " << pr.message();
+        break;
+    }
+
+    case CHECK_BITWISE_EQUAL: {
+        char const* left_descr = __builtin_va_arg(args,char const*);
+        char const* right_descr = __builtin_va_arg(args,char const*);
+
+        os << prefix << left_descr << " =.= " << right_descr << suffix;
+
+        if( !pr.has_empty_message() )
+            os << ". " << pr.message();
+        break;
+    }
+    }
+}
+
+
+
+bool
+report_assertion( assertion_result const& ar,
+                  lazy_ostream const& assertion_descr,
+                  const_string file_name,
+                  std::size_t line_num,
+                  tool_level tl,
+                  check_type ct,
+                  std::size_t num_args, ... )
+{
+    using namespace unit_test;
+
+    if( !framework::test_in_progress() ) {
+# 322 "/usr/include/boost/test/impl/test_tools.ipp" 3 4
+        framework::test_aborted();
+        return false;
+    }
+
+
+    if( !!ar )
+        tl = PASS;
+
+    log_level ll;
+    char const* prefix;
+    char const* suffix;
+
+    switch( tl ) {
+    case PASS:
+        ll = log_successful_tests;
+        prefix = "check ";
+        suffix = " has passed";
+        break;
+    case WARN:
+        ll = log_warnings;
+        prefix = "condition ";
+        suffix = " is not satisfied";
+        break;
+    case CHECK:
+        ll = log_all_errors;
+        prefix = "check ";
+        suffix = " has failed";
+        break;
+    case REQUIRE:
+        ll = log_fatal_errors;
+        prefix = "critical check ";
+        suffix = " has failed";
+        break;
+    default:
+        return true;
+    }
+
+    unit_test_log << unit_test::log::begin( file_name, line_num ) << ll;
+    va_list args;
+    __builtin_va_start(args,num_args);
+
+    format_report( unit_test_log, ar, assertion_descr, tl, ct, num_args, args, prefix, suffix );
+
+    __builtin_va_end(args);
+    unit_test_log << unit_test::log::end();
+
+    switch( tl ) {
+    case PASS:
+        framework::assertion_result( AR_PASSED );
+        return true;
+
+    case WARN:
+        framework::assertion_result( AR_TRIGGERED );
+        return false;
+
+    case CHECK:
+        framework::assertion_result( AR_FAILED );
+        return false;
+
+    case REQUIRE:
+        framework::assertion_result( AR_FAILED );
+        framework::test_unit_aborted( framework::current_test_unit() );
+        unit_test::ut_detail::throw_exception( execution_aborted() );
+
+
+        __builtin_unreachable();;
+    }
+
+    return true;
+}
+
+
+
+assertion_result
+format_assertion_result( const_string expr_val, const_string details )
+{
+    assertion_result res(false);
+
+    bool starts_new_line = first_char( expr_val ) == '\n';
+
+    if( !starts_new_line && !expr_val.is_empty() )
+        res.message().stream() << " [" << expr_val << "]";
+
+    if( !details.is_empty() ) {
+        if( first_char(details) != '[' )
+            res.message().stream() << ". ";
+        else
+            res.message().stream() << " ";
+
+        res.message().stream() << details;
+    }
+
+    if( starts_new_line )
+        res.message().stream() << "." << expr_val;
+
+    return res;
+}
+
+
+
+__attribute__((__visibility__("default"))) std::string
+prod_report_format( assertion_result const& ar, unit_test::lazy_ostream const& assertion_descr, check_type ct, std::size_t num_args, ... )
+{
+    std::ostringstream msg_buff;
+
+    va_list args;
+    __builtin_va_start(args,num_args);
+
+    format_report( msg_buff, ar, assertion_descr, CHECK, ct, num_args, args, "assertion ", " failed" );
+
+    __builtin_va_end(args);
+
+    return msg_buff.str();
+}
+
+
+
+assertion_result
+equal_impl( char const* left, char const* right )
+{
+    return (left && right) ? std::strcmp( left, right ) == 0 : (left == right);
+}
+
+
+
+
+
+assertion_result
+equal_impl( wchar_t const* left, wchar_t const* right )
+{
+    return (left && right) ? std::wcscmp( left, right ) == 0 : (left == right);
+}
+
+
+
+
+
+bool
+is_defined_impl( const_string symbol_name, const_string symbol_value )
+{
+    symbol_value.trim_left( 2 );
+    return symbol_name != symbol_value;
+}
+
+
+
+
+
+
+
+context_frame::context_frame( ::boost::unit_test::lazy_ostream const& context_descr )
+: m_frame_id( unit_test::framework::add_context( context_descr, true ) )
+{
+}
+
+
+
+context_frame::~context_frame()
+{
+    unit_test::framework::clear_context( m_frame_id );
+}
+
+
+
+context_frame::operator bool()
+{
+    return true;
+}
+
+
+
+}
+
+
+
+
+
+struct output_test_stream::Impl
+{
+    std::fstream m_pattern;
+    bool m_match_or_save;
+    bool m_text_or_binary;
+    std::string m_synced_string;
+
+    char get_char()
+    {
+        char res = 0;
+        do {
+            m_pattern.get( res );
+        } while( m_text_or_binary && res == '\r' && !m_pattern.fail() && !m_pattern.eof() );
+
+        return res;
+    }
+
+    void check_and_fill( assertion_result& res )
+    {
+        if( !res.p_predicate_value )
+            res.message() << "Output content: \"" << m_synced_string << '\"';
+    }
+};
+
+
+
+output_test_stream::output_test_stream( const_string pattern_file_name, bool match_or_save, bool text_or_binary )
+: m_pimpl( new Impl )
+{
+    if( !pattern_file_name.is_empty() ) {
+        std::ios::openmode m = match_or_save ? std::ios::in : std::ios::out;
+        if( !text_or_binary )
+            m |= std::ios::binary;
+
+        m_pimpl->m_pattern.open( pattern_file_name.begin(), m );
+
+        if( !m_pimpl->m_pattern.is_open() )
+            (::boost::unit_test::unit_test_log << ::boost::unit_test::log::begin( "boost.test framework", 0 )) ( ::boost::unit_test::log_messages ) << (::boost::unit_test::lazy_ostream::instance() << "Can't open pattern file " << pattern_file_name << " for " << (match_or_save ? "reading" : "writing"));
+    }
+
+    m_pimpl->m_match_or_save = match_or_save;
+    m_pimpl->m_text_or_binary = text_or_binary;
+}
+
+
+
+output_test_stream::~output_test_stream()
+{
+    delete m_pimpl;
+}
+
+
+
+assertion_result
+output_test_stream::is_empty( bool flush_stream )
+{
+    sync();
+
+    assertion_result res( m_pimpl->m_synced_string.empty() );
+
+    m_pimpl->check_and_fill( res );
+
+    if( flush_stream )
+        flush();
+
+    return res;
+}
+
+
+
+assertion_result
+output_test_stream::check_length( std::size_t length_, bool flush_stream )
+{
+    sync();
+
+    assertion_result res( m_pimpl->m_synced_string.length() == length_ );
+
+    m_pimpl->check_and_fill( res );
+
+    if( flush_stream )
+        flush();
+
+    return res;
+}
+
+
+
+assertion_result
+output_test_stream::is_equal( const_string arg, bool flush_stream )
+{
+    sync();
+
+    assertion_result res( const_string( m_pimpl->m_synced_string ) == arg );
+
+    m_pimpl->check_and_fill( res );
+
+    if( flush_stream )
+        flush();
+
+    return res;
+}
+
+
+
+std::string pretty_print_log(std::string str) {
+
+    static const std::string to_replace[] = { "\r", "\n" };
+    static const std::string replacement[] = { "\\r", "\\n" };
+
+    return unit_test::utils::replace_all_occurrences_of(
+        str,
+        to_replace, to_replace + sizeof(to_replace)/sizeof(to_replace[0]),
+        replacement, replacement + sizeof(replacement)/sizeof(replacement[0]));
+}
+
+assertion_result
+output_test_stream::match_pattern( bool flush_stream )
+{
+    const std::string::size_type n_chars_presuffix = 10;
+    sync();
+
+    assertion_result result( true );
+
+    const std::string stream_string_repr = get_stream_string_representation();
+
+    if( !m_pimpl->m_pattern.is_open() ) {
+        result = false;
+        result.message() << "Pattern file can't be opened!";
+    }
+    else {
+        if( m_pimpl->m_match_or_save ) {
+
+            int offset = 0;
+            std::vector<char> last_elements;
+            for ( std::string::size_type i = 0; static_cast<int>(i + offset) < static_cast<int>(stream_string_repr.length()); ++i ) {
+
+                char c = m_pimpl->get_char();
+
+                if( last_elements.size() <= n_chars_presuffix ) {
+                    last_elements.push_back( c );
+                }
+                else {
+                    last_elements[ i % last_elements.size() ] = c;
+                }
+
+                bool is_same = !m_pimpl->m_pattern.fail() &&
+                         !m_pimpl->m_pattern.eof() &&
+                         (stream_string_repr[i+offset] == c);
+
+                if( !is_same ) {
+
+                    result = false;
+
+                    std::string::size_type prefix_size = (std::min)( i + offset, n_chars_presuffix );
+
+                    std::string::size_type suffix_size = (std::min)( stream_string_repr.length() - i - offset,
+                                                                      n_chars_presuffix );
+
+
+                    std::string substr = stream_string_repr.substr(0, i+offset);
+                    std::size_t line = std::count(substr.begin(), substr.end(), '\n');
+                    std::size_t column = i + offset - substr.rfind('\n');
+
+                    result.message()
+                        << "Mismatch at position " << i
+                        << " (line " << line
+                        << ", column " << column
+                        << "): '" << pretty_print_log(std::string(1, stream_string_repr[i+offset])) << "' != '" << pretty_print_log(std::string(1, c)) << "' :\n";
+
+
+
+                    std::string sub_str_prefix(pretty_print_log(stream_string_repr.substr( i + offset - prefix_size, prefix_size )));
+
+
+                    std::string sub_str_suffix(stream_string_repr.substr( i + offset, suffix_size));
+                    result.message() << "... " << sub_str_prefix + pretty_print_log(sub_str_suffix) << " ..." << '\n';
+
+                    result.message() << "... ";
+                    for( std::size_t j = 0; j < last_elements.size() ; j++ )
+                        result.message() << pretty_print_log(std::string(1, last_elements[(i + j + 1) % last_elements.size()]));
+
+                    std::vector<char> last_elements_ordered;
+                    last_elements_ordered.push_back(c);
+                    for( std::string::size_type counter = 0; counter < suffix_size - 1 ; counter++ ) {
+                        char c2 = m_pimpl->get_char();
+
+                        if( m_pimpl->m_pattern.fail() || m_pimpl->m_pattern.eof() )
+                            break;
+
+                        result.message() << pretty_print_log(std::string(1, c2));
+
+                        last_elements_ordered.push_back(c2);
+                    }
+
+
+
+                    std::size_t max_nb_char_in_common = 0;
+                    std::size_t best_pattern_start_index = 0;
+                    std::size_t best_stream_start_index = 0;
+                    for( std::size_t pattern_start_index = best_pattern_start_index;
+                         pattern_start_index < last_elements_ordered.size();
+                         pattern_start_index++ ) {
+                        for( std::size_t stream_start_index = best_stream_start_index;
+                             stream_start_index < sub_str_suffix.size();
+                             stream_start_index++ ) {
+
+                            std::size_t max_size = (std::min)( last_elements_ordered.size() - pattern_start_index, sub_str_suffix.size() - stream_start_index );
+                            if( max_nb_char_in_common > max_size )
+                                break;
+
+                            std::size_t nb_char_in_common = 0;
+                            for( std::size_t k = 0; k < max_size; k++) {
+                                if( last_elements_ordered[pattern_start_index + k] == sub_str_suffix[stream_start_index + k] )
+                                    nb_char_in_common ++;
+                                else
+                                    break;
+                            }
+
+                            if( nb_char_in_common > max_nb_char_in_common ) {
+                                max_nb_char_in_common = nb_char_in_common;
+                                best_pattern_start_index = pattern_start_index;
+                                best_stream_start_index = stream_start_index;
+                            }
+                        }
+                    }
+
+
+                    result.message() << " ...\n... ";
+                    for( std::string::size_type j = 0; j < sub_str_prefix.size(); j++) {
+                        result.message() << ' ';
+                    }
+
+                    result.message() << '~';
+
+                    for( std::size_t k = 1; k < (std::max)(best_pattern_start_index, best_stream_start_index); k++ ) {
+                        std::string s1(pretty_print_log(std::string(1, last_elements_ordered[(std::min)(k, best_pattern_start_index)])));
+                        std::string s2(pretty_print_log(std::string(1, sub_str_suffix[(std::min)(k, best_stream_start_index)])));
+                        for( int h = (std::max)(s1.size(), s2.size()); h > 0; h--)
+                            result.message() << "~";
+                    }
+
+                    if( m_pimpl->m_pattern.eof() ) {
+                        result.message() << "    (reference string shorter than current stream)";
+                    }
+
+                    result.message() << "\n";
+
+
+                    if( m_pimpl->m_pattern.eof() ) {
+                        break;
+                    }
+
+
+                    for(std::string::size_type counter = 0; counter < last_elements_ordered.size() - 1 ; counter++)
+                        last_elements[ (i + 1 + counter) % last_elements.size() ] = last_elements_ordered[counter + 1];
+
+                    i += last_elements_ordered.size()-1;
+                    offset += best_stream_start_index - best_pattern_start_index;
+
+                }
+
+            }
+# 769 "/usr/include/boost/test/impl/test_tools.ipp" 3 4
+        }
+        else {
+            m_pimpl->m_pattern.write( stream_string_repr.c_str(),
+                                      static_cast<std::streamsize>( stream_string_repr.length() ) );
+            m_pimpl->m_pattern.flush();
+        }
+    }
+
+    if( flush_stream )
+        flush();
+
+    return result;
+}
+
+
+
+void
+output_test_stream::flush()
+{
+    m_pimpl->m_synced_string.erase();
+
+
+    str( std::string() );
+
+
+
+}
+
+
+std::string
+output_test_stream::get_stream_string_representation() const {
+    return m_pimpl->m_synced_string;
+}
+
+
+
+std::size_t
+output_test_stream::length()
+{
+    sync();
+
+    return m_pimpl->m_synced_string.length();
+}
+
+
+
+void
+output_test_stream::sync()
+{
+
+
+
+
+    m_pimpl->m_synced_string = str();
+
+}
+
+
+
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 832 "/usr/include/boost/test/impl/test_tools.ipp" 2 3 4
+# 30 "/usr/include/boost/test/included/unit_test.hpp" 2 3 4
+# 1 "/usr/include/boost/test/impl/test_tree.ipp" 1 3 4
+# 14 "/usr/include/boost/test/impl/test_tree.ipp" 3 4
+#define BOOST_TEST_UNIT_TEST_SUITE_IPP_012205GER 
+# 25 "/usr/include/boost/test/impl/test_tree.ipp" 3 4
+# 1 "/usr/include/boost/test/tree/auto_registration.hpp" 1 3 4
+# 16 "/usr/include/boost/test/tree/auto_registration.hpp" 3 4
+#define BOOST_TEST_TREE_AUTO_REGISTRATION_HPP_100211GER 
+# 26 "/usr/include/boost/test/tree/auto_registration.hpp" 3 4
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 27 "/usr/include/boost/test/tree/auto_registration.hpp" 2 3 4
+
+
+
+namespace boost {
+namespace unit_test {
+namespace ut_detail {
+
+
+
+
+
+struct __attribute__((__visibility__("default"))) auto_test_unit_registrar {
+
+                auto_test_unit_registrar( test_case* tc, decorator::collector_t& decorators, counter_t exp_fail = 0 );
+    explicit auto_test_unit_registrar( const_string ts_name, const_string ts_file, std::size_t ts_line, decorator::collector_t& decorators );
+    explicit auto_test_unit_registrar( test_unit_generator const& tc_gen, decorator::collector_t& decorators );
+    explicit auto_test_unit_registrar( boost::shared_ptr<test_unit_generator> tc_gen, decorator::collector_t& decorators );
+    explicit auto_test_unit_registrar( int );
+};
+
+}
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 52 "/usr/include/boost/test/tree/auto_registration.hpp" 2 3 4
+# 26 "/usr/include/boost/test/impl/test_tree.ipp" 2 3 4
+# 38 "/usr/include/boost/test/impl/test_tree.ipp" 3 4
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 39 "/usr/include/boost/test/impl/test_tree.ipp" 2 3 4
+
+
+
+namespace boost {
+namespace unit_test {
+
+
+
+
+
+test_unit::test_unit( const_string name, const_string file_name, std::size_t line_num, test_unit_type t )
+: p_type( t )
+, p_type_name( t == TUT_CASE ? "case" : "suite" )
+, p_file_name( file_name )
+, p_line_num( line_num )
+, p_id( INV_TEST_UNIT_ID )
+, p_parent_id( INV_TEST_UNIT_ID )
+, p_name( std::string( name.begin(), name.size() ) )
+, p_timeout( 0 )
+, p_expected_failures( 0 )
+, p_default_status( RS_INHERIT )
+, p_run_status( RS_INVALID )
+, p_sibling_rank(0)
+{
+}
+
+
+
+test_unit::test_unit( const_string module_name )
+: p_type( TUT_SUITE )
+, p_type_name( "module" )
+, p_line_num( 0 )
+, p_id( INV_TEST_UNIT_ID )
+, p_parent_id( INV_TEST_UNIT_ID )
+, p_name( std::string( module_name.begin(), module_name.size() ) )
+, p_timeout( 0 )
+, p_expected_failures( 0 )
+, p_default_status( RS_INHERIT )
+, p_run_status( RS_INVALID )
+, p_sibling_rank(0)
+{
+}
+
+
+
+test_unit::~test_unit()
+{
+    framework::deregister_test_unit( this );
+}
+
+
+
+void
+test_unit::depends_on( test_unit* tu )
+{
+    if( p_id != framework::master_test_suite().p_id ) {} else unit_test::ut_detail::throw_exception( unit_test::framework::setup_error( "Can't add dependency to the master test suite" ) )
+                                                                              ;
+
+    p_dependencies.value.push_back( tu->p_id );
+}
+
+
+
+void
+test_unit::add_precondition( precondition_t const& pc )
+{
+    p_preconditions.value.push_back( pc );
+}
+
+
+
+test_tools::assertion_result
+test_unit::check_preconditions() const
+{
+    if( ::boost::unit_test::for_each::static_any_t _fe_cur_113 = ::boost::unit_test::for_each::begin( p_dependencies.get(), ::boost::unit_test::for_each::is_const_coll( p_dependencies.get() ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_113 = ::boost::unit_test::for_each::end( p_dependencies.get(), ::boost::unit_test::for_each::is_const_coll( p_dependencies.get() ) ) ) {} else for( bool _fe_con_113 = true; _fe_con_113 && !::boost::unit_test::for_each::done( _fe_cur_113, _fe_end_113, p_dependencies.get(), ::boost::unit_test::for_each::is_const_coll( p_dependencies.get() ) ); _fe_con_113 ? ::boost::unit_test::for_each::next( _fe_cur_113, p_dependencies.get(), ::boost::unit_test::for_each::is_const_coll( p_dependencies.get() ) ) : ((void)&(p_dependencies.get()))) if( (_fe_con_113 = false, false) ) {} else for( test_unit_id dep_id = ::boost::unit_test::for_each::deref( _fe_cur_113, p_dependencies.get(), ::boost::type<test_unit_id >(), ::boost::unit_test::for_each::is_const_coll( p_dependencies.get() ) ); !_fe_con_113; _fe_con_113 = true ) {
+        test_unit const& dep = framework::get( dep_id, TUT_ANY );
+
+        if( !dep.is_enabled() ) {
+            test_tools::assertion_result res(false);
+            res.message() << "dependency test " << dep.p_type_name << " \"" << dep.full_name() << "\" is disabled";
+            return res;
+        }
+
+        test_results const& test_rslt = unit_test::results_collector.results( dep_id );
+        if( !test_rslt.passed() ) {
+            test_tools::assertion_result res(false);
+            res.message() << "dependency test " << dep.p_type_name << " \"" << dep.full_name() << (test_rslt.skipped() ? "\" was skipped":"\" has failed");
+            return res;
+        }
+
+        if( test_rslt.p_test_cases_skipped > 0 ) {
+            test_tools::assertion_result res(false);
+            res.message() << "dependency test " << dep.p_type_name << " \"" << dep.full_name() << "\" has skipped test cases";
+            return res;
+        }
+    }
+
+    if( ::boost::unit_test::for_each::static_any_t _fe_cur_136 = ::boost::unit_test::for_each::begin( p_preconditions.get(), ::boost::unit_test::for_each::is_const_coll( p_preconditions.get() ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_136 = ::boost::unit_test::for_each::end( p_preconditions.get(), ::boost::unit_test::for_each::is_const_coll( p_preconditions.get() ) ) ) {} else for( bool _fe_con_136 = true; _fe_con_136 && !::boost::unit_test::for_each::done( _fe_cur_136, _fe_end_136, p_preconditions.get(), ::boost::unit_test::for_each::is_const_coll( p_preconditions.get() ) ); _fe_con_136 ? ::boost::unit_test::for_each::next( _fe_cur_136, p_preconditions.get(), ::boost::unit_test::for_each::is_const_coll( p_preconditions.get() ) ) : ((void)&(p_preconditions.get()))) if( (_fe_con_136 = false, false) ) {} else for( precondition_t precondition = ::boost::unit_test::for_each::deref( _fe_cur_136, p_preconditions.get(), ::boost::type<precondition_t >(), ::boost::unit_test::for_each::is_const_coll( p_preconditions.get() ) ); !_fe_con_136; _fe_con_136 = true ) {
+        test_tools::assertion_result res = precondition( p_id );
+        if( !res ) {
+            test_tools::assertion_result res_out(false);
+            res_out.message() << "precondition failed";
+            if( !res.has_empty_message() )
+                res_out.message() << ": " << res.message();
+            return res_out;
+        }
+    }
+
+    return true;
+}
+
+
+
+void
+test_unit::increase_exp_fail( counter_t num )
+{
+    p_expected_failures.value += num;
+
+    if( p_parent_id != INV_TEST_UNIT_ID )
+        framework::get<test_suite>( p_parent_id ).increase_exp_fail( num );
+}
+
+
+
+std::string
+test_unit::full_name() const
+{
+    if( p_parent_id == INV_TEST_UNIT_ID || p_parent_id == framework::master_test_suite().p_id )
+        return p_name;
+
+    std::string res = framework::get<test_suite>( p_parent_id ).full_name();
+    res.append("/");
+
+    res.append( p_name );
+
+    return res;
+}
+
+
+
+void
+test_unit::add_label( const_string l )
+{
+    p_labels.value.push_back( std::string() + l );
+}
+
+
+
+bool
+test_unit::has_label( const_string l ) const
+{
+    return std::find( p_labels->begin(), p_labels->end(), l ) != p_labels->end();
+}
+
+
+
+
+
+
+
+test_case::test_case( const_string name, boost::function<void ()> const& test_func )
+: test_unit( name, "", 0, static_cast<test_unit_type>(type) )
+, p_test_func( test_func )
+{
+    framework::register_test_unit( this );
+}
+
+
+
+test_case::test_case( const_string name, const_string file_name, std::size_t line_num, boost::function<void ()> const& test_func )
+: test_unit( name, file_name, line_num, static_cast<test_unit_type>(type) )
+, p_test_func( test_func )
+{
+    framework::register_test_unit( this );
+}
+# 223 "/usr/include/boost/test/impl/test_tree.ipp" 3 4
+test_suite::test_suite( const_string name, const_string file_name, std::size_t line_num )
+: test_unit( ut_detail::normalize_test_case_name( name ), file_name, line_num, static_cast<test_unit_type>(type) )
+{
+    framework::register_test_unit( this );
+}
+
+
+
+test_suite::test_suite( const_string module_name )
+: test_unit( module_name )
+{
+    framework::register_test_unit( this );
+}
+
+
+
+void
+test_suite::add( test_unit* tu, counter_t expected_failures, unsigned timeout )
+{
+    tu->p_timeout.value = timeout;
+
+    m_children.push_back( tu->p_id );
+    tu->p_parent_id.value = p_id;
+
+    if( tu->p_expected_failures != 0 )
+        increase_exp_fail( tu->p_expected_failures );
+
+    if( expected_failures )
+        tu->increase_exp_fail( expected_failures );
+}
+
+
+
+void
+test_suite::add( test_unit_generator const& gen, unsigned timeout )
+{
+    test_unit* tu;
+    while((tu = gen.next()) != 0)
+        add( tu, 0, timeout );
+}
+
+
+
+void
+test_suite::add( test_unit_generator const& gen, decorator::collector_t& decorators )
+{
+    test_unit* tu;
+    while((tu = gen.next()) != 0) {
+        decorators.store_in( *tu );
+        add( tu, 0 );
+    }
+    decorators.reset();
+}
+
+
+
+void
+test_suite::add( boost::shared_ptr<test_unit_generator> gen_ptr, decorator::collector_t& decorators )
+{
+    std::pair<boost::shared_ptr<test_unit_generator>, std::vector<decorator::base_ptr> > tmp_p(gen_ptr, decorators.get_lazy_decorators() );
+    m_generators.push_back(tmp_p);
+    decorators.reset();
+}
+
+
+
+void
+test_suite::generate( )
+{
+    typedef std::pair<boost::shared_ptr<test_unit_generator>, std::vector<decorator::base_ptr> > element_t;
+
+    for(std::vector<element_t>::iterator it(m_generators.begin()), ite(m_generators.end());
+        it < ite;
+        ++it)
+    {
+      test_unit* tu;
+      while((tu = it->first->next()) != 0) {
+          tu->p_decorators.value.insert( tu->p_decorators.value.end(), it->second.begin(), it->second.end() );
+
+          add( tu, 0 );
+      }
+
+    }
+    m_generators.clear();
+# 315 "/usr/include/boost/test/impl/test_tree.ipp" 3 4
+}
+
+
+
+void
+test_suite::check_for_duplicate_test_cases() {
+
+    std::set<std::string> names;
+    for( test_unit_id_list::const_iterator it(m_children.begin()), ite(m_children.end());
+         it < ite;
+         ++it) {
+         std::string name = framework::get(*it, TUT_ANY).p_name;
+         std::pair<std::set<std::string>::iterator, bool> ret = names.insert(name);
+         if( ret.second ) {} else unit_test::ut_detail::throw_exception( unit_test::framework::setup_error( "test unit with name '" + name + std::string("' registered multiple times in the test suite '") + this->p_name.value + "'" ) )
+
+
+
+
+                  ;
+    }
+
+    return;
+}
+
+
+
+void
+test_suite::remove( test_unit_id id )
+{
+    test_unit_id_list::iterator it = std::find( m_children.begin(), m_children.end(), id );
+
+    if( it != m_children.end() )
+        m_children.erase( it );
+}
+
+
+
+test_unit_id
+test_suite::get( const_string tu_name ) const
+{
+    if( ::boost::unit_test::for_each::static_any_t _fe_cur_355 = ::boost::unit_test::for_each::begin( m_children, ::boost::unit_test::for_each::is_const_coll( m_children ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_355 = ::boost::unit_test::for_each::end( m_children, ::boost::unit_test::for_each::is_const_coll( m_children ) ) ) {} else for( bool _fe_con_355 = true; _fe_con_355 && !::boost::unit_test::for_each::done( _fe_cur_355, _fe_end_355, m_children, ::boost::unit_test::for_each::is_const_coll( m_children ) ); _fe_con_355 ? ::boost::unit_test::for_each::next( _fe_cur_355, m_children, ::boost::unit_test::for_each::is_const_coll( m_children ) ) : ((void)&(m_children))) if( (_fe_con_355 = false, false) ) {} else for( test_unit_id id = ::boost::unit_test::for_each::deref( _fe_cur_355, m_children, ::boost::type<test_unit_id >(), ::boost::unit_test::for_each::is_const_coll( m_children ) ); !_fe_con_355; _fe_con_355 = true ) {
+        if( tu_name == framework::get( id, ut_detail::test_id_2_unit_type( id ) ).p_name.get() )
+            return id;
+    }
+
+    return INV_TEST_UNIT_ID;
+}
+
+
+
+
+
+
+
+master_test_suite_t::master_test_suite_t()
+: test_suite( "Master Test Suite" )
+, argc( 0 )
+, argv( 0 )
+{
+    p_default_status.value = RS_ENABLED;
+}
+
+
+
+
+
+void
+traverse_test_tree( test_case const& tc, test_tree_visitor& V, bool ignore_status )
+{
+    if( tc.is_enabled() || ignore_status )
+        V.visit( tc );
+}
+
+
+
+void
+traverse_test_tree( test_suite const& suite, test_tree_visitor& V, bool ignore_status )
+{
+
+    if( !ignore_status && !suite.is_enabled() )
+        return;
+
+
+    if( !V.test_suite_start( suite ) )
+        return;
+
+
+    std::size_t total_children = suite.m_children.size();
+    for( std::size_t i=0; i < total_children; ) {
+
+        traverse_test_tree( suite.m_children[i], V, ignore_status );
+        if( total_children > suite.m_children.size() )
+            total_children = suite.m_children.size();
+        else
+            ++i;
+    }
+
+
+    V.test_suite_finish( suite );
+}
+
+
+
+void
+traverse_test_tree( test_unit_id id, test_tree_visitor& V, bool ignore_status )
+{
+    if( ut_detail::test_id_2_unit_type( id ) == TUT_CASE )
+        traverse_test_tree( framework::get<test_case>( id ), V, ignore_status );
+    else
+        traverse_test_tree( framework::get<test_suite>( id ), V, ignore_status );
+}
+
+
+
+
+
+
+
+namespace ut_detail {
+
+std::string
+normalize_test_case_name( const_string name )
+{
+    std::string norm_name( name.begin(), name.size() );
+
+    if( name[0] == '&' )
+        norm_name = norm_name.substr( 1 );
+
+
+    std::size_t first_not_space = norm_name.find_first_not_of(' ');
+    if( first_not_space ) {
+        norm_name.erase(0, first_not_space);
+    }
+
+    std::size_t last_not_space = norm_name.find_last_not_of(' ');
+    if( last_not_space !=std::string::npos ) {
+        norm_name.erase(last_not_space + 1);
+    }
+
+
+    static const char to_replace[] = { ':', '*', '@', '+', '!', '/', ',' };
+    for(std::size_t index = 0;
+        index < sizeof(to_replace)/sizeof(to_replace[0]);
+        index++) {
+        std::replace(norm_name.begin(), norm_name.end(), to_replace[index], '_');
+    }
+
+    return norm_name;
+}
+
+
+
+
+
+
+
+auto_test_unit_registrar::auto_test_unit_registrar( test_case* tc, decorator::collector_t& decorators, counter_t exp_fail )
+{
+    framework::current_auto_test_suite().add( tc, exp_fail );
+
+    decorators.store_in( *tc );
+    decorators.reset();
+}
+
+
+
+auto_test_unit_registrar::auto_test_unit_registrar( const_string ts_name, const_string ts_file, std::size_t ts_line, decorator::collector_t& decorators )
+{
+    test_unit_id id = framework::current_auto_test_suite().get( ts_name );
+
+    test_suite* ts;
+
+    if( id != INV_TEST_UNIT_ID ) {
+        ts = &framework::get<test_suite>( id );
+        (static_cast <bool> (ts->p_parent_id == framework::current_auto_test_suite().p_id) ? void (0) : __assert_fail ("ts->p_parent_id == framework::current_auto_test_suite().p_id", "/usr/include/boost/test/impl/test_tree.ipp", 489, __extension__ __PRETTY_FUNCTION__));
+    }
+    else {
+        ts = new test_suite( ts_name, ts_file, ts_line );
+        framework::current_auto_test_suite().add( ts );
+    }
+
+    decorators.store_in( *ts );
+    decorators.reset();
+
+    framework::current_auto_test_suite( ts );
+}
+
+
+
+auto_test_unit_registrar::auto_test_unit_registrar( test_unit_generator const& tc_gen, decorator::collector_t& decorators )
+{
+    framework::current_auto_test_suite().add( tc_gen, decorators );
+}
+
+
+
+auto_test_unit_registrar::auto_test_unit_registrar( boost::shared_ptr<test_unit_generator> tc_gen, decorator::collector_t& decorators )
+{
+    framework::current_auto_test_suite().add( tc_gen, decorators );
+}
+
+
+
+
+auto_test_unit_registrar::auto_test_unit_registrar( int )
+{
+    framework::current_auto_test_suite( 0, false );
+}
+
+
+
+}
+
+
+
+
+
+global_fixture::global_fixture(): registered(false)
+{
+    framework::register_global_fixture( *this );
+    registered = true;
+}
+
+void global_fixture::unregister_from_framework() {
+
+
+    if(registered) {
+        framework::deregister_global_fixture( *this );
+    }
+    registered = false;
+}
+
+global_fixture::~global_fixture()
+{
+    this->unregister_from_framework();
+}
+
+
+
+
+
+global_configuration::global_configuration(): registered(false)
+{
+    framework::register_observer( *this );
+    registered = true;
+}
+
+void global_configuration::unregister_from_framework()
+{
+
+
+    if(registered) {
+        framework::deregister_observer( *this );
+    }
+    registered = false;
+}
+
+global_configuration::~global_configuration()
+{
+    this->unregister_from_framework();
+}
+
+
+
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 583 "/usr/include/boost/test/impl/test_tree.ipp" 2 3 4
+# 31 "/usr/include/boost/test/included/unit_test.hpp" 2 3 4
+# 1 "/usr/include/boost/test/impl/unit_test_log.ipp" 1 3 4
+# 16 "/usr/include/boost/test/impl/unit_test_log.ipp" 3 4
+#define BOOST_TEST_UNIT_TEST_LOG_IPP_012205GER 
+# 29 "/usr/include/boost/test/impl/unit_test_log.ipp" 3 4
+# 1 "/usr/include/boost/test/output/xml_log_formatter.hpp" 1 3 4
+# 16 "/usr/include/boost/test/output/xml_log_formatter.hpp" 3 4
+#define BOOST_TEST_XML_LOG_FORMATTER_020105GER 
+# 25 "/usr/include/boost/test/output/xml_log_formatter.hpp" 3 4
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 26 "/usr/include/boost/test/output/xml_log_formatter.hpp" 2 3 4
+
+
+
+namespace boost {
+namespace unit_test {
+namespace output {
+
+
+
+
+
+class xml_log_formatter : public unit_test_log_formatter {
+public:
+
+    void log_start( std::ostream&, counter_t test_cases_amount );
+    void log_finish( std::ostream& );
+    void log_build_info( std::ostream&, bool );
+
+    void test_unit_start( std::ostream&, test_unit const& tu );
+    void test_unit_finish( std::ostream&, test_unit const& tu, unsigned long elapsed );
+    void test_unit_skipped( std::ostream&, test_unit const& tu, const_string reason );
+
+    void log_exception_start( std::ostream&, log_checkpoint_data const&, execution_exception const& ex );
+    void log_exception_finish( std::ostream& );
+
+    void log_entry_start( std::ostream&, log_entry_data const&, log_entry_types let );
+    using unit_test_log_formatter::log_entry_value;
+    void log_entry_value( std::ostream&, const_string value );
+    void log_entry_finish( std::ostream& );
+
+    void entry_context_start( std::ostream&, log_level );
+    void log_entry_context( std::ostream&, log_level, const_string );
+    void entry_context_finish( std::ostream&, log_level );
+
+private:
+
+    const_string m_curr_tag;
+    bool m_value_closed;
+};
+
+}
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 71 "/usr/include/boost/test/output/xml_log_formatter.hpp" 2 3 4
+# 30 "/usr/include/boost/test/impl/unit_test_log.ipp" 2 3 4
+
+
+
+
+
+typedef ::boost::io::ios_base_all_saver io_saver_type;
+
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 38 "/usr/include/boost/test/impl/unit_test_log.ipp" 2 3 4
+
+
+
+namespace boost {
+namespace unit_test {
+
+
+
+
+
+namespace ut_detail {
+
+entry_value_collector const&
+entry_value_collector::operator<<( lazy_ostream const& v ) const
+{
+    unit_test_log << v;
+
+    return *this;
+}
+
+
+
+entry_value_collector const&
+entry_value_collector::operator<<( const_string v ) const
+{
+    unit_test_log << v;
+
+    return *this;
+}
+
+
+
+entry_value_collector::~entry_value_collector()
+{
+    if( m_last )
+        unit_test_log << log::end();
+}
+
+
+
+}
+
+
+
+
+
+namespace {
+
+
+struct unit_test_log_data_helper_impl {
+  typedef boost::shared_ptr<unit_test_log_formatter> formatter_ptr;
+  typedef boost::shared_ptr<io_saver_type> saver_ptr;
+
+  bool m_enabled;
+  output_format m_format;
+  std::ostream* m_stream;
+  saver_ptr m_stream_state_saver;
+  formatter_ptr m_log_formatter;
+  bool m_entry_in_progress;
+
+  unit_test_log_data_helper_impl(unit_test_log_formatter* p_log_formatter, output_format format, bool enabled = false)
+    : m_enabled( enabled )
+    , m_format( format )
+    , m_stream( &std::cout )
+    , m_stream_state_saver( new io_saver_type( std::cout ) )
+    , m_log_formatter()
+    , m_entry_in_progress( false )
+  {
+    m_log_formatter.reset(p_log_formatter);
+    m_log_formatter->set_log_level(log_all_errors);
+  }
+
+
+  std::ostream& stream()
+  {
+      return *m_stream;
+  }
+
+  log_level get_log_level() const
+  {
+      return m_log_formatter->get_log_level();
+  }
+};
+
+struct unit_test_log_impl {
+
+    unit_test_log_impl()
+    {
+      m_log_formatter_data.push_back( unit_test_log_data_helper_impl(new output::compiler_log_formatter, OF_CLF, true) );
+      m_log_formatter_data.push_back( unit_test_log_data_helper_impl(new output::xml_log_formatter, OF_XML, false) );
+      m_log_formatter_data.push_back( unit_test_log_data_helper_impl(new output::junit_log_formatter, OF_JUNIT, false) );
+    }
+
+    typedef std::vector<unit_test_log_data_helper_impl> v_formatter_data_t;
+    v_formatter_data_t m_log_formatter_data;
+
+
+    log_entry_data m_entry_data;
+
+    bool has_entry_in_progress() const {
+        if( ::boost::unit_test::for_each::static_any_t _fe_cur_138 = ::boost::unit_test::for_each::begin( m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( m_log_formatter_data ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_138 = ::boost::unit_test::for_each::end( m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( m_log_formatter_data ) ) ) {} else for( bool _fe_con_138 = true; _fe_con_138 && !::boost::unit_test::for_each::done( _fe_cur_138, _fe_end_138, m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( m_log_formatter_data ) ); _fe_con_138 ? ::boost::unit_test::for_each::next( _fe_cur_138, m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( m_log_formatter_data ) ) : ((void)&(m_log_formatter_data))) if( (_fe_con_138 = false, false) ) {} else for( unit_test_log_data_helper_impl const& current_logger_data = ::boost::unit_test::for_each::deref( _fe_cur_138, m_log_formatter_data, ::boost::type<unit_test_log_data_helper_impl const& >(), ::boost::unit_test::for_each::is_const_coll( m_log_formatter_data ) ); !_fe_con_138; _fe_con_138 = true ) {
+            if( current_logger_data.m_entry_in_progress )
+                return true;
+        }
+        return false;
+    }
+
+
+    log_checkpoint_data m_checkpoint_data;
+
+    void set_checkpoint( const_string file, std::size_t line_num, const_string msg )
+    {
+        assign_op( m_checkpoint_data.m_message, msg, 0 );
+        m_checkpoint_data.m_file_name = file;
+        m_checkpoint_data.m_line_num = line_num;
+    }
+};
+
+unit_test_log_impl& s_log_impl() { static unit_test_log_impl the_inst; return the_inst; }
+
+}
+
+
+
+unit_test_log_t& unit_test_log_t::instance() { static unit_test_log_t the_inst; return the_inst; }
+
+
+
+void
+unit_test_log_t::test_start( counter_t test_cases_amount )
+{
+    if( ::boost::unit_test::for_each::static_any_t _fe_cur_169 = ::boost::unit_test::for_each::begin( s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_169 = ::boost::unit_test::for_each::end( s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) ) {} else for( bool _fe_con_169 = true; _fe_con_169 && !::boost::unit_test::for_each::done( _fe_cur_169, _fe_end_169, s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ); _fe_con_169 ? ::boost::unit_test::for_each::next( _fe_cur_169, s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) : ((void)&(s_log_impl().m_log_formatter_data))) if( (_fe_con_169 = false, false) ) {} else for( unit_test_log_data_helper_impl& current_logger_data = ::boost::unit_test::for_each::deref( _fe_cur_169, s_log_impl().m_log_formatter_data, ::boost::type<unit_test_log_data_helper_impl& >(), ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ); !_fe_con_169; _fe_con_169 = true ) {
+      if( !current_logger_data.m_enabled || current_logger_data.get_log_level() == log_nothing )
+          continue;
+
+      current_logger_data.m_log_formatter->log_start( current_logger_data.stream(), test_cases_amount );
+
+      current_logger_data.m_log_formatter->log_build_info(
+          current_logger_data.stream(),
+          runtime_config::get<bool>( runtime_config::btrt_build_info ));
+
+
+
+      current_logger_data.m_entry_in_progress = false;
+    }
+}
+
+
+
+void
+unit_test_log_t::test_finish()
+{
+    if( ::boost::unit_test::for_each::static_any_t _fe_cur_190 = ::boost::unit_test::for_each::begin( s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_190 = ::boost::unit_test::for_each::end( s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) ) {} else for( bool _fe_con_190 = true; _fe_con_190 && !::boost::unit_test::for_each::done( _fe_cur_190, _fe_end_190, s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ); _fe_con_190 ? ::boost::unit_test::for_each::next( _fe_cur_190, s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) : ((void)&(s_log_impl().m_log_formatter_data))) if( (_fe_con_190 = false, false) ) {} else for( unit_test_log_data_helper_impl& current_logger_data = ::boost::unit_test::for_each::deref( _fe_cur_190, s_log_impl().m_log_formatter_data, ::boost::type<unit_test_log_data_helper_impl& >(), ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ); !_fe_con_190; _fe_con_190 = true ) {
+      if( !current_logger_data.m_enabled || current_logger_data.get_log_level() == log_nothing )
+          continue;
+
+      current_logger_data.m_log_formatter->log_finish( current_logger_data.stream() );
+
+      current_logger_data.stream().flush();
+    }
+}
+
+
+
+void
+unit_test_log_t::test_aborted()
+{
+    (::boost::unit_test::unit_test_log << ::boost::unit_test::log::begin( ::boost::unit_test::const_string( "/usr/include/boost/test/impl/unit_test_log.ipp", sizeof( "/usr/include/boost/test/impl/unit_test_log.ipp" ) - 1 ), 205 ))(log_messages) << "Test is aborted";
+}
+
+
+
+void
+unit_test_log_t::test_unit_start( test_unit const& tu )
+{
+    if( s_log_impl().has_entry_in_progress() )
+        *this << log::end();
+    if( ::boost::unit_test::for_each::static_any_t _fe_cur_215 = ::boost::unit_test::for_each::begin( s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_215 = ::boost::unit_test::for_each::end( s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) ) {} else for( bool _fe_con_215 = true; _fe_con_215 && !::boost::unit_test::for_each::done( _fe_cur_215, _fe_end_215, s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ); _fe_con_215 ? ::boost::unit_test::for_each::next( _fe_cur_215, s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) : ((void)&(s_log_impl().m_log_formatter_data))) if( (_fe_con_215 = false, false) ) {} else for( unit_test_log_data_helper_impl& current_logger_data = ::boost::unit_test::for_each::deref( _fe_cur_215, s_log_impl().m_log_formatter_data, ::boost::type<unit_test_log_data_helper_impl& >(), ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ); !_fe_con_215; _fe_con_215 = true ) {
+        if( !current_logger_data.m_enabled || current_logger_data.get_log_level() > log_test_units )
+            continue;
+        current_logger_data.m_log_formatter->test_unit_start( current_logger_data.stream(), tu );
+    }
+}
+
+
+
+void
+unit_test_log_t::test_unit_finish( test_unit const& tu, unsigned long elapsed )
+{
+    s_log_impl().m_checkpoint_data.clear();
+
+    if( s_log_impl().has_entry_in_progress() )
+        *this << log::end();
+
+    if( ::boost::unit_test::for_each::static_any_t _fe_cur_232 = ::boost::unit_test::for_each::begin( s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_232 = ::boost::unit_test::for_each::end( s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) ) {} else for( bool _fe_con_232 = true; _fe_con_232 && !::boost::unit_test::for_each::done( _fe_cur_232, _fe_end_232, s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ); _fe_con_232 ? ::boost::unit_test::for_each::next( _fe_cur_232, s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) : ((void)&(s_log_impl().m_log_formatter_data))) if( (_fe_con_232 = false, false) ) {} else for( unit_test_log_data_helper_impl& current_logger_data = ::boost::unit_test::for_each::deref( _fe_cur_232, s_log_impl().m_log_formatter_data, ::boost::type<unit_test_log_data_helper_impl& >(), ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ); !_fe_con_232; _fe_con_232 = true ) {
+
+        if( !current_logger_data.m_enabled || current_logger_data.get_log_level() > log_test_units )
+            continue;
+
+        current_logger_data.m_log_formatter->test_unit_finish( current_logger_data.stream(), tu, elapsed );
+    }
+}
+
+
+
+void
+unit_test_log_t::test_unit_skipped( test_unit const& tu, const_string reason )
+{
+    if( s_log_impl().has_entry_in_progress() )
+        *this << log::end();
+
+    if( ::boost::unit_test::for_each::static_any_t _fe_cur_249 = ::boost::unit_test::for_each::begin( s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_249 = ::boost::unit_test::for_each::end( s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) ) {} else for( bool _fe_con_249 = true; _fe_con_249 && !::boost::unit_test::for_each::done( _fe_cur_249, _fe_end_249, s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ); _fe_con_249 ? ::boost::unit_test::for_each::next( _fe_cur_249, s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) : ((void)&(s_log_impl().m_log_formatter_data))) if( (_fe_con_249 = false, false) ) {} else for( unit_test_log_data_helper_impl& current_logger_data = ::boost::unit_test::for_each::deref( _fe_cur_249, s_log_impl().m_log_formatter_data, ::boost::type<unit_test_log_data_helper_impl& >(), ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ); !_fe_con_249; _fe_con_249 = true ) {
+        if( !current_logger_data.m_enabled || current_logger_data.get_log_level() > log_test_units )
+            continue;
+
+        current_logger_data.m_log_formatter->test_unit_skipped( current_logger_data.stream(), tu, reason );
+    }
+}
+
+void
+unit_test_log_t::test_unit_aborted( test_unit const& tu )
+{
+    if( s_log_impl().has_entry_in_progress() )
+        *this << log::end();
+
+    if( ::boost::unit_test::for_each::static_any_t _fe_cur_263 = ::boost::unit_test::for_each::begin( s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_263 = ::boost::unit_test::for_each::end( s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) ) {} else for( bool _fe_con_263 = true; _fe_con_263 && !::boost::unit_test::for_each::done( _fe_cur_263, _fe_end_263, s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ); _fe_con_263 ? ::boost::unit_test::for_each::next( _fe_cur_263, s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) : ((void)&(s_log_impl().m_log_formatter_data))) if( (_fe_con_263 = false, false) ) {} else for( unit_test_log_data_helper_impl& current_logger_data = ::boost::unit_test::for_each::deref( _fe_cur_263, s_log_impl().m_log_formatter_data, ::boost::type<unit_test_log_data_helper_impl& >(), ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ); !_fe_con_263; _fe_con_263 = true ) {
+        if( !current_logger_data.m_enabled || current_logger_data.get_log_level() > log_test_units )
+            continue;
+
+        current_logger_data.m_log_formatter->test_unit_aborted(current_logger_data.stream(), tu );
+    }
+}
+
+void
+unit_test_log_t::test_unit_timed_out( test_unit const& tu )
+{
+    if( s_log_impl().has_entry_in_progress() )
+        *this << log::end();
+
+    if( ::boost::unit_test::for_each::static_any_t _fe_cur_277 = ::boost::unit_test::for_each::begin( s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_277 = ::boost::unit_test::for_each::end( s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) ) {} else for( bool _fe_con_277 = true; _fe_con_277 && !::boost::unit_test::for_each::done( _fe_cur_277, _fe_end_277, s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ); _fe_con_277 ? ::boost::unit_test::for_each::next( _fe_cur_277, s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) : ((void)&(s_log_impl().m_log_formatter_data))) if( (_fe_con_277 = false, false) ) {} else for( unit_test_log_data_helper_impl& current_logger_data = ::boost::unit_test::for_each::deref( _fe_cur_277, s_log_impl().m_log_formatter_data, ::boost::type<unit_test_log_data_helper_impl& >(), ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ); !_fe_con_277; _fe_con_277 = true ) {
+        if( !current_logger_data.m_enabled || current_logger_data.get_log_level() > log_test_units )
+            continue;
+
+        current_logger_data.m_log_formatter->test_unit_timed_out(current_logger_data.stream(), tu );
+    }
+}
+
+
+
+void
+unit_test_log_t::exception_caught( execution_exception const& ex )
+{
+    log_level l =
+        ex.code() <= execution_exception::cpp_exception_error ? log_cpp_exception_errors :
+        (ex.code() <= execution_exception::timeout_error ? log_system_errors
+                                                                : log_fatal_errors );
+
+    if( s_log_impl().has_entry_in_progress() )
+        *this << log::end();
+
+    if( ::boost::unit_test::for_each::static_any_t _fe_cur_298 = ::boost::unit_test::for_each::begin( s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_298 = ::boost::unit_test::for_each::end( s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) ) {} else for( bool _fe_con_298 = true; _fe_con_298 && !::boost::unit_test::for_each::done( _fe_cur_298, _fe_end_298, s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ); _fe_con_298 ? ::boost::unit_test::for_each::next( _fe_cur_298, s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) : ((void)&(s_log_impl().m_log_formatter_data))) if( (_fe_con_298 = false, false) ) {} else for( unit_test_log_data_helper_impl& current_logger_data = ::boost::unit_test::for_each::deref( _fe_cur_298, s_log_impl().m_log_formatter_data, ::boost::type<unit_test_log_data_helper_impl& >(), ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ); !_fe_con_298; _fe_con_298 = true ) {
+
+      if( current_logger_data.m_enabled && l >= current_logger_data.get_log_level() ) {
+
+          current_logger_data.m_log_formatter->log_exception_start( current_logger_data.stream(), s_log_impl().m_checkpoint_data, ex );
+
+          log_entry_context( l );
+
+          current_logger_data.m_log_formatter->log_exception_finish( current_logger_data.stream() );
+      }
+    }
+    clear_entry_context();
+}
+
+
+
+void
+unit_test_log_t::set_checkpoint( const_string file, std::size_t line_num, const_string msg )
+{
+    s_log_impl().set_checkpoint( file, line_num, msg );
+}
+
+
+
+char
+set_unix_slash( char in )
+{
+    return in == '\\' ? '/' : in;
+}
+
+unit_test_log_t&
+unit_test_log_t::operator<<( log::begin const& b )
+{
+    if( s_log_impl().has_entry_in_progress() )
+        *this << log::end();
+
+    if( ::boost::unit_test::for_each::static_any_t _fe_cur_334 = ::boost::unit_test::for_each::begin( s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_334 = ::boost::unit_test::for_each::end( s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) ) {} else for( bool _fe_con_334 = true; _fe_con_334 && !::boost::unit_test::for_each::done( _fe_cur_334, _fe_end_334, s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ); _fe_con_334 ? ::boost::unit_test::for_each::next( _fe_cur_334, s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) : ((void)&(s_log_impl().m_log_formatter_data))) if( (_fe_con_334 = false, false) ) {} else for( unit_test_log_data_helper_impl& current_logger_data = ::boost::unit_test::for_each::deref( _fe_cur_334, s_log_impl().m_log_formatter_data, ::boost::type<unit_test_log_data_helper_impl& >(), ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ); !_fe_con_334; _fe_con_334 = true ) {
+        if( current_logger_data.m_enabled ) {
+            current_logger_data.m_stream_state_saver->restore();
+        }
+    }
+
+    s_log_impl().m_entry_data.clear();
+
+    assign_op( s_log_impl().m_entry_data.m_file_name, b.m_file_name, 0 );
+
+
+    std::transform( s_log_impl().m_entry_data.m_file_name.begin(), s_log_impl().m_entry_data.m_file_name.end(),
+                    s_log_impl().m_entry_data.m_file_name.begin(),
+                    &set_unix_slash );
+
+    s_log_impl().m_entry_data.m_line_num = b.m_line_num;
+
+    return *this;
+}
+
+
+
+unit_test_log_t&
+unit_test_log_t::operator<<( log::end const& )
+{
+    if( s_log_impl().has_entry_in_progress() ) {
+        log_entry_context( s_log_impl().m_entry_data.m_level );
+
+        if( ::boost::unit_test::for_each::static_any_t _fe_cur_362 = ::boost::unit_test::for_each::begin( s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_362 = ::boost::unit_test::for_each::end( s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) ) {} else for( bool _fe_con_362 = true; _fe_con_362 && !::boost::unit_test::for_each::done( _fe_cur_362, _fe_end_362, s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ); _fe_con_362 ? ::boost::unit_test::for_each::next( _fe_cur_362, s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) : ((void)&(s_log_impl().m_log_formatter_data))) if( (_fe_con_362 = false, false) ) {} else for( unit_test_log_data_helper_impl& current_logger_data = ::boost::unit_test::for_each::deref( _fe_cur_362, s_log_impl().m_log_formatter_data, ::boost::type<unit_test_log_data_helper_impl& >(), ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ); !_fe_con_362; _fe_con_362 = true ) {
+            if( current_logger_data.m_enabled && current_logger_data.m_entry_in_progress ) {
+                current_logger_data.m_log_formatter->log_entry_finish( current_logger_data.stream() );
+            }
+            current_logger_data.m_entry_in_progress = false;
+        }
+    }
+
+    clear_entry_context();
+
+    return *this;
+}
+
+
+
+unit_test_log_t&
+unit_test_log_t::operator<<( log_level l )
+{
+    s_log_impl().m_entry_data.m_level = l;
+
+    return *this;
+}
+
+
+
+ut_detail::entry_value_collector
+unit_test_log_t::operator()( log_level l )
+{
+    *this << l;
+
+    return ut_detail::entry_value_collector();
+}
+
+
+
+bool
+unit_test_log_t::log_entry_start(output_format log_format)
+{
+    if( ::boost::unit_test::for_each::static_any_t _fe_cur_400 = ::boost::unit_test::for_each::begin( s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_400 = ::boost::unit_test::for_each::end( s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) ) {} else for( bool _fe_con_400 = true; _fe_con_400 && !::boost::unit_test::for_each::done( _fe_cur_400, _fe_end_400, s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ); _fe_con_400 ? ::boost::unit_test::for_each::next( _fe_cur_400, s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) : ((void)&(s_log_impl().m_log_formatter_data))) if( (_fe_con_400 = false, false) ) {} else for( unit_test_log_data_helper_impl& current_logger_data = ::boost::unit_test::for_each::deref( _fe_cur_400, s_log_impl().m_log_formatter_data, ::boost::type<unit_test_log_data_helper_impl& >(), ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ); !_fe_con_400; _fe_con_400 = true ) {
+
+        if( current_logger_data.m_format != log_format )
+            continue;
+
+        if( current_logger_data.m_entry_in_progress )
+            return true;
+
+        if( !current_logger_data.m_enabled )
+            return false;
+
+        switch( s_log_impl().m_entry_data.m_level ) {
+        case log_successful_tests:
+            current_logger_data.m_log_formatter->log_entry_start( current_logger_data.stream(), s_log_impl().m_entry_data,
+                                                  unit_test_log_formatter::BOOST_UTL_ET_INFO );
+            break;
+        case log_messages:
+            current_logger_data.m_log_formatter->log_entry_start( current_logger_data.stream(), s_log_impl().m_entry_data,
+                                                  unit_test_log_formatter::BOOST_UTL_ET_MESSAGE );
+            break;
+        case log_warnings:
+            current_logger_data.m_log_formatter->log_entry_start( current_logger_data.stream(), s_log_impl().m_entry_data,
+                                                  unit_test_log_formatter::BOOST_UTL_ET_WARNING );
+            break;
+        case log_all_errors:
+        case log_cpp_exception_errors:
+        case log_system_errors:
+            current_logger_data.m_log_formatter->log_entry_start( current_logger_data.stream(), s_log_impl().m_entry_data,
+                                                  unit_test_log_formatter::BOOST_UTL_ET_ERROR );
+            break;
+        case log_fatal_errors:
+            current_logger_data.m_log_formatter->log_entry_start( current_logger_data.stream(), s_log_impl().m_entry_data,
+                                                  unit_test_log_formatter::BOOST_UTL_ET_FATAL_ERROR );
+            break;
+        case log_nothing:
+        case log_test_units:
+        case invalid_log_level:
+            return false;
+        }
+
+        current_logger_data.m_entry_in_progress = true;
+        return true;
+    }
+
+    return false;
+}
+
+
+
+unit_test_log_t&
+unit_test_log_t::operator<<( const_string value )
+{
+    if( ::boost::unit_test::for_each::static_any_t _fe_cur_452 = ::boost::unit_test::for_each::begin( s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_452 = ::boost::unit_test::for_each::end( s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) ) {} else for( bool _fe_con_452 = true; _fe_con_452 && !::boost::unit_test::for_each::done( _fe_cur_452, _fe_end_452, s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ); _fe_con_452 ? ::boost::unit_test::for_each::next( _fe_cur_452, s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) : ((void)&(s_log_impl().m_log_formatter_data))) if( (_fe_con_452 = false, false) ) {} else for( unit_test_log_data_helper_impl& current_logger_data = ::boost::unit_test::for_each::deref( _fe_cur_452, s_log_impl().m_log_formatter_data, ::boost::type<unit_test_log_data_helper_impl& >(), ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ); !_fe_con_452; _fe_con_452 = true ) {
+        if( current_logger_data.m_enabled && s_log_impl().m_entry_data.m_level >= current_logger_data.get_log_level() && !value.empty() && log_entry_start(current_logger_data.m_format) )
+            current_logger_data.m_log_formatter->log_entry_value( current_logger_data.stream(), value );
+
+    }
+    return *this;
+}
+
+
+
+unit_test_log_t&
+unit_test_log_t::operator<<( lazy_ostream const& value )
+{
+    if( ::boost::unit_test::for_each::static_any_t _fe_cur_465 = ::boost::unit_test::for_each::begin( s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_465 = ::boost::unit_test::for_each::end( s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) ) {} else for( bool _fe_con_465 = true; _fe_con_465 && !::boost::unit_test::for_each::done( _fe_cur_465, _fe_end_465, s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ); _fe_con_465 ? ::boost::unit_test::for_each::next( _fe_cur_465, s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) : ((void)&(s_log_impl().m_log_formatter_data))) if( (_fe_con_465 = false, false) ) {} else for( unit_test_log_data_helper_impl& current_logger_data = ::boost::unit_test::for_each::deref( _fe_cur_465, s_log_impl().m_log_formatter_data, ::boost::type<unit_test_log_data_helper_impl& >(), ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ); !_fe_con_465; _fe_con_465 = true ) {
+        if( current_logger_data.m_enabled && s_log_impl().m_entry_data.m_level >= current_logger_data.get_log_level() && !value.empty() ) {
+            if( log_entry_start(current_logger_data.m_format) ) {
+                current_logger_data.m_log_formatter->log_entry_value( current_logger_data.stream(), value );
+            }
+        }
+    }
+    return *this;
+}
+
+
+
+void
+unit_test_log_t::log_entry_context( log_level l )
+{
+    framework::context_generator const& context = framework::get_context();
+    if( context.is_empty() )
+        return;
+
+    const_string frame;
+
+    if( ::boost::unit_test::for_each::static_any_t _fe_cur_486 = ::boost::unit_test::for_each::begin( s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_486 = ::boost::unit_test::for_each::end( s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) ) {} else for( bool _fe_con_486 = true; _fe_con_486 && !::boost::unit_test::for_each::done( _fe_cur_486, _fe_end_486, s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ); _fe_con_486 ? ::boost::unit_test::for_each::next( _fe_cur_486, s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) : ((void)&(s_log_impl().m_log_formatter_data))) if( (_fe_con_486 = false, false) ) {} else for( unit_test_log_data_helper_impl& current_logger_data = ::boost::unit_test::for_each::deref( _fe_cur_486, s_log_impl().m_log_formatter_data, ::boost::type<unit_test_log_data_helper_impl& >(), ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ); !_fe_con_486; _fe_con_486 = true ) {
+        if( current_logger_data.m_enabled ) {
+            current_logger_data.m_log_formatter->entry_context_start( current_logger_data.stream(), l );
+        }
+    }
+
+    while( !(frame=context.next()).is_empty() )
+    {
+        if( ::boost::unit_test::for_each::static_any_t _fe_cur_494 = ::boost::unit_test::for_each::begin( s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_494 = ::boost::unit_test::for_each::end( s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) ) {} else for( bool _fe_con_494 = true; _fe_con_494 && !::boost::unit_test::for_each::done( _fe_cur_494, _fe_end_494, s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ); _fe_con_494 ? ::boost::unit_test::for_each::next( _fe_cur_494, s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) : ((void)&(s_log_impl().m_log_formatter_data))) if( (_fe_con_494 = false, false) ) {} else for( unit_test_log_data_helper_impl& current_logger_data = ::boost::unit_test::for_each::deref( _fe_cur_494, s_log_impl().m_log_formatter_data, ::boost::type<unit_test_log_data_helper_impl& >(), ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ); !_fe_con_494; _fe_con_494 = true ) {
+            if( current_logger_data.m_enabled ) {
+                current_logger_data.m_log_formatter->log_entry_context( current_logger_data.stream(), l, frame );
+            }
+        }
+    }
+
+    if( ::boost::unit_test::for_each::static_any_t _fe_cur_501 = ::boost::unit_test::for_each::begin( s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_501 = ::boost::unit_test::for_each::end( s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) ) {} else for( bool _fe_con_501 = true; _fe_con_501 && !::boost::unit_test::for_each::done( _fe_cur_501, _fe_end_501, s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ); _fe_con_501 ? ::boost::unit_test::for_each::next( _fe_cur_501, s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) : ((void)&(s_log_impl().m_log_formatter_data))) if( (_fe_con_501 = false, false) ) {} else for( unit_test_log_data_helper_impl& current_logger_data = ::boost::unit_test::for_each::deref( _fe_cur_501, s_log_impl().m_log_formatter_data, ::boost::type<unit_test_log_data_helper_impl& >(), ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ); !_fe_con_501; _fe_con_501 = true ) {
+        if( current_logger_data.m_enabled ) {
+            current_logger_data.m_log_formatter->entry_context_finish( current_logger_data.stream(), l );
+        }
+    }
+}
+
+
+
+void
+unit_test_log_t::clear_entry_context()
+{
+    framework::clear_context();
+}
+
+
+
+void
+unit_test_log_t::set_stream( std::ostream& str )
+{
+    if( s_log_impl().has_entry_in_progress() )
+        return;
+
+    if( ::boost::unit_test::for_each::static_any_t _fe_cur_524 = ::boost::unit_test::for_each::begin( s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_524 = ::boost::unit_test::for_each::end( s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) ) {} else for( bool _fe_con_524 = true; _fe_con_524 && !::boost::unit_test::for_each::done( _fe_cur_524, _fe_end_524, s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ); _fe_con_524 ? ::boost::unit_test::for_each::next( _fe_cur_524, s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) : ((void)&(s_log_impl().m_log_formatter_data))) if( (_fe_con_524 = false, false) ) {} else for( unit_test_log_data_helper_impl& current_logger_data = ::boost::unit_test::for_each::deref( _fe_cur_524, s_log_impl().m_log_formatter_data, ::boost::type<unit_test_log_data_helper_impl& >(), ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ); !_fe_con_524; _fe_con_524 = true ) {
+        current_logger_data.m_stream = &str;
+        current_logger_data.m_stream_state_saver.reset( new io_saver_type( str ) );
+    }
+}
+
+
+
+void
+unit_test_log_t::set_stream( output_format log_format, std::ostream& str )
+{
+    if( s_log_impl().has_entry_in_progress() )
+        return;
+
+    if( ::boost::unit_test::for_each::static_any_t _fe_cur_538 = ::boost::unit_test::for_each::begin( s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_538 = ::boost::unit_test::for_each::end( s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) ) {} else for( bool _fe_con_538 = true; _fe_con_538 && !::boost::unit_test::for_each::done( _fe_cur_538, _fe_end_538, s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ); _fe_con_538 ? ::boost::unit_test::for_each::next( _fe_cur_538, s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) : ((void)&(s_log_impl().m_log_formatter_data))) if( (_fe_con_538 = false, false) ) {} else for( unit_test_log_data_helper_impl& current_logger_data = ::boost::unit_test::for_each::deref( _fe_cur_538, s_log_impl().m_log_formatter_data, ::boost::type<unit_test_log_data_helper_impl& >(), ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ); !_fe_con_538; _fe_con_538 = true ) {
+        if( current_logger_data.m_format == log_format) {
+            current_logger_data.m_stream = &str;
+            current_logger_data.m_stream_state_saver.reset( new io_saver_type( str ) );
+            break;
+        }
+    }
+}
+
+std::ostream*
+unit_test_log_t::get_stream( output_format log_format ) const
+{
+    if( ::boost::unit_test::for_each::static_any_t _fe_cur_550 = ::boost::unit_test::for_each::begin( s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_550 = ::boost::unit_test::for_each::end( s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) ) {} else for( bool _fe_con_550 = true; _fe_con_550 && !::boost::unit_test::for_each::done( _fe_cur_550, _fe_end_550, s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ); _fe_con_550 ? ::boost::unit_test::for_each::next( _fe_cur_550, s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) : ((void)&(s_log_impl().m_log_formatter_data))) if( (_fe_con_550 = false, false) ) {} else for( unit_test_log_data_helper_impl& current_logger_data = ::boost::unit_test::for_each::deref( _fe_cur_550, s_log_impl().m_log_formatter_data, ::boost::type<unit_test_log_data_helper_impl& >(), ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ); !_fe_con_550; _fe_con_550 = true ) {
+        if( current_logger_data.m_format == log_format) {
+            return current_logger_data.m_stream;
+        }
+    }
+    return 0;
+}
+
+
+
+void
+unit_test_log_t::set_threshold_level( log_level lev )
+{
+    if( s_log_impl().has_entry_in_progress() || lev == invalid_log_level )
+        return;
+
+    if( ::boost::unit_test::for_each::static_any_t _fe_cur_566 = ::boost::unit_test::for_each::begin( s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_566 = ::boost::unit_test::for_each::end( s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) ) {} else for( bool _fe_con_566 = true; _fe_con_566 && !::boost::unit_test::for_each::done( _fe_cur_566, _fe_end_566, s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ); _fe_con_566 ? ::boost::unit_test::for_each::next( _fe_cur_566, s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) : ((void)&(s_log_impl().m_log_formatter_data))) if( (_fe_con_566 = false, false) ) {} else for( unit_test_log_data_helper_impl& current_logger_data = ::boost::unit_test::for_each::deref( _fe_cur_566, s_log_impl().m_log_formatter_data, ::boost::type<unit_test_log_data_helper_impl& >(), ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ); !_fe_con_566; _fe_con_566 = true ) {
+        current_logger_data.m_log_formatter->set_log_level( lev );
+    }
+}
+
+
+
+void
+unit_test_log_t::set_threshold_level( output_format log_format, log_level lev )
+{
+    if( s_log_impl().has_entry_in_progress() || lev == invalid_log_level )
+        return;
+
+    if( ::boost::unit_test::for_each::static_any_t _fe_cur_579 = ::boost::unit_test::for_each::begin( s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_579 = ::boost::unit_test::for_each::end( s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) ) {} else for( bool _fe_con_579 = true; _fe_con_579 && !::boost::unit_test::for_each::done( _fe_cur_579, _fe_end_579, s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ); _fe_con_579 ? ::boost::unit_test::for_each::next( _fe_cur_579, s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) : ((void)&(s_log_impl().m_log_formatter_data))) if( (_fe_con_579 = false, false) ) {} else for( unit_test_log_data_helper_impl& current_logger_data = ::boost::unit_test::for_each::deref( _fe_cur_579, s_log_impl().m_log_formatter_data, ::boost::type<unit_test_log_data_helper_impl& >(), ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ); !_fe_con_579; _fe_con_579 = true ) {
+        if( current_logger_data.m_format == log_format) {
+            current_logger_data.m_log_formatter->set_log_level( lev );
+            break;
+        }
+    }
+}
+
+
+
+void
+unit_test_log_t::set_format( output_format log_format )
+{
+    if( s_log_impl().has_entry_in_progress() )
+        return;
+
+    if( ::boost::unit_test::for_each::static_any_t _fe_cur_595 = ::boost::unit_test::for_each::begin( s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_595 = ::boost::unit_test::for_each::end( s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) ) {} else for( bool _fe_con_595 = true; _fe_con_595 && !::boost::unit_test::for_each::done( _fe_cur_595, _fe_end_595, s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ); _fe_con_595 ? ::boost::unit_test::for_each::next( _fe_cur_595, s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) : ((void)&(s_log_impl().m_log_formatter_data))) if( (_fe_con_595 = false, false) ) {} else for( unit_test_log_data_helper_impl& current_logger_data = ::boost::unit_test::for_each::deref( _fe_cur_595, s_log_impl().m_log_formatter_data, ::boost::type<unit_test_log_data_helper_impl& >(), ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ); !_fe_con_595; _fe_con_595 = true ) {
+        current_logger_data.m_enabled = current_logger_data.m_format == log_format;
+    }
+}
+
+
+
+void
+unit_test_log_t::add_format( output_format log_format )
+{
+    if( s_log_impl().has_entry_in_progress() )
+        return;
+
+    if( ::boost::unit_test::for_each::static_any_t _fe_cur_608 = ::boost::unit_test::for_each::begin( s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_608 = ::boost::unit_test::for_each::end( s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) ) {} else for( bool _fe_con_608 = true; _fe_con_608 && !::boost::unit_test::for_each::done( _fe_cur_608, _fe_end_608, s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ); _fe_con_608 ? ::boost::unit_test::for_each::next( _fe_cur_608, s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) : ((void)&(s_log_impl().m_log_formatter_data))) if( (_fe_con_608 = false, false) ) {} else for( unit_test_log_data_helper_impl& current_logger_data = ::boost::unit_test::for_each::deref( _fe_cur_608, s_log_impl().m_log_formatter_data, ::boost::type<unit_test_log_data_helper_impl& >(), ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ); !_fe_con_608; _fe_con_608 = true ) {
+        if( current_logger_data.m_format == log_format) {
+            current_logger_data.m_enabled = true;
+            break;
+        }
+    }
+}
+
+
+
+unit_test_log_formatter*
+unit_test_log_t::get_formatter( output_format log_format ) {
+    if( ::boost::unit_test::for_each::static_any_t _fe_cur_620 = ::boost::unit_test::for_each::begin( s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_620 = ::boost::unit_test::for_each::end( s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) ) {} else for( bool _fe_con_620 = true; _fe_con_620 && !::boost::unit_test::for_each::done( _fe_cur_620, _fe_end_620, s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ); _fe_con_620 ? ::boost::unit_test::for_each::next( _fe_cur_620, s_log_impl().m_log_formatter_data, ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ) : ((void)&(s_log_impl().m_log_formatter_data))) if( (_fe_con_620 = false, false) ) {} else for( unit_test_log_data_helper_impl& current_logger_data = ::boost::unit_test::for_each::deref( _fe_cur_620, s_log_impl().m_log_formatter_data, ::boost::type<unit_test_log_data_helper_impl& >(), ::boost::unit_test::for_each::is_const_coll( s_log_impl().m_log_formatter_data ) ); !_fe_con_620; _fe_con_620 = true ) {
+        if( current_logger_data.m_format == log_format) {
+            return current_logger_data.m_log_formatter.get();
+        }
+    }
+    return 0;
+}
+
+
+void
+unit_test_log_t::add_formatter( unit_test_log_formatter* the_formatter )
+{
+
+    for(unit_test_log_impl::v_formatter_data_t::iterator it(s_log_impl().m_log_formatter_data.begin()),
+            ite(s_log_impl().m_log_formatter_data.end());
+        it != ite;
+        ++it)
+    {
+        if( it->m_format == OF_CUSTOM_LOGGER) {
+            s_log_impl().m_log_formatter_data.erase(it);
+            break;
+        }
+    }
+
+    if( the_formatter ) {
+        s_log_impl().m_log_formatter_data.push_back( unit_test_log_data_helper_impl(the_formatter, OF_CUSTOM_LOGGER, true) );
+    }
+}
+
+void
+unit_test_log_t::set_formatter( unit_test_log_formatter* the_formatter )
+{
+
+    log_level current_level = invalid_log_level;
+    std::ostream *current_stream = 0;
+    output_format previous_format = OF_INVALID;
+    for(unit_test_log_impl::v_formatter_data_t::iterator it(s_log_impl().m_log_formatter_data.begin()),
+            ite(s_log_impl().m_log_formatter_data.end());
+        it != ite;
+        ++it)
+    {
+        if( it->m_enabled ) {
+            if( current_level == invalid_log_level || it->m_format < previous_format || it->m_format == OF_CUSTOM_LOGGER) {
+                current_level = it->get_log_level();
+                current_stream = &(it->stream());
+                previous_format = it->m_format;
+            }
+        }
+    }
+
+    if( the_formatter ) {
+        add_formatter(the_formatter);
+        set_format(OF_CUSTOM_LOGGER);
+        set_threshold_level(OF_CUSTOM_LOGGER, current_level);
+        set_stream(OF_CUSTOM_LOGGER, *current_stream);
+    }
+}
+
+
+
+
+
+
+
+void
+unit_test_log_formatter::log_entry_value( std::ostream& ostr, lazy_ostream const& value )
+{
+    log_entry_value( ostr, (wrap_stringstream().ref() << value).str() );
+}
+
+void
+unit_test_log_formatter::set_log_level(log_level new_log_level)
+{
+    m_log_level = new_log_level;
+}
+
+log_level
+unit_test_log_formatter::get_log_level() const
+{
+    return m_log_level;
+}
+
+
+
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 708 "/usr/include/boost/test/impl/unit_test_log.ipp" 2 3 4
+# 32 "/usr/include/boost/test/included/unit_test.hpp" 2 3 4
+# 1 "/usr/include/boost/test/impl/unit_test_main.ipp" 1 3 4
+# 16 "/usr/include/boost/test/impl/unit_test_main.ipp" 3 4
+#define BOOST_TEST_UNIT_TEST_MAIN_IPP_012205GER 
+# 36 "/usr/include/boost/test/impl/unit_test_main.ipp" 3 4
+# 1 "/usr/include/c++/10.2.0/cstdio" 1 3 4
+# 39 "/usr/include/c++/10.2.0/cstdio" 3 4
+       
+# 40 "/usr/include/c++/10.2.0/cstdio" 3
+# 37 "/usr/include/boost/test/impl/unit_test_main.ipp" 2 3 4
+
+
+
+
+
+
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 44 "/usr/include/boost/test/impl/unit_test_main.ipp" 2 3 4
+
+
+
+namespace boost {
+namespace unit_test {
+
+namespace ut_detail {
+
+
+
+
+
+struct hrf_content_reporter : test_tree_visitor {
+    explicit hrf_content_reporter( std::ostream& os ) : m_os( os ), m_indent( -4 ) {}
+
+private:
+    void report_test_unit( test_unit const& tu )
+    {
+        m_os << std::setw( m_indent ) << "" << tu.p_name;
+        m_os << (tu.p_default_status == test_unit::RS_ENABLED ? "*" : " ");
+
+        if( !tu.p_description->empty() )
+            m_os << ": " << tu.p_description;
+
+        m_os << "\n";
+    }
+    virtual void visit( test_case const& tc ) { report_test_unit( tc ); }
+    virtual bool test_suite_start( test_suite const& ts )
+    {
+        if( m_indent >= 0 )
+            report_test_unit( ts );
+        m_indent += 4;
+        return true;
+    }
+    virtual void test_suite_finish( test_suite const& )
+    {
+        m_indent -= 4;
+    }
+
+
+    std::ostream& m_os;
+    int m_indent;
+};
+
+
+
+
+
+struct dot_content_reporter : test_tree_visitor {
+    explicit dot_content_reporter( std::ostream& os ) : m_os( os ) {}
+
+private:
+    void report_test_unit( test_unit const& tu )
+    {
+        bool master_ts = tu.p_parent_id == INV_TEST_UNIT_ID;
+
+        m_os << "tu" << tu.p_id;
+
+        m_os << (master_ts ? "[shape=ellipse,peripheries=2" : "[shape=Mrecord" );
+
+        m_os << ",fontname=Helvetica";
+
+        m_os << (tu.p_default_status == test_unit::RS_ENABLED ? ",color=green" : ",color=yellow");
+
+        if( master_ts )
+            m_os << ",label=\"" << tu.p_name << "\"];\n";
+        else {
+            m_os << ",label=\"" << tu.p_name << "|" << tu.p_file_name << "(" << tu.p_line_num << ")";
+            if( tu.p_timeout > 0 )
+                m_os << "|timeout=" << tu.p_timeout;
+            if( tu.p_expected_failures != 0 )
+                m_os << "|expected failures=" << tu.p_expected_failures;
+            if( !tu.p_labels->empty() ) {
+                m_os << "|labels:";
+
+                if( ::boost::unit_test::for_each::static_any_t _fe_cur_119 = ::boost::unit_test::for_each::begin( tu.p_labels.get(), ::boost::unit_test::for_each::is_const_coll( tu.p_labels.get() ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_119 = ::boost::unit_test::for_each::end( tu.p_labels.get(), ::boost::unit_test::for_each::is_const_coll( tu.p_labels.get() ) ) ) {} else for( bool _fe_con_119 = true; _fe_con_119 && !::boost::unit_test::for_each::done( _fe_cur_119, _fe_end_119, tu.p_labels.get(), ::boost::unit_test::for_each::is_const_coll( tu.p_labels.get() ) ); _fe_con_119 ? ::boost::unit_test::for_each::next( _fe_cur_119, tu.p_labels.get(), ::boost::unit_test::for_each::is_const_coll( tu.p_labels.get() ) ) : ((void)&(tu.p_labels.get()))) if( (_fe_con_119 = false, false) ) {} else for( std::string const& l = ::boost::unit_test::for_each::deref( _fe_cur_119, tu.p_labels.get(), ::boost::type<std::string const& >(), ::boost::unit_test::for_each::is_const_coll( tu.p_labels.get() ) ); !_fe_con_119; _fe_con_119 = true )
+                    m_os << " @" << l;
+            }
+            m_os << "\"];\n";
+        }
+
+        if( !master_ts )
+            m_os << "tu" << tu.p_parent_id << " -> " << "tu" << tu.p_id << ";\n";
+
+        if( ::boost::unit_test::for_each::static_any_t _fe_cur_128 = ::boost::unit_test::for_each::begin( tu.p_dependencies.get(), ::boost::unit_test::for_each::is_const_coll( tu.p_dependencies.get() ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_128 = ::boost::unit_test::for_each::end( tu.p_dependencies.get(), ::boost::unit_test::for_each::is_const_coll( tu.p_dependencies.get() ) ) ) {} else for( bool _fe_con_128 = true; _fe_con_128 && !::boost::unit_test::for_each::done( _fe_cur_128, _fe_end_128, tu.p_dependencies.get(), ::boost::unit_test::for_each::is_const_coll( tu.p_dependencies.get() ) ); _fe_con_128 ? ::boost::unit_test::for_each::next( _fe_cur_128, tu.p_dependencies.get(), ::boost::unit_test::for_each::is_const_coll( tu.p_dependencies.get() ) ) : ((void)&(tu.p_dependencies.get()))) if( (_fe_con_128 = false, false) ) {} else for( test_unit_id dep_id = ::boost::unit_test::for_each::deref( _fe_cur_128, tu.p_dependencies.get(), ::boost::type<test_unit_id >(), ::boost::unit_test::for_each::is_const_coll( tu.p_dependencies.get() ) ); !_fe_con_128; _fe_con_128 = true ) {
+            test_unit const& dep = framework::get( dep_id, TUT_ANY );
+
+            m_os << "tu" << tu.p_id << " -> " << "tu" << dep.p_id << "[color=red,style=dotted,constraint=false];\n";
+        }
+
+    }
+    virtual void visit( test_case const& tc )
+    {
+        report_test_unit( tc );
+    }
+    virtual bool test_suite_start( test_suite const& ts )
+    {
+        if( ts.p_parent_id == INV_TEST_UNIT_ID )
+            m_os << "digraph G {rankdir=LR;\n";
+
+        report_test_unit( ts );
+
+        m_os << "{\n";
+
+        return true;
+    }
+    virtual void test_suite_finish( test_suite const& ts )
+    {
+        m_os << "}\n";
+        if( ts.p_parent_id == INV_TEST_UNIT_ID )
+            m_os << "}\n";
+    }
+
+    std::ostream& m_os;
+};
+
+
+
+
+
+struct labels_collector : test_tree_visitor {
+    std::set<std::string> const& labels() const { return m_labels; }
+
+private:
+    virtual bool visit( test_unit const& tu )
+    {
+        m_labels.insert( tu.p_labels->begin(), tu.p_labels->end() );
+        return true;
+    }
+
+
+    std::set<std::string> m_labels;
+};
+
+struct framework_shutdown_helper {
+    ~framework_shutdown_helper() {
+        try {
+            framework::shutdown();
+        }
+        catch(...) {
+            std::cerr << "Boost.Test shutdown exception caught" << std::endl;
+        }
+    }
+};
+
+}
+
+
+
+
+
+
+
+int __attribute__((__visibility__("default")))
+unit_test_main( init_unit_test_func init_func, int argc, char* argv[] )
+{
+    int result_code = 0;
+
+    ut_detail::framework_shutdown_helper shutdown_helper;
+
+    try {
+
+        framework::init( init_func, argc, argv );
+
+        if( runtime_config::get<bool>( runtime_config::btrt_wait_for_debugger ) ) {
+            results_reporter::get_stream() << "Press any key to continue..." << std::endl;
+
+
+
+            (std::getchar)();
+            results_reporter::get_stream() << "Continuing..." << std::endl;
+        }
+
+        framework::finalize_setup_phase();
+
+        output_format list_cont = runtime_config::get<output_format>( runtime_config::btrt_list_content );
+        if( list_cont != unit_test::OF_INVALID ) {
+            if( list_cont == unit_test::OF_DOT ) {
+                ut_detail::dot_content_reporter reporter( results_reporter::get_stream() );
+
+                traverse_test_tree( framework::master_test_suite().p_id, reporter, true );
+            }
+            else {
+                ut_detail::hrf_content_reporter reporter( results_reporter::get_stream() );
+
+                traverse_test_tree( framework::master_test_suite().p_id, reporter, true );
+            }
+
+            return boost::exit_success;
+        }
+
+        if( runtime_config::get<bool>( runtime_config::btrt_list_labels ) ) {
+            ut_detail::labels_collector collector;
+
+            traverse_test_tree( framework::master_test_suite().p_id, collector, true );
+
+            results_reporter::get_stream() << "Available labels:\n  ";
+            std::copy( collector.labels().begin(), collector.labels().end(),
+                       std::ostream_iterator<std::string>( results_reporter::get_stream(), "\n  " ) );
+            results_reporter::get_stream() << "\n";
+
+            return boost::exit_success;
+        }
+
+        framework::run();
+
+        result_code = !runtime_config::get<bool>( runtime_config::btrt_result_code )
+                        ? boost::exit_success
+                        : results_collector.results( framework::master_test_suite().p_id ).result_code();
+    }
+    catch( framework::nothing_to_test const& ex ) {
+        result_code = ex.m_result_code;
+    }
+    catch( framework::internal_error const& ex ) {
+        results_reporter::get_stream() << "Boost.Test framework internal error: " << ex.what() << std::endl;
+
+        result_code = boost::exit_exception_failure;
+    }
+    catch( framework::setup_error const& ex ) {
+        results_reporter::get_stream() << "Test setup error: " << ex.what() << std::endl;
+
+        result_code = boost::exit_exception_failure;
+    }
+    catch( std::logic_error const& ex ) {
+        results_reporter::get_stream() << "Test setup error: " << ex.what() << std::endl;
+
+        result_code = boost::exit_exception_failure;
+    }
+    catch(...) {
+        results_reporter::get_stream() << "Boost.Test framework internal error: unknown reason" << std::endl;
+
+        result_code = boost::exit_exception_failure;
+    }
+
+    return result_code;
+}
+
+}
+}
+
+
+
+
+
+
+
+int
+main( int argc, char* argv[] )
+{
+
+
+
+
+
+
+    extern ::boost::unit_test::test_suite* init_unit_test_suite( int argc, char* argv[] );
+
+    boost::unit_test::init_unit_test_func init_func = &init_unit_test_suite;
+
+
+    return ::boost::unit_test::unit_test_main( init_func, argc, argv );
+}
+
+
+
+
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 312 "/usr/include/boost/test/impl/unit_test_main.ipp" 2 3 4
+# 33 "/usr/include/boost/test/included/unit_test.hpp" 2 3 4
+# 1 "/usr/include/boost/test/impl/unit_test_monitor.ipp" 1 3 4
+# 17 "/usr/include/boost/test/impl/unit_test_monitor.ipp" 3 4
+#define BOOST_TEST_UNIT_TEST_MONITOR_IPP_012205GER 
+
+
+
+
+
+
+
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 26 "/usr/include/boost/test/impl/unit_test_monitor.ipp" 2 3 4
+
+
+
+namespace boost {
+namespace unit_test {
+
+
+unit_test_monitor_t& unit_test_monitor_t::instance() { static unit_test_monitor_t the_inst; return the_inst; }
+
+
+
+
+
+unit_test_monitor_t::error_level
+unit_test_monitor_t::execute_and_translate( boost::function<void ()> const& func, unsigned long int timeout_microseconds )
+{
+    try {
+        p_catch_system_errors.value = runtime_config::get<bool>( runtime_config::btrt_catch_sys_errors );
+        p_timeout.value = timeout_microseconds;
+        p_auto_start_dbg.value = runtime_config::get<bool>( runtime_config::btrt_auto_start_dbg );
+        p_use_alt_stack.value = runtime_config::get<bool>( runtime_config::btrt_use_alt_stack );
+        p_detect_fp_exceptions.value = runtime_config::get<bool>( runtime_config::btrt_detect_fp_except );
+
+        vexecute( func );
+    }
+    catch( execution_exception const& ex ) {
+        framework::exception_caught( ex );
+        framework::test_unit_aborted( framework::current_test_unit() );
+
+
+        switch( ex.code() ) {
+        case execution_exception::no_error: return test_ok;
+        case execution_exception::user_error: return unexpected_exception;
+        case execution_exception::cpp_exception_error: return unexpected_exception;
+        case execution_exception::system_error: return os_exception;
+        case execution_exception::timeout_error: return os_timeout;
+        case execution_exception::user_fatal_error:
+        case execution_exception::system_fatal_error: return fatal_error;
+        default: return unexpected_exception;
+        }
+    }
+
+    return test_ok;
+}
+
+
+
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 77 "/usr/include/boost/test/impl/unit_test_monitor.ipp" 2 3 4
+# 34 "/usr/include/boost/test/included/unit_test.hpp" 2 3 4
+# 1 "/usr/include/boost/test/impl/unit_test_parameters.ipp" 1 3 4
+# 19 "/usr/include/boost/test/impl/unit_test_parameters.ipp" 3 4
+#define BOOST_TEST_UNIT_TEST_PARAMETERS_IPP_012205GER 
+# 36 "/usr/include/boost/test/impl/unit_test_parameters.ipp" 3 4
+# 1 "/usr/include/boost/test/utils/runtime/parameter.hpp" 1 3 4
+# 16 "/usr/include/boost/test/utils/runtime/parameter.hpp" 3 4
+#define BOOST_TEST_UTILS_RUNTIME_PARAMETER_HPP 
+
+
+
+# 1 "/usr/include/boost/test/utils/runtime/modifier.hpp" 1 3 4
+# 16 "/usr/include/boost/test/utils/runtime/modifier.hpp" 3 4
+#define BOOST_TEST_UTILS_RUNTIME_MODIFIER_HPP 
+# 25 "/usr/include/boost/test/utils/runtime/modifier.hpp" 3 4
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 26 "/usr/include/boost/test/utils/runtime/modifier.hpp" 2 3 4
+
+
+
+
+
+
+
+#define BOOST_TEST_CLA_NEW_API 
+
+
+namespace boost {
+namespace runtime {
+
+
+
+
+
+namespace {
+
+
+auto const& description = unit_test::static_constant<nfp::typed_keyword<cstring,struct description_t>>::value;
+auto const& help = unit_test::static_constant<nfp::typed_keyword<cstring,struct help_t>>::value;
+auto const& env_var = unit_test::static_constant<nfp::typed_keyword<cstring,struct env_var_t>>::value;
+auto const& end_of_params = unit_test::static_constant<nfp::typed_keyword<cstring,struct end_of_params_t>>::value;
+auto const& negation_prefix = unit_test::static_constant<nfp::typed_keyword<cstring,struct neg_prefix_t>>::value;
+auto const& value_hint = unit_test::static_constant<nfp::typed_keyword<cstring,struct value_hint_t>>::value;
+auto const& optional_value = unit_test::static_constant<nfp::keyword<struct optional_value_t>>::value;
+auto const& default_value = unit_test::static_constant<nfp::keyword<struct default_value_t>>::value;
+auto const& callback = unit_test::static_constant<nfp::keyword<struct callback_t>>::value;
+
+template<typename EnumType>
+using enum_values = unit_test::static_constant<
+  nfp::typed_keyword<std::initializer_list<std::pair<const cstring,EnumType>>, struct enum_values_t>
+>;
+# 100 "/usr/include/boost/test/utils/runtime/modifier.hpp" 3 4
+}
+
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 106 "/usr/include/boost/test/utils/runtime/modifier.hpp" 2 3 4
+# 21 "/usr/include/boost/test/utils/runtime/parameter.hpp" 2 3 4
+
+# 1 "/usr/include/boost/test/utils/runtime/argument_factory.hpp" 1 3 4
+# 16 "/usr/include/boost/test/utils/runtime/argument_factory.hpp" 3 4
+#define BOOST_TEST_UTILS_RUNTIME_ARGUMENT_FACTORY_HPP 
+# 29 "/usr/include/boost/test/utils/runtime/argument_factory.hpp" 3 4
+# 1 "/usr/include/boost/function/function2.hpp" 1 3 4
+# 10 "/usr/include/boost/function/function2.hpp" 3 4
+#define BOOST_FUNCTION_NUM_ARGS 2
+# 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
+# 25 "/usr/include/boost/function/detail/maybe_include.hpp" 3 4
+#undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#define BOOST_FUNCTION_MAX_ARGS_DEFINED 2
+
+#define BOOST_FUNCTION_2 
+# 1 "/usr/include/boost/function/function_template.hpp" 1 3 4
+# 21 "/usr/include/boost/function/function_template.hpp" 3 4
+#define BOOST_FUNCTION_TEMPLATE_PARMS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, typename T)
+
+#define BOOST_FUNCTION_TEMPLATE_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, T)
+
+#define BOOST_FUNCTION_PARM(J,I,D) BOOST_PP_CAT(T,I) BOOST_PP_CAT(a,I)
+
+#define BOOST_FUNCTION_PARMS BOOST_PP_ENUM(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_PARM,BOOST_PP_EMPTY)
+
+
+
+
+#define BOOST_FUNCTION_ARG(J,I,D) static_cast<BOOST_PP_CAT(T,I)&&>(BOOST_PP_CAT(a,I))
+#define BOOST_FUNCTION_ARGS BOOST_PP_ENUM(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_ARG,BOOST_PP_EMPTY)
+
+
+#define BOOST_FUNCTION_ARG_TYPE(J,I,D) typedef BOOST_PP_CAT(T,I) BOOST_PP_CAT(BOOST_PP_CAT(arg, BOOST_PP_INC(I)),_type);
+
+
+#define BOOST_FUNCTION_ARG_TYPES BOOST_PP_REPEAT(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_ARG_TYPE,BOOST_PP_EMPTY)
+
+
+
+
+
+#define BOOST_FUNCTION_COMMA ,
+
+
+
+#define BOOST_FUNCTION_FUNCTION BOOST_JOIN(function,BOOST_FUNCTION_NUM_ARGS)
+#define BOOST_FUNCTION_FUNCTION_INVOKER BOOST_JOIN(function_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_VOID_FUNCTION_INVOKER BOOST_JOIN(void_function_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_FUNCTION_OBJ_INVOKER BOOST_JOIN(function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER BOOST_JOIN(void_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_FUNCTION_REF_INVOKER BOOST_JOIN(function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER BOOST_JOIN(void_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_MEMBER_INVOKER BOOST_JOIN(function_mem_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_VOID_MEMBER_INVOKER BOOST_JOIN(function_void_mem_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_GET_FUNCTION_INVOKER BOOST_JOIN(get_function_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER BOOST_JOIN(get_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER BOOST_JOIN(get_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_GET_MEMBER_INVOKER BOOST_JOIN(get_member_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_GET_INVOKER BOOST_JOIN(get_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_VTABLE BOOST_JOIN(basic_vtable,BOOST_FUNCTION_NUM_ARGS)
+
+
+#define BOOST_FUNCTION_VOID_RETURN_TYPE void
+#define BOOST_FUNCTION_RETURN(X) X
+
+
+
+
+
+namespace boost {
+  namespace detail {
+    namespace function {
+      template<
+        typename FunctionPtr,
+        typename R ,
+        typename T0 , typename T1
+        >
+      struct function_invoker2
+      {
+        static R invoke(function_buffer& function_ptr ,
+                        T0 a0 , T1 a1)
+        {
+          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.members.func_ptr);
+          return f( static_cast<T0&&>(a0) , static_cast<T1&&>(a1));
+        }
+      };
+
+      template<
+        typename FunctionPtr,
+        typename R ,
+        typename T0 , typename T1
+        >
+      struct void_function_invoker2
+      {
+        static void
+        invoke(function_buffer& function_ptr ,
+               T0 a0 , T1 a1)
+
+        {
+          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.members.func_ptr);
+          f( static_cast<T0&&>(a0) , static_cast<T1&&>(a1));
+        }
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1
+      >
+      struct function_obj_invoker2
+      {
+        static R invoke(function_buffer& function_obj_ptr ,
+                        T0 a0 , T1 a1)
+
+        {
+          FunctionObj* f;
+          if (function_allows_small_object_optimization<FunctionObj>::value)
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.data);
+          else
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
+          return (*f)( static_cast<T0&&>(a0) , static_cast<T1&&>(a1));
+        }
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1
+      >
+      struct void_function_obj_invoker2
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr ,
+               T0 a0 , T1 a1)
+
+        {
+          FunctionObj* f;
+          if (function_allows_small_object_optimization<FunctionObj>::value)
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.data);
+          else
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
+          (*f)( static_cast<T0&&>(a0) , static_cast<T1&&>(a1));
+        }
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1
+      >
+      struct function_ref_invoker2
+      {
+        static R invoke(function_buffer& function_obj_ptr ,
+                        T0 a0 , T1 a1)
+
+        {
+          FunctionObj* f =
+            reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
+          return (*f)( static_cast<T0&&>(a0) , static_cast<T1&&>(a1));
+        }
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1
+      >
+      struct void_function_ref_invoker2
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr ,
+               T0 a0 , T1 a1)
+
+        {
+          FunctionObj* f =
+            reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
+          (*f)( static_cast<T0&&>(a0) , static_cast<T1&&>(a1));
+        }
+      };
+
+
+
+      template<
+        typename MemberPtr,
+        typename R ,
+        typename T0 , typename T1
+      >
+      struct function_mem_invoker2
+      {
+        static R invoke(function_buffer& function_obj_ptr ,
+                        T0 a0 , T1 a1)
+
+        {
+          MemberPtr* f =
+            reinterpret_cast<MemberPtr*>(function_obj_ptr.data);
+          return boost::mem_fn(*f)( static_cast<T0&&>(a0) , static_cast<T1&&>(a1));
+        }
+      };
+
+      template<
+        typename MemberPtr,
+        typename R ,
+        typename T0 , typename T1
+      >
+      struct function_void_mem_invoker2
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr ,
+               T0 a0 , T1 a1)
+
+        {
+          MemberPtr* f =
+            reinterpret_cast<MemberPtr*>(function_obj_ptr.data);
+          boost::mem_fn(*f)( static_cast<T0&&>(a0) , static_cast<T1&&>(a1));
+        }
+      };
+
+
+      template<
+        typename FunctionPtr,
+        typename R ,
+        typename T0 , typename T1
+      >
+      struct get_function_invoker2
+      {
+        typedef typename conditional<(is_void<R>::value),
+                            void_function_invoker2<
+                            FunctionPtr,
+                            R ,
+                            T0 , T1
+                          >,
+                          function_invoker2<
+                            FunctionPtr,
+                            R ,
+                            T0 , T1
+                          >
+                       >::type type;
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1
+       >
+      struct get_function_obj_invoker2
+      {
+        typedef typename conditional<(is_void<R>::value),
+                            void_function_obj_invoker2<
+                            FunctionObj,
+                            R ,
+                            T0 , T1
+                          >,
+                          function_obj_invoker2<
+                            FunctionObj,
+                            R ,
+                            T0 , T1
+                          >
+                       >::type type;
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1
+       >
+      struct get_function_ref_invoker2
+      {
+        typedef typename conditional<(is_void<R>::value),
+                            void_function_ref_invoker2<
+                            FunctionObj,
+                            R ,
+                            T0 , T1
+                          >,
+                          function_ref_invoker2<
+                            FunctionObj,
+                            R ,
+                            T0 , T1
+                          >
+                       >::type type;
+      };
+
+
+
+      template<
+        typename MemberPtr,
+        typename R ,
+        typename T0 , typename T1
+       >
+      struct get_member_invoker2
+      {
+        typedef typename conditional<(is_void<R>::value),
+                            function_void_mem_invoker2<
+                            MemberPtr,
+                            R ,
+                            T0 , T1
+                          >,
+                          function_mem_invoker2<
+                            MemberPtr,
+                            R ,
+                            T0 , T1
+                          >
+                       >::type type;
+      };
+# 331 "/usr/include/boost/function/function_template.hpp" 3 4
+      template<typename Tag>
+      struct get_invoker2 { };
+
+
+      template<>
+      struct get_invoker2<function_ptr_tag>
+      {
+        template<typename FunctionPtr,
+                 typename R , typename T0 , typename T1>
+        struct apply
+        {
+          typedef typename get_function_invoker2<
+                             FunctionPtr,
+                             R ,
+                             T0 , T1
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<FunctionPtr> manager_type;
+        };
+
+        template<typename FunctionPtr, typename Allocator,
+                 typename R , typename T0 , typename T1>
+        struct apply_a
+        {
+          typedef typename get_function_invoker2<
+                             FunctionPtr,
+                             R ,
+                             T0 , T1
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<FunctionPtr> manager_type;
+        };
+      };
+
+
+
+      template<>
+      struct get_invoker2<member_ptr_tag>
+      {
+        template<typename MemberPtr,
+                 typename R , typename T0 , typename T1>
+        struct apply
+        {
+          typedef typename get_member_invoker2<
+                             MemberPtr,
+                             R ,
+                             T0 , T1
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<MemberPtr> manager_type;
+        };
+
+        template<typename MemberPtr, typename Allocator,
+                 typename R , typename T0 , typename T1>
+        struct apply_a
+        {
+          typedef typename get_member_invoker2<
+                             MemberPtr,
+                             R ,
+                             T0 , T1
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<MemberPtr> manager_type;
+        };
+      };
+
+
+
+      template<>
+      struct get_invoker2<function_obj_tag>
+      {
+        template<typename FunctionObj,
+                 typename R , typename T0 , typename T1>
+        struct apply
+        {
+          typedef typename get_function_obj_invoker2<
+                             FunctionObj,
+                             R ,
+                             T0 , T1
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<FunctionObj> manager_type;
+        };
+
+        template<typename FunctionObj, typename Allocator,
+                 typename R , typename T0 , typename T1>
+        struct apply_a
+        {
+          typedef typename get_function_obj_invoker2<
+                             FunctionObj,
+                             R ,
+                             T0 , T1
+                           >::type
+            invoker_type;
+
+          typedef functor_manager_a<FunctionObj, Allocator> manager_type;
+        };
+      };
+
+
+      template<>
+      struct get_invoker2<function_obj_ref_tag>
+      {
+        template<typename RefWrapper,
+                 typename R , typename T0 , typename T1>
+        struct apply
+        {
+          typedef typename get_function_ref_invoker2<
+                             typename RefWrapper::type,
+                             R ,
+                             T0 , T1
+                           >::type
+            invoker_type;
+
+          typedef reference_manager<typename RefWrapper::type> manager_type;
+        };
+
+        template<typename RefWrapper, typename Allocator,
+                 typename R , typename T0 , typename T1>
+        struct apply_a
+        {
+          typedef typename get_function_ref_invoker2<
+                             typename RefWrapper::type,
+                             R ,
+                             T0 , T1
+                           >::type
+            invoker_type;
+
+          typedef reference_manager<typename RefWrapper::type> manager_type;
+        };
+      };
+# 476 "/usr/include/boost/function/function_template.hpp" 3 4
+      template<typename R , typename T0 , typename T1>
+      struct basic_vtable2
+      {
+
+        typedef R result_type;
+
+
+
+
+        typedef result_type (*invoker_type)(function_buffer&
+                                            ,
+                                            T0 , T1);
+
+        template<typename F>
+        bool assign_to(F f, function_buffer& functor) const
+        {
+          typedef typename get_function_tag<F>::type tag;
+          return assign_to(f, functor, tag());
+        }
+        template<typename F,typename Allocator>
+        bool assign_to_a(F f, function_buffer& functor, Allocator a) const
+        {
+          typedef typename get_function_tag<F>::type tag;
+          return assign_to_a(f, functor, a, tag());
+        }
+
+        void clear(function_buffer& functor) const
+        {
+          if (base.manager)
+            base.manager(functor, functor, destroy_functor_tag);
+        }
+
+      private:
+
+        template<typename FunctionPtr>
+        bool
+        assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag) const
+        {
+          this->clear(functor);
+          if (f) {
+
+
+            functor.members.func_ptr = reinterpret_cast<void (*)()>(f);
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionPtr,typename Allocator>
+        bool
+        assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const
+        {
+          return assign_to(f,functor,function_ptr_tag());
+        }
+
+
+
+        template<typename MemberPtr>
+        bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag) const
+        {
+
+
+
+          if (f) {
+            this->assign_to(boost::mem_fn(f), functor);
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename MemberPtr,typename Allocator>
+        bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag) const
+        {
+
+
+
+          if (f) {
+            this->assign_to_a(boost::mem_fn(f), functor, a);
+            return true;
+          } else {
+            return false;
+          }
+        }
+
+
+
+
+        template<typename FunctionObj>
+        void
+        assign_functor(FunctionObj f, function_buffer& functor, true_type) const
+        {
+          new (reinterpret_cast<void*>(functor.data)) FunctionObj(f);
+        }
+        template<typename FunctionObj,typename Allocator>
+        void
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, true_type) const
+        {
+          assign_functor(f,functor,true_type());
+        }
+
+
+        template<typename FunctionObj>
+        void
+        assign_functor(FunctionObj f, function_buffer& functor, false_type) const
+        {
+          functor.members.obj_ptr = new FunctionObj(f);
+        }
+        template<typename FunctionObj,typename Allocator>
+        void
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, false_type) const
+        {
+          typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;
+
+
+
+
+
+          using wrapper_allocator_type = typename std::allocator_traits<Allocator>::template rebind_alloc<functor_wrapper_type>;
+          using wrapper_allocator_pointer_type = typename std::allocator_traits<wrapper_allocator_type>::pointer;
+
+          wrapper_allocator_type wrapper_allocator(a);
+          wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
+
+
+
+          std::allocator_traits<wrapper_allocator_type>::construct(wrapper_allocator, copy, functor_wrapper_type(f,a));
+
+          functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
+          functor.members.obj_ptr = new_f;
+        }
+
+        template<typename FunctionObj>
+        bool
+        assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) const
+        {
+          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
+            assign_functor(f, functor,
+                           integral_constant<bool, (function_allows_small_object_optimization<FunctionObj>::value)>());
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionObj,typename Allocator>
+        bool
+        assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag) const
+        {
+          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
+            assign_functor_a(f, functor, a,
+                           integral_constant<bool, (function_allows_small_object_optimization<FunctionObj>::value)>());
+            return true;
+          } else {
+            return false;
+          }
+        }
+
+
+        template<typename FunctionObj>
+        bool
+        assign_to(const reference_wrapper<FunctionObj>& f,
+                  function_buffer& functor, function_obj_ref_tag) const
+        {
+          functor.members.obj_ref.obj_ptr = (void *)(f.get_pointer());
+          functor.members.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
+          functor.members.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
+          return true;
+        }
+        template<typename FunctionObj,typename Allocator>
+        bool
+        assign_to_a(const reference_wrapper<FunctionObj>& f,
+                  function_buffer& functor, Allocator, function_obj_ref_tag) const
+        {
+          return assign_to(f,functor,function_obj_ref_tag());
+        }
+
+      public:
+        vtable_base base;
+        invoker_type invoker;
+      };
+    }
+  }
+
+  template<
+    typename R ,
+    typename T0 , typename T1
+  >
+  class function2 : public function_base
+  {
+  public:
+
+    typedef R result_type;
+
+
+
+
+
+  private:
+    typedef boost::detail::function::basic_vtable2<
+              R , T0 , T1>
+      vtable_type;
+
+    vtable_type* get_vtable() const {
+      return reinterpret_cast<vtable_type*>(
+               reinterpret_cast<std::size_t>(vtable) & ~static_cast<std::size_t>(0x01));
+    }
+
+    struct clear_type {};
+
+  public:
+    static const int args = 2;
+
+
+    template<typename Args>
+    struct sig
+    {
+      typedef result_type type;
+    };
+
+
+
+
+    typedef T0 first_argument_type;
+    typedef T1 second_argument_type;
+
+
+    static const int arity = 2;
+    typedef T0 arg1_type; typedef T1 arg2_type;
+
+    typedef function2 self_type;
+
+    function2() = default;
+
+
+
+    template<typename Functor>
+    function2(Functor f
+
+                            ,typename boost::enable_if_<
+                             !(is_integral<Functor>::value),
+                                        int>::type = 0
+
+                            ) :
+      function_base()
+    {
+      this->assign_to(f);
+    }
+    template<typename Functor,typename Allocator>
+    function2(Functor f, Allocator a
+
+                            ,typename boost::enable_if_<
+                              !(is_integral<Functor>::value),
+                                        int>::type = 0
+
+                            ) :
+      function_base()
+    {
+      this->assign_to_a(f,a);
+    }
+
+
+    function2(clear_type*) : function_base() { }
+
+
+
+
+
+
+
+    function2(const function2& f) : function_base()
+    {
+      this->assign_to_own(f);
+    }
+
+
+    function2(function2&& f) : function_base()
+    {
+      this->move_assign(f);
+    }
+
+
+    ~function2() { clear(); }
+
+    result_type operator()( T0 a0 , T1 a1) const
+    {
+      if (this->empty())
+        boost::throw_exception(bad_function_call());
+
+      return get_vtable()->invoker
+               (this->functor , static_cast<T0&&>(a0) , static_cast<T1&&>(a1));
+    }
+
+
+
+
+
+
+    template<typename Functor>
+
+    typename boost::enable_if_<
+                  !(is_integral<Functor>::value),
+               function2&>::type
+
+
+
+    operator=(Functor f)
+    {
+      this->clear();
+      { try {
+        this->assign_to(f);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+      return *this;
+    }
+    template<typename Functor,typename Allocator>
+    void assign(Functor f, Allocator a)
+    {
+      this->clear();
+      { try{
+        this->assign_to_a(f,a);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+    }
+
+
+    function2& operator=(clear_type*)
+    {
+      this->clear();
+      return *this;
+    }
+# 821 "/usr/include/boost/function/function_template.hpp" 3 4
+    function2& operator=(const function2& f)
+    {
+      if (&f == this)
+        return *this;
+
+      this->clear();
+      { try {
+        this->assign_to_own(f);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+      return *this;
+    }
+
+
+
+    function2& operator=(function2&& f)
+    {
+      if (&f == this)
+        return *this;
+
+      this->clear();
+      { try {
+        this->move_assign(f);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+      return *this;
+    }
+
+
+    void swap(function2& other)
+    {
+      if (&other == this)
+        return;
+
+      function2 tmp;
+      tmp.move_assign(*this);
+      this->move_assign(other);
+      other.move_assign(tmp);
+    }
+
+
+    void clear()
+    {
+      if (vtable) {
+        if (!this->has_trivial_copy_and_destroy())
+          get_vtable()->clear(this->functor);
+        vtable = 0;
+      }
+    }
+
+
+
+
+
+  private:
+    struct dummy {
+      void nonnull() {}
+    };
+
+    typedef void (dummy::*safe_bool)();
+
+  public:
+    operator safe_bool () const
+      { return (this->empty())? 0 : &dummy::nonnull; }
+
+    bool operator!() const
+      { return this->empty(); }
+
+
+  private:
+    void assign_to_own(const function2& f)
+    {
+      if (!f.empty()) {
+        this->vtable = f.vtable;
+        if (this->has_trivial_copy_and_destroy())
+
+
+          std::memcpy(this->functor.data, f.functor.data, sizeof(boost::detail::function::function_buffer));
+        else
+          get_vtable()->base.manager(f.functor, this->functor,
+                                     boost::detail::function::clone_functor_tag);
+      }
+    }
+
+    template<typename Functor>
+    void assign_to(Functor f)
+    {
+      using boost::detail::function::vtable_base;
+
+      typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
+      typedef boost::detail::function::get_invoker2<tag> get_invoker;
+      typedef typename get_invoker::
+                         template apply<Functor, R ,
+                        T0 , T1>
+        handler_type;
+
+      typedef typename handler_type::invoker_type invoker_type;
+      typedef typename handler_type::manager_type manager_type;
+
+
+
+
+
+      static const vtable_type stored_vtable =
+        { { &manager_type::manage }, &invoker_type::invoke };
+
+      if (stored_vtable.assign_to(f, functor)) {
+        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
+
+        if (boost::has_trivial_copy_constructor<Functor>::value &&
+            boost::has_trivial_destructor<Functor>::value &&
+            boost::detail::function::function_allows_small_object_optimization<Functor>::value)
+          value |= static_cast<std::size_t>(0x01);
+        vtable = reinterpret_cast<boost::detail::function::vtable_base *>(value);
+      } else
+        vtable = 0;
+    }
+
+    template<typename Functor,typename Allocator>
+    void assign_to_a(Functor f,Allocator a)
+    {
+      using boost::detail::function::vtable_base;
+
+      typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
+      typedef boost::detail::function::get_invoker2<tag> get_invoker;
+      typedef typename get_invoker::
+                         template apply_a<Functor, Allocator, R ,
+                         T0 , T1>
+        handler_type;
+
+      typedef typename handler_type::invoker_type invoker_type;
+      typedef typename handler_type::manager_type manager_type;
+
+
+
+
+
+      static const vtable_type stored_vtable =
+        { { &manager_type::manage }, &invoker_type::invoke };
+
+      if (stored_vtable.assign_to_a(f, functor, a)) {
+        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
+
+        if (boost::has_trivial_copy_constructor<Functor>::value &&
+            boost::has_trivial_destructor<Functor>::value &&
+            boost::detail::function::function_allows_small_object_optimization<Functor>::value)
+          value |= static_cast<std::size_t>(0x01);
+        vtable = reinterpret_cast<boost::detail::function::vtable_base *>(value);
+      } else
+        vtable = 0;
+    }
+
+
+
+
+    void move_assign(function2& f)
+    {
+      if (&f == this)
+        return;
+
+      { try {
+        if (!f.empty()) {
+          this->vtable = f.vtable;
+          if (this->has_trivial_copy_and_destroy())
+
+
+            std::memcpy(this->functor.data, f.functor.data, sizeof(this->functor.data));
+          else
+            get_vtable()->base.manager(f.functor, this->functor,
+                                     boost::detail::function::move_functor_tag);
+          f.vtable = 0;
+        } else {
+          clear();
+        }
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+    }
+  };
+
+  template<typename R , typename T0 , typename T1>
+  inline void swap(function2<
+                     R ,
+                     T0 , T1
+                   >& f1,
+                   function2<
+                     R ,
+                     T0 , T1
+                   >& f2)
+  {
+    f1.swap(f2);
+  }
+
+
+template<typename R , typename T0 , typename T1>
+  void operator==(const function2<
+                          R ,
+                          T0 , T1>&,
+                  const function2<
+                          R ,
+                          T0 , T1>&);
+template<typename R , typename T0 , typename T1>
+  void operator!=(const function2<
+                          R ,
+                          T0 , T1>&,
+                  const function2<
+                          R ,
+                          T0 , T1>& );
+
+
+
+
+
+
+#define BOOST_FUNCTION_PARTIAL_SPEC R (BOOST_FUNCTION_TEMPLATE_ARGS)
+
+
+template<typename R ,
+         typename T0 , typename T1>
+class function<R ( T0 , T1)>
+  : public function2<R , T0 , T1>
+{
+  typedef function2<R , T0 , T1> base_type;
+  typedef function self_type;
+
+  struct clear_type {};
+
+public:
+
+  function() = default;
+
+  template<typename Functor>
+  function(Functor f
+
+           ,typename boost::enable_if_<
+                          !(is_integral<Functor>::value),
+                       int>::type = 0
+
+           ) :
+    base_type(f)
+  {
+  }
+  template<typename Functor,typename Allocator>
+  function(Functor f, Allocator a
+
+           ,typename boost::enable_if_<
+                           !(is_integral<Functor>::value),
+                       int>::type = 0
+
+           ) :
+    base_type(f,a)
+  {
+  }
+
+
+  function(clear_type*) : base_type() {}
+
+
+  function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}
+
+  function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}
+
+
+
+  function(self_type&& f): base_type(static_cast<base_type&&>(f)){}
+  function(base_type&& f): base_type(static_cast<base_type&&>(f)){}
+
+
+  self_type& operator=(const self_type& f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+
+
+  self_type& operator=(self_type&& f)
+  {
+    self_type(static_cast<self_type&&>(f)).swap(*this);
+    return *this;
+  }
+
+
+  template<typename Functor>
+
+  typename boost::enable_if_<
+                         !(is_integral<Functor>::value),
+                      self_type&>::type
+
+
+
+  operator=(Functor f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+
+
+  self_type& operator=(clear_type*)
+  {
+    this->clear();
+    return *this;
+  }
+
+
+  self_type& operator=(const base_type& f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+
+
+  self_type& operator=(base_type&& f)
+  {
+    self_type(static_cast<base_type&&>(f)).swap(*this);
+    return *this;
+  }
+
+};
+
+#undef BOOST_FUNCTION_PARTIAL_SPEC
+
+
+}
+
+
+#undef BOOST_FUNCTION_VTABLE
+#undef BOOST_FUNCTION_COMMA
+#undef BOOST_FUNCTION_FUNCTION
+#undef BOOST_FUNCTION_FUNCTION_INVOKER
+#undef BOOST_FUNCTION_VOID_FUNCTION_INVOKER
+#undef BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
+#undef BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
+#undef BOOST_FUNCTION_FUNCTION_REF_INVOKER
+#undef BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER
+#undef BOOST_FUNCTION_MEMBER_INVOKER
+#undef BOOST_FUNCTION_VOID_MEMBER_INVOKER
+#undef BOOST_FUNCTION_GET_FUNCTION_INVOKER
+#undef BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
+#undef BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER
+#undef BOOST_FUNCTION_GET_MEM_FUNCTION_INVOKER
+#undef BOOST_FUNCTION_GET_INVOKER
+#undef BOOST_FUNCTION_TEMPLATE_PARMS
+#undef BOOST_FUNCTION_TEMPLATE_ARGS
+#undef BOOST_FUNCTION_PARMS
+#undef BOOST_FUNCTION_PARM
+
+#undef BOOST_FUNCTION_ARG
+
+#undef BOOST_FUNCTION_ARGS
+#undef BOOST_FUNCTION_ARG_TYPE
+#undef BOOST_FUNCTION_ARG_TYPES
+#undef BOOST_FUNCTION_VOID_RETURN_TYPE
+#undef BOOST_FUNCTION_RETURN
+# 30 "/usr/include/boost/function/detail/maybe_include.hpp" 2 3 4
+# 12 "/usr/include/boost/function/function2.hpp" 2 3 4
+#undef BOOST_FUNCTION_NUM_ARGS
+# 30 "/usr/include/boost/test/utils/runtime/argument_factory.hpp" 2 3 4
+
+
+
+
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 35 "/usr/include/boost/test/utils/runtime/argument_factory.hpp" 2 3 4
+
+namespace boost {
+namespace runtime {
+
+
+
+
+
+template<typename ValueType, bool is_enum>
+struct value_interpreter;
+
+
+
+template<typename ValueType>
+struct value_interpreter<ValueType, false> {
+    template<typename Modifiers>
+    explicit value_interpreter( Modifiers const& ) {}
+
+    ValueType interpret( cstring param_name, cstring source ) const
+    {
+        ValueType res;
+        if( !unit_test::utils::string_as<ValueType>( source, res ) )
+            unit_test::ut_detail::throw_exception( format_error( param_name ) << source << " can't be interpreted as value of parameter " << param_name << "." )
+                                                                                                     ;
+        return res;
+    }
+};
+
+
+
+template<>
+struct value_interpreter<std::string, false> {
+    template<typename Modifiers>
+    explicit value_interpreter( Modifiers const& ) {}
+
+    std::string interpret( cstring, cstring source ) const
+    {
+        return std::string( source.begin(), source.size() );
+    }
+};
+
+
+
+template<>
+struct value_interpreter<cstring, false> {
+    template<typename Modifiers>
+    explicit value_interpreter( Modifiers const& ) {}
+
+    cstring interpret( cstring, cstring source ) const
+    {
+        return source;
+    }
+};
+
+
+
+template<>
+struct value_interpreter<bool, false> {
+    template<typename Modifiers>
+    explicit value_interpreter( Modifiers const& ) {}
+
+    bool interpret( cstring param_name, cstring source ) const
+    {
+        static cstring const s_YES( "YES" );
+        static cstring const s_Y( "Y" );
+        static cstring const s_NO( "NO" );
+        static cstring const s_N( "N" );
+        static cstring const s_TRUE( "TRUE" );
+        static cstring const s_FALSE( "FALSE" );
+        static cstring const s_one( "1" );
+        static cstring const s_zero( "0" );
+
+        source.trim();
+
+        if( source.is_empty() ||
+            case_ins_eq( source, s_YES ) ||
+            case_ins_eq( source, s_Y ) ||
+            case_ins_eq( source, s_one ) ||
+            case_ins_eq( source, s_TRUE ) )
+            return true;
+
+        if( case_ins_eq( source, s_NO ) ||
+            case_ins_eq( source, s_N ) ||
+            case_ins_eq( source, s_zero ) ||
+            case_ins_eq( source, s_FALSE ) )
+            return false;
+
+        unit_test::ut_detail::throw_exception( format_error( param_name ) << source << " can't be interpreted as bool value." );
+    }
+};
+
+
+
+template<typename EnumType>
+struct value_interpreter<EnumType, true> {
+    template<typename Modifiers>
+    explicit value_interpreter( Modifiers const& m )
+
+    : m_name_to_value( m[enum_values<EnumType>::value] )
+    {
+    }
+# 144 "/usr/include/boost/test/utils/runtime/argument_factory.hpp" 3 4
+    EnumType interpret( cstring param_name, cstring source ) const
+    {
+        typename std::map<cstring,EnumType>::const_iterator found = m_name_to_value.find( source );
+
+        if( found != m_name_to_value.end() ) {} else unit_test::ut_detail::throw_exception( format_error( param_name ) << source << " is not a valid enumeration value name for parameter " << param_name << "." )
+
+                                                                                                          ;
+
+        return found->second;
+    }
+
+private:
+
+    std::map<cstring,EnumType> m_name_to_value;
+};
+
+
+
+
+
+
+
+template<typename ValueType, bool is_enum, bool repeatable>
+class argument_factory;
+
+
+
+template<typename ValueType, bool is_enum>
+class argument_factory<ValueType, is_enum, false> {
+public:
+    template<typename Modifiers>
+    explicit argument_factory( Modifiers const& m )
+    : m_interpreter( m )
+    , m_optional_value( nfp::opt_get( m, optional_value, ValueType() ) )
+    , m_default_value( nfp::opt_get( m, default_value, ValueType() ) )
+    {
+    }
+
+    void produce_argument( cstring source, cstring param_name, arguments_store& store ) const
+    {
+        store.set( param_name, source.empty() ? m_optional_value : m_interpreter.interpret( param_name, source ) );
+    }
+
+    void produce_default( cstring param_name, arguments_store& store ) const
+    {
+        store.set( param_name, m_default_value );
+    }
+
+private:
+
+    typedef value_interpreter<ValueType, is_enum> interp_t;
+    interp_t m_interpreter;
+    ValueType m_optional_value;
+    ValueType m_default_value;
+};
+
+
+
+template<typename ValueType, bool is_enum>
+class argument_factory<ValueType, is_enum, true> {
+public:
+    template<typename Modifiers>
+    explicit argument_factory( Modifiers const& m )
+    : m_interpreter( m )
+    {
+    }
+
+    void produce_argument( cstring source, cstring param_name, arguments_store& store ) const
+    {
+        ValueType value = m_interpreter.interpret( param_name, source );
+
+        if( store.has( param_name ) ) {
+            std::vector<ValueType>& values = store.get<std::vector<ValueType> >( param_name );
+            values.push_back( value );
+        }
+        else {
+            std::vector<ValueType> values( 1, value );
+
+            store.set( param_name, values );
+        }
+
+    }
+    void produce_default( cstring param_name, arguments_store& store ) const
+    {
+        store.set( param_name, std::vector<ValueType>() );
+    }
+
+private:
+
+    value_interpreter<ValueType, is_enum> m_interpreter;
+};
+
+
+
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 242 "/usr/include/boost/test/utils/runtime/argument_factory.hpp" 2 3 4
+# 23 "/usr/include/boost/test/utils/runtime/parameter.hpp" 2 3 4
+
+
+
+
+
+
+
+# 1 "/usr/include/boost/function.hpp" 1 3 4
+# 14 "/usr/include/boost/function.hpp" 3 4
+#define BOOST_FUNCTION_MAX_ARGS 10
+# 25 "/usr/include/boost/function.hpp" 3 4
+# 1 "/usr/include/boost/preprocessor/iterate.hpp" 1 3 4
+# 13 "/usr/include/boost/preprocessor/iterate.hpp" 3 4
+#define BOOST_PREPROCESSOR_ITERATE_HPP 
+
+# 1 "/usr/include/boost/preprocessor/iteration/iterate.hpp" 1 3 4
+# 13 "/usr/include/boost/preprocessor/iteration/iterate.hpp" 3 4
+#define BOOST_PREPROCESSOR_ITERATION_ITERATE_HPP 
+
+
+
+
+
+
+# 1 "/usr/include/boost/preprocessor/slot/slot.hpp" 1 3 4
+# 13 "/usr/include/boost/preprocessor/slot/slot.hpp" 3 4
+#define BOOST_PREPROCESSOR_SLOT_SLOT_HPP 
+
+
+# 1 "/usr/include/boost/preprocessor/slot/detail/def.hpp" 1 3 4
+# 13 "/usr/include/boost/preprocessor/slot/detail/def.hpp" 3 4
+#define BOOST_PREPROCESSOR_SLOT_DETAIL_DEF_HPP 
+
+
+
+#define BOOST_PP_SLOT_OFFSET_10(x) (x) % 1000000000UL
+#define BOOST_PP_SLOT_OFFSET_9(x) BOOST_PP_SLOT_OFFSET_10(x) % 100000000UL
+#define BOOST_PP_SLOT_OFFSET_8(x) BOOST_PP_SLOT_OFFSET_9(x) % 10000000UL
+#define BOOST_PP_SLOT_OFFSET_7(x) BOOST_PP_SLOT_OFFSET_8(x) % 1000000UL
+#define BOOST_PP_SLOT_OFFSET_6(x) BOOST_PP_SLOT_OFFSET_7(x) % 100000UL
+#define BOOST_PP_SLOT_OFFSET_5(x) BOOST_PP_SLOT_OFFSET_6(x) % 10000UL
+#define BOOST_PP_SLOT_OFFSET_4(x) BOOST_PP_SLOT_OFFSET_5(x) % 1000UL
+#define BOOST_PP_SLOT_OFFSET_3(x) BOOST_PP_SLOT_OFFSET_4(x) % 100UL
+#define BOOST_PP_SLOT_OFFSET_2(x) BOOST_PP_SLOT_OFFSET_3(x) % 10UL
+
+
+
+#define BOOST_PP_SLOT_CC_2(a,b) BOOST_PP_SLOT_CC_2_D(a, b)
+#define BOOST_PP_SLOT_CC_3(a,b,c) BOOST_PP_SLOT_CC_3_D(a, b, c)
+#define BOOST_PP_SLOT_CC_4(a,b,c,d) BOOST_PP_SLOT_CC_4_D(a, b, c, d)
+#define BOOST_PP_SLOT_CC_5(a,b,c,d,e) BOOST_PP_SLOT_CC_5_D(a, b, c, d, e)
+#define BOOST_PP_SLOT_CC_6(a,b,c,d,e,f) BOOST_PP_SLOT_CC_6_D(a, b, c, d, e, f)
+#define BOOST_PP_SLOT_CC_7(a,b,c,d,e,f,g) BOOST_PP_SLOT_CC_7_D(a, b, c, d, e, f, g)
+#define BOOST_PP_SLOT_CC_8(a,b,c,d,e,f,g,h) BOOST_PP_SLOT_CC_8_D(a, b, c, d, e, f, g, h)
+#define BOOST_PP_SLOT_CC_9(a,b,c,d,e,f,g,h,i) BOOST_PP_SLOT_CC_9_D(a, b, c, d, e, f, g, h, i)
+#define BOOST_PP_SLOT_CC_10(a,b,c,d,e,f,g,h,i,j) BOOST_PP_SLOT_CC_10_D(a, b, c, d, e, f, g, h, i, j)
+
+#define BOOST_PP_SLOT_CC_2_D(a,b) a ## b
+#define BOOST_PP_SLOT_CC_3_D(a,b,c) a ## b ## c
+#define BOOST_PP_SLOT_CC_4_D(a,b,c,d) a ## b ## c ## d
+#define BOOST_PP_SLOT_CC_5_D(a,b,c,d,e) a ## b ## c ## d ## e
+#define BOOST_PP_SLOT_CC_6_D(a,b,c,d,e,f) a ## b ## c ## d ## e ## f
+#define BOOST_PP_SLOT_CC_7_D(a,b,c,d,e,f,g) a ## b ## c ## d ## e ## f ## g
+#define BOOST_PP_SLOT_CC_8_D(a,b,c,d,e,f,g,h) a ## b ## c ## d ## e ## f ## g ## h
+#define BOOST_PP_SLOT_CC_9_D(a,b,c,d,e,f,g,h,i) a ## b ## c ## d ## e ## f ## g ## h ## i
+#define BOOST_PP_SLOT_CC_10_D(a,b,c,d,e,f,g,h,i,j) a ## b ## c ## d ## e ## f ## g ## h ## i ## j
+# 17 "/usr/include/boost/preprocessor/slot/slot.hpp" 2 3 4
+
+
+
+#define BOOST_PP_ASSIGN_SLOT(i) BOOST_PP_CAT(BOOST_PP_ASSIGN_SLOT_, i)
+
+#define BOOST_PP_ASSIGN_SLOT_1 <boost/preprocessor/slot/detail/slot1.hpp>
+#define BOOST_PP_ASSIGN_SLOT_2 <boost/preprocessor/slot/detail/slot2.hpp>
+#define BOOST_PP_ASSIGN_SLOT_3 <boost/preprocessor/slot/detail/slot3.hpp>
+#define BOOST_PP_ASSIGN_SLOT_4 <boost/preprocessor/slot/detail/slot4.hpp>
+#define BOOST_PP_ASSIGN_SLOT_5 <boost/preprocessor/slot/detail/slot5.hpp>
+
+
+
+#define BOOST_PP_SLOT(i) BOOST_PP_CAT(BOOST_PP_SLOT_, i)()
+# 21 "/usr/include/boost/preprocessor/iteration/iterate.hpp" 2 3 4
+
+
+
+
+#define BOOST_PP_ITERATION_DEPTH() 0
+
+
+
+#define BOOST_PP_ITERATION() BOOST_PP_CAT(BOOST_PP_ITERATION_, BOOST_PP_ITERATION_DEPTH())
+
+
+
+#define BOOST_PP_ITERATION_START() BOOST_PP_CAT(BOOST_PP_ITERATION_START_, BOOST_PP_ITERATION_DEPTH())
+#define BOOST_PP_ITERATION_FINISH() BOOST_PP_CAT(BOOST_PP_ITERATION_FINISH_, BOOST_PP_ITERATION_DEPTH())
+
+
+
+#define BOOST_PP_ITERATION_FLAGS() (BOOST_PP_CAT(BOOST_PP_ITERATION_FLAGS_, BOOST_PP_ITERATION_DEPTH())())
+
+
+
+#define BOOST_PP_FRAME_ITERATION(i) BOOST_PP_CAT(BOOST_PP_ITERATION_, i)
+
+
+
+#define BOOST_PP_FRAME_START(i) BOOST_PP_CAT(BOOST_PP_ITERATION_START_, i)
+#define BOOST_PP_FRAME_FINISH(i) BOOST_PP_CAT(BOOST_PP_ITERATION_FINISH_, i)
+
+
+
+#define BOOST_PP_FRAME_FLAGS(i) (BOOST_PP_CAT(BOOST_PP_ITERATION_FLAGS_, i)())
+
+
+
+#define BOOST_PP_RELATIVE_ITERATION(i) BOOST_PP_CAT(BOOST_PP_RELATIVE_, i)(BOOST_PP_ITERATION_)
+
+#define BOOST_PP_RELATIVE_0(m) BOOST_PP_CAT(m, BOOST_PP_ITERATION_DEPTH())
+#define BOOST_PP_RELATIVE_1(m) BOOST_PP_CAT(m, BOOST_PP_DEC(BOOST_PP_ITERATION_DEPTH()))
+#define BOOST_PP_RELATIVE_2(m) BOOST_PP_CAT(m, BOOST_PP_DEC(BOOST_PP_DEC(BOOST_PP_ITERATION_DEPTH())))
+#define BOOST_PP_RELATIVE_3(m) BOOST_PP_CAT(m, BOOST_PP_DEC(BOOST_PP_DEC(BOOST_PP_DEC(BOOST_PP_ITERATION_DEPTH()))))
+#define BOOST_PP_RELATIVE_4(m) BOOST_PP_CAT(m, BOOST_PP_DEC(BOOST_PP_DEC(BOOST_PP_DEC(BOOST_PP_DEC(BOOST_PP_ITERATION_DEPTH())))))
+
+
+
+#define BOOST_PP_RELATIVE_START(i) BOOST_PP_CAT(BOOST_PP_RELATIVE_, i)(BOOST_PP_ITERATION_START_)
+#define BOOST_PP_RELATIVE_FINISH(i) BOOST_PP_CAT(BOOST_PP_RELATIVE_, i)(BOOST_PP_ITERATION_FINISH_)
+
+
+
+#define BOOST_PP_RELATIVE_FLAGS(i) (BOOST_PP_CAT(BOOST_PP_RELATIVE_, i)(BOOST_PP_ITERATION_FLAGS_)())
+
+
+
+#define BOOST_PP_ITERATE() BOOST_PP_CAT(BOOST_PP_ITERATE_, BOOST_PP_INC(BOOST_PP_ITERATION_DEPTH()))
+
+#define BOOST_PP_ITERATE_1 <boost/preprocessor/iteration/detail/iter/forward1.hpp>
+#define BOOST_PP_ITERATE_2 <boost/preprocessor/iteration/detail/iter/forward2.hpp>
+#define BOOST_PP_ITERATE_3 <boost/preprocessor/iteration/detail/iter/forward3.hpp>
+#define BOOST_PP_ITERATE_4 <boost/preprocessor/iteration/detail/iter/forward4.hpp>
+#define BOOST_PP_ITERATE_5 <boost/preprocessor/iteration/detail/iter/forward5.hpp>
+# 16 "/usr/include/boost/preprocessor/iterate.hpp" 2 3 4
+# 26 "/usr/include/boost/function.hpp" 2 3 4
+# 69 "/usr/include/boost/function.hpp" 3 4
+#define BOOST_PP_ITERATION_PARAMS_1 (3,(0,BOOST_FUNCTION_MAX_ARGS,<boost/function/detail/function_iterate.hpp>))
+# 1 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1 3 4
+# 23 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 3 4
+#define BOOST_PP_VALUE BOOST_PP_ARRAY_ELEM(0, BOOST_PP_ITERATION_PARAMS_1)
+# 1 "/usr/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1 3 4
+# 12 "/usr/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 3 4
+# 1 "/usr/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
+# 16 "/usr/include/boost/preprocessor/slot/detail/shared.hpp" 3 4
+#undef BOOST_PP_SLOT_TEMP_1
+#undef BOOST_PP_SLOT_TEMP_2
+#undef BOOST_PP_SLOT_TEMP_3
+#undef BOOST_PP_SLOT_TEMP_4
+#undef BOOST_PP_SLOT_TEMP_5
+#undef BOOST_PP_SLOT_TEMP_6
+#undef BOOST_PP_SLOT_TEMP_7
+#undef BOOST_PP_SLOT_TEMP_8
+#undef BOOST_PP_SLOT_TEMP_9
+#undef BOOST_PP_SLOT_TEMP_10
+
+
+#define BOOST_PP_SLOT_TEMP_10 0
+# 50 "/usr/include/boost/preprocessor/slot/detail/shared.hpp" 3 4
+#define BOOST_PP_SLOT_TEMP_9 0
+# 72 "/usr/include/boost/preprocessor/slot/detail/shared.hpp" 3 4
+#define BOOST_PP_SLOT_TEMP_8 0
+# 94 "/usr/include/boost/preprocessor/slot/detail/shared.hpp" 3 4
+#define BOOST_PP_SLOT_TEMP_7 0
+# 116 "/usr/include/boost/preprocessor/slot/detail/shared.hpp" 3 4
+#define BOOST_PP_SLOT_TEMP_6 0
+# 138 "/usr/include/boost/preprocessor/slot/detail/shared.hpp" 3 4
+#define BOOST_PP_SLOT_TEMP_5 0
+# 160 "/usr/include/boost/preprocessor/slot/detail/shared.hpp" 3 4
+#define BOOST_PP_SLOT_TEMP_4 0
+# 182 "/usr/include/boost/preprocessor/slot/detail/shared.hpp" 3 4
+#define BOOST_PP_SLOT_TEMP_3 0
+# 204 "/usr/include/boost/preprocessor/slot/detail/shared.hpp" 3 4
+#define BOOST_PP_SLOT_TEMP_2 0
+# 226 "/usr/include/boost/preprocessor/slot/detail/shared.hpp" 3 4
+#define BOOST_PP_SLOT_TEMP_1 0
+# 247 "/usr/include/boost/preprocessor/slot/detail/shared.hpp" 3 4
+#undef BOOST_PP_VALUE
+# 13 "/usr/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2 3 4
+
+#undef BOOST_PP_ITERATION_START_1
+
+#undef BOOST_PP_ITERATION_START_1_DIGIT_1
+#undef BOOST_PP_ITERATION_START_1_DIGIT_2
+#undef BOOST_PP_ITERATION_START_1_DIGIT_3
+#undef BOOST_PP_ITERATION_START_1_DIGIT_4
+#undef BOOST_PP_ITERATION_START_1_DIGIT_5
+#undef BOOST_PP_ITERATION_START_1_DIGIT_6
+#undef BOOST_PP_ITERATION_START_1_DIGIT_7
+#undef BOOST_PP_ITERATION_START_1_DIGIT_8
+#undef BOOST_PP_ITERATION_START_1_DIGIT_9
+#undef BOOST_PP_ITERATION_START_1_DIGIT_10
+
+
+#define BOOST_PP_ITERATION_START_1_DIGIT_3 0
+# 50 "/usr/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 3 4
+#define BOOST_PP_ITERATION_START_1_DIGIT_2 0
+# 72 "/usr/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 3 4
+#define BOOST_PP_ITERATION_START_1_DIGIT_1 0
+# 98 "/usr/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 3 4
+#define BOOST_PP_ITERATION_START_1 BOOST_PP_ITERATION_START_1_DIGIT_1
+# 25 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
+#define BOOST_PP_VALUE BOOST_PP_ARRAY_ELEM(1, BOOST_PP_ITERATION_PARAMS_1)
+# 1 "/usr/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1 3 4
+# 12 "/usr/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 3 4
+# 1 "/usr/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
+# 16 "/usr/include/boost/preprocessor/slot/detail/shared.hpp" 3 4
+#undef BOOST_PP_SLOT_TEMP_1
+#undef BOOST_PP_SLOT_TEMP_2
+#undef BOOST_PP_SLOT_TEMP_3
+#undef BOOST_PP_SLOT_TEMP_4
+#undef BOOST_PP_SLOT_TEMP_5
+#undef BOOST_PP_SLOT_TEMP_6
+#undef BOOST_PP_SLOT_TEMP_7
+#undef BOOST_PP_SLOT_TEMP_8
+#undef BOOST_PP_SLOT_TEMP_9
+#undef BOOST_PP_SLOT_TEMP_10
+
+
+#define BOOST_PP_SLOT_TEMP_10 0
+# 50 "/usr/include/boost/preprocessor/slot/detail/shared.hpp" 3 4
+#define BOOST_PP_SLOT_TEMP_9 0
+# 72 "/usr/include/boost/preprocessor/slot/detail/shared.hpp" 3 4
+#define BOOST_PP_SLOT_TEMP_8 0
+# 94 "/usr/include/boost/preprocessor/slot/detail/shared.hpp" 3 4
+#define BOOST_PP_SLOT_TEMP_7 0
+# 116 "/usr/include/boost/preprocessor/slot/detail/shared.hpp" 3 4
+#define BOOST_PP_SLOT_TEMP_6 0
+# 138 "/usr/include/boost/preprocessor/slot/detail/shared.hpp" 3 4
+#define BOOST_PP_SLOT_TEMP_5 0
+# 160 "/usr/include/boost/preprocessor/slot/detail/shared.hpp" 3 4
+#define BOOST_PP_SLOT_TEMP_4 0
+# 182 "/usr/include/boost/preprocessor/slot/detail/shared.hpp" 3 4
+#define BOOST_PP_SLOT_TEMP_3 0
+# 206 "/usr/include/boost/preprocessor/slot/detail/shared.hpp" 3 4
+#define BOOST_PP_SLOT_TEMP_2 1
+# 226 "/usr/include/boost/preprocessor/slot/detail/shared.hpp" 3 4
+#define BOOST_PP_SLOT_TEMP_1 0
+# 247 "/usr/include/boost/preprocessor/slot/detail/shared.hpp" 3 4
+#undef BOOST_PP_VALUE
+# 13 "/usr/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2 3 4
+
+#undef BOOST_PP_ITERATION_FINISH_1
+
+#undef BOOST_PP_ITERATION_FINISH_1_DIGIT_1
+#undef BOOST_PP_ITERATION_FINISH_1_DIGIT_2
+#undef BOOST_PP_ITERATION_FINISH_1_DIGIT_3
+#undef BOOST_PP_ITERATION_FINISH_1_DIGIT_4
+#undef BOOST_PP_ITERATION_FINISH_1_DIGIT_5
+#undef BOOST_PP_ITERATION_FINISH_1_DIGIT_6
+#undef BOOST_PP_ITERATION_FINISH_1_DIGIT_7
+#undef BOOST_PP_ITERATION_FINISH_1_DIGIT_8
+#undef BOOST_PP_ITERATION_FINISH_1_DIGIT_9
+#undef BOOST_PP_ITERATION_FINISH_1_DIGIT_10
+
+
+#define BOOST_PP_ITERATION_FINISH_1_DIGIT_3 0
+# 52 "/usr/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 3 4
+#define BOOST_PP_ITERATION_FINISH_1_DIGIT_2 1
+# 72 "/usr/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 3 4
+#define BOOST_PP_ITERATION_FINISH_1_DIGIT_1 0
+# 96 "/usr/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 3 4
+#define BOOST_PP_ITERATION_FINISH_1 BOOST_PP_SLOT_CC_2(BOOST_PP_ITERATION_FINISH_1_DIGIT_2, BOOST_PP_ITERATION_FINISH_1_DIGIT_1)
+# 27 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
+#define BOOST_PP_FILENAME_1 BOOST_PP_ARRAY_ELEM(2, BOOST_PP_ITERATION_PARAMS_1)
+
+
+
+#define BOOST_PP_ITERATION_FLAGS_1() 0
+
+
+
+
+
+#undef BOOST_PP_ITERATION_DEPTH
+#define BOOST_PP_ITERATION_DEPTH() 1
+
+#define BOOST_PP_IS_ITERATING 1
+
+
+
+
+
+#define BOOST_PP_ITERATION_1 0
+# 1 "/usr/include/boost/function/detail/function_iterate.hpp" 1 3 4
+# 13 "/usr/include/boost/function/detail/function_iterate.hpp" 3 4
+#define BOOST_FUNCTION_NUM_ARGS BOOST_PP_ITERATION()
+# 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
+# 11 "/usr/include/boost/function/detail/maybe_include.hpp" 3 4
+#undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#define BOOST_FUNCTION_MAX_ARGS_DEFINED 0
+# 15 "/usr/include/boost/function/detail/function_iterate.hpp" 2 3 4
+#undef BOOST_FUNCTION_NUM_ARGS
+# 48 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
+#undef BOOST_PP_ITERATION_1
+
+
+#define BOOST_PP_ITERATION_1 1
+# 1 "/usr/include/boost/function/detail/function_iterate.hpp" 1 3 4
+# 13 "/usr/include/boost/function/detail/function_iterate.hpp" 3 4
+#define BOOST_FUNCTION_NUM_ARGS BOOST_PP_ITERATION()
+# 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
+# 18 "/usr/include/boost/function/detail/maybe_include.hpp" 3 4
+#undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#define BOOST_FUNCTION_MAX_ARGS_DEFINED 1
+# 15 "/usr/include/boost/function/detail/function_iterate.hpp" 2 3 4
+#undef BOOST_FUNCTION_NUM_ARGS
+# 53 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
+#undef BOOST_PP_ITERATION_1
+
+
+#define BOOST_PP_ITERATION_1 2
+# 1 "/usr/include/boost/function/detail/function_iterate.hpp" 1 3 4
+# 13 "/usr/include/boost/function/detail/function_iterate.hpp" 3 4
+#define BOOST_FUNCTION_NUM_ARGS BOOST_PP_ITERATION()
+# 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
+# 25 "/usr/include/boost/function/detail/maybe_include.hpp" 3 4
+#undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#define BOOST_FUNCTION_MAX_ARGS_DEFINED 2
+# 15 "/usr/include/boost/function/detail/function_iterate.hpp" 2 3 4
+#undef BOOST_FUNCTION_NUM_ARGS
+# 58 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
+#undef BOOST_PP_ITERATION_1
+
+
+#define BOOST_PP_ITERATION_1 3
+# 1 "/usr/include/boost/function/detail/function_iterate.hpp" 1 3 4
+# 13 "/usr/include/boost/function/detail/function_iterate.hpp" 3 4
+#define BOOST_FUNCTION_NUM_ARGS BOOST_PP_ITERATION()
+# 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
+# 32 "/usr/include/boost/function/detail/maybe_include.hpp" 3 4
+#undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#define BOOST_FUNCTION_MAX_ARGS_DEFINED 3
+
+#define BOOST_FUNCTION_3 
+# 1 "/usr/include/boost/function/function_template.hpp" 1 3 4
+# 21 "/usr/include/boost/function/function_template.hpp" 3 4
+#define BOOST_FUNCTION_TEMPLATE_PARMS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, typename T)
+
+#define BOOST_FUNCTION_TEMPLATE_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, T)
+
+#define BOOST_FUNCTION_PARM(J,I,D) BOOST_PP_CAT(T,I) BOOST_PP_CAT(a,I)
+
+#define BOOST_FUNCTION_PARMS BOOST_PP_ENUM(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_PARM,BOOST_PP_EMPTY)
+
+
+
+
+#define BOOST_FUNCTION_ARG(J,I,D) static_cast<BOOST_PP_CAT(T,I)&&>(BOOST_PP_CAT(a,I))
+#define BOOST_FUNCTION_ARGS BOOST_PP_ENUM(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_ARG,BOOST_PP_EMPTY)
+
+
+#define BOOST_FUNCTION_ARG_TYPE(J,I,D) typedef BOOST_PP_CAT(T,I) BOOST_PP_CAT(BOOST_PP_CAT(arg, BOOST_PP_INC(I)),_type);
+
+
+#define BOOST_FUNCTION_ARG_TYPES BOOST_PP_REPEAT(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_ARG_TYPE,BOOST_PP_EMPTY)
+
+
+
+
+
+#define BOOST_FUNCTION_COMMA ,
+
+
+
+#define BOOST_FUNCTION_FUNCTION BOOST_JOIN(function,BOOST_FUNCTION_NUM_ARGS)
+#define BOOST_FUNCTION_FUNCTION_INVOKER BOOST_JOIN(function_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_VOID_FUNCTION_INVOKER BOOST_JOIN(void_function_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_FUNCTION_OBJ_INVOKER BOOST_JOIN(function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER BOOST_JOIN(void_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_FUNCTION_REF_INVOKER BOOST_JOIN(function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER BOOST_JOIN(void_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_MEMBER_INVOKER BOOST_JOIN(function_mem_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_VOID_MEMBER_INVOKER BOOST_JOIN(function_void_mem_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_GET_FUNCTION_INVOKER BOOST_JOIN(get_function_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER BOOST_JOIN(get_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER BOOST_JOIN(get_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_GET_MEMBER_INVOKER BOOST_JOIN(get_member_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_GET_INVOKER BOOST_JOIN(get_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_VTABLE BOOST_JOIN(basic_vtable,BOOST_FUNCTION_NUM_ARGS)
+
+
+#define BOOST_FUNCTION_VOID_RETURN_TYPE void
+#define BOOST_FUNCTION_RETURN(X) X
+
+
+
+
+
+namespace boost {
+  namespace detail {
+    namespace function {
+      template<
+        typename FunctionPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2
+        >
+      struct function_invoker3
+      {
+        static R invoke(function_buffer& function_ptr ,
+                        T0 a0 , T1 a1 , T2 a2)
+        {
+          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.members.func_ptr);
+          return f( static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2));
+        }
+      };
+
+      template<
+        typename FunctionPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2
+        >
+      struct void_function_invoker3
+      {
+        static void
+        invoke(function_buffer& function_ptr ,
+               T0 a0 , T1 a1 , T2 a2)
+
+        {
+          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.members.func_ptr);
+          f( static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2));
+        }
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2
+      >
+      struct function_obj_invoker3
+      {
+        static R invoke(function_buffer& function_obj_ptr ,
+                        T0 a0 , T1 a1 , T2 a2)
+
+        {
+          FunctionObj* f;
+          if (function_allows_small_object_optimization<FunctionObj>::value)
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.data);
+          else
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
+          return (*f)( static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2));
+        }
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2
+      >
+      struct void_function_obj_invoker3
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr ,
+               T0 a0 , T1 a1 , T2 a2)
+
+        {
+          FunctionObj* f;
+          if (function_allows_small_object_optimization<FunctionObj>::value)
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.data);
+          else
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
+          (*f)( static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2));
+        }
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2
+      >
+      struct function_ref_invoker3
+      {
+        static R invoke(function_buffer& function_obj_ptr ,
+                        T0 a0 , T1 a1 , T2 a2)
+
+        {
+          FunctionObj* f =
+            reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
+          return (*f)( static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2));
+        }
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2
+      >
+      struct void_function_ref_invoker3
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr ,
+               T0 a0 , T1 a1 , T2 a2)
+
+        {
+          FunctionObj* f =
+            reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
+          (*f)( static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2));
+        }
+      };
+
+
+
+      template<
+        typename MemberPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2
+      >
+      struct function_mem_invoker3
+      {
+        static R invoke(function_buffer& function_obj_ptr ,
+                        T0 a0 , T1 a1 , T2 a2)
+
+        {
+          MemberPtr* f =
+            reinterpret_cast<MemberPtr*>(function_obj_ptr.data);
+          return boost::mem_fn(*f)( static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2));
+        }
+      };
+
+      template<
+        typename MemberPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2
+      >
+      struct function_void_mem_invoker3
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr ,
+               T0 a0 , T1 a1 , T2 a2)
+
+        {
+          MemberPtr* f =
+            reinterpret_cast<MemberPtr*>(function_obj_ptr.data);
+          boost::mem_fn(*f)( static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2));
+        }
+      };
+
+
+      template<
+        typename FunctionPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2
+      >
+      struct get_function_invoker3
+      {
+        typedef typename conditional<(is_void<R>::value),
+                            void_function_invoker3<
+                            FunctionPtr,
+                            R ,
+                            T0 , T1 , T2
+                          >,
+                          function_invoker3<
+                            FunctionPtr,
+                            R ,
+                            T0 , T1 , T2
+                          >
+                       >::type type;
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2
+       >
+      struct get_function_obj_invoker3
+      {
+        typedef typename conditional<(is_void<R>::value),
+                            void_function_obj_invoker3<
+                            FunctionObj,
+                            R ,
+                            T0 , T1 , T2
+                          >,
+                          function_obj_invoker3<
+                            FunctionObj,
+                            R ,
+                            T0 , T1 , T2
+                          >
+                       >::type type;
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2
+       >
+      struct get_function_ref_invoker3
+      {
+        typedef typename conditional<(is_void<R>::value),
+                            void_function_ref_invoker3<
+                            FunctionObj,
+                            R ,
+                            T0 , T1 , T2
+                          >,
+                          function_ref_invoker3<
+                            FunctionObj,
+                            R ,
+                            T0 , T1 , T2
+                          >
+                       >::type type;
+      };
+
+
+
+      template<
+        typename MemberPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2
+       >
+      struct get_member_invoker3
+      {
+        typedef typename conditional<(is_void<R>::value),
+                            function_void_mem_invoker3<
+                            MemberPtr,
+                            R ,
+                            T0 , T1 , T2
+                          >,
+                          function_mem_invoker3<
+                            MemberPtr,
+                            R ,
+                            T0 , T1 , T2
+                          >
+                       >::type type;
+      };
+# 331 "/usr/include/boost/function/function_template.hpp" 3 4
+      template<typename Tag>
+      struct get_invoker3 { };
+
+
+      template<>
+      struct get_invoker3<function_ptr_tag>
+      {
+        template<typename FunctionPtr,
+                 typename R , typename T0 , typename T1 , typename T2>
+        struct apply
+        {
+          typedef typename get_function_invoker3<
+                             FunctionPtr,
+                             R ,
+                             T0 , T1 , T2
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<FunctionPtr> manager_type;
+        };
+
+        template<typename FunctionPtr, typename Allocator,
+                 typename R , typename T0 , typename T1 , typename T2>
+        struct apply_a
+        {
+          typedef typename get_function_invoker3<
+                             FunctionPtr,
+                             R ,
+                             T0 , T1 , T2
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<FunctionPtr> manager_type;
+        };
+      };
+
+
+
+      template<>
+      struct get_invoker3<member_ptr_tag>
+      {
+        template<typename MemberPtr,
+                 typename R , typename T0 , typename T1 , typename T2>
+        struct apply
+        {
+          typedef typename get_member_invoker3<
+                             MemberPtr,
+                             R ,
+                             T0 , T1 , T2
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<MemberPtr> manager_type;
+        };
+
+        template<typename MemberPtr, typename Allocator,
+                 typename R , typename T0 , typename T1 , typename T2>
+        struct apply_a
+        {
+          typedef typename get_member_invoker3<
+                             MemberPtr,
+                             R ,
+                             T0 , T1 , T2
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<MemberPtr> manager_type;
+        };
+      };
+
+
+
+      template<>
+      struct get_invoker3<function_obj_tag>
+      {
+        template<typename FunctionObj,
+                 typename R , typename T0 , typename T1 , typename T2>
+        struct apply
+        {
+          typedef typename get_function_obj_invoker3<
+                             FunctionObj,
+                             R ,
+                             T0 , T1 , T2
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<FunctionObj> manager_type;
+        };
+
+        template<typename FunctionObj, typename Allocator,
+                 typename R , typename T0 , typename T1 , typename T2>
+        struct apply_a
+        {
+          typedef typename get_function_obj_invoker3<
+                             FunctionObj,
+                             R ,
+                             T0 , T1 , T2
+                           >::type
+            invoker_type;
+
+          typedef functor_manager_a<FunctionObj, Allocator> manager_type;
+        };
+      };
+
+
+      template<>
+      struct get_invoker3<function_obj_ref_tag>
+      {
+        template<typename RefWrapper,
+                 typename R , typename T0 , typename T1 , typename T2>
+        struct apply
+        {
+          typedef typename get_function_ref_invoker3<
+                             typename RefWrapper::type,
+                             R ,
+                             T0 , T1 , T2
+                           >::type
+            invoker_type;
+
+          typedef reference_manager<typename RefWrapper::type> manager_type;
+        };
+
+        template<typename RefWrapper, typename Allocator,
+                 typename R , typename T0 , typename T1 , typename T2>
+        struct apply_a
+        {
+          typedef typename get_function_ref_invoker3<
+                             typename RefWrapper::type,
+                             R ,
+                             T0 , T1 , T2
+                           >::type
+            invoker_type;
+
+          typedef reference_manager<typename RefWrapper::type> manager_type;
+        };
+      };
+# 476 "/usr/include/boost/function/function_template.hpp" 3 4
+      template<typename R , typename T0 , typename T1 , typename T2>
+      struct basic_vtable3
+      {
+
+        typedef R result_type;
+
+
+
+
+        typedef result_type (*invoker_type)(function_buffer&
+                                            ,
+                                            T0 , T1 , T2);
+
+        template<typename F>
+        bool assign_to(F f, function_buffer& functor) const
+        {
+          typedef typename get_function_tag<F>::type tag;
+          return assign_to(f, functor, tag());
+        }
+        template<typename F,typename Allocator>
+        bool assign_to_a(F f, function_buffer& functor, Allocator a) const
+        {
+          typedef typename get_function_tag<F>::type tag;
+          return assign_to_a(f, functor, a, tag());
+        }
+
+        void clear(function_buffer& functor) const
+        {
+          if (base.manager)
+            base.manager(functor, functor, destroy_functor_tag);
+        }
+
+      private:
+
+        template<typename FunctionPtr>
+        bool
+        assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag) const
+        {
+          this->clear(functor);
+          if (f) {
+
+
+            functor.members.func_ptr = reinterpret_cast<void (*)()>(f);
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionPtr,typename Allocator>
+        bool
+        assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const
+        {
+          return assign_to(f,functor,function_ptr_tag());
+        }
+
+
+
+        template<typename MemberPtr>
+        bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag) const
+        {
+
+
+
+          if (f) {
+            this->assign_to(boost::mem_fn(f), functor);
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename MemberPtr,typename Allocator>
+        bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag) const
+        {
+
+
+
+          if (f) {
+            this->assign_to_a(boost::mem_fn(f), functor, a);
+            return true;
+          } else {
+            return false;
+          }
+        }
+
+
+
+
+        template<typename FunctionObj>
+        void
+        assign_functor(FunctionObj f, function_buffer& functor, true_type) const
+        {
+          new (reinterpret_cast<void*>(functor.data)) FunctionObj(f);
+        }
+        template<typename FunctionObj,typename Allocator>
+        void
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, true_type) const
+        {
+          assign_functor(f,functor,true_type());
+        }
+
+
+        template<typename FunctionObj>
+        void
+        assign_functor(FunctionObj f, function_buffer& functor, false_type) const
+        {
+          functor.members.obj_ptr = new FunctionObj(f);
+        }
+        template<typename FunctionObj,typename Allocator>
+        void
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, false_type) const
+        {
+          typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;
+
+
+
+
+
+          using wrapper_allocator_type = typename std::allocator_traits<Allocator>::template rebind_alloc<functor_wrapper_type>;
+          using wrapper_allocator_pointer_type = typename std::allocator_traits<wrapper_allocator_type>::pointer;
+
+          wrapper_allocator_type wrapper_allocator(a);
+          wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
+
+
+
+          std::allocator_traits<wrapper_allocator_type>::construct(wrapper_allocator, copy, functor_wrapper_type(f,a));
+
+          functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
+          functor.members.obj_ptr = new_f;
+        }
+
+        template<typename FunctionObj>
+        bool
+        assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) const
+        {
+          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
+            assign_functor(f, functor,
+                           integral_constant<bool, (function_allows_small_object_optimization<FunctionObj>::value)>());
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionObj,typename Allocator>
+        bool
+        assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag) const
+        {
+          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
+            assign_functor_a(f, functor, a,
+                           integral_constant<bool, (function_allows_small_object_optimization<FunctionObj>::value)>());
+            return true;
+          } else {
+            return false;
+          }
+        }
+
+
+        template<typename FunctionObj>
+        bool
+        assign_to(const reference_wrapper<FunctionObj>& f,
+                  function_buffer& functor, function_obj_ref_tag) const
+        {
+          functor.members.obj_ref.obj_ptr = (void *)(f.get_pointer());
+          functor.members.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
+          functor.members.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
+          return true;
+        }
+        template<typename FunctionObj,typename Allocator>
+        bool
+        assign_to_a(const reference_wrapper<FunctionObj>& f,
+                  function_buffer& functor, Allocator, function_obj_ref_tag) const
+        {
+          return assign_to(f,functor,function_obj_ref_tag());
+        }
+
+      public:
+        vtable_base base;
+        invoker_type invoker;
+      };
+    }
+  }
+
+  template<
+    typename R ,
+    typename T0 , typename T1 , typename T2
+  >
+  class function3 : public function_base
+  {
+  public:
+
+    typedef R result_type;
+
+
+
+
+
+  private:
+    typedef boost::detail::function::basic_vtable3<
+              R , T0 , T1 , T2>
+      vtable_type;
+
+    vtable_type* get_vtable() const {
+      return reinterpret_cast<vtable_type*>(
+               reinterpret_cast<std::size_t>(vtable) & ~static_cast<std::size_t>(0x01));
+    }
+
+    struct clear_type {};
+
+  public:
+    static const int args = 3;
+
+
+    template<typename Args>
+    struct sig
+    {
+      typedef result_type type;
+    };
+# 701 "/usr/include/boost/function/function_template.hpp" 3 4
+    static const int arity = 3;
+    typedef T0 arg1_type; typedef T1 arg2_type; typedef T2 arg3_type;
+
+    typedef function3 self_type;
+
+    function3() = default;
+
+
+
+    template<typename Functor>
+    function3(Functor f
+
+                            ,typename boost::enable_if_<
+                             !(is_integral<Functor>::value),
+                                        int>::type = 0
+
+                            ) :
+      function_base()
+    {
+      this->assign_to(f);
+    }
+    template<typename Functor,typename Allocator>
+    function3(Functor f, Allocator a
+
+                            ,typename boost::enable_if_<
+                              !(is_integral<Functor>::value),
+                                        int>::type = 0
+
+                            ) :
+      function_base()
+    {
+      this->assign_to_a(f,a);
+    }
+
+
+    function3(clear_type*) : function_base() { }
+
+
+
+
+
+
+
+    function3(const function3& f) : function_base()
+    {
+      this->assign_to_own(f);
+    }
+
+
+    function3(function3&& f) : function_base()
+    {
+      this->move_assign(f);
+    }
+
+
+    ~function3() { clear(); }
+
+    result_type operator()( T0 a0 , T1 a1 , T2 a2) const
+    {
+      if (this->empty())
+        boost::throw_exception(bad_function_call());
+
+      return get_vtable()->invoker
+               (this->functor , static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2));
+    }
+
+
+
+
+
+
+    template<typename Functor>
+
+    typename boost::enable_if_<
+                  !(is_integral<Functor>::value),
+               function3&>::type
+
+
+
+    operator=(Functor f)
+    {
+      this->clear();
+      { try {
+        this->assign_to(f);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+      return *this;
+    }
+    template<typename Functor,typename Allocator>
+    void assign(Functor f, Allocator a)
+    {
+      this->clear();
+      { try{
+        this->assign_to_a(f,a);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+    }
+
+
+    function3& operator=(clear_type*)
+    {
+      this->clear();
+      return *this;
+    }
+# 821 "/usr/include/boost/function/function_template.hpp" 3 4
+    function3& operator=(const function3& f)
+    {
+      if (&f == this)
+        return *this;
+
+      this->clear();
+      { try {
+        this->assign_to_own(f);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+      return *this;
+    }
+
+
+
+    function3& operator=(function3&& f)
+    {
+      if (&f == this)
+        return *this;
+
+      this->clear();
+      { try {
+        this->move_assign(f);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+      return *this;
+    }
+
+
+    void swap(function3& other)
+    {
+      if (&other == this)
+        return;
+
+      function3 tmp;
+      tmp.move_assign(*this);
+      this->move_assign(other);
+      other.move_assign(tmp);
+    }
+
+
+    void clear()
+    {
+      if (vtable) {
+        if (!this->has_trivial_copy_and_destroy())
+          get_vtable()->clear(this->functor);
+        vtable = 0;
+      }
+    }
+
+
+
+
+
+  private:
+    struct dummy {
+      void nonnull() {}
+    };
+
+    typedef void (dummy::*safe_bool)();
+
+  public:
+    operator safe_bool () const
+      { return (this->empty())? 0 : &dummy::nonnull; }
+
+    bool operator!() const
+      { return this->empty(); }
+
+
+  private:
+    void assign_to_own(const function3& f)
+    {
+      if (!f.empty()) {
+        this->vtable = f.vtable;
+        if (this->has_trivial_copy_and_destroy())
+
+
+          std::memcpy(this->functor.data, f.functor.data, sizeof(boost::detail::function::function_buffer));
+        else
+          get_vtable()->base.manager(f.functor, this->functor,
+                                     boost::detail::function::clone_functor_tag);
+      }
+    }
+
+    template<typename Functor>
+    void assign_to(Functor f)
+    {
+      using boost::detail::function::vtable_base;
+
+      typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
+      typedef boost::detail::function::get_invoker3<tag> get_invoker;
+      typedef typename get_invoker::
+                         template apply<Functor, R ,
+                        T0 , T1 , T2>
+        handler_type;
+
+      typedef typename handler_type::invoker_type invoker_type;
+      typedef typename handler_type::manager_type manager_type;
+
+
+
+
+
+      static const vtable_type stored_vtable =
+        { { &manager_type::manage }, &invoker_type::invoke };
+
+      if (stored_vtable.assign_to(f, functor)) {
+        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
+
+        if (boost::has_trivial_copy_constructor<Functor>::value &&
+            boost::has_trivial_destructor<Functor>::value &&
+            boost::detail::function::function_allows_small_object_optimization<Functor>::value)
+          value |= static_cast<std::size_t>(0x01);
+        vtable = reinterpret_cast<boost::detail::function::vtable_base *>(value);
+      } else
+        vtable = 0;
+    }
+
+    template<typename Functor,typename Allocator>
+    void assign_to_a(Functor f,Allocator a)
+    {
+      using boost::detail::function::vtable_base;
+
+      typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
+      typedef boost::detail::function::get_invoker3<tag> get_invoker;
+      typedef typename get_invoker::
+                         template apply_a<Functor, Allocator, R ,
+                         T0 , T1 , T2>
+        handler_type;
+
+      typedef typename handler_type::invoker_type invoker_type;
+      typedef typename handler_type::manager_type manager_type;
+
+
+
+
+
+      static const vtable_type stored_vtable =
+        { { &manager_type::manage }, &invoker_type::invoke };
+
+      if (stored_vtable.assign_to_a(f, functor, a)) {
+        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
+
+        if (boost::has_trivial_copy_constructor<Functor>::value &&
+            boost::has_trivial_destructor<Functor>::value &&
+            boost::detail::function::function_allows_small_object_optimization<Functor>::value)
+          value |= static_cast<std::size_t>(0x01);
+        vtable = reinterpret_cast<boost::detail::function::vtable_base *>(value);
+      } else
+        vtable = 0;
+    }
+
+
+
+
+    void move_assign(function3& f)
+    {
+      if (&f == this)
+        return;
+
+      { try {
+        if (!f.empty()) {
+          this->vtable = f.vtable;
+          if (this->has_trivial_copy_and_destroy())
+
+
+            std::memcpy(this->functor.data, f.functor.data, sizeof(this->functor.data));
+          else
+            get_vtable()->base.manager(f.functor, this->functor,
+                                     boost::detail::function::move_functor_tag);
+          f.vtable = 0;
+        } else {
+          clear();
+        }
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+    }
+  };
+
+  template<typename R , typename T0 , typename T1 , typename T2>
+  inline void swap(function3<
+                     R ,
+                     T0 , T1 , T2
+                   >& f1,
+                   function3<
+                     R ,
+                     T0 , T1 , T2
+                   >& f2)
+  {
+    f1.swap(f2);
+  }
+
+
+template<typename R , typename T0 , typename T1 , typename T2>
+  void operator==(const function3<
+                          R ,
+                          T0 , T1 , T2>&,
+                  const function3<
+                          R ,
+                          T0 , T1 , T2>&);
+template<typename R , typename T0 , typename T1 , typename T2>
+  void operator!=(const function3<
+                          R ,
+                          T0 , T1 , T2>&,
+                  const function3<
+                          R ,
+                          T0 , T1 , T2>& );
+
+
+
+
+
+
+#define BOOST_FUNCTION_PARTIAL_SPEC R (BOOST_FUNCTION_TEMPLATE_ARGS)
+
+
+template<typename R ,
+         typename T0 , typename T1 , typename T2>
+class function<R ( T0 , T1 , T2)>
+  : public function3<R , T0 , T1 , T2>
+{
+  typedef function3<R , T0 , T1 , T2> base_type;
+  typedef function self_type;
+
+  struct clear_type {};
+
+public:
+
+  function() = default;
+
+  template<typename Functor>
+  function(Functor f
+
+           ,typename boost::enable_if_<
+                          !(is_integral<Functor>::value),
+                       int>::type = 0
+
+           ) :
+    base_type(f)
+  {
+  }
+  template<typename Functor,typename Allocator>
+  function(Functor f, Allocator a
+
+           ,typename boost::enable_if_<
+                           !(is_integral<Functor>::value),
+                       int>::type = 0
+
+           ) :
+    base_type(f,a)
+  {
+  }
+
+
+  function(clear_type*) : base_type() {}
+
+
+  function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}
+
+  function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}
+
+
+
+  function(self_type&& f): base_type(static_cast<base_type&&>(f)){}
+  function(base_type&& f): base_type(static_cast<base_type&&>(f)){}
+
+
+  self_type& operator=(const self_type& f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+
+
+  self_type& operator=(self_type&& f)
+  {
+    self_type(static_cast<self_type&&>(f)).swap(*this);
+    return *this;
+  }
+
+
+  template<typename Functor>
+
+  typename boost::enable_if_<
+                         !(is_integral<Functor>::value),
+                      self_type&>::type
+
+
+
+  operator=(Functor f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+
+
+  self_type& operator=(clear_type*)
+  {
+    this->clear();
+    return *this;
+  }
+
+
+  self_type& operator=(const base_type& f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+
+
+  self_type& operator=(base_type&& f)
+  {
+    self_type(static_cast<base_type&&>(f)).swap(*this);
+    return *this;
+  }
+
+};
+
+#undef BOOST_FUNCTION_PARTIAL_SPEC
+
+
+}
+
+
+#undef BOOST_FUNCTION_VTABLE
+#undef BOOST_FUNCTION_COMMA
+#undef BOOST_FUNCTION_FUNCTION
+#undef BOOST_FUNCTION_FUNCTION_INVOKER
+#undef BOOST_FUNCTION_VOID_FUNCTION_INVOKER
+#undef BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
+#undef BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
+#undef BOOST_FUNCTION_FUNCTION_REF_INVOKER
+#undef BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER
+#undef BOOST_FUNCTION_MEMBER_INVOKER
+#undef BOOST_FUNCTION_VOID_MEMBER_INVOKER
+#undef BOOST_FUNCTION_GET_FUNCTION_INVOKER
+#undef BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
+#undef BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER
+#undef BOOST_FUNCTION_GET_MEM_FUNCTION_INVOKER
+#undef BOOST_FUNCTION_GET_INVOKER
+#undef BOOST_FUNCTION_TEMPLATE_PARMS
+#undef BOOST_FUNCTION_TEMPLATE_ARGS
+#undef BOOST_FUNCTION_PARMS
+#undef BOOST_FUNCTION_PARM
+
+#undef BOOST_FUNCTION_ARG
+
+#undef BOOST_FUNCTION_ARGS
+#undef BOOST_FUNCTION_ARG_TYPE
+#undef BOOST_FUNCTION_ARG_TYPES
+#undef BOOST_FUNCTION_VOID_RETURN_TYPE
+#undef BOOST_FUNCTION_RETURN
+# 37 "/usr/include/boost/function/detail/maybe_include.hpp" 2 3 4
+# 15 "/usr/include/boost/function/detail/function_iterate.hpp" 2 3 4
+#undef BOOST_FUNCTION_NUM_ARGS
+# 63 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
+#undef BOOST_PP_ITERATION_1
+
+
+#define BOOST_PP_ITERATION_1 4
+# 1 "/usr/include/boost/function/detail/function_iterate.hpp" 1 3 4
+# 13 "/usr/include/boost/function/detail/function_iterate.hpp" 3 4
+#define BOOST_FUNCTION_NUM_ARGS BOOST_PP_ITERATION()
+# 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
+# 39 "/usr/include/boost/function/detail/maybe_include.hpp" 3 4
+#undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#define BOOST_FUNCTION_MAX_ARGS_DEFINED 4
+
+#define BOOST_FUNCTION_4 
+# 1 "/usr/include/boost/function/function_template.hpp" 1 3 4
+# 21 "/usr/include/boost/function/function_template.hpp" 3 4
+#define BOOST_FUNCTION_TEMPLATE_PARMS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, typename T)
+
+#define BOOST_FUNCTION_TEMPLATE_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, T)
+
+#define BOOST_FUNCTION_PARM(J,I,D) BOOST_PP_CAT(T,I) BOOST_PP_CAT(a,I)
+
+#define BOOST_FUNCTION_PARMS BOOST_PP_ENUM(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_PARM,BOOST_PP_EMPTY)
+
+
+
+
+#define BOOST_FUNCTION_ARG(J,I,D) static_cast<BOOST_PP_CAT(T,I)&&>(BOOST_PP_CAT(a,I))
+#define BOOST_FUNCTION_ARGS BOOST_PP_ENUM(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_ARG,BOOST_PP_EMPTY)
+
+
+#define BOOST_FUNCTION_ARG_TYPE(J,I,D) typedef BOOST_PP_CAT(T,I) BOOST_PP_CAT(BOOST_PP_CAT(arg, BOOST_PP_INC(I)),_type);
+
+
+#define BOOST_FUNCTION_ARG_TYPES BOOST_PP_REPEAT(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_ARG_TYPE,BOOST_PP_EMPTY)
+
+
+
+
+
+#define BOOST_FUNCTION_COMMA ,
+
+
+
+#define BOOST_FUNCTION_FUNCTION BOOST_JOIN(function,BOOST_FUNCTION_NUM_ARGS)
+#define BOOST_FUNCTION_FUNCTION_INVOKER BOOST_JOIN(function_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_VOID_FUNCTION_INVOKER BOOST_JOIN(void_function_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_FUNCTION_OBJ_INVOKER BOOST_JOIN(function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER BOOST_JOIN(void_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_FUNCTION_REF_INVOKER BOOST_JOIN(function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER BOOST_JOIN(void_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_MEMBER_INVOKER BOOST_JOIN(function_mem_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_VOID_MEMBER_INVOKER BOOST_JOIN(function_void_mem_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_GET_FUNCTION_INVOKER BOOST_JOIN(get_function_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER BOOST_JOIN(get_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER BOOST_JOIN(get_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_GET_MEMBER_INVOKER BOOST_JOIN(get_member_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_GET_INVOKER BOOST_JOIN(get_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_VTABLE BOOST_JOIN(basic_vtable,BOOST_FUNCTION_NUM_ARGS)
+
+
+#define BOOST_FUNCTION_VOID_RETURN_TYPE void
+#define BOOST_FUNCTION_RETURN(X) X
+
+
+
+
+
+namespace boost {
+  namespace detail {
+    namespace function {
+      template<
+        typename FunctionPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3
+        >
+      struct function_invoker4
+      {
+        static R invoke(function_buffer& function_ptr ,
+                        T0 a0 , T1 a1 , T2 a2 , T3 a3)
+        {
+          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.members.func_ptr);
+          return f( static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2) , static_cast<T3&&>(a3));
+        }
+      };
+
+      template<
+        typename FunctionPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3
+        >
+      struct void_function_invoker4
+      {
+        static void
+        invoke(function_buffer& function_ptr ,
+               T0 a0 , T1 a1 , T2 a2 , T3 a3)
+
+        {
+          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.members.func_ptr);
+          f( static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2) , static_cast<T3&&>(a3));
+        }
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3
+      >
+      struct function_obj_invoker4
+      {
+        static R invoke(function_buffer& function_obj_ptr ,
+                        T0 a0 , T1 a1 , T2 a2 , T3 a3)
+
+        {
+          FunctionObj* f;
+          if (function_allows_small_object_optimization<FunctionObj>::value)
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.data);
+          else
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
+          return (*f)( static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2) , static_cast<T3&&>(a3));
+        }
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3
+      >
+      struct void_function_obj_invoker4
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr ,
+               T0 a0 , T1 a1 , T2 a2 , T3 a3)
+
+        {
+          FunctionObj* f;
+          if (function_allows_small_object_optimization<FunctionObj>::value)
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.data);
+          else
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
+          (*f)( static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2) , static_cast<T3&&>(a3));
+        }
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3
+      >
+      struct function_ref_invoker4
+      {
+        static R invoke(function_buffer& function_obj_ptr ,
+                        T0 a0 , T1 a1 , T2 a2 , T3 a3)
+
+        {
+          FunctionObj* f =
+            reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
+          return (*f)( static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2) , static_cast<T3&&>(a3));
+        }
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3
+      >
+      struct void_function_ref_invoker4
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr ,
+               T0 a0 , T1 a1 , T2 a2 , T3 a3)
+
+        {
+          FunctionObj* f =
+            reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
+          (*f)( static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2) , static_cast<T3&&>(a3));
+        }
+      };
+
+
+
+      template<
+        typename MemberPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3
+      >
+      struct function_mem_invoker4
+      {
+        static R invoke(function_buffer& function_obj_ptr ,
+                        T0 a0 , T1 a1 , T2 a2 , T3 a3)
+
+        {
+          MemberPtr* f =
+            reinterpret_cast<MemberPtr*>(function_obj_ptr.data);
+          return boost::mem_fn(*f)( static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2) , static_cast<T3&&>(a3));
+        }
+      };
+
+      template<
+        typename MemberPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3
+      >
+      struct function_void_mem_invoker4
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr ,
+               T0 a0 , T1 a1 , T2 a2 , T3 a3)
+
+        {
+          MemberPtr* f =
+            reinterpret_cast<MemberPtr*>(function_obj_ptr.data);
+          boost::mem_fn(*f)( static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2) , static_cast<T3&&>(a3));
+        }
+      };
+
+
+      template<
+        typename FunctionPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3
+      >
+      struct get_function_invoker4
+      {
+        typedef typename conditional<(is_void<R>::value),
+                            void_function_invoker4<
+                            FunctionPtr,
+                            R ,
+                            T0 , T1 , T2 , T3
+                          >,
+                          function_invoker4<
+                            FunctionPtr,
+                            R ,
+                            T0 , T1 , T2 , T3
+                          >
+                       >::type type;
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3
+       >
+      struct get_function_obj_invoker4
+      {
+        typedef typename conditional<(is_void<R>::value),
+                            void_function_obj_invoker4<
+                            FunctionObj,
+                            R ,
+                            T0 , T1 , T2 , T3
+                          >,
+                          function_obj_invoker4<
+                            FunctionObj,
+                            R ,
+                            T0 , T1 , T2 , T3
+                          >
+                       >::type type;
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3
+       >
+      struct get_function_ref_invoker4
+      {
+        typedef typename conditional<(is_void<R>::value),
+                            void_function_ref_invoker4<
+                            FunctionObj,
+                            R ,
+                            T0 , T1 , T2 , T3
+                          >,
+                          function_ref_invoker4<
+                            FunctionObj,
+                            R ,
+                            T0 , T1 , T2 , T3
+                          >
+                       >::type type;
+      };
+
+
+
+      template<
+        typename MemberPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3
+       >
+      struct get_member_invoker4
+      {
+        typedef typename conditional<(is_void<R>::value),
+                            function_void_mem_invoker4<
+                            MemberPtr,
+                            R ,
+                            T0 , T1 , T2 , T3
+                          >,
+                          function_mem_invoker4<
+                            MemberPtr,
+                            R ,
+                            T0 , T1 , T2 , T3
+                          >
+                       >::type type;
+      };
+# 331 "/usr/include/boost/function/function_template.hpp" 3 4
+      template<typename Tag>
+      struct get_invoker4 { };
+
+
+      template<>
+      struct get_invoker4<function_ptr_tag>
+      {
+        template<typename FunctionPtr,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3>
+        struct apply
+        {
+          typedef typename get_function_invoker4<
+                             FunctionPtr,
+                             R ,
+                             T0 , T1 , T2 , T3
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<FunctionPtr> manager_type;
+        };
+
+        template<typename FunctionPtr, typename Allocator,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3>
+        struct apply_a
+        {
+          typedef typename get_function_invoker4<
+                             FunctionPtr,
+                             R ,
+                             T0 , T1 , T2 , T3
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<FunctionPtr> manager_type;
+        };
+      };
+
+
+
+      template<>
+      struct get_invoker4<member_ptr_tag>
+      {
+        template<typename MemberPtr,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3>
+        struct apply
+        {
+          typedef typename get_member_invoker4<
+                             MemberPtr,
+                             R ,
+                             T0 , T1 , T2 , T3
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<MemberPtr> manager_type;
+        };
+
+        template<typename MemberPtr, typename Allocator,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3>
+        struct apply_a
+        {
+          typedef typename get_member_invoker4<
+                             MemberPtr,
+                             R ,
+                             T0 , T1 , T2 , T3
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<MemberPtr> manager_type;
+        };
+      };
+
+
+
+      template<>
+      struct get_invoker4<function_obj_tag>
+      {
+        template<typename FunctionObj,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3>
+        struct apply
+        {
+          typedef typename get_function_obj_invoker4<
+                             FunctionObj,
+                             R ,
+                             T0 , T1 , T2 , T3
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<FunctionObj> manager_type;
+        };
+
+        template<typename FunctionObj, typename Allocator,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3>
+        struct apply_a
+        {
+          typedef typename get_function_obj_invoker4<
+                             FunctionObj,
+                             R ,
+                             T0 , T1 , T2 , T3
+                           >::type
+            invoker_type;
+
+          typedef functor_manager_a<FunctionObj, Allocator> manager_type;
+        };
+      };
+
+
+      template<>
+      struct get_invoker4<function_obj_ref_tag>
+      {
+        template<typename RefWrapper,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3>
+        struct apply
+        {
+          typedef typename get_function_ref_invoker4<
+                             typename RefWrapper::type,
+                             R ,
+                             T0 , T1 , T2 , T3
+                           >::type
+            invoker_type;
+
+          typedef reference_manager<typename RefWrapper::type> manager_type;
+        };
+
+        template<typename RefWrapper, typename Allocator,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3>
+        struct apply_a
+        {
+          typedef typename get_function_ref_invoker4<
+                             typename RefWrapper::type,
+                             R ,
+                             T0 , T1 , T2 , T3
+                           >::type
+            invoker_type;
+
+          typedef reference_manager<typename RefWrapper::type> manager_type;
+        };
+      };
+# 476 "/usr/include/boost/function/function_template.hpp" 3 4
+      template<typename R , typename T0 , typename T1 , typename T2 , typename T3>
+      struct basic_vtable4
+      {
+
+        typedef R result_type;
+
+
+
+
+        typedef result_type (*invoker_type)(function_buffer&
+                                            ,
+                                            T0 , T1 , T2 , T3);
+
+        template<typename F>
+        bool assign_to(F f, function_buffer& functor) const
+        {
+          typedef typename get_function_tag<F>::type tag;
+          return assign_to(f, functor, tag());
+        }
+        template<typename F,typename Allocator>
+        bool assign_to_a(F f, function_buffer& functor, Allocator a) const
+        {
+          typedef typename get_function_tag<F>::type tag;
+          return assign_to_a(f, functor, a, tag());
+        }
+
+        void clear(function_buffer& functor) const
+        {
+          if (base.manager)
+            base.manager(functor, functor, destroy_functor_tag);
+        }
+
+      private:
+
+        template<typename FunctionPtr>
+        bool
+        assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag) const
+        {
+          this->clear(functor);
+          if (f) {
+
+
+            functor.members.func_ptr = reinterpret_cast<void (*)()>(f);
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionPtr,typename Allocator>
+        bool
+        assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const
+        {
+          return assign_to(f,functor,function_ptr_tag());
+        }
+
+
+
+        template<typename MemberPtr>
+        bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag) const
+        {
+
+
+
+          if (f) {
+            this->assign_to(boost::mem_fn(f), functor);
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename MemberPtr,typename Allocator>
+        bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag) const
+        {
+
+
+
+          if (f) {
+            this->assign_to_a(boost::mem_fn(f), functor, a);
+            return true;
+          } else {
+            return false;
+          }
+        }
+
+
+
+
+        template<typename FunctionObj>
+        void
+        assign_functor(FunctionObj f, function_buffer& functor, true_type) const
+        {
+          new (reinterpret_cast<void*>(functor.data)) FunctionObj(f);
+        }
+        template<typename FunctionObj,typename Allocator>
+        void
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, true_type) const
+        {
+          assign_functor(f,functor,true_type());
+        }
+
+
+        template<typename FunctionObj>
+        void
+        assign_functor(FunctionObj f, function_buffer& functor, false_type) const
+        {
+          functor.members.obj_ptr = new FunctionObj(f);
+        }
+        template<typename FunctionObj,typename Allocator>
+        void
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, false_type) const
+        {
+          typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;
+
+
+
+
+
+          using wrapper_allocator_type = typename std::allocator_traits<Allocator>::template rebind_alloc<functor_wrapper_type>;
+          using wrapper_allocator_pointer_type = typename std::allocator_traits<wrapper_allocator_type>::pointer;
+
+          wrapper_allocator_type wrapper_allocator(a);
+          wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
+
+
+
+          std::allocator_traits<wrapper_allocator_type>::construct(wrapper_allocator, copy, functor_wrapper_type(f,a));
+
+          functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
+          functor.members.obj_ptr = new_f;
+        }
+
+        template<typename FunctionObj>
+        bool
+        assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) const
+        {
+          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
+            assign_functor(f, functor,
+                           integral_constant<bool, (function_allows_small_object_optimization<FunctionObj>::value)>());
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionObj,typename Allocator>
+        bool
+        assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag) const
+        {
+          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
+            assign_functor_a(f, functor, a,
+                           integral_constant<bool, (function_allows_small_object_optimization<FunctionObj>::value)>());
+            return true;
+          } else {
+            return false;
+          }
+        }
+
+
+        template<typename FunctionObj>
+        bool
+        assign_to(const reference_wrapper<FunctionObj>& f,
+                  function_buffer& functor, function_obj_ref_tag) const
+        {
+          functor.members.obj_ref.obj_ptr = (void *)(f.get_pointer());
+          functor.members.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
+          functor.members.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
+          return true;
+        }
+        template<typename FunctionObj,typename Allocator>
+        bool
+        assign_to_a(const reference_wrapper<FunctionObj>& f,
+                  function_buffer& functor, Allocator, function_obj_ref_tag) const
+        {
+          return assign_to(f,functor,function_obj_ref_tag());
+        }
+
+      public:
+        vtable_base base;
+        invoker_type invoker;
+      };
+    }
+  }
+
+  template<
+    typename R ,
+    typename T0 , typename T1 , typename T2 , typename T3
+  >
+  class function4 : public function_base
+  {
+  public:
+
+    typedef R result_type;
+
+
+
+
+
+  private:
+    typedef boost::detail::function::basic_vtable4<
+              R , T0 , T1 , T2 , T3>
+      vtable_type;
+
+    vtable_type* get_vtable() const {
+      return reinterpret_cast<vtable_type*>(
+               reinterpret_cast<std::size_t>(vtable) & ~static_cast<std::size_t>(0x01));
+    }
+
+    struct clear_type {};
+
+  public:
+    static const int args = 4;
+
+
+    template<typename Args>
+    struct sig
+    {
+      typedef result_type type;
+    };
+# 701 "/usr/include/boost/function/function_template.hpp" 3 4
+    static const int arity = 4;
+    typedef T0 arg1_type; typedef T1 arg2_type; typedef T2 arg3_type; typedef T3 arg4_type;
+
+    typedef function4 self_type;
+
+    function4() = default;
+
+
+
+    template<typename Functor>
+    function4(Functor f
+
+                            ,typename boost::enable_if_<
+                             !(is_integral<Functor>::value),
+                                        int>::type = 0
+
+                            ) :
+      function_base()
+    {
+      this->assign_to(f);
+    }
+    template<typename Functor,typename Allocator>
+    function4(Functor f, Allocator a
+
+                            ,typename boost::enable_if_<
+                              !(is_integral<Functor>::value),
+                                        int>::type = 0
+
+                            ) :
+      function_base()
+    {
+      this->assign_to_a(f,a);
+    }
+
+
+    function4(clear_type*) : function_base() { }
+
+
+
+
+
+
+
+    function4(const function4& f) : function_base()
+    {
+      this->assign_to_own(f);
+    }
+
+
+    function4(function4&& f) : function_base()
+    {
+      this->move_assign(f);
+    }
+
+
+    ~function4() { clear(); }
+
+    result_type operator()( T0 a0 , T1 a1 , T2 a2 , T3 a3) const
+    {
+      if (this->empty())
+        boost::throw_exception(bad_function_call());
+
+      return get_vtable()->invoker
+               (this->functor , static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2) , static_cast<T3&&>(a3));
+    }
+
+
+
+
+
+
+    template<typename Functor>
+
+    typename boost::enable_if_<
+                  !(is_integral<Functor>::value),
+               function4&>::type
+
+
+
+    operator=(Functor f)
+    {
+      this->clear();
+      { try {
+        this->assign_to(f);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+      return *this;
+    }
+    template<typename Functor,typename Allocator>
+    void assign(Functor f, Allocator a)
+    {
+      this->clear();
+      { try{
+        this->assign_to_a(f,a);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+    }
+
+
+    function4& operator=(clear_type*)
+    {
+      this->clear();
+      return *this;
+    }
+# 821 "/usr/include/boost/function/function_template.hpp" 3 4
+    function4& operator=(const function4& f)
+    {
+      if (&f == this)
+        return *this;
+
+      this->clear();
+      { try {
+        this->assign_to_own(f);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+      return *this;
+    }
+
+
+
+    function4& operator=(function4&& f)
+    {
+      if (&f == this)
+        return *this;
+
+      this->clear();
+      { try {
+        this->move_assign(f);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+      return *this;
+    }
+
+
+    void swap(function4& other)
+    {
+      if (&other == this)
+        return;
+
+      function4 tmp;
+      tmp.move_assign(*this);
+      this->move_assign(other);
+      other.move_assign(tmp);
+    }
+
+
+    void clear()
+    {
+      if (vtable) {
+        if (!this->has_trivial_copy_and_destroy())
+          get_vtable()->clear(this->functor);
+        vtable = 0;
+      }
+    }
+
+
+
+
+
+  private:
+    struct dummy {
+      void nonnull() {}
+    };
+
+    typedef void (dummy::*safe_bool)();
+
+  public:
+    operator safe_bool () const
+      { return (this->empty())? 0 : &dummy::nonnull; }
+
+    bool operator!() const
+      { return this->empty(); }
+
+
+  private:
+    void assign_to_own(const function4& f)
+    {
+      if (!f.empty()) {
+        this->vtable = f.vtable;
+        if (this->has_trivial_copy_and_destroy())
+
+
+          std::memcpy(this->functor.data, f.functor.data, sizeof(boost::detail::function::function_buffer));
+        else
+          get_vtable()->base.manager(f.functor, this->functor,
+                                     boost::detail::function::clone_functor_tag);
+      }
+    }
+
+    template<typename Functor>
+    void assign_to(Functor f)
+    {
+      using boost::detail::function::vtable_base;
+
+      typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
+      typedef boost::detail::function::get_invoker4<tag> get_invoker;
+      typedef typename get_invoker::
+                         template apply<Functor, R ,
+                        T0 , T1 , T2 , T3>
+        handler_type;
+
+      typedef typename handler_type::invoker_type invoker_type;
+      typedef typename handler_type::manager_type manager_type;
+
+
+
+
+
+      static const vtable_type stored_vtable =
+        { { &manager_type::manage }, &invoker_type::invoke };
+
+      if (stored_vtable.assign_to(f, functor)) {
+        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
+
+        if (boost::has_trivial_copy_constructor<Functor>::value &&
+            boost::has_trivial_destructor<Functor>::value &&
+            boost::detail::function::function_allows_small_object_optimization<Functor>::value)
+          value |= static_cast<std::size_t>(0x01);
+        vtable = reinterpret_cast<boost::detail::function::vtable_base *>(value);
+      } else
+        vtable = 0;
+    }
+
+    template<typename Functor,typename Allocator>
+    void assign_to_a(Functor f,Allocator a)
+    {
+      using boost::detail::function::vtable_base;
+
+      typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
+      typedef boost::detail::function::get_invoker4<tag> get_invoker;
+      typedef typename get_invoker::
+                         template apply_a<Functor, Allocator, R ,
+                         T0 , T1 , T2 , T3>
+        handler_type;
+
+      typedef typename handler_type::invoker_type invoker_type;
+      typedef typename handler_type::manager_type manager_type;
+
+
+
+
+
+      static const vtable_type stored_vtable =
+        { { &manager_type::manage }, &invoker_type::invoke };
+
+      if (stored_vtable.assign_to_a(f, functor, a)) {
+        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
+
+        if (boost::has_trivial_copy_constructor<Functor>::value &&
+            boost::has_trivial_destructor<Functor>::value &&
+            boost::detail::function::function_allows_small_object_optimization<Functor>::value)
+          value |= static_cast<std::size_t>(0x01);
+        vtable = reinterpret_cast<boost::detail::function::vtable_base *>(value);
+      } else
+        vtable = 0;
+    }
+
+
+
+
+    void move_assign(function4& f)
+    {
+      if (&f == this)
+        return;
+
+      { try {
+        if (!f.empty()) {
+          this->vtable = f.vtable;
+          if (this->has_trivial_copy_and_destroy())
+
+
+            std::memcpy(this->functor.data, f.functor.data, sizeof(this->functor.data));
+          else
+            get_vtable()->base.manager(f.functor, this->functor,
+                                     boost::detail::function::move_functor_tag);
+          f.vtable = 0;
+        } else {
+          clear();
+        }
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+    }
+  };
+
+  template<typename R , typename T0 , typename T1 , typename T2 , typename T3>
+  inline void swap(function4<
+                     R ,
+                     T0 , T1 , T2 , T3
+                   >& f1,
+                   function4<
+                     R ,
+                     T0 , T1 , T2 , T3
+                   >& f2)
+  {
+    f1.swap(f2);
+  }
+
+
+template<typename R , typename T0 , typename T1 , typename T2 , typename T3>
+  void operator==(const function4<
+                          R ,
+                          T0 , T1 , T2 , T3>&,
+                  const function4<
+                          R ,
+                          T0 , T1 , T2 , T3>&);
+template<typename R , typename T0 , typename T1 , typename T2 , typename T3>
+  void operator!=(const function4<
+                          R ,
+                          T0 , T1 , T2 , T3>&,
+                  const function4<
+                          R ,
+                          T0 , T1 , T2 , T3>& );
+
+
+
+
+
+
+#define BOOST_FUNCTION_PARTIAL_SPEC R (BOOST_FUNCTION_TEMPLATE_ARGS)
+
+
+template<typename R ,
+         typename T0 , typename T1 , typename T2 , typename T3>
+class function<R ( T0 , T1 , T2 , T3)>
+  : public function4<R , T0 , T1 , T2 , T3>
+{
+  typedef function4<R , T0 , T1 , T2 , T3> base_type;
+  typedef function self_type;
+
+  struct clear_type {};
+
+public:
+
+  function() = default;
+
+  template<typename Functor>
+  function(Functor f
+
+           ,typename boost::enable_if_<
+                          !(is_integral<Functor>::value),
+                       int>::type = 0
+
+           ) :
+    base_type(f)
+  {
+  }
+  template<typename Functor,typename Allocator>
+  function(Functor f, Allocator a
+
+           ,typename boost::enable_if_<
+                           !(is_integral<Functor>::value),
+                       int>::type = 0
+
+           ) :
+    base_type(f,a)
+  {
+  }
+
+
+  function(clear_type*) : base_type() {}
+
+
+  function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}
+
+  function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}
+
+
+
+  function(self_type&& f): base_type(static_cast<base_type&&>(f)){}
+  function(base_type&& f): base_type(static_cast<base_type&&>(f)){}
+
+
+  self_type& operator=(const self_type& f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+
+
+  self_type& operator=(self_type&& f)
+  {
+    self_type(static_cast<self_type&&>(f)).swap(*this);
+    return *this;
+  }
+
+
+  template<typename Functor>
+
+  typename boost::enable_if_<
+                         !(is_integral<Functor>::value),
+                      self_type&>::type
+
+
+
+  operator=(Functor f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+
+
+  self_type& operator=(clear_type*)
+  {
+    this->clear();
+    return *this;
+  }
+
+
+  self_type& operator=(const base_type& f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+
+
+  self_type& operator=(base_type&& f)
+  {
+    self_type(static_cast<base_type&&>(f)).swap(*this);
+    return *this;
+  }
+
+};
+
+#undef BOOST_FUNCTION_PARTIAL_SPEC
+
+
+}
+
+
+#undef BOOST_FUNCTION_VTABLE
+#undef BOOST_FUNCTION_COMMA
+#undef BOOST_FUNCTION_FUNCTION
+#undef BOOST_FUNCTION_FUNCTION_INVOKER
+#undef BOOST_FUNCTION_VOID_FUNCTION_INVOKER
+#undef BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
+#undef BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
+#undef BOOST_FUNCTION_FUNCTION_REF_INVOKER
+#undef BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER
+#undef BOOST_FUNCTION_MEMBER_INVOKER
+#undef BOOST_FUNCTION_VOID_MEMBER_INVOKER
+#undef BOOST_FUNCTION_GET_FUNCTION_INVOKER
+#undef BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
+#undef BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER
+#undef BOOST_FUNCTION_GET_MEM_FUNCTION_INVOKER
+#undef BOOST_FUNCTION_GET_INVOKER
+#undef BOOST_FUNCTION_TEMPLATE_PARMS
+#undef BOOST_FUNCTION_TEMPLATE_ARGS
+#undef BOOST_FUNCTION_PARMS
+#undef BOOST_FUNCTION_PARM
+
+#undef BOOST_FUNCTION_ARG
+
+#undef BOOST_FUNCTION_ARGS
+#undef BOOST_FUNCTION_ARG_TYPE
+#undef BOOST_FUNCTION_ARG_TYPES
+#undef BOOST_FUNCTION_VOID_RETURN_TYPE
+#undef BOOST_FUNCTION_RETURN
+# 44 "/usr/include/boost/function/detail/maybe_include.hpp" 2 3 4
+# 15 "/usr/include/boost/function/detail/function_iterate.hpp" 2 3 4
+#undef BOOST_FUNCTION_NUM_ARGS
+# 68 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
+#undef BOOST_PP_ITERATION_1
+
+
+#define BOOST_PP_ITERATION_1 5
+# 1 "/usr/include/boost/function/detail/function_iterate.hpp" 1 3 4
+# 13 "/usr/include/boost/function/detail/function_iterate.hpp" 3 4
+#define BOOST_FUNCTION_NUM_ARGS BOOST_PP_ITERATION()
+# 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
+# 46 "/usr/include/boost/function/detail/maybe_include.hpp" 3 4
+#undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#define BOOST_FUNCTION_MAX_ARGS_DEFINED 5
+
+#define BOOST_FUNCTION_5 
+# 1 "/usr/include/boost/function/function_template.hpp" 1 3 4
+# 21 "/usr/include/boost/function/function_template.hpp" 3 4
+#define BOOST_FUNCTION_TEMPLATE_PARMS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, typename T)
+
+#define BOOST_FUNCTION_TEMPLATE_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, T)
+
+#define BOOST_FUNCTION_PARM(J,I,D) BOOST_PP_CAT(T,I) BOOST_PP_CAT(a,I)
+
+#define BOOST_FUNCTION_PARMS BOOST_PP_ENUM(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_PARM,BOOST_PP_EMPTY)
+
+
+
+
+#define BOOST_FUNCTION_ARG(J,I,D) static_cast<BOOST_PP_CAT(T,I)&&>(BOOST_PP_CAT(a,I))
+#define BOOST_FUNCTION_ARGS BOOST_PP_ENUM(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_ARG,BOOST_PP_EMPTY)
+
+
+#define BOOST_FUNCTION_ARG_TYPE(J,I,D) typedef BOOST_PP_CAT(T,I) BOOST_PP_CAT(BOOST_PP_CAT(arg, BOOST_PP_INC(I)),_type);
+
+
+#define BOOST_FUNCTION_ARG_TYPES BOOST_PP_REPEAT(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_ARG_TYPE,BOOST_PP_EMPTY)
+
+
+
+
+
+#define BOOST_FUNCTION_COMMA ,
+
+
+
+#define BOOST_FUNCTION_FUNCTION BOOST_JOIN(function,BOOST_FUNCTION_NUM_ARGS)
+#define BOOST_FUNCTION_FUNCTION_INVOKER BOOST_JOIN(function_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_VOID_FUNCTION_INVOKER BOOST_JOIN(void_function_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_FUNCTION_OBJ_INVOKER BOOST_JOIN(function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER BOOST_JOIN(void_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_FUNCTION_REF_INVOKER BOOST_JOIN(function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER BOOST_JOIN(void_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_MEMBER_INVOKER BOOST_JOIN(function_mem_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_VOID_MEMBER_INVOKER BOOST_JOIN(function_void_mem_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_GET_FUNCTION_INVOKER BOOST_JOIN(get_function_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER BOOST_JOIN(get_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER BOOST_JOIN(get_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_GET_MEMBER_INVOKER BOOST_JOIN(get_member_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_GET_INVOKER BOOST_JOIN(get_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_VTABLE BOOST_JOIN(basic_vtable,BOOST_FUNCTION_NUM_ARGS)
+
+
+#define BOOST_FUNCTION_VOID_RETURN_TYPE void
+#define BOOST_FUNCTION_RETURN(X) X
+
+
+
+
+
+namespace boost {
+  namespace detail {
+    namespace function {
+      template<
+        typename FunctionPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4
+        >
+      struct function_invoker5
+      {
+        static R invoke(function_buffer& function_ptr ,
+                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4)
+        {
+          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.members.func_ptr);
+          return f( static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2) , static_cast<T3&&>(a3) , static_cast<T4&&>(a4));
+        }
+      };
+
+      template<
+        typename FunctionPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4
+        >
+      struct void_function_invoker5
+      {
+        static void
+        invoke(function_buffer& function_ptr ,
+               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4)
+
+        {
+          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.members.func_ptr);
+          f( static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2) , static_cast<T3&&>(a3) , static_cast<T4&&>(a4));
+        }
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4
+      >
+      struct function_obj_invoker5
+      {
+        static R invoke(function_buffer& function_obj_ptr ,
+                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4)
+
+        {
+          FunctionObj* f;
+          if (function_allows_small_object_optimization<FunctionObj>::value)
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.data);
+          else
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
+          return (*f)( static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2) , static_cast<T3&&>(a3) , static_cast<T4&&>(a4));
+        }
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4
+      >
+      struct void_function_obj_invoker5
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr ,
+               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4)
+
+        {
+          FunctionObj* f;
+          if (function_allows_small_object_optimization<FunctionObj>::value)
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.data);
+          else
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
+          (*f)( static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2) , static_cast<T3&&>(a3) , static_cast<T4&&>(a4));
+        }
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4
+      >
+      struct function_ref_invoker5
+      {
+        static R invoke(function_buffer& function_obj_ptr ,
+                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4)
+
+        {
+          FunctionObj* f =
+            reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
+          return (*f)( static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2) , static_cast<T3&&>(a3) , static_cast<T4&&>(a4));
+        }
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4
+      >
+      struct void_function_ref_invoker5
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr ,
+               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4)
+
+        {
+          FunctionObj* f =
+            reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
+          (*f)( static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2) , static_cast<T3&&>(a3) , static_cast<T4&&>(a4));
+        }
+      };
+
+
+
+      template<
+        typename MemberPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4
+      >
+      struct function_mem_invoker5
+      {
+        static R invoke(function_buffer& function_obj_ptr ,
+                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4)
+
+        {
+          MemberPtr* f =
+            reinterpret_cast<MemberPtr*>(function_obj_ptr.data);
+          return boost::mem_fn(*f)( static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2) , static_cast<T3&&>(a3) , static_cast<T4&&>(a4));
+        }
+      };
+
+      template<
+        typename MemberPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4
+      >
+      struct function_void_mem_invoker5
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr ,
+               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4)
+
+        {
+          MemberPtr* f =
+            reinterpret_cast<MemberPtr*>(function_obj_ptr.data);
+          boost::mem_fn(*f)( static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2) , static_cast<T3&&>(a3) , static_cast<T4&&>(a4));
+        }
+      };
+
+
+      template<
+        typename FunctionPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4
+      >
+      struct get_function_invoker5
+      {
+        typedef typename conditional<(is_void<R>::value),
+                            void_function_invoker5<
+                            FunctionPtr,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4
+                          >,
+                          function_invoker5<
+                            FunctionPtr,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4
+                          >
+                       >::type type;
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4
+       >
+      struct get_function_obj_invoker5
+      {
+        typedef typename conditional<(is_void<R>::value),
+                            void_function_obj_invoker5<
+                            FunctionObj,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4
+                          >,
+                          function_obj_invoker5<
+                            FunctionObj,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4
+                          >
+                       >::type type;
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4
+       >
+      struct get_function_ref_invoker5
+      {
+        typedef typename conditional<(is_void<R>::value),
+                            void_function_ref_invoker5<
+                            FunctionObj,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4
+                          >,
+                          function_ref_invoker5<
+                            FunctionObj,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4
+                          >
+                       >::type type;
+      };
+
+
+
+      template<
+        typename MemberPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4
+       >
+      struct get_member_invoker5
+      {
+        typedef typename conditional<(is_void<R>::value),
+                            function_void_mem_invoker5<
+                            MemberPtr,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4
+                          >,
+                          function_mem_invoker5<
+                            MemberPtr,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4
+                          >
+                       >::type type;
+      };
+# 331 "/usr/include/boost/function/function_template.hpp" 3 4
+      template<typename Tag>
+      struct get_invoker5 { };
+
+
+      template<>
+      struct get_invoker5<function_ptr_tag>
+      {
+        template<typename FunctionPtr,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
+        struct apply
+        {
+          typedef typename get_function_invoker5<
+                             FunctionPtr,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<FunctionPtr> manager_type;
+        };
+
+        template<typename FunctionPtr, typename Allocator,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
+        struct apply_a
+        {
+          typedef typename get_function_invoker5<
+                             FunctionPtr,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<FunctionPtr> manager_type;
+        };
+      };
+
+
+
+      template<>
+      struct get_invoker5<member_ptr_tag>
+      {
+        template<typename MemberPtr,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
+        struct apply
+        {
+          typedef typename get_member_invoker5<
+                             MemberPtr,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<MemberPtr> manager_type;
+        };
+
+        template<typename MemberPtr, typename Allocator,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
+        struct apply_a
+        {
+          typedef typename get_member_invoker5<
+                             MemberPtr,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<MemberPtr> manager_type;
+        };
+      };
+
+
+
+      template<>
+      struct get_invoker5<function_obj_tag>
+      {
+        template<typename FunctionObj,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
+        struct apply
+        {
+          typedef typename get_function_obj_invoker5<
+                             FunctionObj,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<FunctionObj> manager_type;
+        };
+
+        template<typename FunctionObj, typename Allocator,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
+        struct apply_a
+        {
+          typedef typename get_function_obj_invoker5<
+                             FunctionObj,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4
+                           >::type
+            invoker_type;
+
+          typedef functor_manager_a<FunctionObj, Allocator> manager_type;
+        };
+      };
+
+
+      template<>
+      struct get_invoker5<function_obj_ref_tag>
+      {
+        template<typename RefWrapper,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
+        struct apply
+        {
+          typedef typename get_function_ref_invoker5<
+                             typename RefWrapper::type,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4
+                           >::type
+            invoker_type;
+
+          typedef reference_manager<typename RefWrapper::type> manager_type;
+        };
+
+        template<typename RefWrapper, typename Allocator,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
+        struct apply_a
+        {
+          typedef typename get_function_ref_invoker5<
+                             typename RefWrapper::type,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4
+                           >::type
+            invoker_type;
+
+          typedef reference_manager<typename RefWrapper::type> manager_type;
+        };
+      };
+# 476 "/usr/include/boost/function/function_template.hpp" 3 4
+      template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
+      struct basic_vtable5
+      {
+
+        typedef R result_type;
+
+
+
+
+        typedef result_type (*invoker_type)(function_buffer&
+                                            ,
+                                            T0 , T1 , T2 , T3 , T4);
+
+        template<typename F>
+        bool assign_to(F f, function_buffer& functor) const
+        {
+          typedef typename get_function_tag<F>::type tag;
+          return assign_to(f, functor, tag());
+        }
+        template<typename F,typename Allocator>
+        bool assign_to_a(F f, function_buffer& functor, Allocator a) const
+        {
+          typedef typename get_function_tag<F>::type tag;
+          return assign_to_a(f, functor, a, tag());
+        }
+
+        void clear(function_buffer& functor) const
+        {
+          if (base.manager)
+            base.manager(functor, functor, destroy_functor_tag);
+        }
+
+      private:
+
+        template<typename FunctionPtr>
+        bool
+        assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag) const
+        {
+          this->clear(functor);
+          if (f) {
+
+
+            functor.members.func_ptr = reinterpret_cast<void (*)()>(f);
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionPtr,typename Allocator>
+        bool
+        assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const
+        {
+          return assign_to(f,functor,function_ptr_tag());
+        }
+
+
+
+        template<typename MemberPtr>
+        bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag) const
+        {
+
+
+
+          if (f) {
+            this->assign_to(boost::mem_fn(f), functor);
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename MemberPtr,typename Allocator>
+        bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag) const
+        {
+
+
+
+          if (f) {
+            this->assign_to_a(boost::mem_fn(f), functor, a);
+            return true;
+          } else {
+            return false;
+          }
+        }
+
+
+
+
+        template<typename FunctionObj>
+        void
+        assign_functor(FunctionObj f, function_buffer& functor, true_type) const
+        {
+          new (reinterpret_cast<void*>(functor.data)) FunctionObj(f);
+        }
+        template<typename FunctionObj,typename Allocator>
+        void
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, true_type) const
+        {
+          assign_functor(f,functor,true_type());
+        }
+
+
+        template<typename FunctionObj>
+        void
+        assign_functor(FunctionObj f, function_buffer& functor, false_type) const
+        {
+          functor.members.obj_ptr = new FunctionObj(f);
+        }
+        template<typename FunctionObj,typename Allocator>
+        void
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, false_type) const
+        {
+          typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;
+
+
+
+
+
+          using wrapper_allocator_type = typename std::allocator_traits<Allocator>::template rebind_alloc<functor_wrapper_type>;
+          using wrapper_allocator_pointer_type = typename std::allocator_traits<wrapper_allocator_type>::pointer;
+
+          wrapper_allocator_type wrapper_allocator(a);
+          wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
+
+
+
+          std::allocator_traits<wrapper_allocator_type>::construct(wrapper_allocator, copy, functor_wrapper_type(f,a));
+
+          functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
+          functor.members.obj_ptr = new_f;
+        }
+
+        template<typename FunctionObj>
+        bool
+        assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) const
+        {
+          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
+            assign_functor(f, functor,
+                           integral_constant<bool, (function_allows_small_object_optimization<FunctionObj>::value)>());
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionObj,typename Allocator>
+        bool
+        assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag) const
+        {
+          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
+            assign_functor_a(f, functor, a,
+                           integral_constant<bool, (function_allows_small_object_optimization<FunctionObj>::value)>());
+            return true;
+          } else {
+            return false;
+          }
+        }
+
+
+        template<typename FunctionObj>
+        bool
+        assign_to(const reference_wrapper<FunctionObj>& f,
+                  function_buffer& functor, function_obj_ref_tag) const
+        {
+          functor.members.obj_ref.obj_ptr = (void *)(f.get_pointer());
+          functor.members.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
+          functor.members.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
+          return true;
+        }
+        template<typename FunctionObj,typename Allocator>
+        bool
+        assign_to_a(const reference_wrapper<FunctionObj>& f,
+                  function_buffer& functor, Allocator, function_obj_ref_tag) const
+        {
+          return assign_to(f,functor,function_obj_ref_tag());
+        }
+
+      public:
+        vtable_base base;
+        invoker_type invoker;
+      };
+    }
+  }
+
+  template<
+    typename R ,
+    typename T0 , typename T1 , typename T2 , typename T3 , typename T4
+  >
+  class function5 : public function_base
+  {
+  public:
+
+    typedef R result_type;
+
+
+
+
+
+  private:
+    typedef boost::detail::function::basic_vtable5<
+              R , T0 , T1 , T2 , T3 , T4>
+      vtable_type;
+
+    vtable_type* get_vtable() const {
+      return reinterpret_cast<vtable_type*>(
+               reinterpret_cast<std::size_t>(vtable) & ~static_cast<std::size_t>(0x01));
+    }
+
+    struct clear_type {};
+
+  public:
+    static const int args = 5;
+
+
+    template<typename Args>
+    struct sig
+    {
+      typedef result_type type;
+    };
+# 701 "/usr/include/boost/function/function_template.hpp" 3 4
+    static const int arity = 5;
+    typedef T0 arg1_type; typedef T1 arg2_type; typedef T2 arg3_type; typedef T3 arg4_type; typedef T4 arg5_type;
+
+    typedef function5 self_type;
+
+    function5() = default;
+
+
+
+    template<typename Functor>
+    function5(Functor f
+
+                            ,typename boost::enable_if_<
+                             !(is_integral<Functor>::value),
+                                        int>::type = 0
+
+                            ) :
+      function_base()
+    {
+      this->assign_to(f);
+    }
+    template<typename Functor,typename Allocator>
+    function5(Functor f, Allocator a
+
+                            ,typename boost::enable_if_<
+                              !(is_integral<Functor>::value),
+                                        int>::type = 0
+
+                            ) :
+      function_base()
+    {
+      this->assign_to_a(f,a);
+    }
+
+
+    function5(clear_type*) : function_base() { }
+
+
+
+
+
+
+
+    function5(const function5& f) : function_base()
+    {
+      this->assign_to_own(f);
+    }
+
+
+    function5(function5&& f) : function_base()
+    {
+      this->move_assign(f);
+    }
+
+
+    ~function5() { clear(); }
+
+    result_type operator()( T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4) const
+    {
+      if (this->empty())
+        boost::throw_exception(bad_function_call());
+
+      return get_vtable()->invoker
+               (this->functor , static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2) , static_cast<T3&&>(a3) , static_cast<T4&&>(a4));
+    }
+
+
+
+
+
+
+    template<typename Functor>
+
+    typename boost::enable_if_<
+                  !(is_integral<Functor>::value),
+               function5&>::type
+
+
+
+    operator=(Functor f)
+    {
+      this->clear();
+      { try {
+        this->assign_to(f);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+      return *this;
+    }
+    template<typename Functor,typename Allocator>
+    void assign(Functor f, Allocator a)
+    {
+      this->clear();
+      { try{
+        this->assign_to_a(f,a);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+    }
+
+
+    function5& operator=(clear_type*)
+    {
+      this->clear();
+      return *this;
+    }
+# 821 "/usr/include/boost/function/function_template.hpp" 3 4
+    function5& operator=(const function5& f)
+    {
+      if (&f == this)
+        return *this;
+
+      this->clear();
+      { try {
+        this->assign_to_own(f);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+      return *this;
+    }
+
+
+
+    function5& operator=(function5&& f)
+    {
+      if (&f == this)
+        return *this;
+
+      this->clear();
+      { try {
+        this->move_assign(f);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+      return *this;
+    }
+
+
+    void swap(function5& other)
+    {
+      if (&other == this)
+        return;
+
+      function5 tmp;
+      tmp.move_assign(*this);
+      this->move_assign(other);
+      other.move_assign(tmp);
+    }
+
+
+    void clear()
+    {
+      if (vtable) {
+        if (!this->has_trivial_copy_and_destroy())
+          get_vtable()->clear(this->functor);
+        vtable = 0;
+      }
+    }
+
+
+
+
+
+  private:
+    struct dummy {
+      void nonnull() {}
+    };
+
+    typedef void (dummy::*safe_bool)();
+
+  public:
+    operator safe_bool () const
+      { return (this->empty())? 0 : &dummy::nonnull; }
+
+    bool operator!() const
+      { return this->empty(); }
+
+
+  private:
+    void assign_to_own(const function5& f)
+    {
+      if (!f.empty()) {
+        this->vtable = f.vtable;
+        if (this->has_trivial_copy_and_destroy())
+
+
+          std::memcpy(this->functor.data, f.functor.data, sizeof(boost::detail::function::function_buffer));
+        else
+          get_vtable()->base.manager(f.functor, this->functor,
+                                     boost::detail::function::clone_functor_tag);
+      }
+    }
+
+    template<typename Functor>
+    void assign_to(Functor f)
+    {
+      using boost::detail::function::vtable_base;
+
+      typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
+      typedef boost::detail::function::get_invoker5<tag> get_invoker;
+      typedef typename get_invoker::
+                         template apply<Functor, R ,
+                        T0 , T1 , T2 , T3 , T4>
+        handler_type;
+
+      typedef typename handler_type::invoker_type invoker_type;
+      typedef typename handler_type::manager_type manager_type;
+
+
+
+
+
+      static const vtable_type stored_vtable =
+        { { &manager_type::manage }, &invoker_type::invoke };
+
+      if (stored_vtable.assign_to(f, functor)) {
+        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
+
+        if (boost::has_trivial_copy_constructor<Functor>::value &&
+            boost::has_trivial_destructor<Functor>::value &&
+            boost::detail::function::function_allows_small_object_optimization<Functor>::value)
+          value |= static_cast<std::size_t>(0x01);
+        vtable = reinterpret_cast<boost::detail::function::vtable_base *>(value);
+      } else
+        vtable = 0;
+    }
+
+    template<typename Functor,typename Allocator>
+    void assign_to_a(Functor f,Allocator a)
+    {
+      using boost::detail::function::vtable_base;
+
+      typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
+      typedef boost::detail::function::get_invoker5<tag> get_invoker;
+      typedef typename get_invoker::
+                         template apply_a<Functor, Allocator, R ,
+                         T0 , T1 , T2 , T3 , T4>
+        handler_type;
+
+      typedef typename handler_type::invoker_type invoker_type;
+      typedef typename handler_type::manager_type manager_type;
+
+
+
+
+
+      static const vtable_type stored_vtable =
+        { { &manager_type::manage }, &invoker_type::invoke };
+
+      if (stored_vtable.assign_to_a(f, functor, a)) {
+        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
+
+        if (boost::has_trivial_copy_constructor<Functor>::value &&
+            boost::has_trivial_destructor<Functor>::value &&
+            boost::detail::function::function_allows_small_object_optimization<Functor>::value)
+          value |= static_cast<std::size_t>(0x01);
+        vtable = reinterpret_cast<boost::detail::function::vtable_base *>(value);
+      } else
+        vtable = 0;
+    }
+
+
+
+
+    void move_assign(function5& f)
+    {
+      if (&f == this)
+        return;
+
+      { try {
+        if (!f.empty()) {
+          this->vtable = f.vtable;
+          if (this->has_trivial_copy_and_destroy())
+
+
+            std::memcpy(this->functor.data, f.functor.data, sizeof(this->functor.data));
+          else
+            get_vtable()->base.manager(f.functor, this->functor,
+                                     boost::detail::function::move_functor_tag);
+          f.vtable = 0;
+        } else {
+          clear();
+        }
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+    }
+  };
+
+  template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
+  inline void swap(function5<
+                     R ,
+                     T0 , T1 , T2 , T3 , T4
+                   >& f1,
+                   function5<
+                     R ,
+                     T0 , T1 , T2 , T3 , T4
+                   >& f2)
+  {
+    f1.swap(f2);
+  }
+
+
+template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
+  void operator==(const function5<
+                          R ,
+                          T0 , T1 , T2 , T3 , T4>&,
+                  const function5<
+                          R ,
+                          T0 , T1 , T2 , T3 , T4>&);
+template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
+  void operator!=(const function5<
+                          R ,
+                          T0 , T1 , T2 , T3 , T4>&,
+                  const function5<
+                          R ,
+                          T0 , T1 , T2 , T3 , T4>& );
+
+
+
+
+
+
+#define BOOST_FUNCTION_PARTIAL_SPEC R (BOOST_FUNCTION_TEMPLATE_ARGS)
+
+
+template<typename R ,
+         typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
+class function<R ( T0 , T1 , T2 , T3 , T4)>
+  : public function5<R , T0 , T1 , T2 , T3 , T4>
+{
+  typedef function5<R , T0 , T1 , T2 , T3 , T4> base_type;
+  typedef function self_type;
+
+  struct clear_type {};
+
+public:
+
+  function() = default;
+
+  template<typename Functor>
+  function(Functor f
+
+           ,typename boost::enable_if_<
+                          !(is_integral<Functor>::value),
+                       int>::type = 0
+
+           ) :
+    base_type(f)
+  {
+  }
+  template<typename Functor,typename Allocator>
+  function(Functor f, Allocator a
+
+           ,typename boost::enable_if_<
+                           !(is_integral<Functor>::value),
+                       int>::type = 0
+
+           ) :
+    base_type(f,a)
+  {
+  }
+
+
+  function(clear_type*) : base_type() {}
+
+
+  function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}
+
+  function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}
+
+
+
+  function(self_type&& f): base_type(static_cast<base_type&&>(f)){}
+  function(base_type&& f): base_type(static_cast<base_type&&>(f)){}
+
+
+  self_type& operator=(const self_type& f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+
+
+  self_type& operator=(self_type&& f)
+  {
+    self_type(static_cast<self_type&&>(f)).swap(*this);
+    return *this;
+  }
+
+
+  template<typename Functor>
+
+  typename boost::enable_if_<
+                         !(is_integral<Functor>::value),
+                      self_type&>::type
+
+
+
+  operator=(Functor f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+
+
+  self_type& operator=(clear_type*)
+  {
+    this->clear();
+    return *this;
+  }
+
+
+  self_type& operator=(const base_type& f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+
+
+  self_type& operator=(base_type&& f)
+  {
+    self_type(static_cast<base_type&&>(f)).swap(*this);
+    return *this;
+  }
+
+};
+
+#undef BOOST_FUNCTION_PARTIAL_SPEC
+
+
+}
+
+
+#undef BOOST_FUNCTION_VTABLE
+#undef BOOST_FUNCTION_COMMA
+#undef BOOST_FUNCTION_FUNCTION
+#undef BOOST_FUNCTION_FUNCTION_INVOKER
+#undef BOOST_FUNCTION_VOID_FUNCTION_INVOKER
+#undef BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
+#undef BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
+#undef BOOST_FUNCTION_FUNCTION_REF_INVOKER
+#undef BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER
+#undef BOOST_FUNCTION_MEMBER_INVOKER
+#undef BOOST_FUNCTION_VOID_MEMBER_INVOKER
+#undef BOOST_FUNCTION_GET_FUNCTION_INVOKER
+#undef BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
+#undef BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER
+#undef BOOST_FUNCTION_GET_MEM_FUNCTION_INVOKER
+#undef BOOST_FUNCTION_GET_INVOKER
+#undef BOOST_FUNCTION_TEMPLATE_PARMS
+#undef BOOST_FUNCTION_TEMPLATE_ARGS
+#undef BOOST_FUNCTION_PARMS
+#undef BOOST_FUNCTION_PARM
+
+#undef BOOST_FUNCTION_ARG
+
+#undef BOOST_FUNCTION_ARGS
+#undef BOOST_FUNCTION_ARG_TYPE
+#undef BOOST_FUNCTION_ARG_TYPES
+#undef BOOST_FUNCTION_VOID_RETURN_TYPE
+#undef BOOST_FUNCTION_RETURN
+# 51 "/usr/include/boost/function/detail/maybe_include.hpp" 2 3 4
+# 15 "/usr/include/boost/function/detail/function_iterate.hpp" 2 3 4
+#undef BOOST_FUNCTION_NUM_ARGS
+# 73 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
+#undef BOOST_PP_ITERATION_1
+
+
+#define BOOST_PP_ITERATION_1 6
+# 1 "/usr/include/boost/function/detail/function_iterate.hpp" 1 3 4
+# 13 "/usr/include/boost/function/detail/function_iterate.hpp" 3 4
+#define BOOST_FUNCTION_NUM_ARGS BOOST_PP_ITERATION()
+# 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
+# 53 "/usr/include/boost/function/detail/maybe_include.hpp" 3 4
+#undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#define BOOST_FUNCTION_MAX_ARGS_DEFINED 6
+
+#define BOOST_FUNCTION_6 
+# 1 "/usr/include/boost/function/function_template.hpp" 1 3 4
+# 21 "/usr/include/boost/function/function_template.hpp" 3 4
+#define BOOST_FUNCTION_TEMPLATE_PARMS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, typename T)
+
+#define BOOST_FUNCTION_TEMPLATE_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, T)
+
+#define BOOST_FUNCTION_PARM(J,I,D) BOOST_PP_CAT(T,I) BOOST_PP_CAT(a,I)
+
+#define BOOST_FUNCTION_PARMS BOOST_PP_ENUM(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_PARM,BOOST_PP_EMPTY)
+
+
+
+
+#define BOOST_FUNCTION_ARG(J,I,D) static_cast<BOOST_PP_CAT(T,I)&&>(BOOST_PP_CAT(a,I))
+#define BOOST_FUNCTION_ARGS BOOST_PP_ENUM(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_ARG,BOOST_PP_EMPTY)
+
+
+#define BOOST_FUNCTION_ARG_TYPE(J,I,D) typedef BOOST_PP_CAT(T,I) BOOST_PP_CAT(BOOST_PP_CAT(arg, BOOST_PP_INC(I)),_type);
+
+
+#define BOOST_FUNCTION_ARG_TYPES BOOST_PP_REPEAT(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_ARG_TYPE,BOOST_PP_EMPTY)
+
+
+
+
+
+#define BOOST_FUNCTION_COMMA ,
+
+
+
+#define BOOST_FUNCTION_FUNCTION BOOST_JOIN(function,BOOST_FUNCTION_NUM_ARGS)
+#define BOOST_FUNCTION_FUNCTION_INVOKER BOOST_JOIN(function_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_VOID_FUNCTION_INVOKER BOOST_JOIN(void_function_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_FUNCTION_OBJ_INVOKER BOOST_JOIN(function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER BOOST_JOIN(void_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_FUNCTION_REF_INVOKER BOOST_JOIN(function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER BOOST_JOIN(void_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_MEMBER_INVOKER BOOST_JOIN(function_mem_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_VOID_MEMBER_INVOKER BOOST_JOIN(function_void_mem_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_GET_FUNCTION_INVOKER BOOST_JOIN(get_function_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER BOOST_JOIN(get_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER BOOST_JOIN(get_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_GET_MEMBER_INVOKER BOOST_JOIN(get_member_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_GET_INVOKER BOOST_JOIN(get_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_VTABLE BOOST_JOIN(basic_vtable,BOOST_FUNCTION_NUM_ARGS)
+
+
+#define BOOST_FUNCTION_VOID_RETURN_TYPE void
+#define BOOST_FUNCTION_RETURN(X) X
+
+
+
+
+
+namespace boost {
+  namespace detail {
+    namespace function {
+      template<
+        typename FunctionPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
+        >
+      struct function_invoker6
+      {
+        static R invoke(function_buffer& function_ptr ,
+                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5)
+        {
+          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.members.func_ptr);
+          return f( static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2) , static_cast<T3&&>(a3) , static_cast<T4&&>(a4) , static_cast<T5&&>(a5));
+        }
+      };
+
+      template<
+        typename FunctionPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
+        >
+      struct void_function_invoker6
+      {
+        static void
+        invoke(function_buffer& function_ptr ,
+               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5)
+
+        {
+          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.members.func_ptr);
+          f( static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2) , static_cast<T3&&>(a3) , static_cast<T4&&>(a4) , static_cast<T5&&>(a5));
+        }
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
+      >
+      struct function_obj_invoker6
+      {
+        static R invoke(function_buffer& function_obj_ptr ,
+                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5)
+
+        {
+          FunctionObj* f;
+          if (function_allows_small_object_optimization<FunctionObj>::value)
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.data);
+          else
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
+          return (*f)( static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2) , static_cast<T3&&>(a3) , static_cast<T4&&>(a4) , static_cast<T5&&>(a5));
+        }
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
+      >
+      struct void_function_obj_invoker6
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr ,
+               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5)
+
+        {
+          FunctionObj* f;
+          if (function_allows_small_object_optimization<FunctionObj>::value)
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.data);
+          else
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
+          (*f)( static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2) , static_cast<T3&&>(a3) , static_cast<T4&&>(a4) , static_cast<T5&&>(a5));
+        }
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
+      >
+      struct function_ref_invoker6
+      {
+        static R invoke(function_buffer& function_obj_ptr ,
+                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5)
+
+        {
+          FunctionObj* f =
+            reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
+          return (*f)( static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2) , static_cast<T3&&>(a3) , static_cast<T4&&>(a4) , static_cast<T5&&>(a5));
+        }
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
+      >
+      struct void_function_ref_invoker6
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr ,
+               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5)
+
+        {
+          FunctionObj* f =
+            reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
+          (*f)( static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2) , static_cast<T3&&>(a3) , static_cast<T4&&>(a4) , static_cast<T5&&>(a5));
+        }
+      };
+
+
+
+      template<
+        typename MemberPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
+      >
+      struct function_mem_invoker6
+      {
+        static R invoke(function_buffer& function_obj_ptr ,
+                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5)
+
+        {
+          MemberPtr* f =
+            reinterpret_cast<MemberPtr*>(function_obj_ptr.data);
+          return boost::mem_fn(*f)( static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2) , static_cast<T3&&>(a3) , static_cast<T4&&>(a4) , static_cast<T5&&>(a5));
+        }
+      };
+
+      template<
+        typename MemberPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
+      >
+      struct function_void_mem_invoker6
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr ,
+               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5)
+
+        {
+          MemberPtr* f =
+            reinterpret_cast<MemberPtr*>(function_obj_ptr.data);
+          boost::mem_fn(*f)( static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2) , static_cast<T3&&>(a3) , static_cast<T4&&>(a4) , static_cast<T5&&>(a5));
+        }
+      };
+
+
+      template<
+        typename FunctionPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
+      >
+      struct get_function_invoker6
+      {
+        typedef typename conditional<(is_void<R>::value),
+                            void_function_invoker6<
+                            FunctionPtr,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5
+                          >,
+                          function_invoker6<
+                            FunctionPtr,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5
+                          >
+                       >::type type;
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
+       >
+      struct get_function_obj_invoker6
+      {
+        typedef typename conditional<(is_void<R>::value),
+                            void_function_obj_invoker6<
+                            FunctionObj,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5
+                          >,
+                          function_obj_invoker6<
+                            FunctionObj,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5
+                          >
+                       >::type type;
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
+       >
+      struct get_function_ref_invoker6
+      {
+        typedef typename conditional<(is_void<R>::value),
+                            void_function_ref_invoker6<
+                            FunctionObj,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5
+                          >,
+                          function_ref_invoker6<
+                            FunctionObj,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5
+                          >
+                       >::type type;
+      };
+
+
+
+      template<
+        typename MemberPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
+       >
+      struct get_member_invoker6
+      {
+        typedef typename conditional<(is_void<R>::value),
+                            function_void_mem_invoker6<
+                            MemberPtr,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5
+                          >,
+                          function_mem_invoker6<
+                            MemberPtr,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5
+                          >
+                       >::type type;
+      };
+# 331 "/usr/include/boost/function/function_template.hpp" 3 4
+      template<typename Tag>
+      struct get_invoker6 { };
+
+
+      template<>
+      struct get_invoker6<function_ptr_tag>
+      {
+        template<typename FunctionPtr,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
+        struct apply
+        {
+          typedef typename get_function_invoker6<
+                             FunctionPtr,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<FunctionPtr> manager_type;
+        };
+
+        template<typename FunctionPtr, typename Allocator,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
+        struct apply_a
+        {
+          typedef typename get_function_invoker6<
+                             FunctionPtr,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<FunctionPtr> manager_type;
+        };
+      };
+
+
+
+      template<>
+      struct get_invoker6<member_ptr_tag>
+      {
+        template<typename MemberPtr,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
+        struct apply
+        {
+          typedef typename get_member_invoker6<
+                             MemberPtr,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<MemberPtr> manager_type;
+        };
+
+        template<typename MemberPtr, typename Allocator,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
+        struct apply_a
+        {
+          typedef typename get_member_invoker6<
+                             MemberPtr,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<MemberPtr> manager_type;
+        };
+      };
+
+
+
+      template<>
+      struct get_invoker6<function_obj_tag>
+      {
+        template<typename FunctionObj,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
+        struct apply
+        {
+          typedef typename get_function_obj_invoker6<
+                             FunctionObj,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<FunctionObj> manager_type;
+        };
+
+        template<typename FunctionObj, typename Allocator,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
+        struct apply_a
+        {
+          typedef typename get_function_obj_invoker6<
+                             FunctionObj,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5
+                           >::type
+            invoker_type;
+
+          typedef functor_manager_a<FunctionObj, Allocator> manager_type;
+        };
+      };
+
+
+      template<>
+      struct get_invoker6<function_obj_ref_tag>
+      {
+        template<typename RefWrapper,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
+        struct apply
+        {
+          typedef typename get_function_ref_invoker6<
+                             typename RefWrapper::type,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5
+                           >::type
+            invoker_type;
+
+          typedef reference_manager<typename RefWrapper::type> manager_type;
+        };
+
+        template<typename RefWrapper, typename Allocator,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
+        struct apply_a
+        {
+          typedef typename get_function_ref_invoker6<
+                             typename RefWrapper::type,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5
+                           >::type
+            invoker_type;
+
+          typedef reference_manager<typename RefWrapper::type> manager_type;
+        };
+      };
+# 476 "/usr/include/boost/function/function_template.hpp" 3 4
+      template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
+      struct basic_vtable6
+      {
+
+        typedef R result_type;
+
+
+
+
+        typedef result_type (*invoker_type)(function_buffer&
+                                            ,
+                                            T0 , T1 , T2 , T3 , T4 , T5);
+
+        template<typename F>
+        bool assign_to(F f, function_buffer& functor) const
+        {
+          typedef typename get_function_tag<F>::type tag;
+          return assign_to(f, functor, tag());
+        }
+        template<typename F,typename Allocator>
+        bool assign_to_a(F f, function_buffer& functor, Allocator a) const
+        {
+          typedef typename get_function_tag<F>::type tag;
+          return assign_to_a(f, functor, a, tag());
+        }
+
+        void clear(function_buffer& functor) const
+        {
+          if (base.manager)
+            base.manager(functor, functor, destroy_functor_tag);
+        }
+
+      private:
+
+        template<typename FunctionPtr>
+        bool
+        assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag) const
+        {
+          this->clear(functor);
+          if (f) {
+
+
+            functor.members.func_ptr = reinterpret_cast<void (*)()>(f);
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionPtr,typename Allocator>
+        bool
+        assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const
+        {
+          return assign_to(f,functor,function_ptr_tag());
+        }
+
+
+
+        template<typename MemberPtr>
+        bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag) const
+        {
+
+
+
+          if (f) {
+            this->assign_to(boost::mem_fn(f), functor);
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename MemberPtr,typename Allocator>
+        bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag) const
+        {
+
+
+
+          if (f) {
+            this->assign_to_a(boost::mem_fn(f), functor, a);
+            return true;
+          } else {
+            return false;
+          }
+        }
+
+
+
+
+        template<typename FunctionObj>
+        void
+        assign_functor(FunctionObj f, function_buffer& functor, true_type) const
+        {
+          new (reinterpret_cast<void*>(functor.data)) FunctionObj(f);
+        }
+        template<typename FunctionObj,typename Allocator>
+        void
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, true_type) const
+        {
+          assign_functor(f,functor,true_type());
+        }
+
+
+        template<typename FunctionObj>
+        void
+        assign_functor(FunctionObj f, function_buffer& functor, false_type) const
+        {
+          functor.members.obj_ptr = new FunctionObj(f);
+        }
+        template<typename FunctionObj,typename Allocator>
+        void
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, false_type) const
+        {
+          typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;
+
+
+
+
+
+          using wrapper_allocator_type = typename std::allocator_traits<Allocator>::template rebind_alloc<functor_wrapper_type>;
+          using wrapper_allocator_pointer_type = typename std::allocator_traits<wrapper_allocator_type>::pointer;
+
+          wrapper_allocator_type wrapper_allocator(a);
+          wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
+
+
+
+          std::allocator_traits<wrapper_allocator_type>::construct(wrapper_allocator, copy, functor_wrapper_type(f,a));
+
+          functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
+          functor.members.obj_ptr = new_f;
+        }
+
+        template<typename FunctionObj>
+        bool
+        assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) const
+        {
+          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
+            assign_functor(f, functor,
+                           integral_constant<bool, (function_allows_small_object_optimization<FunctionObj>::value)>());
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionObj,typename Allocator>
+        bool
+        assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag) const
+        {
+          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
+            assign_functor_a(f, functor, a,
+                           integral_constant<bool, (function_allows_small_object_optimization<FunctionObj>::value)>());
+            return true;
+          } else {
+            return false;
+          }
+        }
+
+
+        template<typename FunctionObj>
+        bool
+        assign_to(const reference_wrapper<FunctionObj>& f,
+                  function_buffer& functor, function_obj_ref_tag) const
+        {
+          functor.members.obj_ref.obj_ptr = (void *)(f.get_pointer());
+          functor.members.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
+          functor.members.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
+          return true;
+        }
+        template<typename FunctionObj,typename Allocator>
+        bool
+        assign_to_a(const reference_wrapper<FunctionObj>& f,
+                  function_buffer& functor, Allocator, function_obj_ref_tag) const
+        {
+          return assign_to(f,functor,function_obj_ref_tag());
+        }
+
+      public:
+        vtable_base base;
+        invoker_type invoker;
+      };
+    }
+  }
+
+  template<
+    typename R ,
+    typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
+  >
+  class function6 : public function_base
+  {
+  public:
+
+    typedef R result_type;
+
+
+
+
+
+  private:
+    typedef boost::detail::function::basic_vtable6<
+              R , T0 , T1 , T2 , T3 , T4 , T5>
+      vtable_type;
+
+    vtable_type* get_vtable() const {
+      return reinterpret_cast<vtable_type*>(
+               reinterpret_cast<std::size_t>(vtable) & ~static_cast<std::size_t>(0x01));
+    }
+
+    struct clear_type {};
+
+  public:
+    static const int args = 6;
+
+
+    template<typename Args>
+    struct sig
+    {
+      typedef result_type type;
+    };
+# 701 "/usr/include/boost/function/function_template.hpp" 3 4
+    static const int arity = 6;
+    typedef T0 arg1_type; typedef T1 arg2_type; typedef T2 arg3_type; typedef T3 arg4_type; typedef T4 arg5_type; typedef T5 arg6_type;
+
+    typedef function6 self_type;
+
+    function6() = default;
+
+
+
+    template<typename Functor>
+    function6(Functor f
+
+                            ,typename boost::enable_if_<
+                             !(is_integral<Functor>::value),
+                                        int>::type = 0
+
+                            ) :
+      function_base()
+    {
+      this->assign_to(f);
+    }
+    template<typename Functor,typename Allocator>
+    function6(Functor f, Allocator a
+
+                            ,typename boost::enable_if_<
+                              !(is_integral<Functor>::value),
+                                        int>::type = 0
+
+                            ) :
+      function_base()
+    {
+      this->assign_to_a(f,a);
+    }
+
+
+    function6(clear_type*) : function_base() { }
+
+
+
+
+
+
+
+    function6(const function6& f) : function_base()
+    {
+      this->assign_to_own(f);
+    }
+
+
+    function6(function6&& f) : function_base()
+    {
+      this->move_assign(f);
+    }
+
+
+    ~function6() { clear(); }
+
+    result_type operator()( T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5) const
+    {
+      if (this->empty())
+        boost::throw_exception(bad_function_call());
+
+      return get_vtable()->invoker
+               (this->functor , static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2) , static_cast<T3&&>(a3) , static_cast<T4&&>(a4) , static_cast<T5&&>(a5));
+    }
+
+
+
+
+
+
+    template<typename Functor>
+
+    typename boost::enable_if_<
+                  !(is_integral<Functor>::value),
+               function6&>::type
+
+
+
+    operator=(Functor f)
+    {
+      this->clear();
+      { try {
+        this->assign_to(f);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+      return *this;
+    }
+    template<typename Functor,typename Allocator>
+    void assign(Functor f, Allocator a)
+    {
+      this->clear();
+      { try{
+        this->assign_to_a(f,a);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+    }
+
+
+    function6& operator=(clear_type*)
+    {
+      this->clear();
+      return *this;
+    }
+# 821 "/usr/include/boost/function/function_template.hpp" 3 4
+    function6& operator=(const function6& f)
+    {
+      if (&f == this)
+        return *this;
+
+      this->clear();
+      { try {
+        this->assign_to_own(f);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+      return *this;
+    }
+
+
+
+    function6& operator=(function6&& f)
+    {
+      if (&f == this)
+        return *this;
+
+      this->clear();
+      { try {
+        this->move_assign(f);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+      return *this;
+    }
+
+
+    void swap(function6& other)
+    {
+      if (&other == this)
+        return;
+
+      function6 tmp;
+      tmp.move_assign(*this);
+      this->move_assign(other);
+      other.move_assign(tmp);
+    }
+
+
+    void clear()
+    {
+      if (vtable) {
+        if (!this->has_trivial_copy_and_destroy())
+          get_vtable()->clear(this->functor);
+        vtable = 0;
+      }
+    }
+
+
+
+
+
+  private:
+    struct dummy {
+      void nonnull() {}
+    };
+
+    typedef void (dummy::*safe_bool)();
+
+  public:
+    operator safe_bool () const
+      { return (this->empty())? 0 : &dummy::nonnull; }
+
+    bool operator!() const
+      { return this->empty(); }
+
+
+  private:
+    void assign_to_own(const function6& f)
+    {
+      if (!f.empty()) {
+        this->vtable = f.vtable;
+        if (this->has_trivial_copy_and_destroy())
+
+
+          std::memcpy(this->functor.data, f.functor.data, sizeof(boost::detail::function::function_buffer));
+        else
+          get_vtable()->base.manager(f.functor, this->functor,
+                                     boost::detail::function::clone_functor_tag);
+      }
+    }
+
+    template<typename Functor>
+    void assign_to(Functor f)
+    {
+      using boost::detail::function::vtable_base;
+
+      typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
+      typedef boost::detail::function::get_invoker6<tag> get_invoker;
+      typedef typename get_invoker::
+                         template apply<Functor, R ,
+                        T0 , T1 , T2 , T3 , T4 , T5>
+        handler_type;
+
+      typedef typename handler_type::invoker_type invoker_type;
+      typedef typename handler_type::manager_type manager_type;
+
+
+
+
+
+      static const vtable_type stored_vtable =
+        { { &manager_type::manage }, &invoker_type::invoke };
+
+      if (stored_vtable.assign_to(f, functor)) {
+        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
+
+        if (boost::has_trivial_copy_constructor<Functor>::value &&
+            boost::has_trivial_destructor<Functor>::value &&
+            boost::detail::function::function_allows_small_object_optimization<Functor>::value)
+          value |= static_cast<std::size_t>(0x01);
+        vtable = reinterpret_cast<boost::detail::function::vtable_base *>(value);
+      } else
+        vtable = 0;
+    }
+
+    template<typename Functor,typename Allocator>
+    void assign_to_a(Functor f,Allocator a)
+    {
+      using boost::detail::function::vtable_base;
+
+      typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
+      typedef boost::detail::function::get_invoker6<tag> get_invoker;
+      typedef typename get_invoker::
+                         template apply_a<Functor, Allocator, R ,
+                         T0 , T1 , T2 , T3 , T4 , T5>
+        handler_type;
+
+      typedef typename handler_type::invoker_type invoker_type;
+      typedef typename handler_type::manager_type manager_type;
+
+
+
+
+
+      static const vtable_type stored_vtable =
+        { { &manager_type::manage }, &invoker_type::invoke };
+
+      if (stored_vtable.assign_to_a(f, functor, a)) {
+        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
+
+        if (boost::has_trivial_copy_constructor<Functor>::value &&
+            boost::has_trivial_destructor<Functor>::value &&
+            boost::detail::function::function_allows_small_object_optimization<Functor>::value)
+          value |= static_cast<std::size_t>(0x01);
+        vtable = reinterpret_cast<boost::detail::function::vtable_base *>(value);
+      } else
+        vtable = 0;
+    }
+
+
+
+
+    void move_assign(function6& f)
+    {
+      if (&f == this)
+        return;
+
+      { try {
+        if (!f.empty()) {
+          this->vtable = f.vtable;
+          if (this->has_trivial_copy_and_destroy())
+
+
+            std::memcpy(this->functor.data, f.functor.data, sizeof(this->functor.data));
+          else
+            get_vtable()->base.manager(f.functor, this->functor,
+                                     boost::detail::function::move_functor_tag);
+          f.vtable = 0;
+        } else {
+          clear();
+        }
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+    }
+  };
+
+  template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
+  inline void swap(function6<
+                     R ,
+                     T0 , T1 , T2 , T3 , T4 , T5
+                   >& f1,
+                   function6<
+                     R ,
+                     T0 , T1 , T2 , T3 , T4 , T5
+                   >& f2)
+  {
+    f1.swap(f2);
+  }
+
+
+template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
+  void operator==(const function6<
+                          R ,
+                          T0 , T1 , T2 , T3 , T4 , T5>&,
+                  const function6<
+                          R ,
+                          T0 , T1 , T2 , T3 , T4 , T5>&);
+template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
+  void operator!=(const function6<
+                          R ,
+                          T0 , T1 , T2 , T3 , T4 , T5>&,
+                  const function6<
+                          R ,
+                          T0 , T1 , T2 , T3 , T4 , T5>& );
+
+
+
+
+
+
+#define BOOST_FUNCTION_PARTIAL_SPEC R (BOOST_FUNCTION_TEMPLATE_ARGS)
+
+
+template<typename R ,
+         typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
+class function<R ( T0 , T1 , T2 , T3 , T4 , T5)>
+  : public function6<R , T0 , T1 , T2 , T3 , T4 , T5>
+{
+  typedef function6<R , T0 , T1 , T2 , T3 , T4 , T5> base_type;
+  typedef function self_type;
+
+  struct clear_type {};
+
+public:
+
+  function() = default;
+
+  template<typename Functor>
+  function(Functor f
+
+           ,typename boost::enable_if_<
+                          !(is_integral<Functor>::value),
+                       int>::type = 0
+
+           ) :
+    base_type(f)
+  {
+  }
+  template<typename Functor,typename Allocator>
+  function(Functor f, Allocator a
+
+           ,typename boost::enable_if_<
+                           !(is_integral<Functor>::value),
+                       int>::type = 0
+
+           ) :
+    base_type(f,a)
+  {
+  }
+
+
+  function(clear_type*) : base_type() {}
+
+
+  function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}
+
+  function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}
+
+
+
+  function(self_type&& f): base_type(static_cast<base_type&&>(f)){}
+  function(base_type&& f): base_type(static_cast<base_type&&>(f)){}
+
+
+  self_type& operator=(const self_type& f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+
+
+  self_type& operator=(self_type&& f)
+  {
+    self_type(static_cast<self_type&&>(f)).swap(*this);
+    return *this;
+  }
+
+
+  template<typename Functor>
+
+  typename boost::enable_if_<
+                         !(is_integral<Functor>::value),
+                      self_type&>::type
+
+
+
+  operator=(Functor f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+
+
+  self_type& operator=(clear_type*)
+  {
+    this->clear();
+    return *this;
+  }
+
+
+  self_type& operator=(const base_type& f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+
+
+  self_type& operator=(base_type&& f)
+  {
+    self_type(static_cast<base_type&&>(f)).swap(*this);
+    return *this;
+  }
+
+};
+
+#undef BOOST_FUNCTION_PARTIAL_SPEC
+
+
+}
+
+
+#undef BOOST_FUNCTION_VTABLE
+#undef BOOST_FUNCTION_COMMA
+#undef BOOST_FUNCTION_FUNCTION
+#undef BOOST_FUNCTION_FUNCTION_INVOKER
+#undef BOOST_FUNCTION_VOID_FUNCTION_INVOKER
+#undef BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
+#undef BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
+#undef BOOST_FUNCTION_FUNCTION_REF_INVOKER
+#undef BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER
+#undef BOOST_FUNCTION_MEMBER_INVOKER
+#undef BOOST_FUNCTION_VOID_MEMBER_INVOKER
+#undef BOOST_FUNCTION_GET_FUNCTION_INVOKER
+#undef BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
+#undef BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER
+#undef BOOST_FUNCTION_GET_MEM_FUNCTION_INVOKER
+#undef BOOST_FUNCTION_GET_INVOKER
+#undef BOOST_FUNCTION_TEMPLATE_PARMS
+#undef BOOST_FUNCTION_TEMPLATE_ARGS
+#undef BOOST_FUNCTION_PARMS
+#undef BOOST_FUNCTION_PARM
+
+#undef BOOST_FUNCTION_ARG
+
+#undef BOOST_FUNCTION_ARGS
+#undef BOOST_FUNCTION_ARG_TYPE
+#undef BOOST_FUNCTION_ARG_TYPES
+#undef BOOST_FUNCTION_VOID_RETURN_TYPE
+#undef BOOST_FUNCTION_RETURN
+# 58 "/usr/include/boost/function/detail/maybe_include.hpp" 2 3 4
+# 15 "/usr/include/boost/function/detail/function_iterate.hpp" 2 3 4
+#undef BOOST_FUNCTION_NUM_ARGS
+# 78 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
+#undef BOOST_PP_ITERATION_1
+
+
+#define BOOST_PP_ITERATION_1 7
+# 1 "/usr/include/boost/function/detail/function_iterate.hpp" 1 3 4
+# 13 "/usr/include/boost/function/detail/function_iterate.hpp" 3 4
+#define BOOST_FUNCTION_NUM_ARGS BOOST_PP_ITERATION()
+# 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
+# 60 "/usr/include/boost/function/detail/maybe_include.hpp" 3 4
+#undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#define BOOST_FUNCTION_MAX_ARGS_DEFINED 7
+
+#define BOOST_FUNCTION_7 
+# 1 "/usr/include/boost/function/function_template.hpp" 1 3 4
+# 21 "/usr/include/boost/function/function_template.hpp" 3 4
+#define BOOST_FUNCTION_TEMPLATE_PARMS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, typename T)
+
+#define BOOST_FUNCTION_TEMPLATE_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, T)
+
+#define BOOST_FUNCTION_PARM(J,I,D) BOOST_PP_CAT(T,I) BOOST_PP_CAT(a,I)
+
+#define BOOST_FUNCTION_PARMS BOOST_PP_ENUM(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_PARM,BOOST_PP_EMPTY)
+
+
+
+
+#define BOOST_FUNCTION_ARG(J,I,D) static_cast<BOOST_PP_CAT(T,I)&&>(BOOST_PP_CAT(a,I))
+#define BOOST_FUNCTION_ARGS BOOST_PP_ENUM(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_ARG,BOOST_PP_EMPTY)
+
+
+#define BOOST_FUNCTION_ARG_TYPE(J,I,D) typedef BOOST_PP_CAT(T,I) BOOST_PP_CAT(BOOST_PP_CAT(arg, BOOST_PP_INC(I)),_type);
+
+
+#define BOOST_FUNCTION_ARG_TYPES BOOST_PP_REPEAT(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_ARG_TYPE,BOOST_PP_EMPTY)
+
+
+
+
+
+#define BOOST_FUNCTION_COMMA ,
+
+
+
+#define BOOST_FUNCTION_FUNCTION BOOST_JOIN(function,BOOST_FUNCTION_NUM_ARGS)
+#define BOOST_FUNCTION_FUNCTION_INVOKER BOOST_JOIN(function_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_VOID_FUNCTION_INVOKER BOOST_JOIN(void_function_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_FUNCTION_OBJ_INVOKER BOOST_JOIN(function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER BOOST_JOIN(void_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_FUNCTION_REF_INVOKER BOOST_JOIN(function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER BOOST_JOIN(void_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_MEMBER_INVOKER BOOST_JOIN(function_mem_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_VOID_MEMBER_INVOKER BOOST_JOIN(function_void_mem_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_GET_FUNCTION_INVOKER BOOST_JOIN(get_function_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER BOOST_JOIN(get_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER BOOST_JOIN(get_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_GET_MEMBER_INVOKER BOOST_JOIN(get_member_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_GET_INVOKER BOOST_JOIN(get_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_VTABLE BOOST_JOIN(basic_vtable,BOOST_FUNCTION_NUM_ARGS)
+
+
+#define BOOST_FUNCTION_VOID_RETURN_TYPE void
+#define BOOST_FUNCTION_RETURN(X) X
+
+
+
+
+
+namespace boost {
+  namespace detail {
+    namespace function {
+      template<
+        typename FunctionPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
+        >
+      struct function_invoker7
+      {
+        static R invoke(function_buffer& function_ptr ,
+                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6)
+        {
+          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.members.func_ptr);
+          return f( static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2) , static_cast<T3&&>(a3) , static_cast<T4&&>(a4) , static_cast<T5&&>(a5) , static_cast<T6&&>(a6));
+        }
+      };
+
+      template<
+        typename FunctionPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
+        >
+      struct void_function_invoker7
+      {
+        static void
+        invoke(function_buffer& function_ptr ,
+               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6)
+
+        {
+          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.members.func_ptr);
+          f( static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2) , static_cast<T3&&>(a3) , static_cast<T4&&>(a4) , static_cast<T5&&>(a5) , static_cast<T6&&>(a6));
+        }
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
+      >
+      struct function_obj_invoker7
+      {
+        static R invoke(function_buffer& function_obj_ptr ,
+                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6)
+
+        {
+          FunctionObj* f;
+          if (function_allows_small_object_optimization<FunctionObj>::value)
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.data);
+          else
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
+          return (*f)( static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2) , static_cast<T3&&>(a3) , static_cast<T4&&>(a4) , static_cast<T5&&>(a5) , static_cast<T6&&>(a6));
+        }
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
+      >
+      struct void_function_obj_invoker7
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr ,
+               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6)
+
+        {
+          FunctionObj* f;
+          if (function_allows_small_object_optimization<FunctionObj>::value)
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.data);
+          else
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
+          (*f)( static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2) , static_cast<T3&&>(a3) , static_cast<T4&&>(a4) , static_cast<T5&&>(a5) , static_cast<T6&&>(a6));
+        }
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
+      >
+      struct function_ref_invoker7
+      {
+        static R invoke(function_buffer& function_obj_ptr ,
+                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6)
+
+        {
+          FunctionObj* f =
+            reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
+          return (*f)( static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2) , static_cast<T3&&>(a3) , static_cast<T4&&>(a4) , static_cast<T5&&>(a5) , static_cast<T6&&>(a6));
+        }
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
+      >
+      struct void_function_ref_invoker7
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr ,
+               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6)
+
+        {
+          FunctionObj* f =
+            reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
+          (*f)( static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2) , static_cast<T3&&>(a3) , static_cast<T4&&>(a4) , static_cast<T5&&>(a5) , static_cast<T6&&>(a6));
+        }
+      };
+
+
+
+      template<
+        typename MemberPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
+      >
+      struct function_mem_invoker7
+      {
+        static R invoke(function_buffer& function_obj_ptr ,
+                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6)
+
+        {
+          MemberPtr* f =
+            reinterpret_cast<MemberPtr*>(function_obj_ptr.data);
+          return boost::mem_fn(*f)( static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2) , static_cast<T3&&>(a3) , static_cast<T4&&>(a4) , static_cast<T5&&>(a5) , static_cast<T6&&>(a6));
+        }
+      };
+
+      template<
+        typename MemberPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
+      >
+      struct function_void_mem_invoker7
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr ,
+               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6)
+
+        {
+          MemberPtr* f =
+            reinterpret_cast<MemberPtr*>(function_obj_ptr.data);
+          boost::mem_fn(*f)( static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2) , static_cast<T3&&>(a3) , static_cast<T4&&>(a4) , static_cast<T5&&>(a5) , static_cast<T6&&>(a6));
+        }
+      };
+
+
+      template<
+        typename FunctionPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
+      >
+      struct get_function_invoker7
+      {
+        typedef typename conditional<(is_void<R>::value),
+                            void_function_invoker7<
+                            FunctionPtr,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5 , T6
+                          >,
+                          function_invoker7<
+                            FunctionPtr,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5 , T6
+                          >
+                       >::type type;
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
+       >
+      struct get_function_obj_invoker7
+      {
+        typedef typename conditional<(is_void<R>::value),
+                            void_function_obj_invoker7<
+                            FunctionObj,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5 , T6
+                          >,
+                          function_obj_invoker7<
+                            FunctionObj,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5 , T6
+                          >
+                       >::type type;
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
+       >
+      struct get_function_ref_invoker7
+      {
+        typedef typename conditional<(is_void<R>::value),
+                            void_function_ref_invoker7<
+                            FunctionObj,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5 , T6
+                          >,
+                          function_ref_invoker7<
+                            FunctionObj,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5 , T6
+                          >
+                       >::type type;
+      };
+
+
+
+      template<
+        typename MemberPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
+       >
+      struct get_member_invoker7
+      {
+        typedef typename conditional<(is_void<R>::value),
+                            function_void_mem_invoker7<
+                            MemberPtr,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5 , T6
+                          >,
+                          function_mem_invoker7<
+                            MemberPtr,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5 , T6
+                          >
+                       >::type type;
+      };
+# 331 "/usr/include/boost/function/function_template.hpp" 3 4
+      template<typename Tag>
+      struct get_invoker7 { };
+
+
+      template<>
+      struct get_invoker7<function_ptr_tag>
+      {
+        template<typename FunctionPtr,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
+        struct apply
+        {
+          typedef typename get_function_invoker7<
+                             FunctionPtr,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5 , T6
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<FunctionPtr> manager_type;
+        };
+
+        template<typename FunctionPtr, typename Allocator,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
+        struct apply_a
+        {
+          typedef typename get_function_invoker7<
+                             FunctionPtr,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5 , T6
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<FunctionPtr> manager_type;
+        };
+      };
+
+
+
+      template<>
+      struct get_invoker7<member_ptr_tag>
+      {
+        template<typename MemberPtr,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
+        struct apply
+        {
+          typedef typename get_member_invoker7<
+                             MemberPtr,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5 , T6
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<MemberPtr> manager_type;
+        };
+
+        template<typename MemberPtr, typename Allocator,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
+        struct apply_a
+        {
+          typedef typename get_member_invoker7<
+                             MemberPtr,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5 , T6
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<MemberPtr> manager_type;
+        };
+      };
+
+
+
+      template<>
+      struct get_invoker7<function_obj_tag>
+      {
+        template<typename FunctionObj,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
+        struct apply
+        {
+          typedef typename get_function_obj_invoker7<
+                             FunctionObj,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5 , T6
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<FunctionObj> manager_type;
+        };
+
+        template<typename FunctionObj, typename Allocator,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
+        struct apply_a
+        {
+          typedef typename get_function_obj_invoker7<
+                             FunctionObj,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5 , T6
+                           >::type
+            invoker_type;
+
+          typedef functor_manager_a<FunctionObj, Allocator> manager_type;
+        };
+      };
+
+
+      template<>
+      struct get_invoker7<function_obj_ref_tag>
+      {
+        template<typename RefWrapper,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
+        struct apply
+        {
+          typedef typename get_function_ref_invoker7<
+                             typename RefWrapper::type,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5 , T6
+                           >::type
+            invoker_type;
+
+          typedef reference_manager<typename RefWrapper::type> manager_type;
+        };
+
+        template<typename RefWrapper, typename Allocator,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
+        struct apply_a
+        {
+          typedef typename get_function_ref_invoker7<
+                             typename RefWrapper::type,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5 , T6
+                           >::type
+            invoker_type;
+
+          typedef reference_manager<typename RefWrapper::type> manager_type;
+        };
+      };
+# 476 "/usr/include/boost/function/function_template.hpp" 3 4
+      template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
+      struct basic_vtable7
+      {
+
+        typedef R result_type;
+
+
+
+
+        typedef result_type (*invoker_type)(function_buffer&
+                                            ,
+                                            T0 , T1 , T2 , T3 , T4 , T5 , T6);
+
+        template<typename F>
+        bool assign_to(F f, function_buffer& functor) const
+        {
+          typedef typename get_function_tag<F>::type tag;
+          return assign_to(f, functor, tag());
+        }
+        template<typename F,typename Allocator>
+        bool assign_to_a(F f, function_buffer& functor, Allocator a) const
+        {
+          typedef typename get_function_tag<F>::type tag;
+          return assign_to_a(f, functor, a, tag());
+        }
+
+        void clear(function_buffer& functor) const
+        {
+          if (base.manager)
+            base.manager(functor, functor, destroy_functor_tag);
+        }
+
+      private:
+
+        template<typename FunctionPtr>
+        bool
+        assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag) const
+        {
+          this->clear(functor);
+          if (f) {
+
+
+            functor.members.func_ptr = reinterpret_cast<void (*)()>(f);
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionPtr,typename Allocator>
+        bool
+        assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const
+        {
+          return assign_to(f,functor,function_ptr_tag());
+        }
+
+
+
+        template<typename MemberPtr>
+        bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag) const
+        {
+
+
+
+          if (f) {
+            this->assign_to(boost::mem_fn(f), functor);
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename MemberPtr,typename Allocator>
+        bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag) const
+        {
+
+
+
+          if (f) {
+            this->assign_to_a(boost::mem_fn(f), functor, a);
+            return true;
+          } else {
+            return false;
+          }
+        }
+
+
+
+
+        template<typename FunctionObj>
+        void
+        assign_functor(FunctionObj f, function_buffer& functor, true_type) const
+        {
+          new (reinterpret_cast<void*>(functor.data)) FunctionObj(f);
+        }
+        template<typename FunctionObj,typename Allocator>
+        void
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, true_type) const
+        {
+          assign_functor(f,functor,true_type());
+        }
+
+
+        template<typename FunctionObj>
+        void
+        assign_functor(FunctionObj f, function_buffer& functor, false_type) const
+        {
+          functor.members.obj_ptr = new FunctionObj(f);
+        }
+        template<typename FunctionObj,typename Allocator>
+        void
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, false_type) const
+        {
+          typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;
+
+
+
+
+
+          using wrapper_allocator_type = typename std::allocator_traits<Allocator>::template rebind_alloc<functor_wrapper_type>;
+          using wrapper_allocator_pointer_type = typename std::allocator_traits<wrapper_allocator_type>::pointer;
+
+          wrapper_allocator_type wrapper_allocator(a);
+          wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
+
+
+
+          std::allocator_traits<wrapper_allocator_type>::construct(wrapper_allocator, copy, functor_wrapper_type(f,a));
+
+          functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
+          functor.members.obj_ptr = new_f;
+        }
+
+        template<typename FunctionObj>
+        bool
+        assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) const
+        {
+          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
+            assign_functor(f, functor,
+                           integral_constant<bool, (function_allows_small_object_optimization<FunctionObj>::value)>());
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionObj,typename Allocator>
+        bool
+        assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag) const
+        {
+          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
+            assign_functor_a(f, functor, a,
+                           integral_constant<bool, (function_allows_small_object_optimization<FunctionObj>::value)>());
+            return true;
+          } else {
+            return false;
+          }
+        }
+
+
+        template<typename FunctionObj>
+        bool
+        assign_to(const reference_wrapper<FunctionObj>& f,
+                  function_buffer& functor, function_obj_ref_tag) const
+        {
+          functor.members.obj_ref.obj_ptr = (void *)(f.get_pointer());
+          functor.members.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
+          functor.members.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
+          return true;
+        }
+        template<typename FunctionObj,typename Allocator>
+        bool
+        assign_to_a(const reference_wrapper<FunctionObj>& f,
+                  function_buffer& functor, Allocator, function_obj_ref_tag) const
+        {
+          return assign_to(f,functor,function_obj_ref_tag());
+        }
+
+      public:
+        vtable_base base;
+        invoker_type invoker;
+      };
+    }
+  }
+
+  template<
+    typename R ,
+    typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
+  >
+  class function7 : public function_base
+  {
+  public:
+
+    typedef R result_type;
+
+
+
+
+
+  private:
+    typedef boost::detail::function::basic_vtable7<
+              R , T0 , T1 , T2 , T3 , T4 , T5 , T6>
+      vtable_type;
+
+    vtable_type* get_vtable() const {
+      return reinterpret_cast<vtable_type*>(
+               reinterpret_cast<std::size_t>(vtable) & ~static_cast<std::size_t>(0x01));
+    }
+
+    struct clear_type {};
+
+  public:
+    static const int args = 7;
+
+
+    template<typename Args>
+    struct sig
+    {
+      typedef result_type type;
+    };
+# 701 "/usr/include/boost/function/function_template.hpp" 3 4
+    static const int arity = 7;
+    typedef T0 arg1_type; typedef T1 arg2_type; typedef T2 arg3_type; typedef T3 arg4_type; typedef T4 arg5_type; typedef T5 arg6_type; typedef T6 arg7_type;
+
+    typedef function7 self_type;
+
+    function7() = default;
+
+
+
+    template<typename Functor>
+    function7(Functor f
+
+                            ,typename boost::enable_if_<
+                             !(is_integral<Functor>::value),
+                                        int>::type = 0
+
+                            ) :
+      function_base()
+    {
+      this->assign_to(f);
+    }
+    template<typename Functor,typename Allocator>
+    function7(Functor f, Allocator a
+
+                            ,typename boost::enable_if_<
+                              !(is_integral<Functor>::value),
+                                        int>::type = 0
+
+                            ) :
+      function_base()
+    {
+      this->assign_to_a(f,a);
+    }
+
+
+    function7(clear_type*) : function_base() { }
+
+
+
+
+
+
+
+    function7(const function7& f) : function_base()
+    {
+      this->assign_to_own(f);
+    }
+
+
+    function7(function7&& f) : function_base()
+    {
+      this->move_assign(f);
+    }
+
+
+    ~function7() { clear(); }
+
+    result_type operator()( T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6) const
+    {
+      if (this->empty())
+        boost::throw_exception(bad_function_call());
+
+      return get_vtable()->invoker
+               (this->functor , static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2) , static_cast<T3&&>(a3) , static_cast<T4&&>(a4) , static_cast<T5&&>(a5) , static_cast<T6&&>(a6));
+    }
+
+
+
+
+
+
+    template<typename Functor>
+
+    typename boost::enable_if_<
+                  !(is_integral<Functor>::value),
+               function7&>::type
+
+
+
+    operator=(Functor f)
+    {
+      this->clear();
+      { try {
+        this->assign_to(f);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+      return *this;
+    }
+    template<typename Functor,typename Allocator>
+    void assign(Functor f, Allocator a)
+    {
+      this->clear();
+      { try{
+        this->assign_to_a(f,a);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+    }
+
+
+    function7& operator=(clear_type*)
+    {
+      this->clear();
+      return *this;
+    }
+# 821 "/usr/include/boost/function/function_template.hpp" 3 4
+    function7& operator=(const function7& f)
+    {
+      if (&f == this)
+        return *this;
+
+      this->clear();
+      { try {
+        this->assign_to_own(f);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+      return *this;
+    }
+
+
+
+    function7& operator=(function7&& f)
+    {
+      if (&f == this)
+        return *this;
+
+      this->clear();
+      { try {
+        this->move_assign(f);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+      return *this;
+    }
+
+
+    void swap(function7& other)
+    {
+      if (&other == this)
+        return;
+
+      function7 tmp;
+      tmp.move_assign(*this);
+      this->move_assign(other);
+      other.move_assign(tmp);
+    }
+
+
+    void clear()
+    {
+      if (vtable) {
+        if (!this->has_trivial_copy_and_destroy())
+          get_vtable()->clear(this->functor);
+        vtable = 0;
+      }
+    }
+
+
+
+
+
+  private:
+    struct dummy {
+      void nonnull() {}
+    };
+
+    typedef void (dummy::*safe_bool)();
+
+  public:
+    operator safe_bool () const
+      { return (this->empty())? 0 : &dummy::nonnull; }
+
+    bool operator!() const
+      { return this->empty(); }
+
+
+  private:
+    void assign_to_own(const function7& f)
+    {
+      if (!f.empty()) {
+        this->vtable = f.vtable;
+        if (this->has_trivial_copy_and_destroy())
+
+
+          std::memcpy(this->functor.data, f.functor.data, sizeof(boost::detail::function::function_buffer));
+        else
+          get_vtable()->base.manager(f.functor, this->functor,
+                                     boost::detail::function::clone_functor_tag);
+      }
+    }
+
+    template<typename Functor>
+    void assign_to(Functor f)
+    {
+      using boost::detail::function::vtable_base;
+
+      typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
+      typedef boost::detail::function::get_invoker7<tag> get_invoker;
+      typedef typename get_invoker::
+                         template apply<Functor, R ,
+                        T0 , T1 , T2 , T3 , T4 , T5 , T6>
+        handler_type;
+
+      typedef typename handler_type::invoker_type invoker_type;
+      typedef typename handler_type::manager_type manager_type;
+
+
+
+
+
+      static const vtable_type stored_vtable =
+        { { &manager_type::manage }, &invoker_type::invoke };
+
+      if (stored_vtable.assign_to(f, functor)) {
+        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
+
+        if (boost::has_trivial_copy_constructor<Functor>::value &&
+            boost::has_trivial_destructor<Functor>::value &&
+            boost::detail::function::function_allows_small_object_optimization<Functor>::value)
+          value |= static_cast<std::size_t>(0x01);
+        vtable = reinterpret_cast<boost::detail::function::vtable_base *>(value);
+      } else
+        vtable = 0;
+    }
+
+    template<typename Functor,typename Allocator>
+    void assign_to_a(Functor f,Allocator a)
+    {
+      using boost::detail::function::vtable_base;
+
+      typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
+      typedef boost::detail::function::get_invoker7<tag> get_invoker;
+      typedef typename get_invoker::
+                         template apply_a<Functor, Allocator, R ,
+                         T0 , T1 , T2 , T3 , T4 , T5 , T6>
+        handler_type;
+
+      typedef typename handler_type::invoker_type invoker_type;
+      typedef typename handler_type::manager_type manager_type;
+
+
+
+
+
+      static const vtable_type stored_vtable =
+        { { &manager_type::manage }, &invoker_type::invoke };
+
+      if (stored_vtable.assign_to_a(f, functor, a)) {
+        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
+
+        if (boost::has_trivial_copy_constructor<Functor>::value &&
+            boost::has_trivial_destructor<Functor>::value &&
+            boost::detail::function::function_allows_small_object_optimization<Functor>::value)
+          value |= static_cast<std::size_t>(0x01);
+        vtable = reinterpret_cast<boost::detail::function::vtable_base *>(value);
+      } else
+        vtable = 0;
+    }
+
+
+
+
+    void move_assign(function7& f)
+    {
+      if (&f == this)
+        return;
+
+      { try {
+        if (!f.empty()) {
+          this->vtable = f.vtable;
+          if (this->has_trivial_copy_and_destroy())
+
+
+            std::memcpy(this->functor.data, f.functor.data, sizeof(this->functor.data));
+          else
+            get_vtable()->base.manager(f.functor, this->functor,
+                                     boost::detail::function::move_functor_tag);
+          f.vtable = 0;
+        } else {
+          clear();
+        }
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+    }
+  };
+
+  template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
+  inline void swap(function7<
+                     R ,
+                     T0 , T1 , T2 , T3 , T4 , T5 , T6
+                   >& f1,
+                   function7<
+                     R ,
+                     T0 , T1 , T2 , T3 , T4 , T5 , T6
+                   >& f2)
+  {
+    f1.swap(f2);
+  }
+
+
+template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
+  void operator==(const function7<
+                          R ,
+                          T0 , T1 , T2 , T3 , T4 , T5 , T6>&,
+                  const function7<
+                          R ,
+                          T0 , T1 , T2 , T3 , T4 , T5 , T6>&);
+template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
+  void operator!=(const function7<
+                          R ,
+                          T0 , T1 , T2 , T3 , T4 , T5 , T6>&,
+                  const function7<
+                          R ,
+                          T0 , T1 , T2 , T3 , T4 , T5 , T6>& );
+
+
+
+
+
+
+#define BOOST_FUNCTION_PARTIAL_SPEC R (BOOST_FUNCTION_TEMPLATE_ARGS)
+
+
+template<typename R ,
+         typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
+class function<R ( T0 , T1 , T2 , T3 , T4 , T5 , T6)>
+  : public function7<R , T0 , T1 , T2 , T3 , T4 , T5 , T6>
+{
+  typedef function7<R , T0 , T1 , T2 , T3 , T4 , T5 , T6> base_type;
+  typedef function self_type;
+
+  struct clear_type {};
+
+public:
+
+  function() = default;
+
+  template<typename Functor>
+  function(Functor f
+
+           ,typename boost::enable_if_<
+                          !(is_integral<Functor>::value),
+                       int>::type = 0
+
+           ) :
+    base_type(f)
+  {
+  }
+  template<typename Functor,typename Allocator>
+  function(Functor f, Allocator a
+
+           ,typename boost::enable_if_<
+                           !(is_integral<Functor>::value),
+                       int>::type = 0
+
+           ) :
+    base_type(f,a)
+  {
+  }
+
+
+  function(clear_type*) : base_type() {}
+
+
+  function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}
+
+  function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}
+
+
+
+  function(self_type&& f): base_type(static_cast<base_type&&>(f)){}
+  function(base_type&& f): base_type(static_cast<base_type&&>(f)){}
+
+
+  self_type& operator=(const self_type& f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+
+
+  self_type& operator=(self_type&& f)
+  {
+    self_type(static_cast<self_type&&>(f)).swap(*this);
+    return *this;
+  }
+
+
+  template<typename Functor>
+
+  typename boost::enable_if_<
+                         !(is_integral<Functor>::value),
+                      self_type&>::type
+
+
+
+  operator=(Functor f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+
+
+  self_type& operator=(clear_type*)
+  {
+    this->clear();
+    return *this;
+  }
+
+
+  self_type& operator=(const base_type& f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+
+
+  self_type& operator=(base_type&& f)
+  {
+    self_type(static_cast<base_type&&>(f)).swap(*this);
+    return *this;
+  }
+
+};
+
+#undef BOOST_FUNCTION_PARTIAL_SPEC
+
+
+}
+
+
+#undef BOOST_FUNCTION_VTABLE
+#undef BOOST_FUNCTION_COMMA
+#undef BOOST_FUNCTION_FUNCTION
+#undef BOOST_FUNCTION_FUNCTION_INVOKER
+#undef BOOST_FUNCTION_VOID_FUNCTION_INVOKER
+#undef BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
+#undef BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
+#undef BOOST_FUNCTION_FUNCTION_REF_INVOKER
+#undef BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER
+#undef BOOST_FUNCTION_MEMBER_INVOKER
+#undef BOOST_FUNCTION_VOID_MEMBER_INVOKER
+#undef BOOST_FUNCTION_GET_FUNCTION_INVOKER
+#undef BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
+#undef BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER
+#undef BOOST_FUNCTION_GET_MEM_FUNCTION_INVOKER
+#undef BOOST_FUNCTION_GET_INVOKER
+#undef BOOST_FUNCTION_TEMPLATE_PARMS
+#undef BOOST_FUNCTION_TEMPLATE_ARGS
+#undef BOOST_FUNCTION_PARMS
+#undef BOOST_FUNCTION_PARM
+
+#undef BOOST_FUNCTION_ARG
+
+#undef BOOST_FUNCTION_ARGS
+#undef BOOST_FUNCTION_ARG_TYPE
+#undef BOOST_FUNCTION_ARG_TYPES
+#undef BOOST_FUNCTION_VOID_RETURN_TYPE
+#undef BOOST_FUNCTION_RETURN
+# 65 "/usr/include/boost/function/detail/maybe_include.hpp" 2 3 4
+# 15 "/usr/include/boost/function/detail/function_iterate.hpp" 2 3 4
+#undef BOOST_FUNCTION_NUM_ARGS
+# 83 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
+#undef BOOST_PP_ITERATION_1
+
+
+#define BOOST_PP_ITERATION_1 8
+# 1 "/usr/include/boost/function/detail/function_iterate.hpp" 1 3 4
+# 13 "/usr/include/boost/function/detail/function_iterate.hpp" 3 4
+#define BOOST_FUNCTION_NUM_ARGS BOOST_PP_ITERATION()
+# 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
+# 67 "/usr/include/boost/function/detail/maybe_include.hpp" 3 4
+#undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#define BOOST_FUNCTION_MAX_ARGS_DEFINED 8
+
+#define BOOST_FUNCTION_8 
+# 1 "/usr/include/boost/function/function_template.hpp" 1 3 4
+# 21 "/usr/include/boost/function/function_template.hpp" 3 4
+#define BOOST_FUNCTION_TEMPLATE_PARMS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, typename T)
+
+#define BOOST_FUNCTION_TEMPLATE_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, T)
+
+#define BOOST_FUNCTION_PARM(J,I,D) BOOST_PP_CAT(T,I) BOOST_PP_CAT(a,I)
+
+#define BOOST_FUNCTION_PARMS BOOST_PP_ENUM(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_PARM,BOOST_PP_EMPTY)
+
+
+
+
+#define BOOST_FUNCTION_ARG(J,I,D) static_cast<BOOST_PP_CAT(T,I)&&>(BOOST_PP_CAT(a,I))
+#define BOOST_FUNCTION_ARGS BOOST_PP_ENUM(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_ARG,BOOST_PP_EMPTY)
+
+
+#define BOOST_FUNCTION_ARG_TYPE(J,I,D) typedef BOOST_PP_CAT(T,I) BOOST_PP_CAT(BOOST_PP_CAT(arg, BOOST_PP_INC(I)),_type);
+
+
+#define BOOST_FUNCTION_ARG_TYPES BOOST_PP_REPEAT(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_ARG_TYPE,BOOST_PP_EMPTY)
+
+
+
+
+
+#define BOOST_FUNCTION_COMMA ,
+
+
+
+#define BOOST_FUNCTION_FUNCTION BOOST_JOIN(function,BOOST_FUNCTION_NUM_ARGS)
+#define BOOST_FUNCTION_FUNCTION_INVOKER BOOST_JOIN(function_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_VOID_FUNCTION_INVOKER BOOST_JOIN(void_function_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_FUNCTION_OBJ_INVOKER BOOST_JOIN(function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER BOOST_JOIN(void_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_FUNCTION_REF_INVOKER BOOST_JOIN(function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER BOOST_JOIN(void_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_MEMBER_INVOKER BOOST_JOIN(function_mem_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_VOID_MEMBER_INVOKER BOOST_JOIN(function_void_mem_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_GET_FUNCTION_INVOKER BOOST_JOIN(get_function_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER BOOST_JOIN(get_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER BOOST_JOIN(get_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_GET_MEMBER_INVOKER BOOST_JOIN(get_member_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_GET_INVOKER BOOST_JOIN(get_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_VTABLE BOOST_JOIN(basic_vtable,BOOST_FUNCTION_NUM_ARGS)
+
+
+#define BOOST_FUNCTION_VOID_RETURN_TYPE void
+#define BOOST_FUNCTION_RETURN(X) X
+
+
+
+
+
+namespace boost {
+  namespace detail {
+    namespace function {
+      template<
+        typename FunctionPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
+        >
+      struct function_invoker8
+      {
+        static R invoke(function_buffer& function_ptr ,
+                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7)
+        {
+          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.members.func_ptr);
+          return f( static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2) , static_cast<T3&&>(a3) , static_cast<T4&&>(a4) , static_cast<T5&&>(a5) , static_cast<T6&&>(a6) , static_cast<T7&&>(a7));
+        }
+      };
+
+      template<
+        typename FunctionPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
+        >
+      struct void_function_invoker8
+      {
+        static void
+        invoke(function_buffer& function_ptr ,
+               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7)
+
+        {
+          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.members.func_ptr);
+          f( static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2) , static_cast<T3&&>(a3) , static_cast<T4&&>(a4) , static_cast<T5&&>(a5) , static_cast<T6&&>(a6) , static_cast<T7&&>(a7));
+        }
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
+      >
+      struct function_obj_invoker8
+      {
+        static R invoke(function_buffer& function_obj_ptr ,
+                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7)
+
+        {
+          FunctionObj* f;
+          if (function_allows_small_object_optimization<FunctionObj>::value)
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.data);
+          else
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
+          return (*f)( static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2) , static_cast<T3&&>(a3) , static_cast<T4&&>(a4) , static_cast<T5&&>(a5) , static_cast<T6&&>(a6) , static_cast<T7&&>(a7));
+        }
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
+      >
+      struct void_function_obj_invoker8
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr ,
+               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7)
+
+        {
+          FunctionObj* f;
+          if (function_allows_small_object_optimization<FunctionObj>::value)
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.data);
+          else
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
+          (*f)( static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2) , static_cast<T3&&>(a3) , static_cast<T4&&>(a4) , static_cast<T5&&>(a5) , static_cast<T6&&>(a6) , static_cast<T7&&>(a7));
+        }
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
+      >
+      struct function_ref_invoker8
+      {
+        static R invoke(function_buffer& function_obj_ptr ,
+                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7)
+
+        {
+          FunctionObj* f =
+            reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
+          return (*f)( static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2) , static_cast<T3&&>(a3) , static_cast<T4&&>(a4) , static_cast<T5&&>(a5) , static_cast<T6&&>(a6) , static_cast<T7&&>(a7));
+        }
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
+      >
+      struct void_function_ref_invoker8
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr ,
+               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7)
+
+        {
+          FunctionObj* f =
+            reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
+          (*f)( static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2) , static_cast<T3&&>(a3) , static_cast<T4&&>(a4) , static_cast<T5&&>(a5) , static_cast<T6&&>(a6) , static_cast<T7&&>(a7));
+        }
+      };
+
+
+
+      template<
+        typename MemberPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
+      >
+      struct function_mem_invoker8
+      {
+        static R invoke(function_buffer& function_obj_ptr ,
+                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7)
+
+        {
+          MemberPtr* f =
+            reinterpret_cast<MemberPtr*>(function_obj_ptr.data);
+          return boost::mem_fn(*f)( static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2) , static_cast<T3&&>(a3) , static_cast<T4&&>(a4) , static_cast<T5&&>(a5) , static_cast<T6&&>(a6) , static_cast<T7&&>(a7));
+        }
+      };
+
+      template<
+        typename MemberPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
+      >
+      struct function_void_mem_invoker8
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr ,
+               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7)
+
+        {
+          MemberPtr* f =
+            reinterpret_cast<MemberPtr*>(function_obj_ptr.data);
+          boost::mem_fn(*f)( static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2) , static_cast<T3&&>(a3) , static_cast<T4&&>(a4) , static_cast<T5&&>(a5) , static_cast<T6&&>(a6) , static_cast<T7&&>(a7));
+        }
+      };
+
+
+      template<
+        typename FunctionPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
+      >
+      struct get_function_invoker8
+      {
+        typedef typename conditional<(is_void<R>::value),
+                            void_function_invoker8<
+                            FunctionPtr,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
+                          >,
+                          function_invoker8<
+                            FunctionPtr,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
+                          >
+                       >::type type;
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
+       >
+      struct get_function_obj_invoker8
+      {
+        typedef typename conditional<(is_void<R>::value),
+                            void_function_obj_invoker8<
+                            FunctionObj,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
+                          >,
+                          function_obj_invoker8<
+                            FunctionObj,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
+                          >
+                       >::type type;
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
+       >
+      struct get_function_ref_invoker8
+      {
+        typedef typename conditional<(is_void<R>::value),
+                            void_function_ref_invoker8<
+                            FunctionObj,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
+                          >,
+                          function_ref_invoker8<
+                            FunctionObj,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
+                          >
+                       >::type type;
+      };
+
+
+
+      template<
+        typename MemberPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
+       >
+      struct get_member_invoker8
+      {
+        typedef typename conditional<(is_void<R>::value),
+                            function_void_mem_invoker8<
+                            MemberPtr,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
+                          >,
+                          function_mem_invoker8<
+                            MemberPtr,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
+                          >
+                       >::type type;
+      };
+# 331 "/usr/include/boost/function/function_template.hpp" 3 4
+      template<typename Tag>
+      struct get_invoker8 { };
+
+
+      template<>
+      struct get_invoker8<function_ptr_tag>
+      {
+        template<typename FunctionPtr,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
+        struct apply
+        {
+          typedef typename get_function_invoker8<
+                             FunctionPtr,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<FunctionPtr> manager_type;
+        };
+
+        template<typename FunctionPtr, typename Allocator,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
+        struct apply_a
+        {
+          typedef typename get_function_invoker8<
+                             FunctionPtr,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<FunctionPtr> manager_type;
+        };
+      };
+
+
+
+      template<>
+      struct get_invoker8<member_ptr_tag>
+      {
+        template<typename MemberPtr,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
+        struct apply
+        {
+          typedef typename get_member_invoker8<
+                             MemberPtr,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<MemberPtr> manager_type;
+        };
+
+        template<typename MemberPtr, typename Allocator,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
+        struct apply_a
+        {
+          typedef typename get_member_invoker8<
+                             MemberPtr,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<MemberPtr> manager_type;
+        };
+      };
+
+
+
+      template<>
+      struct get_invoker8<function_obj_tag>
+      {
+        template<typename FunctionObj,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
+        struct apply
+        {
+          typedef typename get_function_obj_invoker8<
+                             FunctionObj,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<FunctionObj> manager_type;
+        };
+
+        template<typename FunctionObj, typename Allocator,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
+        struct apply_a
+        {
+          typedef typename get_function_obj_invoker8<
+                             FunctionObj,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
+                           >::type
+            invoker_type;
+
+          typedef functor_manager_a<FunctionObj, Allocator> manager_type;
+        };
+      };
+
+
+      template<>
+      struct get_invoker8<function_obj_ref_tag>
+      {
+        template<typename RefWrapper,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
+        struct apply
+        {
+          typedef typename get_function_ref_invoker8<
+                             typename RefWrapper::type,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
+                           >::type
+            invoker_type;
+
+          typedef reference_manager<typename RefWrapper::type> manager_type;
+        };
+
+        template<typename RefWrapper, typename Allocator,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
+        struct apply_a
+        {
+          typedef typename get_function_ref_invoker8<
+                             typename RefWrapper::type,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
+                           >::type
+            invoker_type;
+
+          typedef reference_manager<typename RefWrapper::type> manager_type;
+        };
+      };
+# 476 "/usr/include/boost/function/function_template.hpp" 3 4
+      template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
+      struct basic_vtable8
+      {
+
+        typedef R result_type;
+
+
+
+
+        typedef result_type (*invoker_type)(function_buffer&
+                                            ,
+                                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7);
+
+        template<typename F>
+        bool assign_to(F f, function_buffer& functor) const
+        {
+          typedef typename get_function_tag<F>::type tag;
+          return assign_to(f, functor, tag());
+        }
+        template<typename F,typename Allocator>
+        bool assign_to_a(F f, function_buffer& functor, Allocator a) const
+        {
+          typedef typename get_function_tag<F>::type tag;
+          return assign_to_a(f, functor, a, tag());
+        }
+
+        void clear(function_buffer& functor) const
+        {
+          if (base.manager)
+            base.manager(functor, functor, destroy_functor_tag);
+        }
+
+      private:
+
+        template<typename FunctionPtr>
+        bool
+        assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag) const
+        {
+          this->clear(functor);
+          if (f) {
+
+
+            functor.members.func_ptr = reinterpret_cast<void (*)()>(f);
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionPtr,typename Allocator>
+        bool
+        assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const
+        {
+          return assign_to(f,functor,function_ptr_tag());
+        }
+
+
+
+        template<typename MemberPtr>
+        bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag) const
+        {
+
+
+
+          if (f) {
+            this->assign_to(boost::mem_fn(f), functor);
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename MemberPtr,typename Allocator>
+        bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag) const
+        {
+
+
+
+          if (f) {
+            this->assign_to_a(boost::mem_fn(f), functor, a);
+            return true;
+          } else {
+            return false;
+          }
+        }
+
+
+
+
+        template<typename FunctionObj>
+        void
+        assign_functor(FunctionObj f, function_buffer& functor, true_type) const
+        {
+          new (reinterpret_cast<void*>(functor.data)) FunctionObj(f);
+        }
+        template<typename FunctionObj,typename Allocator>
+        void
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, true_type) const
+        {
+          assign_functor(f,functor,true_type());
+        }
+
+
+        template<typename FunctionObj>
+        void
+        assign_functor(FunctionObj f, function_buffer& functor, false_type) const
+        {
+          functor.members.obj_ptr = new FunctionObj(f);
+        }
+        template<typename FunctionObj,typename Allocator>
+        void
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, false_type) const
+        {
+          typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;
+
+
+
+
+
+          using wrapper_allocator_type = typename std::allocator_traits<Allocator>::template rebind_alloc<functor_wrapper_type>;
+          using wrapper_allocator_pointer_type = typename std::allocator_traits<wrapper_allocator_type>::pointer;
+
+          wrapper_allocator_type wrapper_allocator(a);
+          wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
+
+
+
+          std::allocator_traits<wrapper_allocator_type>::construct(wrapper_allocator, copy, functor_wrapper_type(f,a));
+
+          functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
+          functor.members.obj_ptr = new_f;
+        }
+
+        template<typename FunctionObj>
+        bool
+        assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) const
+        {
+          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
+            assign_functor(f, functor,
+                           integral_constant<bool, (function_allows_small_object_optimization<FunctionObj>::value)>());
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionObj,typename Allocator>
+        bool
+        assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag) const
+        {
+          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
+            assign_functor_a(f, functor, a,
+                           integral_constant<bool, (function_allows_small_object_optimization<FunctionObj>::value)>());
+            return true;
+          } else {
+            return false;
+          }
+        }
+
+
+        template<typename FunctionObj>
+        bool
+        assign_to(const reference_wrapper<FunctionObj>& f,
+                  function_buffer& functor, function_obj_ref_tag) const
+        {
+          functor.members.obj_ref.obj_ptr = (void *)(f.get_pointer());
+          functor.members.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
+          functor.members.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
+          return true;
+        }
+        template<typename FunctionObj,typename Allocator>
+        bool
+        assign_to_a(const reference_wrapper<FunctionObj>& f,
+                  function_buffer& functor, Allocator, function_obj_ref_tag) const
+        {
+          return assign_to(f,functor,function_obj_ref_tag());
+        }
+
+      public:
+        vtable_base base;
+        invoker_type invoker;
+      };
+    }
+  }
+
+  template<
+    typename R ,
+    typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
+  >
+  class function8 : public function_base
+  {
+  public:
+
+    typedef R result_type;
+
+
+
+
+
+  private:
+    typedef boost::detail::function::basic_vtable8<
+              R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7>
+      vtable_type;
+
+    vtable_type* get_vtable() const {
+      return reinterpret_cast<vtable_type*>(
+               reinterpret_cast<std::size_t>(vtable) & ~static_cast<std::size_t>(0x01));
+    }
+
+    struct clear_type {};
+
+  public:
+    static const int args = 8;
+
+
+    template<typename Args>
+    struct sig
+    {
+      typedef result_type type;
+    };
+# 701 "/usr/include/boost/function/function_template.hpp" 3 4
+    static const int arity = 8;
+    typedef T0 arg1_type; typedef T1 arg2_type; typedef T2 arg3_type; typedef T3 arg4_type; typedef T4 arg5_type; typedef T5 arg6_type; typedef T6 arg7_type; typedef T7 arg8_type;
+
+    typedef function8 self_type;
+
+    function8() = default;
+
+
+
+    template<typename Functor>
+    function8(Functor f
+
+                            ,typename boost::enable_if_<
+                             !(is_integral<Functor>::value),
+                                        int>::type = 0
+
+                            ) :
+      function_base()
+    {
+      this->assign_to(f);
+    }
+    template<typename Functor,typename Allocator>
+    function8(Functor f, Allocator a
+
+                            ,typename boost::enable_if_<
+                              !(is_integral<Functor>::value),
+                                        int>::type = 0
+
+                            ) :
+      function_base()
+    {
+      this->assign_to_a(f,a);
+    }
+
+
+    function8(clear_type*) : function_base() { }
+
+
+
+
+
+
+
+    function8(const function8& f) : function_base()
+    {
+      this->assign_to_own(f);
+    }
+
+
+    function8(function8&& f) : function_base()
+    {
+      this->move_assign(f);
+    }
+
+
+    ~function8() { clear(); }
+
+    result_type operator()( T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7) const
+    {
+      if (this->empty())
+        boost::throw_exception(bad_function_call());
+
+      return get_vtable()->invoker
+               (this->functor , static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2) , static_cast<T3&&>(a3) , static_cast<T4&&>(a4) , static_cast<T5&&>(a5) , static_cast<T6&&>(a6) , static_cast<T7&&>(a7));
+    }
+
+
+
+
+
+
+    template<typename Functor>
+
+    typename boost::enable_if_<
+                  !(is_integral<Functor>::value),
+               function8&>::type
+
+
+
+    operator=(Functor f)
+    {
+      this->clear();
+      { try {
+        this->assign_to(f);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+      return *this;
+    }
+    template<typename Functor,typename Allocator>
+    void assign(Functor f, Allocator a)
+    {
+      this->clear();
+      { try{
+        this->assign_to_a(f,a);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+    }
+
+
+    function8& operator=(clear_type*)
+    {
+      this->clear();
+      return *this;
+    }
+# 821 "/usr/include/boost/function/function_template.hpp" 3 4
+    function8& operator=(const function8& f)
+    {
+      if (&f == this)
+        return *this;
+
+      this->clear();
+      { try {
+        this->assign_to_own(f);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+      return *this;
+    }
+
+
+
+    function8& operator=(function8&& f)
+    {
+      if (&f == this)
+        return *this;
+
+      this->clear();
+      { try {
+        this->move_assign(f);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+      return *this;
+    }
+
+
+    void swap(function8& other)
+    {
+      if (&other == this)
+        return;
+
+      function8 tmp;
+      tmp.move_assign(*this);
+      this->move_assign(other);
+      other.move_assign(tmp);
+    }
+
+
+    void clear()
+    {
+      if (vtable) {
+        if (!this->has_trivial_copy_and_destroy())
+          get_vtable()->clear(this->functor);
+        vtable = 0;
+      }
+    }
+
+
+
+
+
+  private:
+    struct dummy {
+      void nonnull() {}
+    };
+
+    typedef void (dummy::*safe_bool)();
+
+  public:
+    operator safe_bool () const
+      { return (this->empty())? 0 : &dummy::nonnull; }
+
+    bool operator!() const
+      { return this->empty(); }
+
+
+  private:
+    void assign_to_own(const function8& f)
+    {
+      if (!f.empty()) {
+        this->vtable = f.vtable;
+        if (this->has_trivial_copy_and_destroy())
+
+
+          std::memcpy(this->functor.data, f.functor.data, sizeof(boost::detail::function::function_buffer));
+        else
+          get_vtable()->base.manager(f.functor, this->functor,
+                                     boost::detail::function::clone_functor_tag);
+      }
+    }
+
+    template<typename Functor>
+    void assign_to(Functor f)
+    {
+      using boost::detail::function::vtable_base;
+
+      typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
+      typedef boost::detail::function::get_invoker8<tag> get_invoker;
+      typedef typename get_invoker::
+                         template apply<Functor, R ,
+                        T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7>
+        handler_type;
+
+      typedef typename handler_type::invoker_type invoker_type;
+      typedef typename handler_type::manager_type manager_type;
+
+
+
+
+
+      static const vtable_type stored_vtable =
+        { { &manager_type::manage }, &invoker_type::invoke };
+
+      if (stored_vtable.assign_to(f, functor)) {
+        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
+
+        if (boost::has_trivial_copy_constructor<Functor>::value &&
+            boost::has_trivial_destructor<Functor>::value &&
+            boost::detail::function::function_allows_small_object_optimization<Functor>::value)
+          value |= static_cast<std::size_t>(0x01);
+        vtable = reinterpret_cast<boost::detail::function::vtable_base *>(value);
+      } else
+        vtable = 0;
+    }
+
+    template<typename Functor,typename Allocator>
+    void assign_to_a(Functor f,Allocator a)
+    {
+      using boost::detail::function::vtable_base;
+
+      typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
+      typedef boost::detail::function::get_invoker8<tag> get_invoker;
+      typedef typename get_invoker::
+                         template apply_a<Functor, Allocator, R ,
+                         T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7>
+        handler_type;
+
+      typedef typename handler_type::invoker_type invoker_type;
+      typedef typename handler_type::manager_type manager_type;
+
+
+
+
+
+      static const vtable_type stored_vtable =
+        { { &manager_type::manage }, &invoker_type::invoke };
+
+      if (stored_vtable.assign_to_a(f, functor, a)) {
+        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
+
+        if (boost::has_trivial_copy_constructor<Functor>::value &&
+            boost::has_trivial_destructor<Functor>::value &&
+            boost::detail::function::function_allows_small_object_optimization<Functor>::value)
+          value |= static_cast<std::size_t>(0x01);
+        vtable = reinterpret_cast<boost::detail::function::vtable_base *>(value);
+      } else
+        vtable = 0;
+    }
+
+
+
+
+    void move_assign(function8& f)
+    {
+      if (&f == this)
+        return;
+
+      { try {
+        if (!f.empty()) {
+          this->vtable = f.vtable;
+          if (this->has_trivial_copy_and_destroy())
+
+
+            std::memcpy(this->functor.data, f.functor.data, sizeof(this->functor.data));
+          else
+            get_vtable()->base.manager(f.functor, this->functor,
+                                     boost::detail::function::move_functor_tag);
+          f.vtable = 0;
+        } else {
+          clear();
+        }
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+    }
+  };
+
+  template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
+  inline void swap(function8<
+                     R ,
+                     T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
+                   >& f1,
+                   function8<
+                     R ,
+                     T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
+                   >& f2)
+  {
+    f1.swap(f2);
+  }
+
+
+template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
+  void operator==(const function8<
+                          R ,
+                          T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7>&,
+                  const function8<
+                          R ,
+                          T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7>&);
+template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
+  void operator!=(const function8<
+                          R ,
+                          T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7>&,
+                  const function8<
+                          R ,
+                          T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7>& );
+
+
+
+
+
+
+#define BOOST_FUNCTION_PARTIAL_SPEC R (BOOST_FUNCTION_TEMPLATE_ARGS)
+
+
+template<typename R ,
+         typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
+class function<R ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7)>
+  : public function8<R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7>
+{
+  typedef function8<R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7> base_type;
+  typedef function self_type;
+
+  struct clear_type {};
+
+public:
+
+  function() = default;
+
+  template<typename Functor>
+  function(Functor f
+
+           ,typename boost::enable_if_<
+                          !(is_integral<Functor>::value),
+                       int>::type = 0
+
+           ) :
+    base_type(f)
+  {
+  }
+  template<typename Functor,typename Allocator>
+  function(Functor f, Allocator a
+
+           ,typename boost::enable_if_<
+                           !(is_integral<Functor>::value),
+                       int>::type = 0
+
+           ) :
+    base_type(f,a)
+  {
+  }
+
+
+  function(clear_type*) : base_type() {}
+
+
+  function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}
+
+  function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}
+
+
+
+  function(self_type&& f): base_type(static_cast<base_type&&>(f)){}
+  function(base_type&& f): base_type(static_cast<base_type&&>(f)){}
+
+
+  self_type& operator=(const self_type& f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+
+
+  self_type& operator=(self_type&& f)
+  {
+    self_type(static_cast<self_type&&>(f)).swap(*this);
+    return *this;
+  }
+
+
+  template<typename Functor>
+
+  typename boost::enable_if_<
+                         !(is_integral<Functor>::value),
+                      self_type&>::type
+
+
+
+  operator=(Functor f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+
+
+  self_type& operator=(clear_type*)
+  {
+    this->clear();
+    return *this;
+  }
+
+
+  self_type& operator=(const base_type& f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+
+
+  self_type& operator=(base_type&& f)
+  {
+    self_type(static_cast<base_type&&>(f)).swap(*this);
+    return *this;
+  }
+
+};
+
+#undef BOOST_FUNCTION_PARTIAL_SPEC
+
+
+}
+
+
+#undef BOOST_FUNCTION_VTABLE
+#undef BOOST_FUNCTION_COMMA
+#undef BOOST_FUNCTION_FUNCTION
+#undef BOOST_FUNCTION_FUNCTION_INVOKER
+#undef BOOST_FUNCTION_VOID_FUNCTION_INVOKER
+#undef BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
+#undef BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
+#undef BOOST_FUNCTION_FUNCTION_REF_INVOKER
+#undef BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER
+#undef BOOST_FUNCTION_MEMBER_INVOKER
+#undef BOOST_FUNCTION_VOID_MEMBER_INVOKER
+#undef BOOST_FUNCTION_GET_FUNCTION_INVOKER
+#undef BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
+#undef BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER
+#undef BOOST_FUNCTION_GET_MEM_FUNCTION_INVOKER
+#undef BOOST_FUNCTION_GET_INVOKER
+#undef BOOST_FUNCTION_TEMPLATE_PARMS
+#undef BOOST_FUNCTION_TEMPLATE_ARGS
+#undef BOOST_FUNCTION_PARMS
+#undef BOOST_FUNCTION_PARM
+
+#undef BOOST_FUNCTION_ARG
+
+#undef BOOST_FUNCTION_ARGS
+#undef BOOST_FUNCTION_ARG_TYPE
+#undef BOOST_FUNCTION_ARG_TYPES
+#undef BOOST_FUNCTION_VOID_RETURN_TYPE
+#undef BOOST_FUNCTION_RETURN
+# 72 "/usr/include/boost/function/detail/maybe_include.hpp" 2 3 4
+# 15 "/usr/include/boost/function/detail/function_iterate.hpp" 2 3 4
+#undef BOOST_FUNCTION_NUM_ARGS
+# 88 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
+#undef BOOST_PP_ITERATION_1
+
+
+#define BOOST_PP_ITERATION_1 9
+# 1 "/usr/include/boost/function/detail/function_iterate.hpp" 1 3 4
+# 13 "/usr/include/boost/function/detail/function_iterate.hpp" 3 4
+#define BOOST_FUNCTION_NUM_ARGS BOOST_PP_ITERATION()
+# 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
+# 74 "/usr/include/boost/function/detail/maybe_include.hpp" 3 4
+#undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#define BOOST_FUNCTION_MAX_ARGS_DEFINED 9
+
+#define BOOST_FUNCTION_9 
+# 1 "/usr/include/boost/function/function_template.hpp" 1 3 4
+# 21 "/usr/include/boost/function/function_template.hpp" 3 4
+#define BOOST_FUNCTION_TEMPLATE_PARMS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, typename T)
+
+#define BOOST_FUNCTION_TEMPLATE_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, T)
+
+#define BOOST_FUNCTION_PARM(J,I,D) BOOST_PP_CAT(T,I) BOOST_PP_CAT(a,I)
+
+#define BOOST_FUNCTION_PARMS BOOST_PP_ENUM(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_PARM,BOOST_PP_EMPTY)
+
+
+
+
+#define BOOST_FUNCTION_ARG(J,I,D) static_cast<BOOST_PP_CAT(T,I)&&>(BOOST_PP_CAT(a,I))
+#define BOOST_FUNCTION_ARGS BOOST_PP_ENUM(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_ARG,BOOST_PP_EMPTY)
+
+
+#define BOOST_FUNCTION_ARG_TYPE(J,I,D) typedef BOOST_PP_CAT(T,I) BOOST_PP_CAT(BOOST_PP_CAT(arg, BOOST_PP_INC(I)),_type);
+
+
+#define BOOST_FUNCTION_ARG_TYPES BOOST_PP_REPEAT(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_ARG_TYPE,BOOST_PP_EMPTY)
+
+
+
+
+
+#define BOOST_FUNCTION_COMMA ,
+
+
+
+#define BOOST_FUNCTION_FUNCTION BOOST_JOIN(function,BOOST_FUNCTION_NUM_ARGS)
+#define BOOST_FUNCTION_FUNCTION_INVOKER BOOST_JOIN(function_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_VOID_FUNCTION_INVOKER BOOST_JOIN(void_function_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_FUNCTION_OBJ_INVOKER BOOST_JOIN(function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER BOOST_JOIN(void_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_FUNCTION_REF_INVOKER BOOST_JOIN(function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER BOOST_JOIN(void_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_MEMBER_INVOKER BOOST_JOIN(function_mem_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_VOID_MEMBER_INVOKER BOOST_JOIN(function_void_mem_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_GET_FUNCTION_INVOKER BOOST_JOIN(get_function_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER BOOST_JOIN(get_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER BOOST_JOIN(get_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_GET_MEMBER_INVOKER BOOST_JOIN(get_member_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_GET_INVOKER BOOST_JOIN(get_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_VTABLE BOOST_JOIN(basic_vtable,BOOST_FUNCTION_NUM_ARGS)
+
+
+#define BOOST_FUNCTION_VOID_RETURN_TYPE void
+#define BOOST_FUNCTION_RETURN(X) X
+
+
+
+
+
+namespace boost {
+  namespace detail {
+    namespace function {
+      template<
+        typename FunctionPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
+        >
+      struct function_invoker9
+      {
+        static R invoke(function_buffer& function_ptr ,
+                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8)
+        {
+          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.members.func_ptr);
+          return f( static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2) , static_cast<T3&&>(a3) , static_cast<T4&&>(a4) , static_cast<T5&&>(a5) , static_cast<T6&&>(a6) , static_cast<T7&&>(a7) , static_cast<T8&&>(a8));
+        }
+      };
+
+      template<
+        typename FunctionPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
+        >
+      struct void_function_invoker9
+      {
+        static void
+        invoke(function_buffer& function_ptr ,
+               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8)
+
+        {
+          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.members.func_ptr);
+          f( static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2) , static_cast<T3&&>(a3) , static_cast<T4&&>(a4) , static_cast<T5&&>(a5) , static_cast<T6&&>(a6) , static_cast<T7&&>(a7) , static_cast<T8&&>(a8));
+        }
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
+      >
+      struct function_obj_invoker9
+      {
+        static R invoke(function_buffer& function_obj_ptr ,
+                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8)
+
+        {
+          FunctionObj* f;
+          if (function_allows_small_object_optimization<FunctionObj>::value)
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.data);
+          else
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
+          return (*f)( static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2) , static_cast<T3&&>(a3) , static_cast<T4&&>(a4) , static_cast<T5&&>(a5) , static_cast<T6&&>(a6) , static_cast<T7&&>(a7) , static_cast<T8&&>(a8));
+        }
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
+      >
+      struct void_function_obj_invoker9
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr ,
+               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8)
+
+        {
+          FunctionObj* f;
+          if (function_allows_small_object_optimization<FunctionObj>::value)
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.data);
+          else
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
+          (*f)( static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2) , static_cast<T3&&>(a3) , static_cast<T4&&>(a4) , static_cast<T5&&>(a5) , static_cast<T6&&>(a6) , static_cast<T7&&>(a7) , static_cast<T8&&>(a8));
+        }
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
+      >
+      struct function_ref_invoker9
+      {
+        static R invoke(function_buffer& function_obj_ptr ,
+                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8)
+
+        {
+          FunctionObj* f =
+            reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
+          return (*f)( static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2) , static_cast<T3&&>(a3) , static_cast<T4&&>(a4) , static_cast<T5&&>(a5) , static_cast<T6&&>(a6) , static_cast<T7&&>(a7) , static_cast<T8&&>(a8));
+        }
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
+      >
+      struct void_function_ref_invoker9
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr ,
+               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8)
+
+        {
+          FunctionObj* f =
+            reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
+          (*f)( static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2) , static_cast<T3&&>(a3) , static_cast<T4&&>(a4) , static_cast<T5&&>(a5) , static_cast<T6&&>(a6) , static_cast<T7&&>(a7) , static_cast<T8&&>(a8));
+        }
+      };
+
+
+
+      template<
+        typename MemberPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
+      >
+      struct function_mem_invoker9
+      {
+        static R invoke(function_buffer& function_obj_ptr ,
+                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8)
+
+        {
+          MemberPtr* f =
+            reinterpret_cast<MemberPtr*>(function_obj_ptr.data);
+          return boost::mem_fn(*f)( static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2) , static_cast<T3&&>(a3) , static_cast<T4&&>(a4) , static_cast<T5&&>(a5) , static_cast<T6&&>(a6) , static_cast<T7&&>(a7) , static_cast<T8&&>(a8));
+        }
+      };
+
+      template<
+        typename MemberPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
+      >
+      struct function_void_mem_invoker9
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr ,
+               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8)
+
+        {
+          MemberPtr* f =
+            reinterpret_cast<MemberPtr*>(function_obj_ptr.data);
+          boost::mem_fn(*f)( static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2) , static_cast<T3&&>(a3) , static_cast<T4&&>(a4) , static_cast<T5&&>(a5) , static_cast<T6&&>(a6) , static_cast<T7&&>(a7) , static_cast<T8&&>(a8));
+        }
+      };
+
+
+      template<
+        typename FunctionPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
+      >
+      struct get_function_invoker9
+      {
+        typedef typename conditional<(is_void<R>::value),
+                            void_function_invoker9<
+                            FunctionPtr,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
+                          >,
+                          function_invoker9<
+                            FunctionPtr,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
+                          >
+                       >::type type;
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
+       >
+      struct get_function_obj_invoker9
+      {
+        typedef typename conditional<(is_void<R>::value),
+                            void_function_obj_invoker9<
+                            FunctionObj,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
+                          >,
+                          function_obj_invoker9<
+                            FunctionObj,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
+                          >
+                       >::type type;
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
+       >
+      struct get_function_ref_invoker9
+      {
+        typedef typename conditional<(is_void<R>::value),
+                            void_function_ref_invoker9<
+                            FunctionObj,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
+                          >,
+                          function_ref_invoker9<
+                            FunctionObj,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
+                          >
+                       >::type type;
+      };
+
+
+
+      template<
+        typename MemberPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
+       >
+      struct get_member_invoker9
+      {
+        typedef typename conditional<(is_void<R>::value),
+                            function_void_mem_invoker9<
+                            MemberPtr,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
+                          >,
+                          function_mem_invoker9<
+                            MemberPtr,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
+                          >
+                       >::type type;
+      };
+# 331 "/usr/include/boost/function/function_template.hpp" 3 4
+      template<typename Tag>
+      struct get_invoker9 { };
+
+
+      template<>
+      struct get_invoker9<function_ptr_tag>
+      {
+        template<typename FunctionPtr,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
+        struct apply
+        {
+          typedef typename get_function_invoker9<
+                             FunctionPtr,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<FunctionPtr> manager_type;
+        };
+
+        template<typename FunctionPtr, typename Allocator,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
+        struct apply_a
+        {
+          typedef typename get_function_invoker9<
+                             FunctionPtr,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<FunctionPtr> manager_type;
+        };
+      };
+
+
+
+      template<>
+      struct get_invoker9<member_ptr_tag>
+      {
+        template<typename MemberPtr,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
+        struct apply
+        {
+          typedef typename get_member_invoker9<
+                             MemberPtr,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<MemberPtr> manager_type;
+        };
+
+        template<typename MemberPtr, typename Allocator,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
+        struct apply_a
+        {
+          typedef typename get_member_invoker9<
+                             MemberPtr,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<MemberPtr> manager_type;
+        };
+      };
+
+
+
+      template<>
+      struct get_invoker9<function_obj_tag>
+      {
+        template<typename FunctionObj,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
+        struct apply
+        {
+          typedef typename get_function_obj_invoker9<
+                             FunctionObj,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<FunctionObj> manager_type;
+        };
+
+        template<typename FunctionObj, typename Allocator,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
+        struct apply_a
+        {
+          typedef typename get_function_obj_invoker9<
+                             FunctionObj,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
+                           >::type
+            invoker_type;
+
+          typedef functor_manager_a<FunctionObj, Allocator> manager_type;
+        };
+      };
+
+
+      template<>
+      struct get_invoker9<function_obj_ref_tag>
+      {
+        template<typename RefWrapper,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
+        struct apply
+        {
+          typedef typename get_function_ref_invoker9<
+                             typename RefWrapper::type,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
+                           >::type
+            invoker_type;
+
+          typedef reference_manager<typename RefWrapper::type> manager_type;
+        };
+
+        template<typename RefWrapper, typename Allocator,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
+        struct apply_a
+        {
+          typedef typename get_function_ref_invoker9<
+                             typename RefWrapper::type,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
+                           >::type
+            invoker_type;
+
+          typedef reference_manager<typename RefWrapper::type> manager_type;
+        };
+      };
+# 476 "/usr/include/boost/function/function_template.hpp" 3 4
+      template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
+      struct basic_vtable9
+      {
+
+        typedef R result_type;
+
+
+
+
+        typedef result_type (*invoker_type)(function_buffer&
+                                            ,
+                                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8);
+
+        template<typename F>
+        bool assign_to(F f, function_buffer& functor) const
+        {
+          typedef typename get_function_tag<F>::type tag;
+          return assign_to(f, functor, tag());
+        }
+        template<typename F,typename Allocator>
+        bool assign_to_a(F f, function_buffer& functor, Allocator a) const
+        {
+          typedef typename get_function_tag<F>::type tag;
+          return assign_to_a(f, functor, a, tag());
+        }
+
+        void clear(function_buffer& functor) const
+        {
+          if (base.manager)
+            base.manager(functor, functor, destroy_functor_tag);
+        }
+
+      private:
+
+        template<typename FunctionPtr>
+        bool
+        assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag) const
+        {
+          this->clear(functor);
+          if (f) {
+
+
+            functor.members.func_ptr = reinterpret_cast<void (*)()>(f);
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionPtr,typename Allocator>
+        bool
+        assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const
+        {
+          return assign_to(f,functor,function_ptr_tag());
+        }
+
+
+
+        template<typename MemberPtr>
+        bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag) const
+        {
+
+
+
+          if (f) {
+            this->assign_to(boost::mem_fn(f), functor);
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename MemberPtr,typename Allocator>
+        bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag) const
+        {
+
+
+
+          if (f) {
+            this->assign_to_a(boost::mem_fn(f), functor, a);
+            return true;
+          } else {
+            return false;
+          }
+        }
+
+
+
+
+        template<typename FunctionObj>
+        void
+        assign_functor(FunctionObj f, function_buffer& functor, true_type) const
+        {
+          new (reinterpret_cast<void*>(functor.data)) FunctionObj(f);
+        }
+        template<typename FunctionObj,typename Allocator>
+        void
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, true_type) const
+        {
+          assign_functor(f,functor,true_type());
+        }
+
+
+        template<typename FunctionObj>
+        void
+        assign_functor(FunctionObj f, function_buffer& functor, false_type) const
+        {
+          functor.members.obj_ptr = new FunctionObj(f);
+        }
+        template<typename FunctionObj,typename Allocator>
+        void
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, false_type) const
+        {
+          typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;
+
+
+
+
+
+          using wrapper_allocator_type = typename std::allocator_traits<Allocator>::template rebind_alloc<functor_wrapper_type>;
+          using wrapper_allocator_pointer_type = typename std::allocator_traits<wrapper_allocator_type>::pointer;
+
+          wrapper_allocator_type wrapper_allocator(a);
+          wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
+
+
+
+          std::allocator_traits<wrapper_allocator_type>::construct(wrapper_allocator, copy, functor_wrapper_type(f,a));
+
+          functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
+          functor.members.obj_ptr = new_f;
+        }
+
+        template<typename FunctionObj>
+        bool
+        assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) const
+        {
+          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
+            assign_functor(f, functor,
+                           integral_constant<bool, (function_allows_small_object_optimization<FunctionObj>::value)>());
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionObj,typename Allocator>
+        bool
+        assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag) const
+        {
+          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
+            assign_functor_a(f, functor, a,
+                           integral_constant<bool, (function_allows_small_object_optimization<FunctionObj>::value)>());
+            return true;
+          } else {
+            return false;
+          }
+        }
+
+
+        template<typename FunctionObj>
+        bool
+        assign_to(const reference_wrapper<FunctionObj>& f,
+                  function_buffer& functor, function_obj_ref_tag) const
+        {
+          functor.members.obj_ref.obj_ptr = (void *)(f.get_pointer());
+          functor.members.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
+          functor.members.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
+          return true;
+        }
+        template<typename FunctionObj,typename Allocator>
+        bool
+        assign_to_a(const reference_wrapper<FunctionObj>& f,
+                  function_buffer& functor, Allocator, function_obj_ref_tag) const
+        {
+          return assign_to(f,functor,function_obj_ref_tag());
+        }
+
+      public:
+        vtable_base base;
+        invoker_type invoker;
+      };
+    }
+  }
+
+  template<
+    typename R ,
+    typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
+  >
+  class function9 : public function_base
+  {
+  public:
+
+    typedef R result_type;
+
+
+
+
+
+  private:
+    typedef boost::detail::function::basic_vtable9<
+              R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8>
+      vtable_type;
+
+    vtable_type* get_vtable() const {
+      return reinterpret_cast<vtable_type*>(
+               reinterpret_cast<std::size_t>(vtable) & ~static_cast<std::size_t>(0x01));
+    }
+
+    struct clear_type {};
+
+  public:
+    static const int args = 9;
+
+
+    template<typename Args>
+    struct sig
+    {
+      typedef result_type type;
+    };
+# 701 "/usr/include/boost/function/function_template.hpp" 3 4
+    static const int arity = 9;
+    typedef T0 arg1_type; typedef T1 arg2_type; typedef T2 arg3_type; typedef T3 arg4_type; typedef T4 arg5_type; typedef T5 arg6_type; typedef T6 arg7_type; typedef T7 arg8_type; typedef T8 arg9_type;
+
+    typedef function9 self_type;
+
+    function9() = default;
+
+
+
+    template<typename Functor>
+    function9(Functor f
+
+                            ,typename boost::enable_if_<
+                             !(is_integral<Functor>::value),
+                                        int>::type = 0
+
+                            ) :
+      function_base()
+    {
+      this->assign_to(f);
+    }
+    template<typename Functor,typename Allocator>
+    function9(Functor f, Allocator a
+
+                            ,typename boost::enable_if_<
+                              !(is_integral<Functor>::value),
+                                        int>::type = 0
+
+                            ) :
+      function_base()
+    {
+      this->assign_to_a(f,a);
+    }
+
+
+    function9(clear_type*) : function_base() { }
+
+
+
+
+
+
+
+    function9(const function9& f) : function_base()
+    {
+      this->assign_to_own(f);
+    }
+
+
+    function9(function9&& f) : function_base()
+    {
+      this->move_assign(f);
+    }
+
+
+    ~function9() { clear(); }
+
+    result_type operator()( T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8) const
+    {
+      if (this->empty())
+        boost::throw_exception(bad_function_call());
+
+      return get_vtable()->invoker
+               (this->functor , static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2) , static_cast<T3&&>(a3) , static_cast<T4&&>(a4) , static_cast<T5&&>(a5) , static_cast<T6&&>(a6) , static_cast<T7&&>(a7) , static_cast<T8&&>(a8));
+    }
+
+
+
+
+
+
+    template<typename Functor>
+
+    typename boost::enable_if_<
+                  !(is_integral<Functor>::value),
+               function9&>::type
+
+
+
+    operator=(Functor f)
+    {
+      this->clear();
+      { try {
+        this->assign_to(f);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+      return *this;
+    }
+    template<typename Functor,typename Allocator>
+    void assign(Functor f, Allocator a)
+    {
+      this->clear();
+      { try{
+        this->assign_to_a(f,a);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+    }
+
+
+    function9& operator=(clear_type*)
+    {
+      this->clear();
+      return *this;
+    }
+# 821 "/usr/include/boost/function/function_template.hpp" 3 4
+    function9& operator=(const function9& f)
+    {
+      if (&f == this)
+        return *this;
+
+      this->clear();
+      { try {
+        this->assign_to_own(f);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+      return *this;
+    }
+
+
+
+    function9& operator=(function9&& f)
+    {
+      if (&f == this)
+        return *this;
+
+      this->clear();
+      { try {
+        this->move_assign(f);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+      return *this;
+    }
+
+
+    void swap(function9& other)
+    {
+      if (&other == this)
+        return;
+
+      function9 tmp;
+      tmp.move_assign(*this);
+      this->move_assign(other);
+      other.move_assign(tmp);
+    }
+
+
+    void clear()
+    {
+      if (vtable) {
+        if (!this->has_trivial_copy_and_destroy())
+          get_vtable()->clear(this->functor);
+        vtable = 0;
+      }
+    }
+
+
+
+
+
+  private:
+    struct dummy {
+      void nonnull() {}
+    };
+
+    typedef void (dummy::*safe_bool)();
+
+  public:
+    operator safe_bool () const
+      { return (this->empty())? 0 : &dummy::nonnull; }
+
+    bool operator!() const
+      { return this->empty(); }
+
+
+  private:
+    void assign_to_own(const function9& f)
+    {
+      if (!f.empty()) {
+        this->vtable = f.vtable;
+        if (this->has_trivial_copy_and_destroy())
+
+
+          std::memcpy(this->functor.data, f.functor.data, sizeof(boost::detail::function::function_buffer));
+        else
+          get_vtable()->base.manager(f.functor, this->functor,
+                                     boost::detail::function::clone_functor_tag);
+      }
+    }
+
+    template<typename Functor>
+    void assign_to(Functor f)
+    {
+      using boost::detail::function::vtable_base;
+
+      typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
+      typedef boost::detail::function::get_invoker9<tag> get_invoker;
+      typedef typename get_invoker::
+                         template apply<Functor, R ,
+                        T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8>
+        handler_type;
+
+      typedef typename handler_type::invoker_type invoker_type;
+      typedef typename handler_type::manager_type manager_type;
+
+
+
+
+
+      static const vtable_type stored_vtable =
+        { { &manager_type::manage }, &invoker_type::invoke };
+
+      if (stored_vtable.assign_to(f, functor)) {
+        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
+
+        if (boost::has_trivial_copy_constructor<Functor>::value &&
+            boost::has_trivial_destructor<Functor>::value &&
+            boost::detail::function::function_allows_small_object_optimization<Functor>::value)
+          value |= static_cast<std::size_t>(0x01);
+        vtable = reinterpret_cast<boost::detail::function::vtable_base *>(value);
+      } else
+        vtable = 0;
+    }
+
+    template<typename Functor,typename Allocator>
+    void assign_to_a(Functor f,Allocator a)
+    {
+      using boost::detail::function::vtable_base;
+
+      typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
+      typedef boost::detail::function::get_invoker9<tag> get_invoker;
+      typedef typename get_invoker::
+                         template apply_a<Functor, Allocator, R ,
+                         T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8>
+        handler_type;
+
+      typedef typename handler_type::invoker_type invoker_type;
+      typedef typename handler_type::manager_type manager_type;
+
+
+
+
+
+      static const vtable_type stored_vtable =
+        { { &manager_type::manage }, &invoker_type::invoke };
+
+      if (stored_vtable.assign_to_a(f, functor, a)) {
+        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
+
+        if (boost::has_trivial_copy_constructor<Functor>::value &&
+            boost::has_trivial_destructor<Functor>::value &&
+            boost::detail::function::function_allows_small_object_optimization<Functor>::value)
+          value |= static_cast<std::size_t>(0x01);
+        vtable = reinterpret_cast<boost::detail::function::vtable_base *>(value);
+      } else
+        vtable = 0;
+    }
+
+
+
+
+    void move_assign(function9& f)
+    {
+      if (&f == this)
+        return;
+
+      { try {
+        if (!f.empty()) {
+          this->vtable = f.vtable;
+          if (this->has_trivial_copy_and_destroy())
+
+
+            std::memcpy(this->functor.data, f.functor.data, sizeof(this->functor.data));
+          else
+            get_vtable()->base.manager(f.functor, this->functor,
+                                     boost::detail::function::move_functor_tag);
+          f.vtable = 0;
+        } else {
+          clear();
+        }
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+    }
+  };
+
+  template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
+  inline void swap(function9<
+                     R ,
+                     T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
+                   >& f1,
+                   function9<
+                     R ,
+                     T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
+                   >& f2)
+  {
+    f1.swap(f2);
+  }
+
+
+template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
+  void operator==(const function9<
+                          R ,
+                          T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8>&,
+                  const function9<
+                          R ,
+                          T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8>&);
+template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
+  void operator!=(const function9<
+                          R ,
+                          T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8>&,
+                  const function9<
+                          R ,
+                          T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8>& );
+
+
+
+
+
+
+#define BOOST_FUNCTION_PARTIAL_SPEC R (BOOST_FUNCTION_TEMPLATE_ARGS)
+
+
+template<typename R ,
+         typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
+class function<R ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8)>
+  : public function9<R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8>
+{
+  typedef function9<R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8> base_type;
+  typedef function self_type;
+
+  struct clear_type {};
+
+public:
+
+  function() = default;
+
+  template<typename Functor>
+  function(Functor f
+
+           ,typename boost::enable_if_<
+                          !(is_integral<Functor>::value),
+                       int>::type = 0
+
+           ) :
+    base_type(f)
+  {
+  }
+  template<typename Functor,typename Allocator>
+  function(Functor f, Allocator a
+
+           ,typename boost::enable_if_<
+                           !(is_integral<Functor>::value),
+                       int>::type = 0
+
+           ) :
+    base_type(f,a)
+  {
+  }
+
+
+  function(clear_type*) : base_type() {}
+
+
+  function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}
+
+  function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}
+
+
+
+  function(self_type&& f): base_type(static_cast<base_type&&>(f)){}
+  function(base_type&& f): base_type(static_cast<base_type&&>(f)){}
+
+
+  self_type& operator=(const self_type& f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+
+
+  self_type& operator=(self_type&& f)
+  {
+    self_type(static_cast<self_type&&>(f)).swap(*this);
+    return *this;
+  }
+
+
+  template<typename Functor>
+
+  typename boost::enable_if_<
+                         !(is_integral<Functor>::value),
+                      self_type&>::type
+
+
+
+  operator=(Functor f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+
+
+  self_type& operator=(clear_type*)
+  {
+    this->clear();
+    return *this;
+  }
+
+
+  self_type& operator=(const base_type& f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+
+
+  self_type& operator=(base_type&& f)
+  {
+    self_type(static_cast<base_type&&>(f)).swap(*this);
+    return *this;
+  }
+
+};
+
+#undef BOOST_FUNCTION_PARTIAL_SPEC
+
+
+}
+
+
+#undef BOOST_FUNCTION_VTABLE
+#undef BOOST_FUNCTION_COMMA
+#undef BOOST_FUNCTION_FUNCTION
+#undef BOOST_FUNCTION_FUNCTION_INVOKER
+#undef BOOST_FUNCTION_VOID_FUNCTION_INVOKER
+#undef BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
+#undef BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
+#undef BOOST_FUNCTION_FUNCTION_REF_INVOKER
+#undef BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER
+#undef BOOST_FUNCTION_MEMBER_INVOKER
+#undef BOOST_FUNCTION_VOID_MEMBER_INVOKER
+#undef BOOST_FUNCTION_GET_FUNCTION_INVOKER
+#undef BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
+#undef BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER
+#undef BOOST_FUNCTION_GET_MEM_FUNCTION_INVOKER
+#undef BOOST_FUNCTION_GET_INVOKER
+#undef BOOST_FUNCTION_TEMPLATE_PARMS
+#undef BOOST_FUNCTION_TEMPLATE_ARGS
+#undef BOOST_FUNCTION_PARMS
+#undef BOOST_FUNCTION_PARM
+
+#undef BOOST_FUNCTION_ARG
+
+#undef BOOST_FUNCTION_ARGS
+#undef BOOST_FUNCTION_ARG_TYPE
+#undef BOOST_FUNCTION_ARG_TYPES
+#undef BOOST_FUNCTION_VOID_RETURN_TYPE
+#undef BOOST_FUNCTION_RETURN
+# 79 "/usr/include/boost/function/detail/maybe_include.hpp" 2 3 4
+# 15 "/usr/include/boost/function/detail/function_iterate.hpp" 2 3 4
+#undef BOOST_FUNCTION_NUM_ARGS
+# 93 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
+#undef BOOST_PP_ITERATION_1
+
+
+#define BOOST_PP_ITERATION_1 10
+# 1 "/usr/include/boost/function/detail/function_iterate.hpp" 1 3 4
+# 13 "/usr/include/boost/function/detail/function_iterate.hpp" 3 4
+#define BOOST_FUNCTION_NUM_ARGS BOOST_PP_ITERATION()
+# 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
+# 81 "/usr/include/boost/function/detail/maybe_include.hpp" 3 4
+#undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#define BOOST_FUNCTION_MAX_ARGS_DEFINED 10
+
+#define BOOST_FUNCTION_10 
+# 1 "/usr/include/boost/function/function_template.hpp" 1 3 4
+# 21 "/usr/include/boost/function/function_template.hpp" 3 4
+#define BOOST_FUNCTION_TEMPLATE_PARMS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, typename T)
+
+#define BOOST_FUNCTION_TEMPLATE_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, T)
+
+#define BOOST_FUNCTION_PARM(J,I,D) BOOST_PP_CAT(T,I) BOOST_PP_CAT(a,I)
+
+#define BOOST_FUNCTION_PARMS BOOST_PP_ENUM(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_PARM,BOOST_PP_EMPTY)
+
+
+
+
+#define BOOST_FUNCTION_ARG(J,I,D) static_cast<BOOST_PP_CAT(T,I)&&>(BOOST_PP_CAT(a,I))
+#define BOOST_FUNCTION_ARGS BOOST_PP_ENUM(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_ARG,BOOST_PP_EMPTY)
+
+
+#define BOOST_FUNCTION_ARG_TYPE(J,I,D) typedef BOOST_PP_CAT(T,I) BOOST_PP_CAT(BOOST_PP_CAT(arg, BOOST_PP_INC(I)),_type);
+
+
+#define BOOST_FUNCTION_ARG_TYPES BOOST_PP_REPEAT(BOOST_FUNCTION_NUM_ARGS,BOOST_FUNCTION_ARG_TYPE,BOOST_PP_EMPTY)
+
+
+
+
+
+#define BOOST_FUNCTION_COMMA ,
+
+
+
+#define BOOST_FUNCTION_FUNCTION BOOST_JOIN(function,BOOST_FUNCTION_NUM_ARGS)
+#define BOOST_FUNCTION_FUNCTION_INVOKER BOOST_JOIN(function_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_VOID_FUNCTION_INVOKER BOOST_JOIN(void_function_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_FUNCTION_OBJ_INVOKER BOOST_JOIN(function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER BOOST_JOIN(void_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_FUNCTION_REF_INVOKER BOOST_JOIN(function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER BOOST_JOIN(void_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_MEMBER_INVOKER BOOST_JOIN(function_mem_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_VOID_MEMBER_INVOKER BOOST_JOIN(function_void_mem_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_GET_FUNCTION_INVOKER BOOST_JOIN(get_function_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER BOOST_JOIN(get_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER BOOST_JOIN(get_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_GET_MEMBER_INVOKER BOOST_JOIN(get_member_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_GET_INVOKER BOOST_JOIN(get_invoker,BOOST_FUNCTION_NUM_ARGS)
+
+#define BOOST_FUNCTION_VTABLE BOOST_JOIN(basic_vtable,BOOST_FUNCTION_NUM_ARGS)
+
+
+#define BOOST_FUNCTION_VOID_RETURN_TYPE void
+#define BOOST_FUNCTION_RETURN(X) X
+
+
+
+
+
+namespace boost {
+  namespace detail {
+    namespace function {
+      template<
+        typename FunctionPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
+        >
+      struct function_invoker10
+      {
+        static R invoke(function_buffer& function_ptr ,
+                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8 , T9 a9)
+        {
+          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.members.func_ptr);
+          return f( static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2) , static_cast<T3&&>(a3) , static_cast<T4&&>(a4) , static_cast<T5&&>(a5) , static_cast<T6&&>(a6) , static_cast<T7&&>(a7) , static_cast<T8&&>(a8) , static_cast<T9&&>(a9));
+        }
+      };
+
+      template<
+        typename FunctionPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
+        >
+      struct void_function_invoker10
+      {
+        static void
+        invoke(function_buffer& function_ptr ,
+               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8 , T9 a9)
+
+        {
+          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.members.func_ptr);
+          f( static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2) , static_cast<T3&&>(a3) , static_cast<T4&&>(a4) , static_cast<T5&&>(a5) , static_cast<T6&&>(a6) , static_cast<T7&&>(a7) , static_cast<T8&&>(a8) , static_cast<T9&&>(a9));
+        }
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
+      >
+      struct function_obj_invoker10
+      {
+        static R invoke(function_buffer& function_obj_ptr ,
+                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8 , T9 a9)
+
+        {
+          FunctionObj* f;
+          if (function_allows_small_object_optimization<FunctionObj>::value)
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.data);
+          else
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
+          return (*f)( static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2) , static_cast<T3&&>(a3) , static_cast<T4&&>(a4) , static_cast<T5&&>(a5) , static_cast<T6&&>(a6) , static_cast<T7&&>(a7) , static_cast<T8&&>(a8) , static_cast<T9&&>(a9));
+        }
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
+      >
+      struct void_function_obj_invoker10
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr ,
+               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8 , T9 a9)
+
+        {
+          FunctionObj* f;
+          if (function_allows_small_object_optimization<FunctionObj>::value)
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.data);
+          else
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
+          (*f)( static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2) , static_cast<T3&&>(a3) , static_cast<T4&&>(a4) , static_cast<T5&&>(a5) , static_cast<T6&&>(a6) , static_cast<T7&&>(a7) , static_cast<T8&&>(a8) , static_cast<T9&&>(a9));
+        }
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
+      >
+      struct function_ref_invoker10
+      {
+        static R invoke(function_buffer& function_obj_ptr ,
+                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8 , T9 a9)
+
+        {
+          FunctionObj* f =
+            reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
+          return (*f)( static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2) , static_cast<T3&&>(a3) , static_cast<T4&&>(a4) , static_cast<T5&&>(a5) , static_cast<T6&&>(a6) , static_cast<T7&&>(a7) , static_cast<T8&&>(a8) , static_cast<T9&&>(a9));
+        }
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
+      >
+      struct void_function_ref_invoker10
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr ,
+               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8 , T9 a9)
+
+        {
+          FunctionObj* f =
+            reinterpret_cast<FunctionObj*>(function_obj_ptr.members.obj_ptr);
+          (*f)( static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2) , static_cast<T3&&>(a3) , static_cast<T4&&>(a4) , static_cast<T5&&>(a5) , static_cast<T6&&>(a6) , static_cast<T7&&>(a7) , static_cast<T8&&>(a8) , static_cast<T9&&>(a9));
+        }
+      };
+
+
+
+      template<
+        typename MemberPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
+      >
+      struct function_mem_invoker10
+      {
+        static R invoke(function_buffer& function_obj_ptr ,
+                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8 , T9 a9)
+
+        {
+          MemberPtr* f =
+            reinterpret_cast<MemberPtr*>(function_obj_ptr.data);
+          return boost::mem_fn(*f)( static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2) , static_cast<T3&&>(a3) , static_cast<T4&&>(a4) , static_cast<T5&&>(a5) , static_cast<T6&&>(a6) , static_cast<T7&&>(a7) , static_cast<T8&&>(a8) , static_cast<T9&&>(a9));
+        }
+      };
+
+      template<
+        typename MemberPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
+      >
+      struct function_void_mem_invoker10
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr ,
+               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8 , T9 a9)
+
+        {
+          MemberPtr* f =
+            reinterpret_cast<MemberPtr*>(function_obj_ptr.data);
+          boost::mem_fn(*f)( static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2) , static_cast<T3&&>(a3) , static_cast<T4&&>(a4) , static_cast<T5&&>(a5) , static_cast<T6&&>(a6) , static_cast<T7&&>(a7) , static_cast<T8&&>(a8) , static_cast<T9&&>(a9));
+        }
+      };
+
+
+      template<
+        typename FunctionPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
+      >
+      struct get_function_invoker10
+      {
+        typedef typename conditional<(is_void<R>::value),
+                            void_function_invoker10<
+                            FunctionPtr,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
+                          >,
+                          function_invoker10<
+                            FunctionPtr,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
+                          >
+                       >::type type;
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
+       >
+      struct get_function_obj_invoker10
+      {
+        typedef typename conditional<(is_void<R>::value),
+                            void_function_obj_invoker10<
+                            FunctionObj,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
+                          >,
+                          function_obj_invoker10<
+                            FunctionObj,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
+                          >
+                       >::type type;
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
+       >
+      struct get_function_ref_invoker10
+      {
+        typedef typename conditional<(is_void<R>::value),
+                            void_function_ref_invoker10<
+                            FunctionObj,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
+                          >,
+                          function_ref_invoker10<
+                            FunctionObj,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
+                          >
+                       >::type type;
+      };
+
+
+
+      template<
+        typename MemberPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
+       >
+      struct get_member_invoker10
+      {
+        typedef typename conditional<(is_void<R>::value),
+                            function_void_mem_invoker10<
+                            MemberPtr,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
+                          >,
+                          function_mem_invoker10<
+                            MemberPtr,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
+                          >
+                       >::type type;
+      };
+# 331 "/usr/include/boost/function/function_template.hpp" 3 4
+      template<typename Tag>
+      struct get_invoker10 { };
+
+
+      template<>
+      struct get_invoker10<function_ptr_tag>
+      {
+        template<typename FunctionPtr,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
+        struct apply
+        {
+          typedef typename get_function_invoker10<
+                             FunctionPtr,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<FunctionPtr> manager_type;
+        };
+
+        template<typename FunctionPtr, typename Allocator,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
+        struct apply_a
+        {
+          typedef typename get_function_invoker10<
+                             FunctionPtr,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<FunctionPtr> manager_type;
+        };
+      };
+
+
+
+      template<>
+      struct get_invoker10<member_ptr_tag>
+      {
+        template<typename MemberPtr,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
+        struct apply
+        {
+          typedef typename get_member_invoker10<
+                             MemberPtr,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<MemberPtr> manager_type;
+        };
+
+        template<typename MemberPtr, typename Allocator,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
+        struct apply_a
+        {
+          typedef typename get_member_invoker10<
+                             MemberPtr,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<MemberPtr> manager_type;
+        };
+      };
+
+
+
+      template<>
+      struct get_invoker10<function_obj_tag>
+      {
+        template<typename FunctionObj,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
+        struct apply
+        {
+          typedef typename get_function_obj_invoker10<
+                             FunctionObj,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<FunctionObj> manager_type;
+        };
+
+        template<typename FunctionObj, typename Allocator,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
+        struct apply_a
+        {
+          typedef typename get_function_obj_invoker10<
+                             FunctionObj,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
+                           >::type
+            invoker_type;
+
+          typedef functor_manager_a<FunctionObj, Allocator> manager_type;
+        };
+      };
+
+
+      template<>
+      struct get_invoker10<function_obj_ref_tag>
+      {
+        template<typename RefWrapper,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
+        struct apply
+        {
+          typedef typename get_function_ref_invoker10<
+                             typename RefWrapper::type,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
+                           >::type
+            invoker_type;
+
+          typedef reference_manager<typename RefWrapper::type> manager_type;
+        };
+
+        template<typename RefWrapper, typename Allocator,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
+        struct apply_a
+        {
+          typedef typename get_function_ref_invoker10<
+                             typename RefWrapper::type,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
+                           >::type
+            invoker_type;
+
+          typedef reference_manager<typename RefWrapper::type> manager_type;
+        };
+      };
+# 476 "/usr/include/boost/function/function_template.hpp" 3 4
+      template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
+      struct basic_vtable10
+      {
+
+        typedef R result_type;
+
+
+
+
+        typedef result_type (*invoker_type)(function_buffer&
+                                            ,
+                                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9);
+
+        template<typename F>
+        bool assign_to(F f, function_buffer& functor) const
+        {
+          typedef typename get_function_tag<F>::type tag;
+          return assign_to(f, functor, tag());
+        }
+        template<typename F,typename Allocator>
+        bool assign_to_a(F f, function_buffer& functor, Allocator a) const
+        {
+          typedef typename get_function_tag<F>::type tag;
+          return assign_to_a(f, functor, a, tag());
+        }
+
+        void clear(function_buffer& functor) const
+        {
+          if (base.manager)
+            base.manager(functor, functor, destroy_functor_tag);
+        }
+
+      private:
+
+        template<typename FunctionPtr>
+        bool
+        assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag) const
+        {
+          this->clear(functor);
+          if (f) {
+
+
+            functor.members.func_ptr = reinterpret_cast<void (*)()>(f);
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionPtr,typename Allocator>
+        bool
+        assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const
+        {
+          return assign_to(f,functor,function_ptr_tag());
+        }
+
+
+
+        template<typename MemberPtr>
+        bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag) const
+        {
+
+
+
+          if (f) {
+            this->assign_to(boost::mem_fn(f), functor);
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename MemberPtr,typename Allocator>
+        bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag) const
+        {
+
+
+
+          if (f) {
+            this->assign_to_a(boost::mem_fn(f), functor, a);
+            return true;
+          } else {
+            return false;
+          }
+        }
+
+
+
+
+        template<typename FunctionObj>
+        void
+        assign_functor(FunctionObj f, function_buffer& functor, true_type) const
+        {
+          new (reinterpret_cast<void*>(functor.data)) FunctionObj(f);
+        }
+        template<typename FunctionObj,typename Allocator>
+        void
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, true_type) const
+        {
+          assign_functor(f,functor,true_type());
+        }
+
+
+        template<typename FunctionObj>
+        void
+        assign_functor(FunctionObj f, function_buffer& functor, false_type) const
+        {
+          functor.members.obj_ptr = new FunctionObj(f);
+        }
+        template<typename FunctionObj,typename Allocator>
+        void
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, false_type) const
+        {
+          typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;
+
+
+
+
+
+          using wrapper_allocator_type = typename std::allocator_traits<Allocator>::template rebind_alloc<functor_wrapper_type>;
+          using wrapper_allocator_pointer_type = typename std::allocator_traits<wrapper_allocator_type>::pointer;
+
+          wrapper_allocator_type wrapper_allocator(a);
+          wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
+
+
+
+          std::allocator_traits<wrapper_allocator_type>::construct(wrapper_allocator, copy, functor_wrapper_type(f,a));
+
+          functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
+          functor.members.obj_ptr = new_f;
+        }
+
+        template<typename FunctionObj>
+        bool
+        assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) const
+        {
+          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
+            assign_functor(f, functor,
+                           integral_constant<bool, (function_allows_small_object_optimization<FunctionObj>::value)>());
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionObj,typename Allocator>
+        bool
+        assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag) const
+        {
+          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
+            assign_functor_a(f, functor, a,
+                           integral_constant<bool, (function_allows_small_object_optimization<FunctionObj>::value)>());
+            return true;
+          } else {
+            return false;
+          }
+        }
+
+
+        template<typename FunctionObj>
+        bool
+        assign_to(const reference_wrapper<FunctionObj>& f,
+                  function_buffer& functor, function_obj_ref_tag) const
+        {
+          functor.members.obj_ref.obj_ptr = (void *)(f.get_pointer());
+          functor.members.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
+          functor.members.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
+          return true;
+        }
+        template<typename FunctionObj,typename Allocator>
+        bool
+        assign_to_a(const reference_wrapper<FunctionObj>& f,
+                  function_buffer& functor, Allocator, function_obj_ref_tag) const
+        {
+          return assign_to(f,functor,function_obj_ref_tag());
+        }
+
+      public:
+        vtable_base base;
+        invoker_type invoker;
+      };
+    }
+  }
+
+  template<
+    typename R ,
+    typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
+  >
+  class function10 : public function_base
+  {
+  public:
+
+    typedef R result_type;
+
+
+
+
+
+  private:
+    typedef boost::detail::function::basic_vtable10<
+              R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>
+      vtable_type;
+
+    vtable_type* get_vtable() const {
+      return reinterpret_cast<vtable_type*>(
+               reinterpret_cast<std::size_t>(vtable) & ~static_cast<std::size_t>(0x01));
+    }
+
+    struct clear_type {};
+
+  public:
+    static const int args = 10;
+
+
+    template<typename Args>
+    struct sig
+    {
+      typedef result_type type;
+    };
+# 701 "/usr/include/boost/function/function_template.hpp" 3 4
+    static const int arity = 10;
+    typedef T0 arg1_type; typedef T1 arg2_type; typedef T2 arg3_type; typedef T3 arg4_type; typedef T4 arg5_type; typedef T5 arg6_type; typedef T6 arg7_type; typedef T7 arg8_type; typedef T8 arg9_type; typedef T9 arg10_type;
+
+    typedef function10 self_type;
+
+    function10() = default;
+
+
+
+    template<typename Functor>
+    function10(Functor f
+
+                            ,typename boost::enable_if_<
+                             !(is_integral<Functor>::value),
+                                        int>::type = 0
+
+                            ) :
+      function_base()
+    {
+      this->assign_to(f);
+    }
+    template<typename Functor,typename Allocator>
+    function10(Functor f, Allocator a
+
+                            ,typename boost::enable_if_<
+                              !(is_integral<Functor>::value),
+                                        int>::type = 0
+
+                            ) :
+      function_base()
+    {
+      this->assign_to_a(f,a);
+    }
+
+
+    function10(clear_type*) : function_base() { }
+
+
+
+
+
+
+
+    function10(const function10& f) : function_base()
+    {
+      this->assign_to_own(f);
+    }
+
+
+    function10(function10&& f) : function_base()
+    {
+      this->move_assign(f);
+    }
+
+
+    ~function10() { clear(); }
+
+    result_type operator()( T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8 , T9 a9) const
+    {
+      if (this->empty())
+        boost::throw_exception(bad_function_call());
+
+      return get_vtable()->invoker
+               (this->functor , static_cast<T0&&>(a0) , static_cast<T1&&>(a1) , static_cast<T2&&>(a2) , static_cast<T3&&>(a3) , static_cast<T4&&>(a4) , static_cast<T5&&>(a5) , static_cast<T6&&>(a6) , static_cast<T7&&>(a7) , static_cast<T8&&>(a8) , static_cast<T9&&>(a9));
+    }
+
+
+
+
+
+
+    template<typename Functor>
+
+    typename boost::enable_if_<
+                  !(is_integral<Functor>::value),
+               function10&>::type
+
+
+
+    operator=(Functor f)
+    {
+      this->clear();
+      { try {
+        this->assign_to(f);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+      return *this;
+    }
+    template<typename Functor,typename Allocator>
+    void assign(Functor f, Allocator a)
+    {
+      this->clear();
+      { try{
+        this->assign_to_a(f,a);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+    }
+
+
+    function10& operator=(clear_type*)
+    {
+      this->clear();
+      return *this;
+    }
+# 821 "/usr/include/boost/function/function_template.hpp" 3 4
+    function10& operator=(const function10& f)
+    {
+      if (&f == this)
+        return *this;
+
+      this->clear();
+      { try {
+        this->assign_to_own(f);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+      return *this;
+    }
+
+
+
+    function10& operator=(function10&& f)
+    {
+      if (&f == this)
+        return *this;
+
+      this->clear();
+      { try {
+        this->move_assign(f);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+      return *this;
+    }
+
+
+    void swap(function10& other)
+    {
+      if (&other == this)
+        return;
+
+      function10 tmp;
+      tmp.move_assign(*this);
+      this->move_assign(other);
+      other.move_assign(tmp);
+    }
+
+
+    void clear()
+    {
+      if (vtable) {
+        if (!this->has_trivial_copy_and_destroy())
+          get_vtable()->clear(this->functor);
+        vtable = 0;
+      }
+    }
+
+
+
+
+
+  private:
+    struct dummy {
+      void nonnull() {}
+    };
+
+    typedef void (dummy::*safe_bool)();
+
+  public:
+    operator safe_bool () const
+      { return (this->empty())? 0 : &dummy::nonnull; }
+
+    bool operator!() const
+      { return this->empty(); }
+
+
+  private:
+    void assign_to_own(const function10& f)
+    {
+      if (!f.empty()) {
+        this->vtable = f.vtable;
+        if (this->has_trivial_copy_and_destroy())
+
+
+          std::memcpy(this->functor.data, f.functor.data, sizeof(boost::detail::function::function_buffer));
+        else
+          get_vtable()->base.manager(f.functor, this->functor,
+                                     boost::detail::function::clone_functor_tag);
+      }
+    }
+
+    template<typename Functor>
+    void assign_to(Functor f)
+    {
+      using boost::detail::function::vtable_base;
+
+      typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
+      typedef boost::detail::function::get_invoker10<tag> get_invoker;
+      typedef typename get_invoker::
+                         template apply<Functor, R ,
+                        T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>
+        handler_type;
+
+      typedef typename handler_type::invoker_type invoker_type;
+      typedef typename handler_type::manager_type manager_type;
+
+
+
+
+
+      static const vtable_type stored_vtable =
+        { { &manager_type::manage }, &invoker_type::invoke };
+
+      if (stored_vtable.assign_to(f, functor)) {
+        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
+
+        if (boost::has_trivial_copy_constructor<Functor>::value &&
+            boost::has_trivial_destructor<Functor>::value &&
+            boost::detail::function::function_allows_small_object_optimization<Functor>::value)
+          value |= static_cast<std::size_t>(0x01);
+        vtable = reinterpret_cast<boost::detail::function::vtable_base *>(value);
+      } else
+        vtable = 0;
+    }
+
+    template<typename Functor,typename Allocator>
+    void assign_to_a(Functor f,Allocator a)
+    {
+      using boost::detail::function::vtable_base;
+
+      typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
+      typedef boost::detail::function::get_invoker10<tag> get_invoker;
+      typedef typename get_invoker::
+                         template apply_a<Functor, Allocator, R ,
+                         T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>
+        handler_type;
+
+      typedef typename handler_type::invoker_type invoker_type;
+      typedef typename handler_type::manager_type manager_type;
+
+
+
+
+
+      static const vtable_type stored_vtable =
+        { { &manager_type::manage }, &invoker_type::invoke };
+
+      if (stored_vtable.assign_to_a(f, functor, a)) {
+        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
+
+        if (boost::has_trivial_copy_constructor<Functor>::value &&
+            boost::has_trivial_destructor<Functor>::value &&
+            boost::detail::function::function_allows_small_object_optimization<Functor>::value)
+          value |= static_cast<std::size_t>(0x01);
+        vtable = reinterpret_cast<boost::detail::function::vtable_base *>(value);
+      } else
+        vtable = 0;
+    }
+
+
+
+
+    void move_assign(function10& f)
+    {
+      if (&f == this)
+        return;
+
+      { try {
+        if (!f.empty()) {
+          this->vtable = f.vtable;
+          if (this->has_trivial_copy_and_destroy())
+
+
+            std::memcpy(this->functor.data, f.functor.data, sizeof(this->functor.data));
+          else
+            get_vtable()->base.manager(f.functor, this->functor,
+                                     boost::detail::function::move_functor_tag);
+          f.vtable = 0;
+        } else {
+          clear();
+        }
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+    }
+  };
+
+  template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
+  inline void swap(function10<
+                     R ,
+                     T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
+                   >& f1,
+                   function10<
+                     R ,
+                     T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
+                   >& f2)
+  {
+    f1.swap(f2);
+  }
+
+
+template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
+  void operator==(const function10<
+                          R ,
+                          T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>&,
+                  const function10<
+                          R ,
+                          T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>&);
+template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
+  void operator!=(const function10<
+                          R ,
+                          T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>&,
+                  const function10<
+                          R ,
+                          T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>& );
+
+
+
+
+
+
+#define BOOST_FUNCTION_PARTIAL_SPEC R (BOOST_FUNCTION_TEMPLATE_ARGS)
+
+
+template<typename R ,
+         typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
+class function<R ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9)>
+  : public function10<R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>
+{
+  typedef function10<R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9> base_type;
+  typedef function self_type;
+
+  struct clear_type {};
+
+public:
+
+  function() = default;
+
+  template<typename Functor>
+  function(Functor f
+
+           ,typename boost::enable_if_<
+                          !(is_integral<Functor>::value),
+                       int>::type = 0
+
+           ) :
+    base_type(f)
+  {
+  }
+  template<typename Functor,typename Allocator>
+  function(Functor f, Allocator a
+
+           ,typename boost::enable_if_<
+                           !(is_integral<Functor>::value),
+                       int>::type = 0
+
+           ) :
+    base_type(f,a)
+  {
+  }
+
+
+  function(clear_type*) : base_type() {}
+
+
+  function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}
+
+  function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}
+
+
+
+  function(self_type&& f): base_type(static_cast<base_type&&>(f)){}
+  function(base_type&& f): base_type(static_cast<base_type&&>(f)){}
+
+
+  self_type& operator=(const self_type& f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+
+
+  self_type& operator=(self_type&& f)
+  {
+    self_type(static_cast<self_type&&>(f)).swap(*this);
+    return *this;
+  }
+
+
+  template<typename Functor>
+
+  typename boost::enable_if_<
+                         !(is_integral<Functor>::value),
+                      self_type&>::type
+
+
+
+  operator=(Functor f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+
+
+  self_type& operator=(clear_type*)
+  {
+    this->clear();
+    return *this;
+  }
+
+
+  self_type& operator=(const base_type& f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+
+
+  self_type& operator=(base_type&& f)
+  {
+    self_type(static_cast<base_type&&>(f)).swap(*this);
+    return *this;
+  }
+
+};
+
+#undef BOOST_FUNCTION_PARTIAL_SPEC
+
+
+}
+
+
+#undef BOOST_FUNCTION_VTABLE
+#undef BOOST_FUNCTION_COMMA
+#undef BOOST_FUNCTION_FUNCTION
+#undef BOOST_FUNCTION_FUNCTION_INVOKER
+#undef BOOST_FUNCTION_VOID_FUNCTION_INVOKER
+#undef BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
+#undef BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
+#undef BOOST_FUNCTION_FUNCTION_REF_INVOKER
+#undef BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER
+#undef BOOST_FUNCTION_MEMBER_INVOKER
+#undef BOOST_FUNCTION_VOID_MEMBER_INVOKER
+#undef BOOST_FUNCTION_GET_FUNCTION_INVOKER
+#undef BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
+#undef BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER
+#undef BOOST_FUNCTION_GET_MEM_FUNCTION_INVOKER
+#undef BOOST_FUNCTION_GET_INVOKER
+#undef BOOST_FUNCTION_TEMPLATE_PARMS
+#undef BOOST_FUNCTION_TEMPLATE_ARGS
+#undef BOOST_FUNCTION_PARMS
+#undef BOOST_FUNCTION_PARM
+
+#undef BOOST_FUNCTION_ARG
+
+#undef BOOST_FUNCTION_ARGS
+#undef BOOST_FUNCTION_ARG_TYPE
+#undef BOOST_FUNCTION_ARG_TYPES
+#undef BOOST_FUNCTION_VOID_RETURN_TYPE
+#undef BOOST_FUNCTION_RETURN
+# 86 "/usr/include/boost/function/detail/maybe_include.hpp" 2 3 4
+# 15 "/usr/include/boost/function/detail/function_iterate.hpp" 2 3 4
+#undef BOOST_FUNCTION_NUM_ARGS
+# 98 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
+#undef BOOST_PP_ITERATION_1
+# 1332 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 3 4
+#undef BOOST_PP_IS_ITERATING
+
+#undef BOOST_PP_ITERATION_DEPTH
+#define BOOST_PP_ITERATION_DEPTH() 0
+
+#undef BOOST_PP_ITERATION_START_1
+#undef BOOST_PP_ITERATION_FINISH_1
+#undef BOOST_PP_FILENAME_1
+
+#undef BOOST_PP_ITERATION_FLAGS_1
+#undef BOOST_PP_ITERATION_PARAMS_1
+# 71 "/usr/include/boost/function.hpp" 2 3 4
+#undef BOOST_PP_ITERATION_PARAMS_1
+# 31 "/usr/include/boost/test/utils/runtime/parameter.hpp" 2 3 4
+# 1 "/usr/include/boost/algorithm/cxx11/all_of.hpp" 1 3 4
+# 13 "/usr/include/boost/algorithm/cxx11/all_of.hpp" 3 4
+#define BOOST_ALGORITHM_ALL_OF_HPP 
+
+
+# 1 "/usr/include/boost/range/begin.hpp" 1 3 4
+# 12 "/usr/include/boost/range/begin.hpp" 3 4
+#define BOOST_RANGE_BEGIN_HPP 
+
+
+
+
+
+# 1 "/usr/include/boost/range/config.hpp" 1 3 4
+# 12 "/usr/include/boost/range/config.hpp" 3 4
+#define BOOST_RANGE_CONFIG_HPP 
+# 29 "/usr/include/boost/range/config.hpp" 3 4
+#define BOOST_RANGE_DEDUCED_TYPENAME BOOST_DEDUCED_TYPENAME
+# 44 "/usr/include/boost/range/config.hpp" 3 4
+#define BOOST_RANGE_ARRAY_REF() (&boost_range_array)
+
+
+
+#define BOOST_RANGE_UNUSED __attribute__((unused))
+# 19 "/usr/include/boost/range/begin.hpp" 2 3 4
+
+
+
+
+
+# 1 "/usr/include/boost/range/iterator.hpp" 1 3 4
+# 12 "/usr/include/boost/range/iterator.hpp" 3 4
+#define BOOST_RANGE_ITERATOR_HPP 
+
+
+
+
+
+
+# 1 "/usr/include/boost/range/range_fwd.hpp" 1 3 4
+# 11 "/usr/include/boost/range/range_fwd.hpp" 3 4
+#define BOOST_RANGE_RANGE_FWD_HPP_INCLUDED 
+
+namespace boost
+{
+
+
+    template<typename C, typename Enabler>
+    struct range_iterator;
+
+    template<typename C, typename Enabler>
+    struct range_mutable_iterator;
+
+    template<typename C, typename Enabler>
+    struct range_const_iterator;
+
+
+    template<typename IteratorT>
+    class iterator_range;
+
+    template<typename ForwardRange>
+    class sub_range;
+
+
+    template<typename T>
+    struct range_category;
+
+    template<typename T>
+    struct range_difference;
+
+    template<typename T>
+    struct range_pointer;
+
+    template<typename T>
+    struct range_reference;
+
+    template<typename T>
+    struct range_reverse_iterator;
+
+    template<typename T>
+    struct range_size;
+
+    template<typename T>
+    struct range_value;
+
+    template<typename T>
+    struct has_range_iterator;
+
+    template<typename T>
+    struct has_range_const_iterator;
+
+}
+# 20 "/usr/include/boost/range/iterator.hpp" 2 3 4
+# 1 "/usr/include/boost/range/mutable_iterator.hpp" 1 3 4
+# 12 "/usr/include/boost/range/mutable_iterator.hpp" 3 4
+#define BOOST_RANGE_MUTABLE_ITERATOR_HPP 
+# 21 "/usr/include/boost/range/mutable_iterator.hpp" 3 4
+# 1 "/usr/include/boost/range/detail/extract_optional_type.hpp" 1 3 4
+# 11 "/usr/include/boost/range/detail/extract_optional_type.hpp" 3 4
+#define BOOST_RANGE_DETAIL_EXTRACT_OPTIONAL_TYPE_HPP_INCLUDED 
+# 26 "/usr/include/boost/range/detail/extract_optional_type.hpp" 3 4
+#define BOOST_RANGE_EXTRACT_OPTIONAL_TYPE(a_typedef) BOOST_MPL_HAS_XXX_TRAIT_DEF(a_typedef) template< typename C, bool B = BOOST_PP_CAT(has_, a_typedef)<C>::value > struct BOOST_PP_CAT(extract_, a_typedef) {}; template< typename C > struct BOOST_PP_CAT(extract_, a_typedef)< C, true > { typedef BOOST_DEDUCED_TYPENAME C::a_typedef type; };
+# 22 "/usr/include/boost/range/mutable_iterator.hpp" 2 3 4
+
+
+
+
+
+namespace boost
+{
+
+
+
+
+
+    namespace range_detail
+    {
+
+template< typename T, typename fallback_ = boost::mpl::bool_<false> > struct has_iterator { struct gcc_3_2_wknd { template< typename U > static boost::mpl::aux::yes_tag test( boost::mpl::aux::type_wrapper<U> const volatile* , boost::mpl::aux::type_wrapper<typename U::iterator>* = 0 ); static boost::mpl::aux::no_tag test(...); }; typedef boost::mpl::aux::type_wrapper<T> t_; static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::aux::yes_tag); typedef boost::mpl::bool_<value> type; }; template< typename C, bool B = has_iterator<C>::value > struct extract_iterator {}; template< typename C > struct extract_iterator< C, true > { typedef typename C::iterator type; };
+
+template< typename C >
+struct range_mutable_iterator
+        : range_detail::extract_iterator<
+            typename remove_reference<C>::type>
+{};
+
+
+
+
+
+template< typename Iterator >
+struct range_mutable_iterator< std::pair<Iterator,Iterator> >
+{
+    typedef Iterator type;
+};
+
+
+
+
+
+template< typename T, std::size_t sz >
+struct range_mutable_iterator< T[sz] >
+{
+    typedef T* type;
+};
+
+    }
+
+template<typename C, typename Enabler=void>
+struct range_mutable_iterator
+        : range_detail::range_mutable_iterator<
+            typename remove_reference<C>::type
+        >
+{
+};
+
+}
+
+# 1 "/usr/include/boost/range/detail/msvc_has_iterator_workaround.hpp" 1 3 4
+# 12 "/usr/include/boost/range/detail/msvc_has_iterator_workaround.hpp" 3 4
+#define BOOST_RANGE_DETAIL_MSVC_HAS_ITERATOR_WORKAROUND_HPP 
+# 78 "/usr/include/boost/range/mutable_iterator.hpp" 2 3 4
+# 21 "/usr/include/boost/range/iterator.hpp" 2 3 4
+# 1 "/usr/include/boost/range/const_iterator.hpp" 1 3 4
+# 12 "/usr/include/boost/range/const_iterator.hpp" 3 4
+#define BOOST_RANGE_CONST_ITERATOR_HPP 
+# 27 "/usr/include/boost/range/const_iterator.hpp" 3 4
+namespace boost
+{
+
+
+
+
+    namespace range_detail
+    {
+
+template< typename T, typename fallback_ = boost::mpl::bool_<false> > struct has_const_iterator { struct gcc_3_2_wknd { template< typename U > static boost::mpl::aux::yes_tag test( boost::mpl::aux::type_wrapper<U> const volatile* , boost::mpl::aux::type_wrapper<typename U::const_iterator>* = 0 ); static boost::mpl::aux::no_tag test(...); }; typedef boost::mpl::aux::type_wrapper<T> t_; static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::aux::yes_tag); typedef boost::mpl::bool_<value> type; }; template< typename C, bool B = has_const_iterator<C>::value > struct extract_const_iterator {}; template< typename C > struct extract_const_iterator< C, true > { typedef typename C::const_iterator type; };
+
+template< typename C >
+struct range_const_iterator_helper
+        : extract_const_iterator<C>
+{};
+
+
+
+
+
+template< typename Iterator >
+struct range_const_iterator_helper<std::pair<Iterator,Iterator> >
+{
+    typedef Iterator type;
+};
+
+
+
+
+
+template< typename T, std::size_t sz >
+struct range_const_iterator_helper< T[sz] >
+{
+    typedef const T* type;
+};
+
+    }
+
+template<typename C, typename Enabler=void>
+struct range_const_iterator
+        : range_detail::range_const_iterator_helper<
+            typename remove_reference<C>::type
+        >
+{
+};
+
+}
+# 22 "/usr/include/boost/range/iterator.hpp" 2 3 4
+
+
+
+
+namespace boost
+{
+# 60 "/usr/include/boost/range/iterator.hpp" 3 4
+    template< typename C, typename Enabler=void >
+    struct range_iterator
+      : mpl::if_c<
+            is_const<typename remove_reference<C>::type>::value,
+            range_const_iterator<typename remove_const<typename remove_reference<C>::type>::type>,
+            range_mutable_iterator<typename remove_reference<C>::type>
+        >::type
+    {
+    };
+
+
+
+}
+# 25 "/usr/include/boost/range/begin.hpp" 2 3 4
+
+
+
+namespace boost
+{
+
+
+namespace range_detail
+{
+
+
+
+
+
+
+    template< typename C >
+    constexpr inline typename range_iterator<C>::type
+    range_begin( C& c )
+    {
+
+
+
+
+
+        return c.begin();
+    }
+
+
+
+
+
+    template< typename Iterator >
+    constexpr inline Iterator range_begin( const std::pair<Iterator,Iterator>& p )
+    {
+        return p.first;
+    }
+
+    template< typename Iterator >
+    constexpr inline Iterator range_begin( std::pair<Iterator,Iterator>& p )
+    {
+        return p.first;
+    }
+# 75 "/usr/include/boost/range/begin.hpp" 3 4
+    template< typename T, std::size_t sz >
+    constexpr inline const T* range_begin( const T (&a)[sz] ) noexcept
+    {
+        return a;
+    }
+
+    template< typename T, std::size_t sz >
+    constexpr inline T* range_begin( T (&a)[sz] ) noexcept
+    {
+        return a;
+    }
+
+
+
+}
+
+
+
+
+
+namespace range_adl_barrier
+{
+
+template< class T >
+
+constexpr
+
+inline typename range_iterator<T>::type begin( T& r )
+{
+
+    using namespace range_detail;
+
+    return range_begin( r );
+}
+
+template< class T >
+
+constexpr
+
+inline typename range_iterator<const T>::type begin( const T& r )
+{
+
+    using namespace range_detail;
+
+    return range_begin( r );
+}
+
+    }
+}
+
+
+
+namespace boost
+{
+    namespace range_adl_barrier
+    {
+        template< class T >
+        inline typename range_iterator<const T>::type
+        const_begin( const T& r )
+        {
+            return boost::range_adl_barrier::begin( r );
+        }
+    }
+
+    using namespace range_adl_barrier;
+}
+# 17 "/usr/include/boost/algorithm/cxx11/all_of.hpp" 2 3 4
+# 1 "/usr/include/boost/range/end.hpp" 1 3 4
+# 12 "/usr/include/boost/range/end.hpp" 3 4
+#define BOOST_RANGE_END_HPP 
+# 24 "/usr/include/boost/range/end.hpp" 3 4
+# 1 "/usr/include/boost/range/detail/implementation_help.hpp" 1 3 4
+# 12 "/usr/include/boost/range/detail/implementation_help.hpp" 3 4
+#define BOOST_RANGE_DETAIL_IMPLEMENTATION_HELP_HPP 
+
+
+# 1 "/usr/include/boost/range/detail/common.hpp" 1 3 4
+# 12 "/usr/include/boost/range/detail/common.hpp" 3 4
+#define BOOST_RANGE_DETAIL_COMMON_HPP 
+
+
+
+
+
+
+# 1 "/usr/include/boost/range/detail/sfinae.hpp" 1 3 4
+# 12 "/usr/include/boost/range/detail/sfinae.hpp" 3 4
+#define BOOST_RANGE_DETAIL_SFINAE_HPP 
+
+
+
+
+
+
+
+namespace boost
+{
+    namespace range_detail
+    {
+        using type_traits::yes_type;
+        using type_traits::no_type;
+
+
+
+
+
+        yes_type is_string_impl( const char* const );
+        yes_type is_string_impl( const wchar_t* const );
+        no_type is_string_impl( ... );
+
+        template< std::size_t sz >
+        yes_type is_char_array_impl( char (&boost_range_array)[sz] );
+        template< std::size_t sz >
+        yes_type is_char_array_impl( const char (&boost_range_array)[sz] );
+        no_type is_char_array_impl( ... );
+
+        template< std::size_t sz >
+        yes_type is_wchar_t_array_impl( wchar_t (&boost_range_array)[sz] );
+        template< std::size_t sz >
+        yes_type is_wchar_t_array_impl( const wchar_t (&boost_range_array)[sz] );
+        no_type is_wchar_t_array_impl( ... );
+
+        yes_type is_char_ptr_impl( char* const );
+        no_type is_char_ptr_impl( ... );
+
+        yes_type is_const_char_ptr_impl( const char* const );
+        no_type is_const_char_ptr_impl( ... );
+
+        yes_type is_wchar_t_ptr_impl( wchar_t* const );
+        no_type is_wchar_t_ptr_impl( ... );
+
+        yes_type is_const_wchar_t_ptr_impl( const wchar_t* const );
+        no_type is_const_wchar_t_ptr_impl( ... );
+
+
+
+
+
+        template< typename Iterator >
+        yes_type is_pair_impl( const std::pair<Iterator,Iterator>* );
+        no_type is_pair_impl( ... );
+
+
+
+
+
+        struct char_or_wchar_t_array_tag {};
+
+    }
+
+}
+# 20 "/usr/include/boost/range/detail/common.hpp" 2 3 4
+# 29 "/usr/include/boost/range/detail/common.hpp" 3 4
+namespace boost
+{
+    namespace range_detail
+    {
+# 46 "/usr/include/boost/range/detail/common.hpp" 3 4
+        typedef mpl::int_<1>::type std_container_;
+        typedef mpl::int_<2>::type std_pair_;
+        typedef mpl::int_<3>::type const_std_pair_;
+        typedef mpl::int_<4>::type array_;
+        typedef mpl::int_<5>::type const_array_;
+        typedef mpl::int_<6>::type char_array_;
+        typedef mpl::int_<7>::type wchar_t_array_;
+        typedef mpl::int_<8>::type char_ptr_;
+        typedef mpl::int_<9>::type const_char_ptr_;
+        typedef mpl::int_<10>::type wchar_t_ptr_;
+        typedef mpl::int_<11>::type const_wchar_t_ptr_;
+        typedef mpl::int_<12>::type string_;
+
+        template< typename C >
+        struct range_helper
+        {
+            static C* c;
+            static C ptr;
+
+            static const bool is_pair_ = sizeof( boost::range_detail::is_pair_impl( c ) ) == sizeof( yes_type );
+            static const bool is_char_ptr_ = sizeof( boost::range_detail::is_char_ptr_impl( ptr ) ) == sizeof( yes_type );
+            static const bool is_const_char_ptr_ = sizeof( boost::range_detail::is_const_char_ptr_impl( ptr ) ) == sizeof( yes_type );
+            static const bool is_wchar_t_ptr_ = sizeof( boost::range_detail::is_wchar_t_ptr_impl( ptr ) ) == sizeof( yes_type );
+            static const bool is_const_wchar_t_ptr_ = sizeof( boost::range_detail::is_const_wchar_t_ptr_impl( ptr ) ) == sizeof( yes_type );
+            static const bool is_char_array_ = sizeof( boost::range_detail::is_char_array_impl( ptr ) ) == sizeof( yes_type );
+            static const bool is_wchar_t_array_ = sizeof( boost::range_detail::is_wchar_t_array_impl( ptr ) ) == sizeof( yes_type );
+            static const bool is_string_ = (is_const_char_ptr_ || is_const_wchar_t_ptr_);
+            static const bool is_array_ = boost::is_array<C>::value;
+
+        };
+
+        template< typename C >
+        class range
+        {
+            typedef typename boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_pair_,
+                                                                  boost::range_detail::std_pair_,
+                                                                  void >::type pair_t;
+            typedef typename boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_array_,
+                                                                    boost::range_detail::array_,
+                                                                    pair_t >::type array_t;
+            typedef typename boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_string_,
+                                                                    boost::range_detail::string_,
+                                                                    array_t >::type string_t;
+            typedef typename boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_const_char_ptr_,
+                                                                    boost::range_detail::const_char_ptr_,
+                                                                    string_t >::type const_char_ptr_t;
+            typedef typename boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_char_ptr_,
+                                                                    boost::range_detail::char_ptr_,
+                                                                    const_char_ptr_t >::type char_ptr_t;
+            typedef typename boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_const_wchar_t_ptr_,
+                                                                    boost::range_detail::const_wchar_t_ptr_,
+                                                                    char_ptr_t >::type const_wchar_ptr_t;
+            typedef typename boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_wchar_t_ptr_,
+                                                                    boost::range_detail::wchar_t_ptr_,
+                                                                    const_wchar_ptr_t >::type wchar_ptr_t;
+            typedef typename boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_wchar_t_array_,
+                                                                    boost::range_detail::wchar_t_array_,
+                                                                    wchar_ptr_t >::type wchar_array_t;
+            typedef typename boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_char_array_,
+                                                                    boost::range_detail::char_array_,
+                                                                    wchar_array_t >::type char_array_t;
+        public:
+            typedef typename boost::mpl::if_c< ::boost::is_void<char_array_t>::value,
+                                                                    boost::range_detail::std_container_,
+                                                                    char_array_t >::type type;
+        };
+    }
+}
+# 16 "/usr/include/boost/range/detail/implementation_help.hpp" 2 3 4
+# 24 "/usr/include/boost/range/detail/implementation_help.hpp" 3 4
+namespace boost
+{
+    namespace range_detail
+    {
+        template <typename T>
+        inline void boost_range_silence_warning( const T& ) { }
+
+
+
+
+
+        inline const char* str_end( const char* s, const char* )
+        {
+            return s + strlen( s );
+        }
+
+
+        inline const wchar_t* str_end( const wchar_t* s, const wchar_t* )
+        {
+            return s + wcslen( s );
+        }
+# 56 "/usr/include/boost/range/detail/implementation_help.hpp" 3 4
+        template< class Char >
+        inline Char* str_end( Char* s )
+        {
+            return const_cast<Char*>( str_end( s, s ) );
+        }
+
+        template< class T, std::size_t sz >
+        constexpr inline T* array_end( T (&boost_range_array)[sz] ) noexcept
+        {
+            return boost_range_array + sz;
+        }
+
+        template< class T, std::size_t sz >
+        constexpr inline const T* array_end( const T (&boost_range_array)[sz] ) noexcept
+        {
+            return boost_range_array + sz;
+        }
+
+
+
+
+
+        template< class Char >
+        inline std::size_t str_size( const Char* const& s )
+        {
+            return str_end( s ) - s;
+        }
+
+        template< class T, std::size_t sz >
+        inline std::size_t array_size( T (&boost_range_array)[sz] )
+        {
+            boost_range_silence_warning( boost_range_array );
+            return sz;
+        }
+
+        template< class T, std::size_t sz >
+        inline std::size_t array_size( const T (&boost_range_array)[sz] )
+        {
+            boost_range_silence_warning( boost_range_array );
+            return sz;
+        }
+
+        inline bool is_same_address(const void* l, const void* r)
+        {
+            return l == r;
+        }
+
+        template<class T1, class T2>
+        inline bool is_same_object(const T1& l, const T2& r)
+        {
+            return range_detail::is_same_address(&l, &r);
+        }
+
+    }
+
+}
+# 25 "/usr/include/boost/range/end.hpp" 2 3 4
+
+
+
+
+
+namespace boost
+{
+
+
+namespace range_detail
+{
+
+
+
+
+
+        template< typename C >
+        constexpr inline typename range_iterator<C>::type
+        range_end( C& c )
+        {
+
+
+
+
+
+            return c.end();
+        }
+
+
+
+
+
+        template< typename Iterator >
+        constexpr inline Iterator range_end( const std::pair<Iterator,Iterator>& p )
+        {
+            return p.second;
+        }
+
+        template< typename Iterator >
+        constexpr inline Iterator range_end( std::pair<Iterator,Iterator>& p )
+        {
+            return p.second;
+        }
+
+
+
+
+
+        template< typename T, std::size_t sz >
+        constexpr inline const T* range_end( const T (&a)[sz] ) noexcept
+        {
+            return range_detail::array_end<T,sz>( a );
+        }
+
+        template< typename T, std::size_t sz >
+        constexpr inline T* range_end( T (&a)[sz] ) noexcept
+        {
+            return range_detail::array_end<T,sz>( a );
+        }
+
+
+}
+
+
+namespace range_adl_barrier
+{
+
+template< class T >
+
+constexpr
+
+inline typename range_iterator<T>::type end( T& r )
+{
+
+    using namespace range_detail;
+
+    return range_end( r );
+}
+
+template< class T >
+
+constexpr
+
+inline typename range_iterator<const T>::type end( const T& r )
+{
+
+    using namespace range_detail;
+
+    return range_end( r );
+}
+
+    }
+}
+
+
+
+namespace boost
+{
+    namespace range_adl_barrier
+    {
+        template< class T >
+        constexpr inline typename range_iterator<const T>::type
+        const_end( const T& r )
+        {
+            return boost::range_adl_barrier::end( r );
+        }
+    }
+    using namespace range_adl_barrier;
+}
+# 18 "/usr/include/boost/algorithm/cxx11/all_of.hpp" 2 3 4
+
+namespace boost { namespace algorithm {
+# 30 "/usr/include/boost/algorithm/cxx11/all_of.hpp" 3 4
+template<typename InputIterator, typename Predicate>
+constexpr bool all_of ( InputIterator first, InputIterator last, Predicate p )
+{
+    for ( ; first != last; ++first )
+        if ( !p(*first))
+            return false;
+    return true;
+}
+# 46 "/usr/include/boost/algorithm/cxx11/all_of.hpp" 3 4
+template<typename Range, typename Predicate>
+constexpr bool all_of ( const Range &r, Predicate p )
+{
+    return boost::algorithm::all_of ( boost::begin (r), boost::end (r), p );
+}
+# 60 "/usr/include/boost/algorithm/cxx11/all_of.hpp" 3 4
+template<typename InputIterator, typename T>
+constexpr bool all_of_equal ( InputIterator first, InputIterator last, const T &val )
+{
+    for ( ; first != last; ++first )
+    if ( val != *first )
+        return false;
+    return true;
+}
+# 76 "/usr/include/boost/algorithm/cxx11/all_of.hpp" 3 4
+template<typename Range, typename T>
+constexpr bool all_of_equal ( const Range &r, const T &val )
+{
+    return boost::algorithm::all_of_equal ( boost::begin (r), boost::end (r), val );
+}
+
+}}
+# 32 "/usr/include/boost/test/utils/runtime/parameter.hpp" 2 3 4
+
+
+
+
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 37 "/usr/include/boost/test/utils/runtime/parameter.hpp" 2 3 4
+
+namespace boost {
+namespace runtime {
+
+inline
+std::ostream& commandline_pretty_print(
+    std::ostream& ostr,
+    std::string const& prefix,
+    std::string const& to_print) {
+
+    const int split_at = 80;
+
+    std::string::size_type current = 0;
+
+    while(current < to_print.size()) {
+
+
+        std::string::size_type startpos = to_print.find_first_not_of(" \t\n", current);
+        current += startpos - current;
+
+        bool has_more_lines = (current + split_at) < to_print.size();
+
+        if(has_more_lines) {
+          std::string::size_type endpos = to_print.find_last_of(" \t\n", current + split_at);
+          std::string sub(to_print.substr(current, endpos - current));
+          ostr << prefix << sub;
+          ostr << "\n";
+          current += endpos - current;
+        }
+        else
+        {
+          ostr << prefix << to_print.substr(current, split_at);
+          current += split_at;
+        }
+    }
+    return ostr;
+}
+
+
+
+
+
+
+struct parameter_cla_id {
+    parameter_cla_id( cstring prefix, cstring tag, cstring value_separator, bool negatable )
+    : m_prefix( prefix.begin(), prefix.size() )
+    , m_tag( tag.begin(), tag.size() )
+    , m_value_separator( value_separator.begin(), value_separator.size() )
+    , m_negatable( negatable )
+    {
+
+        if( algorithm::all_of( m_prefix.begin(), m_prefix.end(), valid_prefix_char ) ) {} else unit_test::ut_detail::throw_exception( invalid_cla_id() << "Parameter " << m_tag << " has invalid characters in prefix." )
+
+                                                                                      ;
+
+        if( algorithm::all_of( m_tag.begin(), m_tag.end(), valid_name_char ) ) {} else unit_test::ut_detail::throw_exception( invalid_cla_id() << "Parameter " << m_tag << " has invalid characters in name." )
+
+                                                                                    ;
+
+        if( algorithm::all_of( m_value_separator.begin(), m_value_separator.end(), valid_separator_char ) ) {} else unit_test::ut_detail::throw_exception( invalid_cla_id() << "Parameter " << m_tag << " has invalid characters in value separator." )
+
+                                                                                               ;
+    }
+
+    static bool valid_prefix_char( char c )
+    {
+        return c == '-' || c == '/' ;
+    }
+    static bool valid_separator_char( char c )
+    {
+        return c == '=' || c == ':' || c == ' ' || c == '\0';
+    }
+    static bool valid_name_char( char c )
+    {
+        return std::isalnum( c ) || c == '+' || c == '_' || c == '?';
+    }
+
+    std::string m_prefix;
+    std::string m_tag;
+    std::string m_value_separator;
+    bool m_negatable;
+};
+
+typedef std::vector<parameter_cla_id> param_cla_ids;
+
+
+
+
+
+cstring const help_prefix("////");
+
+class basic_param {
+    typedef function<void (cstring)> callback_type;
+    typedef unit_test::readwrite_property<bool> bool_property;
+
+protected:
+
+    template<typename Modifiers>
+    basic_param( cstring name, bool is_optional, bool is_repeatable, Modifiers const& m )
+    : p_name( name.begin(), name.end() )
+    , p_description( nfp::opt_get( m, description, std::string() ) )
+    , p_help( nfp::opt_get( m, runtime::help, std::string() ) )
+    , p_env_var( nfp::opt_get( m, env_var, std::string() ) )
+    , p_value_hint( nfp::opt_get( m, value_hint, std::string() ) )
+    , p_optional( is_optional )
+    , p_repeatable( is_repeatable )
+    , p_has_optional_value( m.has( optional_value ) )
+    , p_has_default_value( m.has( default_value ) || is_repeatable )
+    , p_callback( nfp::opt_get( m, callback, callback_type() ) )
+    {
+        add_cla_id( help_prefix, name, ":" );
+    }
+
+public:
+    virtual ~basic_param() {}
+
+
+    std::string const p_name;
+    std::string const p_description;
+    std::string const p_help;
+    std::string const p_env_var;
+    std::string const p_value_hint;
+    bool const p_optional;
+    bool const p_repeatable;
+    bool_property p_has_optional_value;
+    bool_property p_has_default_value;
+    callback_type const p_callback;
+
+
+    virtual basic_param_ptr clone() const = 0;
+
+
+    param_cla_ids const& cla_ids() const { return m_cla_ids; }
+    void add_cla_id( cstring prefix, cstring tag, cstring value_separator )
+    {
+        add_cla_id_impl( prefix, tag, value_separator, false, true );
+    }
+
+
+    virtual void produce_argument( cstring token, bool negative_form, arguments_store& store ) const = 0;
+    virtual void produce_default( arguments_store& store ) const = 0;
+
+
+    virtual void usage( std::ostream& ostr, cstring negation_prefix_, bool use_color = true )
+    {
+        namespace utils = unit_test::utils;
+        namespace ut_detail = unit_test::ut_detail;
+
+
+        ostr << "  ";
+        {
+
+          utils::scope_setcolor const sc(use_color, ostr, utils::term_attr::BRIGHT, utils::term_color::GREEN); boost::ignore_unused( sc );
+          ostr << p_name;
+        }
+
+        ostr << '\n';
+
+        if( !p_description.empty() ) {
+          commandline_pretty_print(ostr, "    ", p_description) << '\n';
+        }
+
+        if( ::boost::unit_test::for_each::static_any_t _fe_cur_199 = ::boost::unit_test::for_each::begin( cla_ids(), ::boost::unit_test::for_each::is_const_coll( cla_ids() ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_199 = ::boost::unit_test::for_each::end( cla_ids(), ::boost::unit_test::for_each::is_const_coll( cla_ids() ) ) ) {} else for( bool _fe_con_199 = true; _fe_con_199 && !::boost::unit_test::for_each::done( _fe_cur_199, _fe_end_199, cla_ids(), ::boost::unit_test::for_each::is_const_coll( cla_ids() ) ); _fe_con_199 ? ::boost::unit_test::for_each::next( _fe_cur_199, cla_ids(), ::boost::unit_test::for_each::is_const_coll( cla_ids() ) ) : ((void)&(cla_ids()))) if( (_fe_con_199 = false, false) ) {} else for( parameter_cla_id const& id = ::boost::unit_test::for_each::deref( _fe_cur_199, cla_ids(), ::boost::type<parameter_cla_id const& >(), ::boost::unit_test::for_each::is_const_coll( cla_ids() ) ); !_fe_con_199; _fe_con_199 = true ) {
+            if( id.m_prefix == help_prefix )
+                continue;
+
+            ostr << "    " << id.m_prefix;
+
+            if( id.m_negatable )
+                cla_name_help( ostr, id.m_tag, negation_prefix_, use_color );
+            else
+                cla_name_help( ostr, id.m_tag, "", use_color );
+
+            utils::scope_setcolor const sc(use_color, ostr, utils::term_attr::BRIGHT, utils::term_color::YELLOW); boost::ignore_unused( sc );
+            bool optional_value_ = false;
+
+            if( p_has_optional_value ) {
+                optional_value_ = true;
+                ostr << '[';
+            }
+
+
+            if( id.m_value_separator.empty() )
+                ostr << ' ';
+            else {
+                ostr << id.m_value_separator;
+            }
+
+            value_help( ostr );
+
+            if( optional_value_ )
+                ostr << ']';
+
+            ostr << '\n';
+        }
+    }
+
+    virtual void help( std::ostream& ostr, cstring negation_prefix_, bool use_color = true )
+    {
+        usage( ostr, negation_prefix_, use_color );
+
+        if( !p_help.empty() ) {
+            ostr << '\n';
+            commandline_pretty_print(ostr, "  ", p_help);
+        }
+    }
+
+protected:
+    void add_cla_id_impl( cstring prefix,
+                                             cstring tag,
+                                             cstring value_separator,
+                                             bool negatable,
+                                             bool validate_value_separator )
+    {
+        if( !tag.is_empty() ) {} else unit_test::ut_detail::throw_exception( invalid_cla_id() << "Parameter can't have an empty name." )
+                                                                                       ;
+
+        if( !prefix.is_empty() ) {} else unit_test::ut_detail::throw_exception( invalid_cla_id() << "Parameter " << tag << " can't have an empty prefix." )
+
+                                                                                ;
+
+        if( !value_separator.is_empty() ) {} else unit_test::ut_detail::throw_exception( invalid_cla_id() << "Parameter " << tag << " can't have an empty value separator." )
+
+                                                                                         ;
+
+
+        value_separator.trim();
+        if( !validate_value_separator || !value_separator.is_empty() || !p_has_optional_value ) {} else unit_test::ut_detail::throw_exception( invalid_cla_id() << "Parameter " << tag << " with optional value attribute can't use space as value separator." )
+
+                                                                                                                      ;
+
+        m_cla_ids.push_back( parameter_cla_id( prefix, tag, value_separator, negatable ) );
+    }
+
+private:
+
+    virtual void cla_name_help( std::ostream& ostr, cstring cla_tag, cstring , bool = true) const
+    {
+        ostr << cla_tag;
+    }
+    virtual void value_help( std::ostream& ostr ) const
+    {
+        if( p_value_hint.empty() )
+            ostr << "<value>";
+        else
+            ostr << p_value_hint;
+    }
+
+
+    param_cla_ids m_cla_ids;
+};
+
+
+
+
+
+enum args_amount {
+    OPTIONAL_PARAM,
+    REQUIRED_PARAM,
+    REPEATABLE_PARAM
+};
+
+
+
+template<typename ValueType, args_amount a = runtime::OPTIONAL_PARAM, bool is_enum = false>
+class parameter : public basic_param {
+public:
+
+
+    template<typename Modifiers=nfp::no_params_type>
+    parameter( cstring name, Modifiers const& m = nfp::no_params )
+
+
+
+
+    : basic_param( name, a != runtime::REQUIRED_PARAM, a == runtime::REPEATABLE_PARAM, m )
+    , m_arg_factory( m )
+    {
+        if( !m.has( default_value ) || a == runtime::OPTIONAL_PARAM ) {} else unit_test::ut_detail::throw_exception( invalid_param_spec() << "Parameter " << name << " is not optional and can't have default_value." )
+
+                                                                                                      ;
+
+        if( !m.has( optional_value ) || !this->p_repeatable ) {} else unit_test::ut_detail::throw_exception( invalid_param_spec() << "Parameter " << name << " is repeatable and can't have optional_value." )
+
+                                                                                                     ;
+    }
+
+private:
+    virtual basic_param_ptr clone() const
+    {
+        return basic_param_ptr( new parameter( *this ) );
+    }
+    virtual void produce_argument( cstring token, bool , arguments_store& store ) const
+    {
+        m_arg_factory.produce_argument( token, this->p_name, store );
+    }
+    virtual void produce_default( arguments_store& store ) const
+    {
+        if( !this->p_has_default_value )
+            return;
+
+        m_arg_factory.produce_default( this->p_name, store );
+    }
+
+
+    typedef argument_factory<ValueType, is_enum, a == runtime::REPEATABLE_PARAM> factory_t;
+    factory_t m_arg_factory;
+};
+
+
+
+class option : public basic_param {
+public:
+
+
+    template<typename Modifiers=nfp::no_params_type>
+    option( cstring name, Modifiers const& m = nfp::no_params )
+
+
+
+
+    : basic_param( name, true, false, nfp::opt_append( nfp::opt_append( m, optional_value = true), default_value = false) )
+    , m_arg_factory( nfp::opt_append( nfp::opt_append( m, optional_value = true), default_value = false) )
+    {
+    }
+
+    void add_cla_id( cstring prefix, cstring tag, cstring value_separator, bool negatable = false )
+    {
+        add_cla_id_impl( prefix, tag, value_separator, negatable, false );
+    }
+
+private:
+    virtual basic_param_ptr clone() const
+    {
+        return basic_param_ptr( new option( *this ) );
+    }
+
+    virtual void produce_argument( cstring token, bool negative_form, arguments_store& store ) const
+    {
+        if( token.empty() )
+            store.set( p_name, !negative_form );
+        else {
+            if( !negative_form ) {} else unit_test::ut_detail::throw_exception( format_error( p_name ) << "Can't set value to negative form of the argument." )
+                                                                                                               ;
+
+            m_arg_factory.produce_argument( token, p_name, store );
+        }
+    }
+
+    virtual void produce_default( arguments_store& store ) const
+    {
+        m_arg_factory.produce_default( p_name, store );
+    }
+    virtual void cla_name_help( std::ostream& ostr, cstring cla_tag, cstring negation_prefix_, bool use_color = true ) const
+    {
+        namespace utils = unit_test::utils;
+        namespace ut_detail = unit_test::ut_detail;
+
+        if( !negation_prefix_.is_empty() ) {
+            utils::scope_setcolor const sc(use_color, ostr, utils::term_attr::BRIGHT, utils::term_color::YELLOW); boost::ignore_unused( sc );
+            ostr << '[' << negation_prefix_ << ']';
+        }
+        ostr << cla_tag;
+    }
+    virtual void value_help( std::ostream& ostr ) const
+    {
+        if( p_value_hint.empty() )
+            ostr << "<boolean value>";
+        else
+            ostr << p_value_hint;
+    }
+
+
+    typedef argument_factory<bool, false, false> factory_t;
+    factory_t m_arg_factory;
+};
+
+
+
+template<typename EnumType, args_amount a = runtime::OPTIONAL_PARAM>
+class enum_parameter : public parameter<EnumType, a, true> {
+    typedef parameter<EnumType, a, true> base;
+public:
+
+
+    template<typename Modifiers=nfp::no_params_type>
+    enum_parameter( cstring name, Modifiers const& m = nfp::no_params )
+
+
+
+
+    : base( name, m )
+    {
+
+        auto const& values = m[enum_values<EnumType>::value];
+        auto it = values.begin();
+
+
+
+
+        while( it != values.end() ) {
+            m_valid_names.push_back( it->first );
+            ++it;
+        }
+    }
+
+private:
+    virtual basic_param_ptr clone() const
+    {
+        return basic_param_ptr( new enum_parameter( *this ) );
+    }
+
+    virtual void value_help( std::ostream& ostr ) const
+    {
+        if( this->p_value_hint.empty() ) {
+            ostr << "<";
+            bool first = true;
+            if( ::boost::unit_test::for_each::static_any_t _fe_cur_454 = ::boost::unit_test::for_each::begin( m_valid_names, ::boost::unit_test::for_each::is_const_coll( m_valid_names ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_454 = ::boost::unit_test::for_each::end( m_valid_names, ::boost::unit_test::for_each::is_const_coll( m_valid_names ) ) ) {} else for( bool _fe_con_454 = true; _fe_con_454 && !::boost::unit_test::for_each::done( _fe_cur_454, _fe_end_454, m_valid_names, ::boost::unit_test::for_each::is_const_coll( m_valid_names ) ); _fe_con_454 ? ::boost::unit_test::for_each::next( _fe_cur_454, m_valid_names, ::boost::unit_test::for_each::is_const_coll( m_valid_names ) ) : ((void)&(m_valid_names))) if( (_fe_con_454 = false, false) ) {} else for( cstring name = ::boost::unit_test::for_each::deref( _fe_cur_454, m_valid_names, ::boost::type<cstring >(), ::boost::unit_test::for_each::is_const_coll( m_valid_names ) ); !_fe_con_454; _fe_con_454 = true ) {
+                if( first )
+                    first = false;
+                else
+                    ostr << '|';
+                ostr << name;
+            }
+            ostr << ">";
+        }
+        else
+            ostr << this->p_value_hint;
+    }
+
+
+    std::vector<cstring> m_valid_names;
+};
+
+
+
+
+
+
+class parameters_store {
+    struct lg_compare {
+        bool operator()( cstring lh, cstring rh ) const
+        {
+            return std::lexicographical_compare(lh.begin(), lh.end(),
+                                                rh.begin(), rh.end());
+        }
+    };
+public:
+
+    typedef std::map<cstring, basic_param_ptr, lg_compare> storage_type;
+
+
+    void add( basic_param const& in )
+    {
+        basic_param_ptr p = in.clone();
+
+        if( m_parameters.insert( std::make_pair( cstring(p->p_name), p ) ).second ) {} else unit_test::ut_detail::throw_exception( duplicate_param() << "Parameter " << p->p_name << " is duplicate." )
+                                                                                                ;
+    }
+
+
+    bool is_empty() const { return m_parameters.empty(); }
+
+    storage_type const& all() const { return m_parameters; }
+
+    bool has( cstring name ) const
+    {
+        return m_parameters.find( name ) != m_parameters.end();
+    }
+
+    basic_param_ptr get( cstring name ) const
+    {
+        storage_type::const_iterator const& found = m_parameters.find( name );
+        if( found != m_parameters.end() ) {} else unit_test::ut_detail::throw_exception( unknown_param() << "Parameter " << name << " is unknown." )
+                                                                                       ;
+
+        return found->second;
+    }
+
+private:
+
+    storage_type m_parameters;
+};
+
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 525 "/usr/include/boost/test/utils/runtime/parameter.hpp" 2 3 4
+# 37 "/usr/include/boost/test/impl/unit_test_parameters.ipp" 2 3 4
+
+# 1 "/usr/include/boost/test/utils/runtime/finalize.hpp" 1 3 4
+# 16 "/usr/include/boost/test/utils/runtime/finalize.hpp" 3 4
+#define BOOST_TEST_UTILS_RUNTIME_FINALIZE_HPP 
+# 25 "/usr/include/boost/test/utils/runtime/finalize.hpp" 3 4
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 26 "/usr/include/boost/test/utils/runtime/finalize.hpp" 2 3 4
+
+namespace boost {
+namespace runtime {
+
+inline void
+finalize_arguments( parameters_store const& params, runtime::arguments_store& args )
+{
+    if( ::boost::unit_test::for_each::static_any_t _fe_cur_33 = ::boost::unit_test::for_each::begin( params.all(), ::boost::unit_test::for_each::is_const_coll( params.all() ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_33 = ::boost::unit_test::for_each::end( params.all(), ::boost::unit_test::for_each::is_const_coll( params.all() ) ) ) {} else for( bool _fe_con_33 = true; _fe_con_33 && !::boost::unit_test::for_each::done( _fe_cur_33, _fe_end_33, params.all(), ::boost::unit_test::for_each::is_const_coll( params.all() ) ); _fe_con_33 ? ::boost::unit_test::for_each::next( _fe_cur_33, params.all(), ::boost::unit_test::for_each::is_const_coll( params.all() ) ) : ((void)&(params.all()))) if( (_fe_con_33 = false, false) ) {} else for( parameters_store::storage_type::value_type const& v = ::boost::unit_test::for_each::deref( _fe_cur_33, params.all(), ::boost::type<parameters_store::storage_type::value_type const& >(), ::boost::unit_test::for_each::is_const_coll( params.all() ) ); !_fe_con_33; _fe_con_33 = true ) {
+        basic_param_ptr param = v.second;
+
+        if( !args.has( param->p_name ) ) {
+            if( param->p_has_default_value )
+                param->produce_default( args );
+
+            if( !args.has( param->p_name ) ) {
+                if( param->p_optional ) {} else unit_test::ut_detail::throw_exception( missing_req_arg( param->p_name ) << "Missing argument for required parameter " << param->p_name << "." )
+                                                                                                                            ;
+            }
+        }
+
+        if( args.has( param->p_name ) && !!param->p_callback )
+            param->p_callback( param->p_name );
+    }
+}
+
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 55 "/usr/include/boost/test/utils/runtime/finalize.hpp" 2 3 4
+# 39 "/usr/include/boost/test/impl/unit_test_parameters.ipp" 2 3 4
+# 1 "/usr/include/boost/test/utils/runtime/cla/parser.hpp" 1 3 4
+# 13 "/usr/include/boost/test/utils/runtime/cla/parser.hpp" 3 4
+#define BOOST_TEST_UTILS_RUNTIME_CLA_PARSER_HPP 
+
+
+
+
+
+
+# 1 "/usr/include/boost/test/utils/runtime/cla/argv_traverser.hpp" 1 3 4
+# 16 "/usr/include/boost/test/utils/runtime/cla/argv_traverser.hpp" 3 4
+#define BOOST_TEST_UTILS_RUNTIME_CLA_ARGV_TRAVERSER_HPP 
+
+
+
+# 1 "/usr/include/c++/10.2.0/cstring" 1 3 4
+# 39 "/usr/include/c++/10.2.0/cstring" 3 4
+       
+# 40 "/usr/include/c++/10.2.0/cstring" 3
+# 21 "/usr/include/boost/test/utils/runtime/cla/argv_traverser.hpp" 2 3 4
+
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 23 "/usr/include/boost/test/utils/runtime/cla/argv_traverser.hpp" 2 3 4
+
+namespace boost {
+namespace runtime {
+namespace cla {
+
+
+
+
+
+class argv_traverser {
+    typedef char const** argv_type;
+public:
+
+
+
+    argv_traverser( int argc, argv_type argv )
+    : m_argc( argc )
+    , m_curr_token( 0 )
+    , m_token_size( 0 )
+    , m_argv( argv )
+    {
+
+        save_token();
+    }
+
+
+    int remainder()
+    {
+        return m_argc;
+    }
+
+
+    bool eoi() const
+    {
+        return m_curr_token == m_argc;
+    }
+
+
+    cstring current_token()
+    {
+        if( eoi() )
+            return cstring();
+
+        return cstring( m_argv[m_curr_token], m_token_size );
+    }
+
+
+    void save_token()
+    {
+        ++m_curr_token;
+
+        if( !eoi() )
+            m_token_size = ::strlen( m_argv[m_curr_token] );
+    }
+
+
+    void next_token()
+    {
+        if( !eoi() ) {
+            for( std::size_t i = m_curr_token; i < m_argc-1; ++i )
+                m_argv[i] = m_argv[i + 1];
+
+            --m_argc;
+
+            m_token_size = ::strlen( m_argv[m_curr_token] );
+        }
+    }
+
+private:
+
+
+    std::size_t m_argc;
+    std::size_t m_curr_token;
+    std::size_t m_token_size;
+    argv_type m_argv;
+};
+
+}
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 105 "/usr/include/boost/test/utils/runtime/cla/argv_traverser.hpp" 2 3 4
+# 21 "/usr/include/boost/test/utils/runtime/cla/parser.hpp" 2 3 4
+# 35 "/usr/include/boost/test/utils/runtime/cla/parser.hpp" 3 4
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 36 "/usr/include/boost/test/utils/runtime/cla/parser.hpp" 2 3 4
+
+namespace boost {
+namespace runtime {
+namespace cla {
+
+
+
+
+
+namespace rt_cla_detail {
+
+struct parameter_trie;
+typedef shared_ptr<parameter_trie> parameter_trie_ptr;
+typedef std::map<char,parameter_trie_ptr> trie_per_char;
+typedef std::vector<boost::reference_wrapper<parameter_cla_id const> > param_cla_id_list;
+
+struct parameter_trie {
+    parameter_trie() : m_has_final_candidate( false ) {}
+
+
+    parameter_trie_ptr make_subtrie( char c )
+    {
+        trie_per_char::const_iterator it = m_subtrie.find( c );
+
+        if( it == m_subtrie.end() )
+            it = m_subtrie.insert( std::make_pair( c, parameter_trie_ptr( new parameter_trie ) ) ).first;
+
+        return it->second;
+    }
+
+
+    parameter_trie_ptr make_subtrie( cstring s )
+    {
+        parameter_trie_ptr res;
+
+        if( ::boost::unit_test::for_each::static_any_t _fe_cur_71 = ::boost::unit_test::for_each::begin( s, ::boost::unit_test::for_each::is_const_coll( s ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_71 = ::boost::unit_test::for_each::end( s, ::boost::unit_test::for_each::is_const_coll( s ) ) ) {} else for( bool _fe_con_71 = true; _fe_con_71 && !::boost::unit_test::for_each::done( _fe_cur_71, _fe_end_71, s, ::boost::unit_test::for_each::is_const_coll( s ) ); _fe_con_71 ? ::boost::unit_test::for_each::next( _fe_cur_71, s, ::boost::unit_test::for_each::is_const_coll( s ) ) : ((void)&(s))) if( (_fe_con_71 = false, false) ) {} else for( char c = ::boost::unit_test::for_each::deref( _fe_cur_71, s, ::boost::type<char >(), ::boost::unit_test::for_each::is_const_coll( s ) ); !_fe_con_71; _fe_con_71 = true )
+            res = (res ? res->make_subtrie( c ) : make_subtrie( c ));
+
+        return res;
+    }
+
+
+    void add_candidate_id( parameter_cla_id const& param_id, basic_param_ptr param_candidate, bool final )
+    {
+        if( !m_has_final_candidate && (!final || m_id_candidates.empty()) ) {} else unit_test::ut_detail::throw_exception( conflicting_param() << "Parameter cla id " << param_id.m_tag << " conflicts with the " << "parameter cla id " << m_id_candidates.back().get().m_tag )
+
+                                                                                            ;
+
+        m_has_final_candidate = final;
+        m_id_candidates.push_back( ref(param_id) );
+
+        if( m_id_candidates.size() == 1 )
+            m_param_candidate = param_candidate;
+        else
+            m_param_candidate.reset();
+    }
+
+
+    parameter_trie_ptr get_subtrie( char c ) const
+    {
+        trie_per_char::const_iterator it = m_subtrie.find( c );
+
+        return it != m_subtrie.end() ? it->second : parameter_trie_ptr();
+    }
+
+
+    trie_per_char m_subtrie;
+    param_cla_id_list m_id_candidates;
+    basic_param_ptr m_param_candidate;
+    bool m_has_final_candidate;
+};
+
+
+
+
+
+static void
+report_foreing_token( cstring program_name, cstring token )
+{
+    std::cerr << "Boost.Test WARNING: token \"" << token << "\" does not correspond to the Boost.Test argument \n"
+              << "                    and should be placed after all Boost.Test arguments and the -- separator.\n"
+              << "                    For example: " << program_name << " --random -- " << token << "\n";
+}
+
+}
+
+
+
+
+
+class parser {
+public:
+
+
+
+    template<typename Modifiers=nfp::no_params_type>
+    parser( parameters_store const& parameters, Modifiers const& m = nfp::no_params )
+
+
+
+
+    {
+        nfp::opt_assign( m_end_of_param_indicator, m, end_of_params );
+        nfp::opt_assign( m_negation_prefix, m, negation_prefix );
+
+        if( algorithm::all_of( m_end_of_param_indicator.begin(), m_end_of_param_indicator.end(), parameter_cla_id::valid_prefix_char ) ) {} else unit_test::ut_detail::throw_exception( invalid_cla_id() << "End of parameters indicator can only consist of prefix characters." )
+
+
+                                                                                                                      ;
+
+        if( algorithm::all_of( m_negation_prefix.begin(), m_negation_prefix.end(), parameter_cla_id::valid_name_char ) ) {} else unit_test::ut_detail::throw_exception( invalid_cla_id() << "Negation prefix can only consist of prefix characters." )
+
+
+                                                                                                          ;
+
+        build_trie( parameters );
+    }
+
+
+    int
+    parse( int argc, char** argv, runtime::arguments_store& res )
+    {
+
+        m_program_name = argv[0];
+        cstring path_sep( "\\/" );
+
+        cstring::iterator it = unit_test::utils::find_last_of( m_program_name.begin(), m_program_name.end(),
+                                                                path_sep.begin(), path_sep.end() );
+        if( it != m_program_name.end() )
+            m_program_name.trim_left( it + 1 );
+
+
+        argv_traverser tr( argc, (char const**)argv );
+
+
+        while( !tr.eoi() ) {
+            cstring curr_token = tr.current_token();
+
+            cstring prefix;
+            cstring name;
+            cstring value_separator;
+            bool negative_form = false;
+
+
+
+            if( !validate_token_format( curr_token, prefix, name, value_separator, negative_form ) ) {
+
+                tr.next_token();
+                break;
+            }
+
+
+            trie_ptr curr_trie = m_param_trie[prefix];
+
+            if( !curr_trie ) {
+
+                rt_cla_detail::report_foreing_token( m_program_name, curr_token );
+                tr.save_token();
+                continue;
+            }
+
+            curr_token.trim_left( prefix.size() );
+
+
+            locate_result locate_res = locate_parameter( curr_trie, name, curr_token );
+            parameter_cla_id const& found_id = locate_res.first;
+            basic_param_ptr found_param = locate_res.second;
+
+            if( negative_form ) {
+                if( found_id.m_negatable ) {} else unit_test::ut_detail::throw_exception( format_error( found_param->p_name ) << "Parameter tag " << found_id.m_tag << " is not negatable." )
+
+                                                                                                       ;
+
+                curr_token.trim_left( m_negation_prefix.size() );
+            }
+
+            curr_token.trim_left( name.size() );
+
+            bool should_go_to_next = true;
+            cstring value;
+
+
+
+            if( !value_separator.is_empty() || !found_param->p_has_optional_value ) {
+
+
+
+
+                if( found_id.m_value_separator == value_separator ) {} else unit_test::ut_detail::throw_exception( format_error( found_param->p_name ) << "Invalid separator for the parameter " << found_param->p_name << " in the argument " << tr.current_token() )
+
+
+
+                                                                                      ;
+
+                curr_token.trim_left( value_separator.size() );
+
+
+                value = curr_token;
+                if( value.is_empty() ) {
+                    tr.next_token();
+                    value = tr.current_token();
+                }
+
+                if( !value.is_empty() ) {} else unit_test::ut_detail::throw_exception( format_error( found_param->p_name ) << "Missing an argument value for the parameter " << found_param->p_name << " in the argument " << tr.current_token() )
+
+
+
+                                                                                      ;
+            }
+            else if( (value_separator.is_empty() && found_id.m_value_separator.empty()) ) {
+
+                value = curr_token;
+                if( value.is_empty() ) {
+                    tr.next_token();
+
+                    if(!found_param->p_has_optional_value) {
+
+
+
+
+                        value = tr.current_token();
+                    }
+                    else {
+
+
+
+
+                        cstring value_check = tr.current_token();
+
+                        cstring prefix_test, name_test, value_separator_test;
+                        bool negative_form_test;
+                        if( validate_token_format( value_check, prefix_test, name_test, value_separator_test, negative_form_test )
+                            && m_param_trie[prefix_test]) {
+
+                          should_go_to_next = false;
+                        }
+                        else {
+
+                          value = value_check;
+                        }
+                    }
+                }
+            }
+
+
+            if( !res.has( found_param->p_name ) || found_param->p_repeatable ) {} else unit_test::ut_detail::throw_exception( duplicate_arg( found_param->p_name ) << "Duplicate argument value for the parameter " << found_param->p_name << " in the argument " << tr.current_token() )
+
+
+
+                                                                                  ;
+
+
+            found_param->produce_argument( value, negative_form, res );
+
+            if(should_go_to_next) {
+                tr.next_token();
+            }
+        }
+
+
+        return tr.remainder();
+    }
+
+
+    void
+    version( std::ostream& ostr )
+    {
+       ostr << "Boost.Test module ";
+
+
+
+
+
+
+       ostr << "in executable '" << m_program_name << "'\n";
+       ostr << "Compiled from Boost version "
+            << 107200/100000 << "."
+            << 107200/100 % 1000 << "."
+            << 107200 % 100 ;
+       ostr << " with ";
+
+       ostr << "header-only inclusion of";
+
+
+
+
+
+       ostr << " Boost.Test\n";
+       ostr << "- Compiler: " << "GNU C++ version " "10.2.0" << '\n'
+            << "- Platform: " << "linux" << '\n'
+            << "- STL     : " << "GNU libstdc++ version " "20200723";
+       ostr << std::endl;
+    }
+
+    void
+    usage(std::ostream& ostr,
+          cstring param_name = cstring(),
+          bool use_color = true)
+    {
+        namespace utils = unit_test::utils;
+        namespace ut_detail = unit_test::ut_detail;
+
+        if( !param_name.is_empty() ) {
+            basic_param_ptr param = locate_parameter( m_param_trie[help_prefix], param_name, "" ).second;
+            param->usage( ostr, m_negation_prefix );
+        }
+        else {
+            ostr << "\n  The program '" << m_program_name << "' is a Boost.Test module containing unit tests.";
+
+            {
+              utils::scope_setcolor const sc(use_color, ostr, utils::term_attr::BRIGHT, utils::term_color::ORIGINAL); boost::ignore_unused( sc );
+              ostr << "\n\n  Usage\n    ";
+            }
+
+            {
+                utils::scope_setcolor const sc(use_color, ostr, utils::term_attr::BRIGHT, utils::term_color::GREEN); boost::ignore_unused( sc );
+                ostr << m_program_name << " [Boost.Test argument]... ";
+            }
+            if( !m_end_of_param_indicator.empty() ) {
+                utils::scope_setcolor const sc(use_color, ostr, utils::term_attr::BRIGHT, utils::term_color::YELLOW); boost::ignore_unused( sc );
+                ostr << '[' << m_end_of_param_indicator << " [custom test module argument]...]";
+            }
+        }
+
+        ostr << "\n\n  Use\n      ";
+        {
+
+            utils::scope_setcolor const sc(use_color, ostr, utils::term_attr::BRIGHT, utils::term_color::GREEN); boost::ignore_unused( sc );
+            ostr << m_program_name << " --help";
+        }
+        ostr << "\n  or  ";
+        {
+            utils::scope_setcolor const sc(use_color, ostr, utils::term_attr::BRIGHT, utils::term_color::GREEN); boost::ignore_unused( sc );
+            ostr << m_program_name << " --help=<parameter name>";
+        }
+        ostr << "\n  for detailed help on Boost.Test parameters.\n";
+    }
+
+    void
+    help(std::ostream& ostr,
+         parameters_store const& parameters,
+         cstring param_name,
+         bool use_color = true)
+    {
+        namespace utils = unit_test::utils;
+        namespace ut_detail = unit_test::ut_detail;
+
+        if( !param_name.is_empty() ) {
+            basic_param_ptr param = locate_parameter( m_param_trie[help_prefix], param_name, "" ).second;
+            param->help( ostr, m_negation_prefix, use_color);
+            return;
+        }
+
+        usage(ostr, cstring(), use_color);
+
+        ostr << "\n\n";
+        {
+          utils::scope_setcolor const sc(use_color, ostr, utils::term_attr::BRIGHT, utils::term_color::ORIGINAL); boost::ignore_unused( sc );
+          ostr << "  Command line flags:\n";
+        }
+        runtime::commandline_pretty_print(
+            ostr,
+            "   ",
+            "The command line flags of Boost.Test are listed below. "
+            "All parameters are optional. You can specify parameter value either "
+            "as a command line argument or as a value of its corresponding environment "
+            "variable. If a flag is specified as a command line argument and an environment variable "
+            "at the same time, the command line takes precedence. "
+            "The command line argument "
+            "support name guessing, and works with shorter names as long as those are not ambiguous."
+        );
+
+        if( !m_end_of_param_indicator.empty() ) {
+            ostr << "\n\n   All the arguments after the '";
+            {
+                utils::scope_setcolor const sc(use_color, ostr, utils::term_attr::BRIGHT, utils::term_color::YELLOW); boost::ignore_unused( sc );
+                ostr << m_end_of_param_indicator;
+            }
+            ostr << "' are ignored by Boost.Test.";
+        }
+
+
+        {
+          utils::scope_setcolor const sc(use_color, ostr, utils::term_attr::BRIGHT, utils::term_color::ORIGINAL); boost::ignore_unused( sc );
+          ostr << "\n\n  Environment variables:\n";
+        }
+        runtime::commandline_pretty_print(
+            ostr,
+            "   ",
+            "Every argument listed below may also be set by a corresponding environment"
+            "variable. For an argument '--argument_x=<value>', the corresponding "
+            "environment variable is 'BOOST_TEST_ARGUMENT_X=value"
+        );
+
+
+
+        ostr << "\n\n  The following parameters are supported:\n";
+
+        if( ::boost::unit_test::for_each::static_any_t _fe_cur_434 = ::boost::unit_test::for_each::begin( parameters.all(), ::boost::unit_test::for_each::is_const_coll( parameters.all() ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_434 = ::boost::unit_test::for_each::end( parameters.all(), ::boost::unit_test::for_each::is_const_coll( parameters.all() ) ) ) {} else for( bool _fe_con_434 = true; _fe_con_434 && !::boost::unit_test::for_each::done( _fe_cur_434, _fe_end_434, parameters.all(), ::boost::unit_test::for_each::is_const_coll( parameters.all() ) ); _fe_con_434 ? ::boost::unit_test::for_each::next( _fe_cur_434, parameters.all(), ::boost::unit_test::for_each::is_const_coll( parameters.all() ) ) : ((void)&(parameters.all()))) if( (_fe_con_434 = false, false) ) {} else for( parameters_store::storage_type::value_type const& v = ::boost::unit_test::for_each::deref( _fe_cur_434, parameters.all(), ::boost::type<parameters_store::storage_type::value_type const& >(), ::boost::unit_test::for_each::is_const_coll( parameters.all() ) ); !_fe_con_434; _fe_con_434 = true )
+
+
+
+        {
+            basic_param_ptr param = v.second;
+            ostr << "\n";
+            param->usage( ostr, m_negation_prefix, use_color);
+        }
+
+    }
+
+private:
+    typedef rt_cla_detail::parameter_trie_ptr trie_ptr;
+    typedef rt_cla_detail::trie_per_char trie_per_char;
+    typedef std::map<cstring,trie_ptr> str_to_trie;
+
+    void
+    build_trie( parameters_store const& parameters )
+    {
+
+        if( ::boost::unit_test::for_each::static_any_t _fe_cur_455 = ::boost::unit_test::for_each::begin( parameters.all(), ::boost::unit_test::for_each::is_const_coll( parameters.all() ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_455 = ::boost::unit_test::for_each::end( parameters.all(), ::boost::unit_test::for_each::is_const_coll( parameters.all() ) ) ) {} else for( bool _fe_con_455 = true; _fe_con_455 && !::boost::unit_test::for_each::done( _fe_cur_455, _fe_end_455, parameters.all(), ::boost::unit_test::for_each::is_const_coll( parameters.all() ) ); _fe_con_455 ? ::boost::unit_test::for_each::next( _fe_cur_455, parameters.all(), ::boost::unit_test::for_each::is_const_coll( parameters.all() ) ) : ((void)&(parameters.all()))) if( (_fe_con_455 = false, false) ) {} else for( parameters_store::storage_type::value_type const& v = ::boost::unit_test::for_each::deref( _fe_cur_455, parameters.all(), ::boost::type<parameters_store::storage_type::value_type const& >(), ::boost::unit_test::for_each::is_const_coll( parameters.all() ) ); !_fe_con_455; _fe_con_455 = true ) {
+            basic_param_ptr param = v.second;
+
+
+            if( ::boost::unit_test::for_each::static_any_t _fe_cur_459 = ::boost::unit_test::for_each::begin( param->cla_ids(), ::boost::unit_test::for_each::is_const_coll( param->cla_ids() ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_459 = ::boost::unit_test::for_each::end( param->cla_ids(), ::boost::unit_test::for_each::is_const_coll( param->cla_ids() ) ) ) {} else for( bool _fe_con_459 = true; _fe_con_459 && !::boost::unit_test::for_each::done( _fe_cur_459, _fe_end_459, param->cla_ids(), ::boost::unit_test::for_each::is_const_coll( param->cla_ids() ) ); _fe_con_459 ? ::boost::unit_test::for_each::next( _fe_cur_459, param->cla_ids(), ::boost::unit_test::for_each::is_const_coll( param->cla_ids() ) ) : ((void)&(param->cla_ids()))) if( (_fe_con_459 = false, false) ) {} else for( parameter_cla_id const& id = ::boost::unit_test::for_each::deref( _fe_cur_459, param->cla_ids(), ::boost::type<parameter_cla_id const& >(), ::boost::unit_test::for_each::is_const_coll( param->cla_ids() ) ); !_fe_con_459; _fe_con_459 = true ) {
+
+                trie_ptr next_trie = m_param_trie[id.m_prefix];
+                if( !next_trie )
+                    next_trie = m_param_trie[id.m_prefix] = trie_ptr( new rt_cla_detail::parameter_trie );
+
+
+
+                for( size_t index = 0; index < id.m_tag.size(); ++index ) {
+                    next_trie = next_trie->make_subtrie( id.m_tag[index] );
+
+                    next_trie->add_candidate_id( id, param, index == (id.m_tag.size() - 1) );
+                }
+            }
+        }
+    }
+
+    bool
+    validate_token_format( cstring token, cstring& prefix, cstring& name, cstring& separator, bool& negative_form )
+    {
+
+        cstring::iterator it = token.begin();
+        while( it != token.end() && parameter_cla_id::valid_prefix_char( *it ) )
+            ++it;
+
+        prefix.assign( token.begin(), it );
+
+        if( prefix.empty() )
+            return true;
+
+
+        while( it != token.end() && parameter_cla_id::valid_name_char( *it ) )
+            ++it;
+
+        name.assign( prefix.end(), it );
+
+        if( name.empty() ) {
+            if( prefix == m_end_of_param_indicator )
+                return false;
+
+            unit_test::ut_detail::throw_exception( format_error() << "Invalid format for an actual argument " << token );
+        }
+
+
+        while( it != token.end() && parameter_cla_id::valid_separator_char( *it ) )
+            ++it;
+
+        separator.assign( name.end(), it );
+
+
+        negative_form = !m_negation_prefix.empty() && ( name.substr( 0, m_negation_prefix.size() ) == m_negation_prefix );
+        if( negative_form )
+            name.trim_left( m_negation_prefix.size() );
+
+        return true;
+    }
+
+
+    typedef std::pair<parameter_cla_id, basic_param_ptr> locate_result;
+
+    locate_result
+    locate_parameter( trie_ptr curr_trie, cstring name, cstring token )
+    {
+        std::vector<trie_ptr> typo_candidates;
+        std::vector<trie_ptr> next_typo_candidates;
+        trie_ptr next_trie;
+
+        if( ::boost::unit_test::for_each::static_any_t _fe_cur_526 = ::boost::unit_test::for_each::begin( name, ::boost::unit_test::for_each::is_const_coll( name ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_526 = ::boost::unit_test::for_each::end( name, ::boost::unit_test::for_each::is_const_coll( name ) ) ) {} else for( bool _fe_con_526 = true; _fe_con_526 && !::boost::unit_test::for_each::done( _fe_cur_526, _fe_end_526, name, ::boost::unit_test::for_each::is_const_coll( name ) ); _fe_con_526 ? ::boost::unit_test::for_each::next( _fe_cur_526, name, ::boost::unit_test::for_each::is_const_coll( name ) ) : ((void)&(name))) if( (_fe_con_526 = false, false) ) {} else for( char c = ::boost::unit_test::for_each::deref( _fe_cur_526, name, ::boost::type<char >(), ::boost::unit_test::for_each::is_const_coll( name ) ); !_fe_con_526; _fe_con_526 = true ) {
+            if( curr_trie ) {
+
+                next_trie = curr_trie->get_subtrie( c );
+
+                if( next_trie )
+                    curr_trie = next_trie;
+                else {
+
+
+                    if( ::boost::unit_test::for_each::static_any_t _fe_cur_536 = ::boost::unit_test::for_each::begin( curr_trie->m_subtrie, ::boost::unit_test::for_each::is_const_coll( curr_trie->m_subtrie ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_536 = ::boost::unit_test::for_each::end( curr_trie->m_subtrie, ::boost::unit_test::for_each::is_const_coll( curr_trie->m_subtrie ) ) ) {} else for( bool _fe_con_536 = true; _fe_con_536 && !::boost::unit_test::for_each::done( _fe_cur_536, _fe_end_536, curr_trie->m_subtrie, ::boost::unit_test::for_each::is_const_coll( curr_trie->m_subtrie ) ); _fe_con_536 ? ::boost::unit_test::for_each::next( _fe_cur_536, curr_trie->m_subtrie, ::boost::unit_test::for_each::is_const_coll( curr_trie->m_subtrie ) ) : ((void)&(curr_trie->m_subtrie))) if( (_fe_con_536 = false, false) ) {} else for( trie_per_char::value_type const& typo_cand = ::boost::unit_test::for_each::deref( _fe_cur_536, curr_trie->m_subtrie, ::boost::type<trie_per_char::value_type const& >(), ::boost::unit_test::for_each::is_const_coll( curr_trie->m_subtrie ) ); !_fe_con_536; _fe_con_536 = true ) {
+
+                        typo_candidates.push_back( typo_cand.second );
+
+
+                        if( (next_trie = typo_cand.second->get_subtrie( c )) )
+                            typo_candidates.push_back( next_trie );
+                    }
+
+
+                    typo_candidates.push_back( curr_trie );
+
+                    curr_trie.reset();
+                }
+            }
+            else {
+
+                if( ::boost::unit_test::for_each::static_any_t _fe_cur_553 = ::boost::unit_test::for_each::begin( typo_candidates, ::boost::unit_test::for_each::is_const_coll( typo_candidates ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_553 = ::boost::unit_test::for_each::end( typo_candidates, ::boost::unit_test::for_each::is_const_coll( typo_candidates ) ) ) {} else for( bool _fe_con_553 = true; _fe_con_553 && !::boost::unit_test::for_each::done( _fe_cur_553, _fe_end_553, typo_candidates, ::boost::unit_test::for_each::is_const_coll( typo_candidates ) ); _fe_con_553 ? ::boost::unit_test::for_each::next( _fe_cur_553, typo_candidates, ::boost::unit_test::for_each::is_const_coll( typo_candidates ) ) : ((void)&(typo_candidates))) if( (_fe_con_553 = false, false) ) {} else for( trie_ptr typo_cand = ::boost::unit_test::for_each::deref( _fe_cur_553, typo_candidates, ::boost::type<trie_ptr >(), ::boost::unit_test::for_each::is_const_coll( typo_candidates ) ); !_fe_con_553; _fe_con_553 = true ) {
+                    trie_ptr next_typo_cand = typo_cand->get_subtrie( c );
+
+                    if( next_typo_cand )
+                        next_typo_candidates.push_back( next_typo_cand );
+                }
+
+                next_typo_candidates.swap( typo_candidates );
+                next_typo_candidates.clear();
+            }
+        }
+
+        if( !curr_trie ) {
+            std::vector<cstring> typo_candidate_names;
+            std::set<parameter_cla_id const*> unique_typo_candidate;
+            typo_candidate_names.reserve( typo_candidates.size() );
+
+
+            if( ::boost::unit_test::for_each::static_any_t _fe_cur_571 = ::boost::unit_test::for_each::begin( typo_candidates, ::boost::unit_test::for_each::is_const_coll( typo_candidates ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_571 = ::boost::unit_test::for_each::end( typo_candidates, ::boost::unit_test::for_each::is_const_coll( typo_candidates ) ) ) {} else for( bool _fe_con_571 = true; _fe_con_571 && !::boost::unit_test::for_each::done( _fe_cur_571, _fe_end_571, typo_candidates, ::boost::unit_test::for_each::is_const_coll( typo_candidates ) ); _fe_con_571 ? ::boost::unit_test::for_each::next( _fe_cur_571, typo_candidates, ::boost::unit_test::for_each::is_const_coll( typo_candidates ) ) : ((void)&(typo_candidates))) if( (_fe_con_571 = false, false) ) {} else for( trie_ptr trie_cand = ::boost::unit_test::for_each::deref( _fe_cur_571, typo_candidates, ::boost::type<trie_ptr >(), ::boost::unit_test::for_each::is_const_coll( typo_candidates ) ); !_fe_con_571; _fe_con_571 = true ) {
+
+                if( trie_cand->m_id_candidates.size() > 1 )
+                    continue;
+
+                if( ::boost::unit_test::for_each::static_any_t _fe_cur_576 = ::boost::unit_test::for_each::begin( trie_cand->m_id_candidates, ::boost::unit_test::for_each::is_const_coll( trie_cand->m_id_candidates ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_576 = ::boost::unit_test::for_each::end( trie_cand->m_id_candidates, ::boost::unit_test::for_each::is_const_coll( trie_cand->m_id_candidates ) ) ) {} else for( bool _fe_con_576 = true; _fe_con_576 && !::boost::unit_test::for_each::done( _fe_cur_576, _fe_end_576, trie_cand->m_id_candidates, ::boost::unit_test::for_each::is_const_coll( trie_cand->m_id_candidates ) ); _fe_con_576 ? ::boost::unit_test::for_each::next( _fe_cur_576, trie_cand->m_id_candidates, ::boost::unit_test::for_each::is_const_coll( trie_cand->m_id_candidates ) ) : ((void)&(trie_cand->m_id_candidates))) if( (_fe_con_576 = false, false) ) {} else for( parameter_cla_id const& param_cand = ::boost::unit_test::for_each::deref( _fe_cur_576, trie_cand->m_id_candidates, ::boost::type<parameter_cla_id const& >(), ::boost::unit_test::for_each::is_const_coll( trie_cand->m_id_candidates ) ); !_fe_con_576; _fe_con_576 = true ) {
+                    if( !unique_typo_candidate.insert( &param_cand ).second )
+                        continue;
+
+                    typo_candidate_names.push_back( param_cand.m_tag );
+                }
+            }
+
+
+            unit_test::ut_detail::throw_exception( unrecognized_param( std::move(typo_candidate_names) ) << "An unrecognized parameter in the argument " << token )
+
+                                          ;
+
+
+
+
+
+        }
+
+        if( curr_trie->m_id_candidates.size() > 1 ) {
+            std::vector<cstring> amb_names;
+            if( ::boost::unit_test::for_each::static_any_t _fe_cur_597 = ::boost::unit_test::for_each::begin( curr_trie->m_id_candidates, ::boost::unit_test::for_each::is_const_coll( curr_trie->m_id_candidates ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_597 = ::boost::unit_test::for_each::end( curr_trie->m_id_candidates, ::boost::unit_test::for_each::is_const_coll( curr_trie->m_id_candidates ) ) ) {} else for( bool _fe_con_597 = true; _fe_con_597 && !::boost::unit_test::for_each::done( _fe_cur_597, _fe_end_597, curr_trie->m_id_candidates, ::boost::unit_test::for_each::is_const_coll( curr_trie->m_id_candidates ) ); _fe_con_597 ? ::boost::unit_test::for_each::next( _fe_cur_597, curr_trie->m_id_candidates, ::boost::unit_test::for_each::is_const_coll( curr_trie->m_id_candidates ) ) : ((void)&(curr_trie->m_id_candidates))) if( (_fe_con_597 = false, false) ) {} else for( parameter_cla_id const& param_id = ::boost::unit_test::for_each::deref( _fe_cur_597, curr_trie->m_id_candidates, ::boost::type<parameter_cla_id const& >(), ::boost::unit_test::for_each::is_const_coll( curr_trie->m_id_candidates ) ); !_fe_con_597; _fe_con_597 = true )
+                amb_names.push_back( param_id.m_tag );
+
+
+            unit_test::ut_detail::throw_exception( ambiguous_param( std::move( amb_names ) ) << "An ambiguous parameter name in the argument " << token )
+                                                                                            ;
+
+
+
+
+        }
+
+        return locate_result( curr_trie->m_id_candidates.back().get(), curr_trie->m_param_candidate );
+    }
+
+
+    cstring m_program_name;
+    std::string m_end_of_param_indicator;
+    std::string m_negation_prefix;
+    str_to_trie m_param_trie;
+};
+
+}
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 624 "/usr/include/boost/test/utils/runtime/cla/parser.hpp" 2 3 4
+# 40 "/usr/include/boost/test/impl/unit_test_parameters.ipp" 2 3 4
+# 1 "/usr/include/boost/test/utils/runtime/env/fetch.hpp" 1 3 4
+# 16 "/usr/include/boost/test/utils/runtime/env/fetch.hpp" 3 4
+#define BOOST_TEST_UTILS_RUNTIME_ENV_FETCH_HPP 
+
+
+
+
+
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 23 "/usr/include/boost/test/utils/runtime/env/fetch.hpp" 2 3 4
+
+
+# 1 "/usr/include/c++/10.2.0/stdlib.h" 1 3 4
+# 26 "/usr/include/boost/test/utils/runtime/env/fetch.hpp" 2 3 4
+
+namespace boost {
+namespace runtime {
+namespace env {
+
+namespace env_detail {
+# 40 "/usr/include/boost/test/utils/runtime/env/fetch.hpp" 3 4
+inline std::pair<cstring,bool>
+sys_read_var( cstring var_name )
+{
+    using namespace std;
+    char const* res = getenv( var_name.begin() );
+
+    return std::make_pair( cstring(res), res != __null );
+}
+# 65 "/usr/include/boost/test/utils/runtime/env/fetch.hpp" 3 4
+template<typename ReadFunc>
+inline void
+fetch_absent( parameters_store const& params, runtime::arguments_store& args, ReadFunc read_func )
+{
+    if( ::boost::unit_test::for_each::static_any_t _fe_cur_69 = ::boost::unit_test::for_each::begin( params.all(), ::boost::unit_test::for_each::is_const_coll( params.all() ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_69 = ::boost::unit_test::for_each::end( params.all(), ::boost::unit_test::for_each::is_const_coll( params.all() ) ) ) {} else for( bool _fe_con_69 = true; _fe_con_69 && !::boost::unit_test::for_each::done( _fe_cur_69, _fe_end_69, params.all(), ::boost::unit_test::for_each::is_const_coll( params.all() ) ); _fe_con_69 ? ::boost::unit_test::for_each::next( _fe_cur_69, params.all(), ::boost::unit_test::for_each::is_const_coll( params.all() ) ) : ((void)&(params.all()))) if( (_fe_con_69 = false, false) ) {} else for( parameters_store::storage_type::value_type const& v = ::boost::unit_test::for_each::deref( _fe_cur_69, params.all(), ::boost::type<parameters_store::storage_type::value_type const& >(), ::boost::unit_test::for_each::is_const_coll( params.all() ) ); !_fe_con_69; _fe_con_69 = true ) {
+        basic_param_ptr param = v.second;
+
+        if( args.has( param->p_name ) || param->p_env_var.empty() )
+            continue;
+
+        std::pair<cstring,bool> value = read_func( param->p_env_var );
+
+        if( !value.second )
+            continue;
+
+
+        if( !value.first.is_empty() || param->p_has_optional_value ) {} else unit_test::ut_detail::throw_exception( format_error( param->p_name ) << "Missing an argument value for the parameter " << param->p_name << " in the environment." )
+
+
+                                           ;
+
+
+        param->produce_argument( value.first, false, args );
+
+    }
+}
+
+
+
+}
+
+inline void
+fetch_absent( parameters_store const& params, runtime::arguments_store& args )
+{
+    env_detail::fetch_absent( params, args, &env_detail::sys_read_var );
+}
+
+}
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 107 "/usr/include/boost/test/utils/runtime/env/fetch.hpp" 2 3 4
+# 41 "/usr/include/boost/test/impl/unit_test_parameters.ipp" 2 3 4
+
+
+
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 45 "/usr/include/boost/test/impl/unit_test_parameters.ipp" 2 3 4
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 46 "/usr/include/boost/test/impl/unit_test_parameters.ipp" 2 3 4
+
+
+
+# 1 "/usr/include/c++/10.2.0/cstdlib" 1 3 4
+# 39 "/usr/include/c++/10.2.0/cstdlib" 3 4
+       
+# 40 "/usr/include/c++/10.2.0/cstdlib" 3
+# 50 "/usr/include/boost/test/impl/unit_test_parameters.ipp" 2 3 4
+
+
+
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 54 "/usr/include/boost/test/impl/unit_test_parameters.ipp" 2 3 4
+
+
+
+
+
+
+
+namespace boost {
+namespace unit_test {
+
+namespace rt = boost::runtime;
+
+
+
+
+
+namespace runtime_config {
+
+
+std::string btrt_auto_start_dbg = "auto_start_dbg";
+std::string btrt_break_exec_path = "break_exec_path";
+std::string btrt_build_info = "build_info";
+std::string btrt_catch_sys_errors = "catch_system_errors";
+std::string btrt_color_output = "color_output";
+std::string btrt_detect_fp_except = "detect_fp_exceptions";
+std::string btrt_detect_mem_leaks = "detect_memory_leaks";
+std::string btrt_list_content = "list_content";
+std::string btrt_list_labels = "list_labels";
+std::string btrt_log_format = "log_format";
+std::string btrt_log_level = "log_level";
+std::string btrt_log_sink = "log_sink";
+std::string btrt_combined_logger = "logger";
+std::string btrt_output_format = "output_format";
+std::string btrt_random_seed = "random";
+std::string btrt_report_format = "report_format";
+std::string btrt_report_level = "report_level";
+std::string btrt_report_mem_leaks = "report_memory_leaks_to";
+std::string btrt_report_sink = "report_sink";
+std::string btrt_result_code = "result_code";
+std::string btrt_run_filters = "run_test";
+std::string btrt_save_test_pattern = "save_pattern";
+std::string btrt_show_progress = "show_progress";
+std::string btrt_use_alt_stack = "use_alt_stack";
+std::string btrt_wait_for_debugger = "wait_for_debugger";
+
+std::string btrt_help = "help";
+std::string btrt_usage = "usage";
+std::string btrt_version = "version";
+
+
+
+namespace {
+
+void
+register_parameters( rt::parameters_store& store )
+{
+    rt::option auto_start_dbg( btrt_auto_start_dbg, (
+        rt::description = "Automatically attaches debugger in case of system level failure (signal).",
+        rt::env_var = "BOOST_TEST_AUTO_START_DBG",
+
+        rt::help = "Specifies whether Boost.Test should attempt "
+                   "to attach a debugger when fatal system error occurs. At the moment this feature "
+                   "is only available on a few selected platforms: Win32 and *nix. There is a "
+                   "default debugger configured for these platforms. You can manually configure "
+                   "different debugger. For more details on how to configure the debugger see the "
+                   "Boost.Test debug API, specifically the function boost::debug::set_debugger."
+    ));
+
+    auto_start_dbg.add_cla_id( "--", btrt_auto_start_dbg, "=" );
+    auto_start_dbg.add_cla_id( "-", "d", " " );
+    store.add( auto_start_dbg );
+
+
+
+    rt::parameter<std::string> break_exec_path( btrt_break_exec_path, (
+        rt::description = "For the exception safety testing allows to break at specific execution path.",
+        rt::env_var = "BOOST_TEST_BREAK_EXEC_PATH"
+
+        ,
+        rt::callback = [](rt::cstring) {
+            if( false ) {} else unit_test::ut_detail::throw_exception( unit_test::framework::setup_error( "parameter break_exec_path is disabled in this release" ) );
+        }
+
+    ));
+
+    break_exec_path.add_cla_id( "--", btrt_break_exec_path, "=" );
+    store.add( break_exec_path );
+
+
+
+    rt::option build_info( btrt_build_info, (
+        rt::description = "Displays library build information.",
+        rt::env_var = "BOOST_TEST_BUILD_INFO",
+        rt::help = "Displays library build information, including: platform, "
+                   "compiler, STL version and Boost version."
+    ));
+
+    build_info.add_cla_id( "--", btrt_build_info, "=" );
+    build_info.add_cla_id( "-", "i", " " );
+    store.add( build_info );
+
+
+
+    rt::option catch_sys_errors( btrt_catch_sys_errors, (
+        rt::description = "Allows to switch between catching and ignoring system errors (signals).",
+        rt::env_var = "BOOST_TEST_CATCH_SYSTEM_ERRORS",
+        rt::default_value =
+
+
+
+            true,
+
+        rt::help = "If option " + btrt_catch_sys_errors + " has value 'no' the frameworks does not attempt to catch "
+                   "asynchronous system failure events (signals on *NIX platforms or structured exceptions on Windows). "
+                   " Default value is "
+
+
+
+                    "true."
+
+    ));
+
+    catch_sys_errors.add_cla_id( "--", btrt_catch_sys_errors, "=", true );
+    catch_sys_errors.add_cla_id( "-", "s", " " );
+    store.add( catch_sys_errors );
+
+
+
+    rt::option color_output( btrt_color_output, (
+        rt::description = "Enables color output of the framework log and report messages.",
+        rt::env_var = "BOOST_TEST_COLOR_OUTPUT",
+        rt::default_value = true,
+        rt::help = "Produces color output for logs, reports and help. "
+                   "Defaults to true. "
+    ));
+
+    color_output.add_cla_id( "--", btrt_color_output, "=", true );
+    color_output.add_cla_id( "-", "x", " " );
+    store.add( color_output );
+
+
+
+    rt::option detect_fp_except( btrt_detect_fp_except, (
+        rt::description = "Enables/disables floating point exceptions traps.",
+        rt::env_var = "BOOST_TEST_DETECT_FP_EXCEPTIONS",
+        rt::help = "Enables/disables hardware traps for the floating "
+                   "point exceptions (if supported on your platfrom)."
+    ));
+
+    detect_fp_except.add_cla_id( "--", btrt_detect_fp_except, "=", true );
+    store.add( detect_fp_except );
+
+
+
+    rt::parameter<unsigned long> detect_mem_leaks( btrt_detect_mem_leaks, (
+        rt::description = "Turns on/off memory leaks detection (optionally breaking on specified alloc order number).",
+        rt::env_var = "BOOST_TEST_DETECT_MEMORY_LEAK",
+        rt::default_value = 1L,
+        rt::optional_value = 1L,
+        rt::value_hint = "<alloc order number>",
+        rt::help = "Enables/disables memory leaks detection. "
+                   "This parameter has optional long integer value. The default value is 1, which "
+                   "enables the memory leak detection. The value 0 disables memory leak detection. "
+                   "Any value N greater than 1 is treated as leak allocation number and tells the "
+                   "framework to setup runtime breakpoint at Nth heap allocation. If value is "
+                   "omitted the default value is assumed."
+    ));
+
+    detect_mem_leaks.add_cla_id( "--", btrt_detect_mem_leaks, "=" );
+    store.add( detect_mem_leaks );
+
+
+
+    rt::enum_parameter<unit_test::output_format> list_content( btrt_list_content, (
+        rt::description = "Lists the content of test tree - names of all test suites and test cases.",
+        rt::env_var = "BOOST_TEST_LIST_CONTENT",
+        rt::default_value = OF_INVALID,
+        rt::optional_value = OF_CLF,
+        rt::enum_values<unit_test::output_format>::value =
+
+        {
+            { "HRF", OF_CLF },
+            { "DOT", OF_DOT }
+        },
+
+
+
+
+
+
+        rt::help = "Lists the test suites and cases "
+                   "of the test module instead of executing the test cases. The format of the "
+                   "desired output can be passed to the command. Currently the "
+                   "framework supports two formats: human readable format (HRF) and dot graph "
+                   "format (DOT). If value is omitted HRF value is assumed."
+    ));
+    list_content.add_cla_id( "--", btrt_list_content, "=" );
+    store.add( list_content );
+
+
+
+    rt::option list_labels( btrt_list_labels, (
+        rt::description = "Lists all available labels.",
+        rt::env_var = "BOOST_TEST_LIST_LABELS",
+        rt::help = "Option " + btrt_list_labels + " instructs the framework to list all the the labels "
+                   "defined in the test module instead of executing the test cases."
+    ));
+
+    list_labels.add_cla_id( "--", btrt_list_labels, "=" );
+    store.add( list_labels );
+
+
+
+    rt::enum_parameter<unit_test::output_format> log_format( btrt_log_format, (
+        rt::description = "Specifies log format.",
+        rt::env_var = "BOOST_TEST_LOG_FORMAT",
+        rt::default_value = OF_CLF,
+        rt::enum_values<unit_test::output_format>::value =
+
+        {
+            { "HRF", OF_CLF },
+            { "CLF", OF_CLF },
+            { "XML", OF_XML },
+            { "JUNIT", OF_JUNIT },
+        },
+# 287 "/usr/include/boost/test/impl/unit_test_parameters.ipp" 3 4
+        rt::help = "Set the frameowrk's log format to one "
+                   "of the formats supplied by the framework. The only acceptable values for this "
+                   "parameter are the names of the output formats supplied by the framework. By "
+                   "default the framework uses human readable format (HRF) for testing log. This "
+                   "format is similar to compiler error format. Alternatively you can specify XML "
+                   "or JUNIT as log format, which are easier to process by testing automation tools."
+    ));
+
+    log_format.add_cla_id( "--", btrt_log_format, "=" );
+    log_format.add_cla_id( "-", "f", " " );
+    store.add( log_format );
+
+
+
+    rt::enum_parameter<unit_test::log_level> log_level( btrt_log_level, (
+        rt::description = "Specifies the logging level of the test execution.",
+        rt::env_var = "BOOST_TEST_LOG_LEVEL",
+        rt::default_value = log_all_errors,
+        rt::enum_values<unit_test::log_level>::value =
+
+        {
+            { "all" , log_successful_tests },
+            { "success" , log_successful_tests },
+            { "test_suite" , log_test_units },
+            { "unit_scope" , log_test_units },
+            { "message" , log_messages },
+            { "warning" , log_warnings },
+            { "error" , log_all_errors },
+            { "cpp_exception" , log_cpp_exception_errors },
+            { "system_error" , log_system_errors },
+            { "fatal_error" , log_fatal_errors },
+            { "nothing" , log_nothing }
+        },
+# 335 "/usr/include/boost/test/impl/unit_test_parameters.ipp" 3 4
+        rt::help = "Set the framework's log level. "
+                   "The log level defines the verbosity of the testing logs produced by a test "
+                   "module. The verbosity ranges from a complete log, when all assertions "
+                   "(both successful and failing) are reported, all notifications about "
+                   "test units start and finish are included, to an empty log when nothing "
+                   "is reported to a testing log stream."
+    ));
+
+    log_level.add_cla_id( "--", btrt_log_level, "=" );
+    log_level.add_cla_id( "-", "l", " " );
+    store.add( log_level );
+
+
+
+    rt::parameter<std::string> log_sink( btrt_log_sink, (
+        rt::description = "Specifies log sink: stdout (default), stderr or file name.",
+        rt::env_var = "BOOST_TEST_LOG_SINK",
+        rt::value_hint = "<stderr|stdout|file name>",
+        rt::help = "Sets the log sink - the location "
+                   "where Boost.Test writes the logs of the test execution. It allows to easily redirect the "
+                   "test logs to file or standard streams. By default testing log is "
+                   "directed to standard output."
+    ));
+
+    log_sink.add_cla_id( "--", btrt_log_sink, "=" );
+    log_sink.add_cla_id( "-", "k", " " );
+    store.add( log_sink );
+
+
+
+    rt::enum_parameter<unit_test::output_format> output_format( btrt_output_format, (
+        rt::description = "Specifies output format (both log and report).",
+        rt::env_var = "BOOST_TEST_OUTPUT_FORMAT",
+        rt::enum_values<unit_test::output_format>::value =
+
+        {
+            { "HRF", OF_CLF },
+            { "CLF", OF_CLF },
+            { "XML", OF_XML }
+        },
+
+
+
+
+
+
+
+        rt::help = "Combines an effect of " + btrt_report_format +
+                   " and " + btrt_log_format + " parameters. If this parameter is specified, "
+                   "it overrides the value of other two parameters. This parameter does not "
+                   "have a default value. The only acceptable values are string names of "
+                   "output formats: HRF - human readable format and XML - XML formats for "
+                   "automation tools processing."
+    ));
+
+    output_format.add_cla_id( "--", btrt_output_format, "=" );
+    output_format.add_cla_id( "-", "o", " " );
+    store.add( output_format );
+
+
+
+    rt::parameter<std::string,rt::REPEATABLE_PARAM> combined_logger( btrt_combined_logger, (
+        rt::description = "Specifies log level and sink for one or several log format",
+        rt::env_var = "BOOST_TEST_LOGGER",
+        rt::value_hint = "log_format,log_level,log_sink[:log_format,log_level,log_sink]",
+        rt::help = "Specify one or more logging definition, which include the logger type, level and sink. "
+                   "The log format, level and sink follow the same format as for the argument '--" + btrt_log_format +
+                   "', '--" + btrt_log_level + "' and '--" + btrt_log_sink + "' respetively. "
+                   "This command can take several logging definition separated by a ':', or be repeated "
+                   "on the command line."
+    ));
+
+    combined_logger.add_cla_id( "--", btrt_combined_logger, "=" );
+    store.add( combined_logger );
+
+
+
+    rt::parameter<unsigned> random_seed( btrt_random_seed, (
+        rt::description = "Allows to switch between sequential and random order of test units execution."
+                          " Optionally allows to specify concrete seed for random number generator.",
+        rt::env_var = "BOOST_TEST_RANDOM",
+        rt::default_value = 0U,
+        rt::optional_value = 1U,
+        rt::value_hint = "<seed>",
+        rt::help = "Instructs the framework to execute the "
+                   "test cases in random order. This parameter accepts an optional unsigned "
+                   "integer argument. If parameter is specified without the argument value testing "
+                   "order is randomized based on current time. Alternatively you can specify "
+                   "any positive value greater than 1 and it will be used as random seed for "
+                   "the run. "
+                   "By default, the test cases are executed in an "
+                   "order defined by their declaration and the optional dependencies among the test units."
+    ));
+
+    random_seed.add_cla_id( "--", btrt_random_seed, "=" );
+    store.add( random_seed );
+
+
+
+    rt::enum_parameter<unit_test::output_format> report_format( btrt_report_format, (
+        rt::description = "Specifies the test report format.",
+        rt::env_var = "BOOST_TEST_REPORT_FORMAT",
+        rt::default_value = OF_CLF,
+        rt::enum_values<unit_test::output_format>::value =
+
+        {
+            { "HRF", OF_CLF },
+            { "CLF", OF_CLF },
+            { "XML", OF_XML }
+        },
+
+
+
+
+
+
+
+        rt::help = "Set the framework's report format "
+                   "to one of the formats supplied by the framework. The only acceptable values "
+                   "for this parameter are the names of the output formats. By default the framework "
+                   "uses human readable format (HRF) for results reporting. Alternatively you can "
+                   "specify XML as report format. This format is easier to process by testing "
+                   "automation tools."
+    ));
+
+    report_format.add_cla_id( "--", btrt_report_format, "=" );
+    report_format.add_cla_id( "-", "m", " " );
+    store.add( report_format );
+
+
+
+    rt::enum_parameter<unit_test::report_level> report_level( btrt_report_level, (
+        rt::description = "Specifies test report level.",
+        rt::env_var = "BOOST_TEST_REPORT_LEVEL",
+        rt::default_value = CONFIRMATION_REPORT,
+        rt::enum_values<unit_test::report_level>::value =
+
+        {
+            { "confirm", CONFIRMATION_REPORT },
+            { "short", SHORT_REPORT },
+            { "detailed", DETAILED_REPORT },
+            { "no", NO_REPORT }
+        },
+# 486 "/usr/include/boost/test/impl/unit_test_parameters.ipp" 3 4
+        rt::help = "Set the verbosity level of the "
+                   "result report generated by the testing framework. Use value 'no' to "
+                   "disable the results report completely."
+    ));
+
+    report_level.add_cla_id( "--", btrt_report_level, "=" );
+    report_level.add_cla_id( "-", "r", " " );
+    store.add( report_level );
+
+
+
+    rt::parameter<std::string> report_mem_leaks( btrt_report_mem_leaks, (
+        rt::description = "File where to report memory leaks to.",
+        rt::env_var = "BOOST_TEST_REPORT_MEMORY_LEAKS_TO",
+        rt::default_value = std::string(),
+        rt::value_hint = "<file name>",
+        rt::help = "Parameter " + btrt_report_mem_leaks + " allows to specify a file where to report "
+                   "memory leaks to. The parameter does not have default value. If it is not specified, "
+                   "memory leaks (if any) are reported to the standard error stream."
+    ));
+
+    report_mem_leaks.add_cla_id( "--", btrt_report_mem_leaks, "=" );
+    store.add( report_mem_leaks );
+
+
+
+    rt::parameter<std::string> report_sink( btrt_report_sink, (
+        rt::description = "Specifies report sink: stderr(default), stdout or file name.",
+        rt::env_var = "BOOST_TEST_REPORT_SINK",
+        rt::value_hint = "<stderr|stdout|file name>",
+        rt::help = "Sets the result report sink - "
+                   "the location where the framework writes the result report to. "
+                   "The sink may be a a file or a standard "
+                   "stream. The default is 'stderr': the "
+                   "standard error stream."
+    ));
+
+    report_sink.add_cla_id( "--", btrt_report_sink, "=" );
+    report_sink.add_cla_id( "-", "e", " " );
+    store.add( report_sink );
+
+
+
+    rt::option result_code( btrt_result_code, (
+        rt::description = "Disables test modules's result code generation.",
+        rt::env_var = "BOOST_TEST_RESULT_CODE",
+        rt::default_value = true,
+        rt::help = "The 'no' argument value for the parameter " + btrt_result_code + " instructs the "
+                   "framework to always return zero result code. This can be used for test programs "
+                   "executed within IDE. By default this parameter has value 'yes'."
+    ));
+
+    result_code.add_cla_id( "--", btrt_result_code, "=", true );
+    result_code.add_cla_id( "-", "c", " " );
+    store.add( result_code );
+
+
+
+    rt::parameter<std::string,rt::REPEATABLE_PARAM> tests_to_run( btrt_run_filters, (
+        rt::description = "Filters which tests to execute.",
+        rt::env_var = "BOOST_TEST_RUN_FILTERS",
+        rt::value_hint = "<test unit filter>",
+        rt::help = "Filters which test units to execute. "
+                   "The framework supports both 'selection filters', which allow to select "
+                   "which test units to enable from the set of available test units, and 'disabler "
+                   "filters', which allow to disable some test units. Boost.test also supports "
+                   "enabling/disabling test units at compile time. These settings identify the default "
+                   "set of test units to run. Parameter " + btrt_run_filters + " is used to change this default. "
+                   "This parameter is repeatable, so you can specify more than one filter if necessary."
+    ));
+
+    tests_to_run.add_cla_id( "--", btrt_run_filters, "=" );
+    tests_to_run.add_cla_id( "-", "t", " " );
+    store.add( tests_to_run );
+
+
+
+    rt::option save_test_pattern( btrt_save_test_pattern, (
+        rt::description = "Allows to switch between saving or matching test pattern file.",
+        rt::env_var = "BOOST_TEST_SAVE_PATTERN",
+        rt::help = "Parameter " + btrt_save_test_pattern + " facilitates switching mode of operation for "
+                   "testing output streams.\n\nThis parameter serves no particular purpose within the "
+                   "framework itself. It can be used by test modules relying on output_test_stream to "
+                   "implement testing logic. Default mode is 'match' (false)."
+    ));
+
+    save_test_pattern.add_cla_id( "--", btrt_save_test_pattern, "=" );
+    store.add( save_test_pattern );
+
+
+
+    rt::option show_progress( btrt_show_progress, (
+        rt::description = "Turns on progress display.",
+        rt::env_var = "BOOST_TEST_SHOW_PROGRESS",
+        rt::help = "Instructs the framework to display the progress of the tests. "
+                   "This feature is turned off by default."
+    ));
+
+    show_progress.add_cla_id( "--", btrt_show_progress, "=" );
+    show_progress.add_cla_id( "-", "p", " " );
+    store.add( show_progress );
+
+
+
+    rt::option use_alt_stack( btrt_use_alt_stack, (
+        rt::description = "Turns on/off usage of an alternative stack for signal handling.",
+        rt::env_var = "BOOST_TEST_USE_ALT_STACK",
+        rt::default_value = true,
+        rt::help = "Instructs the framework to use an alternative "
+                   "stack for operating system's signals handling (on platforms where this is supported). "
+                   "The feature is enabled by default, but can be disabled using this command line switch."
+    ));
+
+    use_alt_stack.add_cla_id( "--", btrt_use_alt_stack, "=", true );
+    store.add( use_alt_stack );
+
+
+
+    rt::option wait_for_debugger( btrt_wait_for_debugger, (
+        rt::description = "Forces test module to wait for button to be pressed before starting test run.",
+        rt::env_var = "BOOST_TEST_WAIT_FOR_DEBUGGER",
+        rt::help = "Instructs the framework to pause before starting "
+                   "test units execution, so that you can attach a debugger to the test module process. "
+                   "This feature is turned off by default."
+    ));
+
+    wait_for_debugger.add_cla_id( "--", btrt_wait_for_debugger, "=" );
+    wait_for_debugger.add_cla_id( "-", "w", " " );
+    store.add( wait_for_debugger );
+
+
+
+    rt::parameter<std::string> help( btrt_help, (
+        rt::description = "Help for framework parameters.",
+        rt::optional_value = std::string(),
+        rt::value_hint = "<parameter name>",
+        rt::help = "Displays help on the framework's parameters. "
+                   "The parameter accepts an optional argument value. If present, an argument value is "
+                   "interpreted as a parameter name (name guessing works as well, so for example "
+                   "'--help=rand' displays help on the parameter 'random'). If the parameter name is unknown "
+                   "or ambiguous error is reported. If argument value is absent, a summary of all "
+                   "framework's parameter is displayed."
+    ));
+    help.add_cla_id( "--", btrt_help, "=" );
+    store.add( help );
+
+
+
+    rt::option usage( btrt_usage, (
+        rt::description = "Short message explaining usage of Boost.Test parameters."
+    ));
+    usage.add_cla_id( "-", "?", " " );
+    store.add( usage );
+
+
+
+    rt::option version( btrt_version, (
+        rt::description = "Prints Boost.Test version and exits."
+    ));
+    version.add_cla_id( "--", btrt_version, " " );
+    store.add( version );
+}
+
+static rt::arguments_store s_arguments_store;
+static rt::parameters_store s_parameters_store;
+
+
+
+}
+
+void
+init( int& argc, char** argv )
+{
+    shared_ptr<rt::cla::parser> parser;
+
+    try {
+
+        if( s_parameters_store.is_empty() )
+            register_parameters( s_parameters_store );
+
+
+        s_arguments_store.clear();
+
+
+        parser.reset( new rt::cla::parser( s_parameters_store, (rt::end_of_params = "--", rt::negation_prefix = "no_") ) );
+        argc = parser->parse( argc, argv, s_arguments_store );
+
+
+        rt::env::fetch_absent( s_parameters_store, s_arguments_store );
+
+
+        rt::finalize_arguments( s_parameters_store, s_arguments_store );
+
+
+        bool use_color = true;
+        if( s_arguments_store.has(btrt_color_output ) ) {
+            use_color = runtime_config::get<bool>(runtime_config::btrt_color_output);
+        }
+
+
+        if( runtime_config::get<bool>( btrt_version ) ) {
+            parser->version( std::cerr );
+            unit_test::ut_detail::throw_exception( framework::nothing_to_test( boost::exit_success ) );
+        }
+        else if( runtime_config::get<bool>( btrt_usage ) ) {
+            parser->usage( std::cerr, runtime::cstring(), use_color );
+            unit_test::ut_detail::throw_exception( framework::nothing_to_test( boost::exit_success ) );
+        }
+        else if( s_arguments_store.has( btrt_help ) ) {
+            parser->help(std::cerr,
+                         s_parameters_store,
+                         runtime_config::get<std::string>( btrt_help ),
+                         use_color );
+            unit_test::ut_detail::throw_exception( framework::nothing_to_test( boost::exit_success ) );
+        }
+
+
+        if( s_arguments_store.has( btrt_output_format ) ) {
+            unit_test::output_format of = s_arguments_store.get<unit_test::output_format>( btrt_output_format );
+            s_arguments_store.set( btrt_report_format, of );
+            s_arguments_store.set( btrt_log_format, of );
+        }
+
+    }
+    catch( rt::init_error const& ex ) {
+        if( false ) {} else unit_test::ut_detail::throw_exception( unit_test::framework::setup_error( ex.msg ) );
+    }
+    catch( rt::ambiguous_param const& ex ) {
+        std::cerr << ex.msg << "\n Did you mean one of these?\n";
+
+        if( ::boost::unit_test::for_each::static_any_t _fe_cur_716 = ::boost::unit_test::for_each::begin( ex.m_amb_candidates, ::boost::unit_test::for_each::is_const_coll( ex.m_amb_candidates ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_716 = ::boost::unit_test::for_each::end( ex.m_amb_candidates, ::boost::unit_test::for_each::is_const_coll( ex.m_amb_candidates ) ) ) {} else for( bool _fe_con_716 = true; _fe_con_716 && !::boost::unit_test::for_each::done( _fe_cur_716, _fe_end_716, ex.m_amb_candidates, ::boost::unit_test::for_each::is_const_coll( ex.m_amb_candidates ) ); _fe_con_716 ? ::boost::unit_test::for_each::next( _fe_cur_716, ex.m_amb_candidates, ::boost::unit_test::for_each::is_const_coll( ex.m_amb_candidates ) ) : ((void)&(ex.m_amb_candidates))) if( (_fe_con_716 = false, false) ) {} else for( rt::cstring name = ::boost::unit_test::for_each::deref( _fe_cur_716, ex.m_amb_candidates, ::boost::type<rt::cstring >(), ::boost::unit_test::for_each::is_const_coll( ex.m_amb_candidates ) ); !_fe_con_716; _fe_con_716 = true )
+            std::cerr << "   " << name << "\n";
+
+        unit_test::ut_detail::throw_exception( framework::nothing_to_test( boost::exit_exception_failure ) );
+    }
+    catch( rt::unrecognized_param const& ex ) {
+        std::cerr << ex.msg << "\n";
+
+        if( !ex.m_typo_candidates.empty() ) {
+            std::cerr << " Did you mean one of these?\n";
+
+            if( ::boost::unit_test::for_each::static_any_t _fe_cur_727 = ::boost::unit_test::for_each::begin( ex.m_typo_candidates, ::boost::unit_test::for_each::is_const_coll( ex.m_typo_candidates ) ) ) {} else if( ::boost::unit_test::for_each::static_any_t _fe_end_727 = ::boost::unit_test::for_each::end( ex.m_typo_candidates, ::boost::unit_test::for_each::is_const_coll( ex.m_typo_candidates ) ) ) {} else for( bool _fe_con_727 = true; _fe_con_727 && !::boost::unit_test::for_each::done( _fe_cur_727, _fe_end_727, ex.m_typo_candidates, ::boost::unit_test::for_each::is_const_coll( ex.m_typo_candidates ) ); _fe_con_727 ? ::boost::unit_test::for_each::next( _fe_cur_727, ex.m_typo_candidates, ::boost::unit_test::for_each::is_const_coll( ex.m_typo_candidates ) ) : ((void)&(ex.m_typo_candidates))) if( (_fe_con_727 = false, false) ) {} else for( rt::cstring name = ::boost::unit_test::for_each::deref( _fe_cur_727, ex.m_typo_candidates, ::boost::type<rt::cstring >(), ::boost::unit_test::for_each::is_const_coll( ex.m_typo_candidates ) ); !_fe_con_727; _fe_con_727 = true )
+                std::cerr << "   " << name << "\n";
+        }
+        else if( parser ) {
+            std::cerr << "\n";
+            parser->usage( std::cerr );
+        }
+
+        unit_test::ut_detail::throw_exception( framework::nothing_to_test( boost::exit_exception_failure ) );
+    }
+    catch( rt::input_error const& ex ) {
+        std::cerr << ex.msg << "\n\n";
+
+        if( parser )
+            parser->usage( std::cerr, ex.param_name );
+
+        unit_test::ut_detail::throw_exception( framework::nothing_to_test( boost::exit_exception_failure ) );
+    }
+}
+
+
+
+rt::arguments_store const&
+argument_store()
+{
+    return s_arguments_store;
+}
+
+
+
+bool
+save_pattern()
+{
+    return runtime_config::get<bool>( btrt_save_test_pattern );
+}
+
+
+
+}
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 770 "/usr/include/boost/test/impl/unit_test_parameters.ipp" 2 3 4
+# 35 "/usr/include/boost/test/included/unit_test.hpp" 2 3 4
+# 1 "/usr/include/boost/test/impl/xml_log_formatter.ipp" 1 3 4
+# 16 "/usr/include/boost/test/impl/xml_log_formatter.ipp" 3 4
+#define BOOST_TEST_XML_LOG_FORMATTER_IPP_020105GER 
+# 32 "/usr/include/boost/test/impl/xml_log_formatter.ipp" 3 4
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 33 "/usr/include/boost/test/impl/xml_log_formatter.ipp" 2 3 4
+
+
+
+namespace boost {
+namespace unit_test {
+namespace output {
+
+static const_string tu_type_name( test_unit const& tu )
+{
+    return tu.p_type == TUT_CASE ? "TestCase" : "TestSuite";
+}
+
+
+
+
+
+void
+xml_log_formatter::log_start( std::ostream& ostr, counter_t )
+{
+    ostr << "<TestLog>";
+}
+
+
+
+void
+xml_log_formatter::log_finish( std::ostream& ostr )
+{
+    ostr << "</TestLog>";
+}
+
+
+
+void
+xml_log_formatter::log_build_info( std::ostream& ostr, bool log_build_info )
+{
+    if( log_build_info ) {
+        ostr << "<BuildInfo"
+                << " platform" << utils::attr_value() << "linux"
+                << " compiler" << utils::attr_value() << "GNU C++ version " "10.2.0"
+                << " stl" << utils::attr_value() << "GNU libstdc++ version " "20200723"
+                << " boost=\"" << 107200/100000 << "."
+                                << 107200/100 % 1000 << "."
+                                << 107200 % 100 << '\"'
+                << "/>";
+    }
+}
+
+
+
+void
+xml_log_formatter::test_unit_start( std::ostream& ostr, test_unit const& tu )
+{
+    ostr << "<" << tu_type_name( tu ) << " name" << utils::attr_value() << tu.p_name.get();
+
+    if( !tu.p_file_name.empty() )
+        ostr << ::boost::unit_test::const_string( " file", sizeof( " file" ) - 1 ) << utils::attr_value() << tu.p_file_name
+             << ::boost::unit_test::const_string( " line", sizeof( " line" ) - 1 ) << utils::attr_value() << tu.p_line_num;
+
+    ostr << ">";
+}
+
+
+
+void
+xml_log_formatter::test_unit_finish( std::ostream& ostr, test_unit const& tu, unsigned long elapsed )
+{
+    if( tu.p_type == TUT_CASE )
+        ostr << "<TestingTime>" << elapsed << "</TestingTime>";
+
+    ostr << "</" << tu_type_name( tu ) << ">";
+}
+
+
+
+void
+xml_log_formatter::test_unit_skipped( std::ostream& ostr, test_unit const& tu, const_string reason )
+{
+    ostr << "<" << tu_type_name( tu )
+         << " name" << utils::attr_value() << tu.p_name
+         << " skipped" << utils::attr_value() << "yes"
+         << " reason" << utils::attr_value() << reason
+         << "/>";
+}
+
+
+
+void
+xml_log_formatter::log_exception_start( std::ostream& ostr, log_checkpoint_data const& checkpoint_data, execution_exception const& ex )
+{
+    execution_exception::location const& loc = ex.where();
+
+    ostr << "<Exception file" << utils::attr_value() << loc.m_file_name
+         << " line" << utils::attr_value() << loc.m_line_num;
+
+    if( !loc.m_function.is_empty() )
+        ostr << " function" << utils::attr_value() << loc.m_function;
+
+    ostr << ">" << utils::cdata() << ex.what();
+
+    if( !checkpoint_data.m_file_name.is_empty() ) {
+        ostr << "<LastCheckpoint file" << utils::attr_value() << checkpoint_data.m_file_name
+             << " line" << utils::attr_value() << checkpoint_data.m_line_num
+             << ">"
+             << utils::cdata() << checkpoint_data.m_message
+             << "</LastCheckpoint>";
+    }
+}
+
+
+
+void
+xml_log_formatter::log_exception_finish( std::ostream& ostr )
+{
+    ostr << "</Exception>";
+}
+
+
+
+void
+xml_log_formatter::log_entry_start( std::ostream& ostr, log_entry_data const& entry_data, log_entry_types let )
+{
+    static literal_string xml_tags[] = { "Info", "Message", "Warning", "Error", "FatalError" };
+
+    m_curr_tag = xml_tags[let];
+    ostr << '<' << m_curr_tag
+         << ::boost::unit_test::const_string( " file", sizeof( " file" ) - 1 ) << utils::attr_value() << entry_data.m_file_name
+         << ::boost::unit_test::const_string( " line", sizeof( " line" ) - 1 ) << utils::attr_value() << entry_data.m_line_num
+         << ::boost::unit_test::const_string( "><![CDATA[", sizeof( "><![CDATA[" ) - 1 );
+
+    m_value_closed = false;
+}
+
+
+
+void
+xml_log_formatter::log_entry_value( std::ostream& ostr, const_string value )
+{
+    utils::print_escaped_cdata( ostr, value );
+}
+
+
+
+void
+xml_log_formatter::log_entry_finish( std::ostream& ostr )
+{
+    if( !m_value_closed ) {
+        ostr << ::boost::unit_test::const_string( "]]>", sizeof( "]]>" ) - 1 );
+        m_value_closed = true;
+    }
+
+    ostr << ::boost::unit_test::const_string( "</", sizeof( "</" ) - 1 ) << m_curr_tag << ::boost::unit_test::const_string( ">", sizeof( ">" ) - 1 );
+
+    m_curr_tag.clear();
+}
+
+
+
+void
+xml_log_formatter::entry_context_start( std::ostream& ostr, log_level )
+{
+    if( !m_value_closed ) {
+        ostr << ::boost::unit_test::const_string( "]]>", sizeof( "]]>" ) - 1 );
+        m_value_closed = true;
+    }
+
+    ostr << ::boost::unit_test::const_string( "<Context>", sizeof( "<Context>" ) - 1 );
+}
+
+
+
+void
+xml_log_formatter::entry_context_finish( std::ostream& ostr, log_level )
+{
+    ostr << ::boost::unit_test::const_string( "</Context>", sizeof( "</Context>" ) - 1 );
+}
+
+
+
+void
+xml_log_formatter::log_entry_context( std::ostream& ostr, log_level, const_string context_descr )
+{
+    ostr << ::boost::unit_test::const_string( "<Frame>", sizeof( "<Frame>" ) - 1 ) << utils::cdata() << context_descr << ::boost::unit_test::const_string( "</Frame>", sizeof( "</Frame>" ) - 1 );
+}
+
+
+
+}
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 224 "/usr/include/boost/test/impl/xml_log_formatter.ipp" 2 3 4
+# 36 "/usr/include/boost/test/included/unit_test.hpp" 2 3 4
+# 1 "/usr/include/boost/test/impl/xml_report_formatter.ipp" 1 3 4
+# 16 "/usr/include/boost/test/impl/xml_report_formatter.ipp" 3 4
+#define BOOST_TEST_XML_REPORT_FORMATTER_IPP_020105GER 
+# 26 "/usr/include/boost/test/impl/xml_report_formatter.ipp" 3 4
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 27 "/usr/include/boost/test/impl/xml_report_formatter.ipp" 2 3 4
+
+
+
+namespace boost {
+namespace unit_test {
+namespace output {
+
+void
+xml_report_formatter::results_report_start( std::ostream& ostr )
+{
+    ostr << "<TestResult>";
+}
+
+
+
+void
+xml_report_formatter::results_report_finish( std::ostream& ostr )
+{
+    ostr << "</TestResult>";
+}
+
+
+
+
+void
+xml_report_formatter::test_unit_report_start( test_unit const& tu, std::ostream& ostr )
+{
+    test_results const& tr = results_collector.results( tu.p_id );
+
+    const_string descr;
+
+    if( tr.passed() )
+        descr = "passed";
+    else if( tr.p_skipped )
+        descr = "skipped";
+    else if( tr.p_timed_out )
+        descr = "timed-out";
+    else if( tr.p_aborted )
+        descr = "aborted";
+    else
+        descr = "failed";
+
+    ostr << '<' << ( tu.p_type == TUT_CASE ? "TestCase" : "TestSuite" )
+         << " name" << utils::attr_value() << tu.p_name.get()
+         << " result" << utils::attr_value() << descr
+         << " assertions_passed" << utils::attr_value() << tr.p_assertions_passed
+         << " assertions_failed" << utils::attr_value() << tr.p_assertions_failed
+         << " warnings_failed" << utils::attr_value() << tr.p_warnings_failed
+         << " expected_failures" << utils::attr_value() << tr.p_expected_failures
+            ;
+
+    if( tu.p_type == TUT_SUITE ) {
+        ostr << " test_cases_passed" << utils::attr_value() << tr.p_test_cases_passed
+             << " test_cases_passed_with_warnings" << utils::attr_value() << tr.p_test_cases_warned
+             << " test_cases_failed" << utils::attr_value() << tr.p_test_cases_failed
+             << " test_cases_skipped" << utils::attr_value() << tr.p_test_cases_skipped
+             << " test_cases_aborted" << utils::attr_value() << tr.p_test_cases_aborted
+             << " test_cases_timed_out" << utils::attr_value() << tr.p_test_cases_timed_out
+             << " test_suites_timed_out"<< utils::attr_value() << tr.p_test_suites_timed_out
+             ;
+    }
+
+    ostr << '>';
+}
+
+
+
+void
+xml_report_formatter::test_unit_report_finish( test_unit const& tu, std::ostream& ostr )
+{
+    ostr << "</" << ( tu.p_type == TUT_CASE ? "TestCase" : "TestSuite" ) << '>';
+}
+
+
+
+void
+xml_report_formatter::do_confirmation_report( test_unit const& tu, std::ostream& ostr )
+{
+    test_unit_report_start( tu, ostr );
+    test_unit_report_finish( tu, ostr );
+}
+
+
+
+}
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 116 "/usr/include/boost/test/impl/xml_report_formatter.ipp" 2 3 4
+# 37 "/usr/include/boost/test/included/unit_test.hpp" 2 3 4
+
+# 1 "/usr/include/boost/test/unit_test.hpp" 1 3 4
+# 15 "/usr/include/boost/test/unit_test.hpp" 3 4
+#define BOOST_TEST_UNIT_TEST_HPP_071894GER 
+
+
+
+# 1 "/usr/include/boost/test/unit_test_suite.hpp" 1 3 4
+# 13 "/usr/include/boost/test/unit_test_suite.hpp" 3 4
+#define BOOST_TEST_UNIT_TEST_SUITE_HPP_071894GER 
+
+
+
+
+# 1 "/usr/include/boost/test/tree/test_case_template.hpp" 1 3 4
+# 13 "/usr/include/boost/test/tree/test_case_template.hpp" 3 4
+#define BOOST_TEST_TREE_TEST_CASE_TEMPLATE_HPP_091911GER 
+# 28 "/usr/include/boost/test/tree/test_case_template.hpp" 3 4
+# 1 "/usr/include/boost/mpl/for_each.hpp" 1 3 4
+
+
+#define BOOST_MPL_FOR_EACH_HPP_INCLUDED 
+# 17 "/usr/include/boost/mpl/for_each.hpp" 3 4
+# 1 "/usr/include/boost/mpl/is_sequence.hpp" 1 3 4
+
+
+#define BOOST_MPL_IS_SEQUENCE_HPP_INCLUDED 
+# 19 "/usr/include/boost/mpl/is_sequence.hpp" 3 4
+# 1 "/usr/include/boost/mpl/begin_end.hpp" 1 3 4
+
+
+#define BOOST_MPL_BEGIN_END_HPP_INCLUDED 
+# 17 "/usr/include/boost/mpl/begin_end.hpp" 3 4
+# 1 "/usr/include/boost/mpl/begin_end_fwd.hpp" 1 3 4
+
+
+#define BOOST_MPL_BEGIN_END_FWD_HPP_INCLUDED 
+# 17 "/usr/include/boost/mpl/begin_end_fwd.hpp" 3 4
+namespace boost { namespace mpl {
+
+template< typename Tag > struct begin_impl;
+template< typename Tag > struct end_impl;
+
+template< typename Sequence > struct begin;
+template< typename Sequence > struct end;
+
+}}
+# 18 "/usr/include/boost/mpl/begin_end.hpp" 2 3 4
+# 1 "/usr/include/boost/mpl/aux_/begin_end_impl.hpp" 1 3 4
+
+
+#define BOOST_MPL_AUX_BEGIN_END_IMPL_HPP_INCLUDED 
+# 18 "/usr/include/boost/mpl/aux_/begin_end_impl.hpp" 3 4
+# 1 "/usr/include/boost/mpl/sequence_tag_fwd.hpp" 1 3 4
+
+
+#define BOOST_MPL_SEQUENCE_TAG_FWD_HPP_INCLUDED 
+# 17 "/usr/include/boost/mpl/sequence_tag_fwd.hpp" 3 4
+namespace boost { namespace mpl {
+
+struct nested_begin_end_tag;
+struct non_sequence_tag;
+
+template< typename Sequence > struct sequence_tag;
+
+}}
+# 19 "/usr/include/boost/mpl/aux_/begin_end_impl.hpp" 2 3 4
+
+
+# 1 "/usr/include/boost/mpl/aux_/has_begin.hpp" 1 3 4
+
+
+#define BOOST_MPL_AUX_HAS_BEGIN_HPP_INCLUDED 
+# 19 "/usr/include/boost/mpl/aux_/has_begin.hpp" 3 4
+namespace boost { namespace mpl { namespace aux {
+template< typename T, typename fallback_ = boost::mpl::bool_<true> > struct has_begin { struct gcc_3_2_wknd { template< typename U > static boost::mpl::aux::yes_tag test( boost::mpl::aux::type_wrapper<U> const volatile* , boost::mpl::aux::type_wrapper<typename U::begin>* = 0 ); static boost::mpl::aux::no_tag test(...); }; typedef boost::mpl::aux::type_wrapper<T> t_; static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::aux::yes_tag); typedef boost::mpl::bool_<value> type; };
+}}}
+# 22 "/usr/include/boost/mpl/aux_/begin_end_impl.hpp" 2 3 4
+
+# 1 "/usr/include/boost/mpl/aux_/traits_lambda_spec.hpp" 1 3 4
+
+
+#define BOOST_MPL_AUX_TRAITS_LAMBDA_SPEC_HPP_INCLUDED 
+# 24 "/usr/include/boost/mpl/aux_/traits_lambda_spec.hpp" 3 4
+#define BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC_IMPL(i,trait) 
+# 58 "/usr/include/boost/mpl/aux_/traits_lambda_spec.hpp" 3 4
+#define BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(i,trait) BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC_IMPL(i, trait) template<> struct trait<non_sequence_tag> {};
+# 24 "/usr/include/boost/mpl/aux_/begin_end_impl.hpp" 2 3 4
+
+
+namespace boost { namespace mpl {
+
+
+namespace aux {
+
+template< typename Sequence >
+struct begin_type
+{
+    typedef typename Sequence::begin type;
+};
+template< typename Sequence >
+struct end_type
+{
+    typedef typename Sequence::end type;
+};
+
+}
+
+
+
+
+
+template< typename Tag >
+struct begin_impl
+{
+    template< typename Sequence > struct apply
+    {
+        typedef typename eval_if<aux::has_begin<Sequence, true_>,
+                                 aux::begin_type<Sequence>, void_>::type type;
+    };
+};
+
+template< typename Tag >
+struct end_impl
+{
+    template< typename Sequence > struct apply
+    {
+        typedef typename eval_if<aux::has_begin<Sequence, true_>,
+                                 aux::end_type<Sequence>, void_>::type type;
+    };
+};
+
+
+
+#define AUX778076_IMPL_SPEC(name,tag,result) template<> struct name ##_impl<tag> { template< typename Sequence > struct apply { typedef result type; }; };
+# 82 "/usr/include/boost/mpl/aux_/begin_end_impl.hpp" 3 4
+template<> struct begin_impl<nested_begin_end_tag> { template< typename Sequence > struct apply { typedef typename Sequence::begin type; }; };
+template<> struct end_impl<nested_begin_end_tag> { template< typename Sequence > struct apply { typedef typename Sequence::end type; }; };
+
+
+
+
+template<> struct begin_impl<non_sequence_tag> { template< typename Sequence > struct apply { typedef void_ type; }; };
+template<> struct end_impl<non_sequence_tag> { template< typename Sequence > struct apply { typedef void_ type; }; };
+template<> struct begin_impl<na> { template< typename Sequence > struct apply { typedef void_ type; }; };
+template<> struct end_impl<na> { template< typename Sequence > struct apply { typedef void_ type; }; };
+
+#undef AUX778076_IMPL_SPEC
+
+
+
+
+
+}}
+# 19 "/usr/include/boost/mpl/begin_end.hpp" 2 3 4
+# 1 "/usr/include/boost/mpl/sequence_tag.hpp" 1 3 4
+
+
+#define BOOST_MPL_SEQUENCE_TAG_HPP_INCLUDED 
+# 26 "/usr/include/boost/mpl/sequence_tag.hpp" 3 4
+namespace boost { namespace mpl {
+# 78 "/usr/include/boost/mpl/sequence_tag.hpp" 3 4
+namespace aux {
+
+template< bool has_tag_, bool has_begin_ >
+struct sequence_tag_impl
+{
+
+
+    template< typename Sequence > struct result2_;
+};
+
+#define AUX_CLASS_SEQUENCE_TAG_SPEC(has_tag,has_begin,result_type) template<> struct sequence_tag_impl<has_tag,has_begin> { template< typename Sequence > struct result2_ { typedef result_type type; }; };
+# 98 "/usr/include/boost/mpl/sequence_tag.hpp" 3 4
+template<> struct sequence_tag_impl<true,true> { template< typename Sequence > struct result2_ { typedef typename Sequence::tag type; }; };
+template<> struct sequence_tag_impl<true,false> { template< typename Sequence > struct result2_ { typedef typename Sequence::tag type; }; };
+template<> struct sequence_tag_impl<false,true> { template< typename Sequence > struct result2_ { typedef nested_begin_end_tag type; }; };
+template<> struct sequence_tag_impl<false,false> { template< typename Sequence > struct result2_ { typedef non_sequence_tag type; }; };
+
+#undef AUX_CLASS_SEQUENCE_TAG_SPEC
+
+}
+
+template<
+      typename Sequence = na
+    >
+struct sequence_tag
+    : aux::sequence_tag_impl<
+          ::boost::mpl::aux::has_tag<Sequence>::value
+        , ::boost::mpl::aux::has_begin<Sequence>::value
+        >::template result2_<Sequence>
+{
+};
+
+
+
+template<> struct sequence_tag< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : sequence_tag< T1 > { }; }; template< typename Tag > struct lambda< sequence_tag< na > , Tag , int_<-1> > { typedef false_ is_le; typedef sequence_tag< na > result_; typedef sequence_tag< na > type; }; namespace aux { template< typename T1 > struct template_arity< sequence_tag< T1 > > : int_<1> { }; template<> struct template_arity< sequence_tag< na > > : int_<-1> { }; }
+
+}}
+# 20 "/usr/include/boost/mpl/begin_end.hpp" 2 3 4
+
+
+
+namespace boost { namespace mpl {
+
+
+
+
+template<
+      typename Sequence = na
+    >
+struct begin
+{
+    typedef typename sequence_tag<Sequence>::type tag_;
+    typedef typename begin_impl< tag_ >
+        ::template apply< Sequence >::type type;
+
+   
+};
+
+template<
+      typename Sequence = na
+    >
+struct end
+{
+    typedef typename sequence_tag<Sequence>::type tag_;
+    typedef typename end_impl< tag_ >
+        ::template apply< Sequence >::type type;
+
+   
+};
+
+template<> struct begin< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : begin< T1 > { }; }; template< typename Tag > struct lambda< begin< na > , Tag , int_<-1> > { typedef false_ is_le; typedef begin< na > result_; typedef begin< na > type; }; namespace aux { template< typename T1 > struct template_arity< begin< T1 > > : int_<1> { }; template<> struct template_arity< begin< na > > : int_<-1> { }; }
+template<> struct end< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : end< T1 > { }; }; template< typename Tag > struct lambda< end< na > , Tag , int_<-1> > { typedef false_ is_le; typedef end< na > result_; typedef end< na > type; }; namespace aux { template< typename T1 > struct template_arity< end< T1 > > : int_<1> { }; template<> struct template_arity< end< na > > : int_<-1> { }; }
+
+}}
+# 20 "/usr/include/boost/mpl/is_sequence.hpp" 2 3 4
+# 40 "/usr/include/boost/mpl/is_sequence.hpp" 3 4
+namespace boost { namespace mpl {
+# 90 "/usr/include/boost/mpl/is_sequence.hpp" 3 4
+template<
+      typename T = na
+    >
+struct is_sequence
+    : not_< is_same< typename begin<T>::type, void_ > >
+{
+   
+};
+# 108 "/usr/include/boost/mpl/is_sequence.hpp" 3 4
+template<> struct is_sequence< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : is_sequence< T1 > { }; }; template< typename Tag > struct lambda< is_sequence< na > , Tag , int_<-1> > { typedef false_ is_le; typedef is_sequence< na > result_; typedef is_sequence< na > type; }; namespace aux { template< typename T1 > struct template_arity< is_sequence< T1 > > : int_<1> { }; template<> struct template_arity< is_sequence< na > > : int_<-1> { }; }
+
+}}
+# 18 "/usr/include/boost/mpl/for_each.hpp" 2 3 4
+
+# 1 "/usr/include/boost/mpl/apply.hpp" 1 3 4
+# 20 "/usr/include/boost/mpl/for_each.hpp" 2 3 4
+
+
+# 1 "/usr/include/boost/mpl/deref.hpp" 1 3 4
+
+
+#define BOOST_MPL_DEREF_HPP_INCLUDED 
+# 17 "/usr/include/boost/mpl/deref.hpp" 3 4
+# 1 "/usr/include/boost/mpl/aux_/msvc_type.hpp" 1 3 4
+
+
+#define BOOST_MPL_AUX_MSVC_TYPE_HPP_INCLUDED 
+# 20 "/usr/include/boost/mpl/aux_/msvc_type.hpp" 3 4
+namespace boost { namespace mpl { namespace aux {
+# 48 "/usr/include/boost/mpl/aux_/msvc_type.hpp" 3 4
+template< typename T > struct msvc_type
+{
+    typedef typename T::type type;
+};
+
+template<> struct msvc_type<int>
+{
+    typedef int type;
+};
+
+
+
+}}}
+# 18 "/usr/include/boost/mpl/deref.hpp" 2 3 4
+
+
+
+
+namespace boost { namespace mpl {
+
+template<
+      typename Iterator = na
+    >
+struct deref
+{
+
+    typedef typename Iterator::type type;
+
+
+
+   
+};
+
+template<> struct deref< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : deref< T1 > { }; }; template< typename Tag > struct lambda< deref< na > , Tag , int_<-1> > { typedef false_ is_le; typedef deref< na > result_; typedef deref< na > type; }; namespace aux { template< typename T1 > struct template_arity< deref< T1 > > : int_<1> { }; template<> struct template_arity< deref< na > > : int_<-1> { }; }
+
+}}
+# 23 "/usr/include/boost/mpl/for_each.hpp" 2 3 4
+
+
+
+# 1 "/usr/include/boost/mpl/aux_/unwrap.hpp" 1 3 4
+
+
+#define BOOST_MPL_AUX_UNWRAP_HPP_INCLUDED 
+# 21 "/usr/include/boost/mpl/aux_/unwrap.hpp" 3 4
+namespace boost { namespace mpl { namespace aux {
+
+template< typename F >
+
+inline
+F& unwrap(F& f, long)
+{
+    return f;
+}
+
+template< typename F >
+
+inline
+F&
+unwrap(reference_wrapper<F>& f, int)
+{
+    return f;
+}
+
+template< typename F >
+
+inline
+F&
+unwrap(reference_wrapper<F> const& f, int)
+{
+    return f;
+}
+
+}}}
+# 27 "/usr/include/boost/mpl/for_each.hpp" 2 3 4
+
+
+# 1 "/usr/include/boost/utility/value_init.hpp" 1 3 4
+# 16 "/usr/include/boost/utility/value_init.hpp" 3 4
+#define BOOST_UTILITY_VALUE_INIT_21AGO2002_HPP 
+
+
+
+
+
+
+
+# 1 "/usr/include/boost/aligned_storage.hpp" 1 3 4
+# 14 "/usr/include/boost/aligned_storage.hpp" 3 4
+#define BOOST_ALIGNED_STORAGE_HPP 
+
+# 1 "/usr/include/boost/type_traits/aligned_storage.hpp" 1 3 4
+# 14 "/usr/include/boost/type_traits/aligned_storage.hpp" 3 4
+#define BOOST_TT_ALIGNED_STORAGE_HPP 
+# 25 "/usr/include/boost/type_traits/aligned_storage.hpp" 3 4
+namespace boost {
+
+namespace detail { namespace aligned_storage {
+
+static const std::size_t alignment_of_max_align = ::boost::alignment_of<boost::detail::max_align>::value
+
+
+     ;
+
+
+
+
+template <
+      std::size_t size_
+    , std::size_t alignment_
+>
+struct aligned_storage_imp
+{
+    union data_t
+    {
+        char buf[size_];
+
+        typename ::boost::type_with_alignment<alignment_>::type align_;
+    } data_;
+    void* address() const { return const_cast<aligned_storage_imp*>(this); }
+};
+template <std::size_t size>
+struct aligned_storage_imp<size, std::size_t(-1)>
+{
+   union data_t
+   {
+      char buf[size];
+      ::boost::detail::max_align align_;
+   } data_;
+   void* address() const { return const_cast<aligned_storage_imp*>(this); }
+};
+
+template< std::size_t alignment_ >
+struct aligned_storage_imp<0u,alignment_>
+{
+
+    void* address() const { return 0; }
+};
+
+}}
+
+template <
+      std::size_t size_
+    , std::size_t alignment_ = std::size_t(-1)
+>
+class aligned_storage :
+
+   private
+
+
+
+   ::boost::detail::aligned_storage::aligned_storage_imp<size_, alignment_>
+{
+
+public:
+
+    typedef ::boost::detail::aligned_storage::aligned_storage_imp<size_, alignment_> type;
+
+    static const std::size_t size = size_
+
+
+         ;
+    static const std::size_t alignment = ( alignment_ == std::size_t(-1) ? ::boost::detail::aligned_storage::alignment_of_max_align : alignment_ )
+
+
+
+
+
+
+         ;
+
+private:
+
+    aligned_storage(const aligned_storage&);
+    aligned_storage& operator=(const aligned_storage&);
+
+public:
+
+    aligned_storage()
+    {
+    }
+
+    ~aligned_storage()
+    {
+    }
+
+public:
+
+    void* address()
+    {
+        return static_cast<type*>(this)->address();
+    }
+
+    const void* address() const
+    {
+        return static_cast<const type*>(this)->address();
+    }
+};
+
+
+
+
+
+template <std::size_t size_, std::size_t alignment_>
+struct is_pod< ::boost::detail::aligned_storage::aligned_storage_imp<size_, alignment_> > : public true_type{};
+
+}
+# 17 "/usr/include/boost/aligned_storage.hpp" 2 3 4
+# 25 "/usr/include/boost/utility/value_init.hpp" 2 3 4
+
+
+
+# 1 "/usr/include/boost/type_traits/cv_traits.hpp" 1 3 4
+# 13 "/usr/include/boost/type_traits/cv_traits.hpp" 3 4
+#define BOOST_TT_CV_TRAITS_HPP_INCLUDED 
+
+
+# 1 "/usr/include/boost/type_traits/add_volatile.hpp" 1 3 4
+# 11 "/usr/include/boost/type_traits/add_volatile.hpp" 3 4
+#define BOOST_TT_ADD_VOLATILE_HPP_INCLUDED 
+
+
+
+namespace boost {
+# 30 "/usr/include/boost/type_traits/add_volatile.hpp" 3 4
+template <class T> struct add_volatile{ typedef T volatile type; };
+
+
+
+
+
+template <class T> struct add_volatile<T&>{ typedef T& type; };
+
+
+
+   template <class T> using add_volatile_t = typename add_volatile<T>::type;
+
+
+
+}
+# 17 "/usr/include/boost/type_traits/cv_traits.hpp" 2 3 4
+# 1 "/usr/include/boost/type_traits/add_cv.hpp" 1 3 4
+# 12 "/usr/include/boost/type_traits/add_cv.hpp" 3 4
+#define BOOST_TT_ADD_CV_HPP_INCLUDED 
+
+
+
+namespace boost {
+# 31 "/usr/include/boost/type_traits/add_cv.hpp" 3 4
+template <class T> struct add_cv{ typedef T const volatile type; };
+
+
+
+
+
+template <class T> struct add_cv<T&>{ typedef T& type; };
+
+
+
+   template <class T> using add_cv_t = typename add_cv<T>::type;
+
+
+
+}
+# 18 "/usr/include/boost/type_traits/cv_traits.hpp" 2 3 4
+
+
+
+# 1 "/usr/include/boost/type_traits/remove_volatile.hpp" 1 3 4
+# 12 "/usr/include/boost/type_traits/remove_volatile.hpp" 3 4
+#define BOOST_TT_REMOVE_VOLATILE_HPP_INCLUDED 
+
+
+
+
+
+namespace boost {
+
+
+   template <class T> struct remove_volatile{ typedef T type; };
+   template <class T> struct remove_volatile<T volatile>{ typedef T type; };
+
+
+   template <class T, std::size_t N> struct remove_volatile<T volatile[N]>{ typedef T type[N]; };
+
+   template <class T> struct remove_volatile<T volatile[]>{ typedef T type[]; };
+
+
+
+
+
+   template <class T> using remove_volatile_t = typename remove_volatile<T>::type;
+
+
+
+}
+# 22 "/usr/include/boost/type_traits/cv_traits.hpp" 2 3 4
+# 29 "/usr/include/boost/utility/value_init.hpp" 2 3 4
+
+# 1 "/usr/include/boost/swap.hpp" 1 3 4
+# 10 "/usr/include/boost/swap.hpp" 3 4
+#define BOOST_SWAP_HPP 
+
+
+
+
+# 1 "/usr/include/boost/core/swap.hpp" 1 3 4
+# 10 "/usr/include/boost/core/swap.hpp" 3 4
+#define BOOST_CORE_SWAP_HPP 
+# 30 "/usr/include/boost/core/swap.hpp" 3 4
+namespace boost_swap_impl
+{
+
+
+  template<class T> struct is_const { enum _vt { value = 0 }; };
+  template<class T> struct is_const<T const> { enum _vt { value = 1 }; };
+
+  template<class T>
+ 
+  void swap_impl(T& left, T& right)
+  {
+    using namespace std;
+    swap(left,right);
+  }
+
+  template<class T, std::size_t N>
+ 
+  void swap_impl(T (& left)[N], T (& right)[N])
+  {
+    for (std::size_t i = 0; i < N; ++i)
+    {
+      ::boost_swap_impl::swap_impl(left[i], right[i]);
+    }
+  }
+}
+
+namespace boost
+{
+  template<class T1, class T2>
+ 
+  typename enable_if_c< !boost_swap_impl::is_const<T1>::value && !boost_swap_impl::is_const<T2>::value >::type
+  swap(T1& left, T2& right)
+  {
+    ::boost_swap_impl::swap_impl(left, right);
+  }
+}
+# 16 "/usr/include/boost/swap.hpp" 2 3 4
+# 31 "/usr/include/boost/utility/value_init.hpp" 2 3 4
+# 1 "/usr/include/c++/10.2.0/cstring" 1 3 4
+# 39 "/usr/include/c++/10.2.0/cstring" 3 4
+       
+# 40 "/usr/include/c++/10.2.0/cstring" 3
+# 32 "/usr/include/boost/utility/value_init.hpp" 2 3 4
+# 57 "/usr/include/boost/utility/value_init.hpp" 3 4
+#define BOOST_DETAIL_VALUE_INIT_WORKAROUND 0
+
+
+
+namespace boost {
+
+template<class T>
+class initialized
+{
+  private :
+    struct wrapper
+    {
+
+      typename
+
+      remove_const<T>::type data;
+
+     
+      wrapper()
+      :
+      data()
+      {
+      }
+
+     
+      wrapper(T const & arg)
+      :
+      data(arg)
+      {
+      }
+    };
+
+    mutable
+
+      typename
+
+      aligned_storage<sizeof(wrapper), alignment_of<wrapper>::value>::type x;
+
+   
+    wrapper * wrapper_address() const
+    {
+      return static_cast<wrapper *>( static_cast<void*>(&x));
+    }
+
+  public :
+
+   
+    initialized()
+    {
+
+
+
+      new (wrapper_address()) wrapper();
+    }
+
+   
+    initialized(initialized const & arg)
+    {
+      new (wrapper_address()) wrapper( static_cast<wrapper const &>(*(arg.wrapper_address())));
+    }
+
+   
+    explicit initialized(T const & arg)
+    {
+      new (wrapper_address()) wrapper(arg);
+    }
+
+   
+    initialized & operator=(initialized const & arg)
+    {
+
+      static_assert(! is_const<T>::value, "! is_const<T>::value");
+      *wrapper_address() = static_cast<wrapper const &>(*(arg.wrapper_address()));
+      return *this;
+    }
+
+   
+    ~initialized()
+    {
+      wrapper_address()->wrapper::~wrapper();
+    }
+
+   
+    T const & data() const
+    {
+      return wrapper_address()->data;
+    }
+
+   
+    T& data()
+    {
+      return wrapper_address()->data;
+    }
+
+   
+    void swap(initialized & arg)
+    {
+      ::boost::swap( this->data(), arg.data() );
+    }
+
+   
+    operator T const &() const
+    {
+      return wrapper_address()->data;
+    }
+
+   
+    operator T&()
+    {
+      return wrapper_address()->data;
+    }
+
+} ;
+
+template<class T>
+
+T const& get ( initialized<T> const& x )
+{
+  return x.data() ;
+}
+
+template<class T>
+
+T& get ( initialized<T>& x )
+{
+  return x.data() ;
+}
+
+template<class T>
+
+void swap ( initialized<T> & lhs, initialized<T> & rhs )
+{
+  lhs.swap(rhs) ;
+}
+
+template<class T>
+class value_initialized
+{
+  private :
+
+
+    initialized<T> m_data;
+
+  public :
+
+   
+    value_initialized()
+    :
+    m_data()
+    { }
+
+   
+    T const & data() const
+    {
+      return m_data.data();
+    }
+
+   
+    T& data()
+    {
+      return m_data.data();
+    }
+
+   
+    void swap(value_initialized & arg)
+    {
+      m_data.swap(arg.m_data);
+    }
+
+   
+    operator T const &() const
+    {
+      return m_data;
+    }
+
+   
+    operator T&()
+    {
+      return m_data;
+    }
+} ;
+
+
+template<class T>
+
+T const& get ( value_initialized<T> const& x )
+{
+  return x.data() ;
+}
+
+template<class T>
+
+T& get ( value_initialized<T>& x )
+{
+  return x.data() ;
+}
+
+template<class T>
+
+void swap ( value_initialized<T> & lhs, value_initialized<T> & rhs )
+{
+  lhs.swap(rhs) ;
+}
+
+
+class initialized_value_t
+{
+  public :
+
+    template <class T> operator T() const
+    {
+      return initialized<T>().data();
+    }
+};
+
+initialized_value_t const initialized_value = {} ;
+
+
+}
+# 30 "/usr/include/boost/mpl/for_each.hpp" 2 3 4
+
+namespace boost { namespace mpl {
+
+namespace aux {
+
+template< bool done = true >
+struct for_each_impl
+{
+    template<
+          typename Iterator
+        , typename LastIterator
+        , typename TransformFunc
+        , typename F
+        >
+   
+    static void execute(
+          Iterator*
+        , LastIterator*
+        , TransformFunc*
+        , F
+        )
+    {
+    }
+};
+
+template<>
+struct for_each_impl<false>
+{
+    template<
+          typename Iterator
+        , typename LastIterator
+        , typename TransformFunc
+        , typename F
+        >
+   
+    static void execute(
+          Iterator*
+        , LastIterator*
+        , TransformFunc*
+        , F f
+        )
+    {
+        typedef typename deref<Iterator>::type item;
+        typedef typename apply1<TransformFunc,item>::type arg;
+
+
+
+        value_initialized<arg> x;
+        aux::unwrap(f, 0)(boost::get(x));
+
+        typedef typename mpl::next<Iterator>::type iter;
+        for_each_impl<boost::is_same<iter,LastIterator>::value>
+            ::execute( static_cast<iter*>(0), static_cast<LastIterator*>(0), static_cast<TransformFunc*>(0), f);
+    }
+};
+
+}
+
+
+
+template<
+      typename Sequence
+    , typename TransformOp
+    , typename F
+    >
+
+inline
+void for_each(F f, Sequence* = 0, TransformOp* = 0)
+{
+    enum { mpl_assertion_in_line_99 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_arg( (void (*) ( is_sequence<Sequence> ))0, 1 ) ) ) };
+
+    typedef typename begin<Sequence>::type first;
+    typedef typename end<Sequence>::type last;
+
+    aux::for_each_impl< boost::is_same<first,last>::value >
+        ::execute(static_cast<first*>(0), static_cast<last*>(0), static_cast<TransformOp*>(0), f);
+}
+
+template<
+      typename Sequence
+    , typename F
+    >
+
+inline
+void for_each(F f, Sequence* = 0)
+{
+
+
+  boost::mpl::for_each<Sequence, identity<> >(f);
+}
+
+}}
+# 29 "/usr/include/boost/test/tree/test_case_template.hpp" 2 3 4
+
+
+
+
+
+
+
+# 1 "/usr/include/boost/function/function0.hpp" 1 3 4
+# 10 "/usr/include/boost/function/function0.hpp" 3 4
+#define BOOST_FUNCTION_NUM_ARGS 0
+# 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
+# 11 "/usr/include/boost/function/detail/maybe_include.hpp" 3 4
+#undef BOOST_FUNCTION_MAX_ARGS_DEFINED
+#define BOOST_FUNCTION_MAX_ARGS_DEFINED 0
+# 12 "/usr/include/boost/function/function0.hpp" 2 3 4
+#undef BOOST_FUNCTION_NUM_ARGS
+# 37 "/usr/include/boost/test/tree/test_case_template.hpp" 2 3 4
+# 54 "/usr/include/boost/test/tree/test_case_template.hpp" 3 4
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 55 "/usr/include/boost/test/tree/test_case_template.hpp" 2 3 4
+
+
+
+
+namespace boost {
+namespace unit_test {
+namespace ut_detail {
+
+
+
+
+
+template<typename TestCaseTemplate,typename TestType>
+class test_case_template_invoker {
+public:
+    void operator()() { TestCaseTemplate::run( (boost::type<TestType>*)0 ); }
+};
+
+
+
+
+
+template<typename Generator, typename TestCaseTemplate>
+struct generate_test_case_4_type {
+    explicit generate_test_case_4_type( const_string tc_name, const_string tc_file, std::size_t tc_line, Generator& G )
+    : m_test_case_name( tc_name )
+    , m_test_case_file( tc_file )
+    , m_test_case_line( tc_line )
+    , m_holder( G )
+    {}
+
+    template<typename TestType>
+    void operator()( mpl::identity<TestType> )
+    {
+        std::string full_name;
+        assign_op( full_name, m_test_case_name, 0 );
+        full_name += '<';
+
+        full_name += boost::core::demangle(typeid(TestType).name());
+
+
+
+
+
+        static const std::string to_replace[] = { "class ", "struct ", ",", "  ", " <", " >"};
+        static const std::string replacement[] = { "", "" , ", ", " ", "<" , ">"};
+
+        full_name = unit_test::utils::replace_all_occurrences_of(
+            full_name,
+            to_replace, to_replace + sizeof(to_replace)/sizeof(to_replace[0]),
+            replacement, replacement + sizeof(replacement)/sizeof(replacement[0]));
+
+        typedef typename boost::remove_reference<TestType>::type TestTypewoRef;
+        if( boost::is_const<TestTypewoRef>::value )
+            full_name += "_const";
+        if( boost::is_volatile<TestTypewoRef>::value )
+            full_name += "_volatile";
+        if( boost::is_rvalue_reference<TestType>::value )
+            full_name += "_refref";
+        else if( boost::is_lvalue_reference<TestType>::value )
+            full_name += "_ref";
+
+        full_name += '>';
+
+        m_holder.m_test_cases.push_back( new test_case( ut_detail::normalize_test_case_name( full_name ),
+                                                        m_test_case_file,
+                                                        m_test_case_line,
+                                                        test_case_template_invoker<TestCaseTemplate,TestType>() ) );
+    }
+
+private:
+
+    const_string m_test_case_name;
+    const_string m_test_case_file;
+    std::size_t m_test_case_line;
+    Generator& m_holder;
+};
+
+
+
+
+
+class template_test_case_gen_base : public test_unit_generator {
+public:
+    virtual test_unit* next() const
+    {
+        if( m_test_cases.empty() )
+            return 0;
+
+        test_unit* res = m_test_cases.front();
+        m_test_cases.pop_front();
+
+        return res;
+    }
+
+
+    mutable std::list<test_unit*> m_test_cases;
+};
+
+template<typename TestCaseTemplate,typename TestTypesList, typename enabler = void>
+class template_test_case_gen : public template_test_case_gen_base {
+public:
+
+    template_test_case_gen( const_string tc_name, const_string tc_file, std::size_t tc_line )
+    {
+        typedef generate_test_case_4_type<template_test_case_gen<TestCaseTemplate,TestTypesList>,TestCaseTemplate> single_test_gen;
+
+        mpl::for_each<TestTypesList,mpl::make_identity<mpl::_> >( single_test_gen( tc_name, tc_file, tc_line, *this ) );
+    }
+};
+
+
+
+
+
+
+template<typename TestCaseTemplate,
+         template <class ...> class C,
+         typename... parameter_pack>
+class template_test_case_gen<
+    TestCaseTemplate,
+    C<parameter_pack...>,
+    typename std::enable_if<!boost::mpl::is_sequence<C<parameter_pack...>>::value>::type >
+  : public template_test_case_gen_base {
+
+    template<typename F>
+    void for_each(F &f)
+    {
+        auto l = { (f(mpl::identity<parameter_pack>()), 0)... };
+        (void)l;
+    }
+
+public:
+
+    template_test_case_gen( const_string tc_name, const_string tc_file, std::size_t tc_line )
+    {
+        using this_type = template_test_case_gen<
+            TestCaseTemplate,
+            C<parameter_pack...>,
+            typename std::enable_if<!boost::mpl::is_sequence<C<parameter_pack...>>::value>::type>;
+        using single_test_gen = generate_test_case_4_type<this_type, TestCaseTemplate>;
+
+        single_test_gen op( tc_name, tc_file, tc_line, *this );
+
+        this->for_each(op);
+    }
+};
+
+
+
+}
+}
+}
+
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 210 "/usr/include/boost/test/tree/test_case_template.hpp" 2 3 4
+# 19 "/usr/include/boost/test/unit_test_suite.hpp" 2 3 4
+
+
+
+# 1 "/usr/include/boost/test/detail/suppress_warnings.hpp" 1 3 4
+# 36 "/usr/include/boost/test/detail/suppress_warnings.hpp" 3 4
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
+# 23 "/usr/include/boost/test/unit_test_suite.hpp" 2 3 4
+# 35 "/usr/include/boost/test/unit_test_suite.hpp" 3 4
+#define BOOST_TEST_CASE_NAME(test_function,test_name) boost::unit_test::make_test_case( boost::function<void ()>(test_function), test_name , __FILE__, __LINE__ )
+
+
+
+#define BOOST_TEST_CASE(test_function) BOOST_TEST_CASE_NAME(test_function, BOOST_TEST_STRINGIZE( test_function) )
+
+#define BOOST_CLASS_TEST_CASE(test_function,tc_instance) boost::unit_test::make_test_case( (test_function), BOOST_TEST_STRINGIZE( test_function ), __FILE__, __LINE__, tc_instance )
+# 50 "/usr/include/boost/test/unit_test_suite.hpp" 3 4
+#define BOOST_TEST_SUITE(testsuite_name) ( new boost::unit_test::test_suite( testsuite_name, __FILE__, __LINE__ ) )
+
+
+
+
+
+
+#define BOOST_AUTO_TEST_SUITE_WITH_DECOR(suite_name,decorators) namespace suite_name { BOOST_AUTO_TU_REGISTRAR( suite_name )( BOOST_STRINGIZE( suite_name ), __FILE__, __LINE__, decorators );
+
+
+
+
+
+
+
+#define BOOST_AUTO_TEST_SUITE_NO_DECOR(suite_name) BOOST_AUTO_TEST_SUITE_WITH_DECOR( suite_name, boost::unit_test::decorator::collector_t::instance() )
+
+
+
+
+
+
+#define BOOST_AUTO_TEST_SUITE(...) BOOST_TEST_INVOKE_IF_N_ARGS( 1, BOOST_AUTO_TEST_SUITE_NO_DECOR, BOOST_AUTO_TEST_SUITE_WITH_DECOR, __VA_ARGS__)
+# 92 "/usr/include/boost/test/unit_test_suite.hpp" 3 4
+#define BOOST_FIXTURE_TEST_SUITE_WITH_DECOR(suite_name,F,decorators) BOOST_AUTO_TEST_SUITE_WITH_DECOR( suite_name, decorators ) typedef F BOOST_AUTO_TEST_CASE_FIXTURE;
+
+
+
+
+#define BOOST_FIXTURE_TEST_SUITE_NO_DECOR(suite_name,F) BOOST_AUTO_TEST_SUITE_NO_DECOR( suite_name ) typedef F BOOST_AUTO_TEST_CASE_FIXTURE;
+
+
+
+
+
+
+#define BOOST_FIXTURE_TEST_SUITE(...) BOOST_TEST_INVOKE_IF_N_ARGS( 2, BOOST_FIXTURE_TEST_SUITE_NO_DECOR, BOOST_FIXTURE_TEST_SUITE_WITH_DECOR, __VA_ARGS__)
+# 125 "/usr/include/boost/test/unit_test_suite.hpp" 3 4
+#define BOOST_AUTO_TEST_SUITE_END() BOOST_AUTO_TU_REGISTRAR( end_suite )( 1 ); }
+# 135 "/usr/include/boost/test/unit_test_suite.hpp" 3 4
+#define BOOST_AUTO_TEST_CASE_EXPECTED_FAILURES(test_name,n) BOOST_TEST_DECORATOR( * boost::unit_test::expected_failures( n ) )
+
+
+
+
+
+
+
+#define BOOST_FIXTURE_TEST_CASE_WITH_DECOR(test_name,F,decorators) struct test_name : public F { void test_method(); }; static void BOOST_AUTO_TC_INVOKER( test_name )() { BOOST_TEST_CHECKPOINT('"' << #test_name << "\" fixture ctor"); test_name t; BOOST_TEST_CHECKPOINT('"' << #test_name << "\" fixture setup"); boost::unit_test::setup_conditional(t); BOOST_TEST_CHECKPOINT('"' << #test_name << "\" test entry"); t.test_method(); BOOST_TEST_CHECKPOINT('"' << #test_name << "\" fixture teardown"); boost::unit_test::teardown_conditional(t); BOOST_TEST_CHECKPOINT('"' << #test_name << "\" fixture dtor"); } struct BOOST_AUTO_TC_UNIQUE_ID( test_name ) {}; BOOST_AUTO_TU_REGISTRAR( test_name )( boost::unit_test::make_test_case( &BOOST_AUTO_TC_INVOKER( test_name ), #test_name, __FILE__, __LINE__ ), decorators ); void test_name::test_method()
+# 170 "/usr/include/boost/test/unit_test_suite.hpp" 3 4
+#define BOOST_FIXTURE_TEST_CASE_NO_DECOR(test_name,F) BOOST_FIXTURE_TEST_CASE_WITH_DECOR( test_name, F, boost::unit_test::decorator::collector_t::instance() )
+
+
+
+
+
+
+#define BOOST_FIXTURE_TEST_CASE(...) BOOST_TEST_INVOKE_IF_N_ARGS( 2, BOOST_FIXTURE_TEST_CASE_NO_DECOR, BOOST_FIXTURE_TEST_CASE_WITH_DECOR, __VA_ARGS__)
+# 197 "/usr/include/boost/test/unit_test_suite.hpp" 3 4
+#define BOOST_AUTO_TEST_CASE_NO_DECOR(test_name) BOOST_FIXTURE_TEST_CASE_NO_DECOR( test_name, BOOST_AUTO_TEST_CASE_FIXTURE )
+
+
+
+
+#define BOOST_AUTO_TEST_CASE_WITH_DECOR(test_name,decorators) BOOST_FIXTURE_TEST_CASE_WITH_DECOR( test_name, BOOST_AUTO_TEST_CASE_FIXTURE, decorators )
+
+
+
+
+
+
+#define BOOST_AUTO_TEST_CASE(...) BOOST_TEST_INVOKE_IF_N_ARGS( 1, BOOST_AUTO_TEST_CASE_NO_DECOR, BOOST_AUTO_TEST_CASE_WITH_DECOR, __VA_ARGS__)
+# 229 "/usr/include/boost/test/unit_test_suite.hpp" 3 4
+#define BOOST_FIXTURE_TEST_CASE_TEMPLATE(test_name,type_name,TL,F) template<typename type_name> struct test_name : public F { void test_method(); }; struct BOOST_AUTO_TC_INVOKER( test_name ) { template<typename TestType> static void run( boost::type<TestType>* = 0 ) { BOOST_TEST_CHECKPOINT('"' << #test_name << "\" fixture ctor"); test_name<TestType> t; BOOST_TEST_CHECKPOINT('"' << #test_name << "\" fixture setup"); boost::unit_test::setup_conditional(t); BOOST_TEST_CHECKPOINT('"' << #test_name << "\" test entry"); t.test_method(); BOOST_TEST_CHECKPOINT('"' << #test_name << "\" fixture teardown"); boost::unit_test::teardown_conditional(t); BOOST_TEST_CHECKPOINT('"' << #test_name << "\" fixture dtor"); } }; BOOST_AUTO_TU_REGISTRAR( test_name )( boost::unit_test::ut_detail::template_test_case_gen< BOOST_AUTO_TC_INVOKER( test_name ),TL >( BOOST_STRINGIZE( test_name ), __FILE__, __LINE__ ), boost::unit_test::decorator::collector_t::instance() ); template<typename type_name> void test_name<type_name>::test_method()
+# 264 "/usr/include/boost/test/unit_test_suite.hpp" 3 4
+#define BOOST_AUTO_TEST_CASE_TEMPLATE(test_name,type_name,TL) BOOST_FIXTURE_TEST_CASE_TEMPLATE( test_name, type_name, TL, BOOST_AUTO_TEST_CASE_FIXTURE )
+# 273 "/usr/include/boost/test/unit_test_suite.hpp" 3 4
+#define BOOST_TEST_CASE_TEMPLATE(name,typelist) boost::unit_test::ut_detail::template_test_case_gen<name,typelist>( BOOST_TEST_STRINGIZE( name ), __FILE__, __LINE__ )
+# 282 "/usr/include/boost/test/unit_test_suite.hpp" 3 4
+#define BOOST_TEST_CASE_TEMPLATE_FUNCTION(name,type_name) template<typename type_name> void BOOST_JOIN( name, _impl )( boost::type<type_name>* ); struct name { template<typename TestType> static void run( boost::type<TestType>* frwrd = 0 ) { BOOST_JOIN( name, _impl )( frwrd ); } }; template<typename type_name> void BOOST_JOIN( name, _impl )( boost::type<type_name>* )
+# 302 "/usr/include/boost/test/unit_test_suite.hpp" 3 4
+#define BOOST_GLOBAL_FIXTURE(F) static boost::unit_test::ut_detail::global_configuration_impl<F> BOOST_JOIN( gf_, F )
+
+
+
+
+
+
+
+#define BOOST_TEST_GLOBAL_CONFIGURATION(F) static boost::unit_test::ut_detail::global_configuration_impl<F> BOOST_JOIN( gf_, F )
+
+
+
+
+
+
+
+#define BOOST_TEST_GLOBAL_FIXTURE(F) static boost::unit_test::ut_detail::global_fixture_impl<F> BOOST_JOIN( gf_, F )
+
+
+
+
+
+
+
+#define BOOST_TEST_DECORATOR(D) static boost::unit_test::decorator::collector_t const& BOOST_TEST_APPEND_UNIQUE_ID(decorator_collector) BOOST_ATTRIBUTE_UNUSED = D;
+# 335 "/usr/include/boost/test/unit_test_suite.hpp" 3 4
+namespace boost { namespace unit_test { namespace ut_detail {
+
+struct nil_t {};
+
+}
+}
+}
+
+
+typedef ::boost::unit_test::ut_detail::nil_t BOOST_AUTO_TEST_CASE_FIXTURE;
+
+
+
+
+
+
+
+#define BOOST_TEST_INTERNAL_HAS_COUNTER 
+
+
+
+#define BOOST_TEST_APPEND_UNIQUE_ID(name) BOOST_JOIN( BOOST_JOIN( name, __LINE__ ), __COUNTER__)
+# 366 "/usr/include/boost/test/unit_test_suite.hpp" 3 4
+#define BOOST_AUTO_TU_REGISTRAR(test_name) static boost::unit_test::ut_detail::auto_test_unit_registrar BOOST_TEST_APPEND_UNIQUE_ID( BOOST_JOIN( test_name, _registrar ) ) BOOST_ATTRIBUTE_UNUSED
+
+
+
+#define BOOST_AUTO_TC_INVOKER(test_name) BOOST_JOIN( test_name, _invoker )
+#define BOOST_AUTO_TC_UNIQUE_ID(test_name) BOOST_JOIN( test_name, _id )
+# 404 "/usr/include/boost/test/unit_test_suite.hpp" 3 4
+# 1 "/usr/include/boost/test/detail/enable_warnings.hpp" 1 3 4
+# 34 "/usr/include/boost/test/detail/enable_warnings.hpp" 3 4
+#pragma GCC diagnostic pop
+# 405 "/usr/include/boost/test/unit_test_suite.hpp" 2 3 4
+# 20 "/usr/include/boost/test/unit_test.hpp" 2 3 4
+# 43 "/usr/include/boost/test/unit_test.hpp" 3 4
+namespace boost { namespace unit_test {
+
+int __attribute__((__visibility__("default"))) unit_test_main( init_unit_test_func init_func, int argc, char* argv[] );
+
+}
+
+
+namespace unit_test_framework=unit_test;
+
+}
+# 39 "/usr/include/boost/test/included/unit_test.hpp" 2 3 4
+# 10 "FastMathTest.cpp" 2
+# 1 "/usr/include/c++/10.2.0/cmath" 1 3
+# 39 "/usr/include/c++/10.2.0/cmath" 3
+       
+# 40 "/usr/include/c++/10.2.0/cmath" 3
+
+
+
+
+#define _GLIBCXX_INCLUDE_NEXT_C_HEADERS 
+
+#undef _GLIBCXX_INCLUDE_NEXT_C_HEADERS
+# 11 "FastMathTest.cpp" 2
+
+
+# 12 "FastMathTest.cpp"
+using namespace boost::unit_test;
+
+test_suite* init_unit_test_suite(int argc, char* argv[])
+{
+  const char* name = "Fast math tester";
+  unit_test_log.set_threshold_level(log_messages);
+  framework::master_test_suite().p_name.value = name;
+  
+# 19 "FastMathTest.cpp" 3 4
+ (::boost::unit_test::unit_test_log << ::boost::unit_test::log::begin( ::boost::unit_test::const_string( "FastMathTest.cpp", sizeof( "FastMathTest.cpp" ) - 1 ), 19 ))(::boost::unit_test::log_messages) << (::boost::unit_test::lazy_ostream::instance() << 
+# 19 "FastMathTest.cpp"
+ ""
+# 19 "FastMathTest.cpp" 3 4
+ )
+# 19 "FastMathTest.cpp"
+                       ;
+  
+# 20 "FastMathTest.cpp" 3 4
+ (::boost::unit_test::unit_test_log << ::boost::unit_test::log::begin( ::boost::unit_test::const_string( "FastMathTest.cpp", sizeof( "FastMathTest.cpp" ) - 1 ), 20 ))(::boost::unit_test::log_messages) << (::boost::unit_test::lazy_ostream::instance() << 
+# 20 "FastMathTest.cpp"
+ name
+# 20 "FastMathTest.cpp" 3 4
+ )
+# 20 "FastMathTest.cpp"
+                         ;
+  
+# 21 "FastMathTest.cpp" 3 4
+ (::boost::unit_test::unit_test_log << ::boost::unit_test::log::begin( ::boost::unit_test::const_string( "FastMathTest.cpp", sizeof( "FastMathTest.cpp" ) - 1 ), 21 ))(::boost::unit_test::log_messages) << (::boost::unit_test::lazy_ostream::instance() << 
+# 21 "FastMathTest.cpp"
+ std::string(std::strlen(name), '=')
+# 21 "FastMathTest.cpp" 3 4
+ )
+# 21 "FastMathTest.cpp"
+                                                        ;
+  return 
+# 22 "FastMathTest.cpp" 3 4
+        __null
+# 22 "FastMathTest.cpp"
+            ;
+}
+
+
+# 25 "FastMathTest.cpp" 3 4
+struct 
+# 25 "FastMathTest.cpp"
+fmifloor 
+# 25 "FastMathTest.cpp" 3 4
+: public BOOST_AUTO_TEST_CASE_FIXTURE { void test_method(); }; static void 
+# 25 "FastMathTest.cpp"
+fmifloor_invoker
+# 25 "FastMathTest.cpp" 3 4
+() { ::boost::unit_test::unit_test_log.set_checkpoint( ::boost::unit_test::const_string( "FastMathTest.cpp", sizeof( "FastMathTest.cpp" ) - 1 ), static_cast<std::size_t>(25), (::boost::wrap_stringstream().ref() << '"' << 
+# 25 "FastMathTest.cpp"
+"fmifloor" 
+# 25 "FastMathTest.cpp" 3 4
+<< "\" fixture ctor").str() ); 
+# 25 "FastMathTest.cpp"
+fmifloor 
+# 25 "FastMathTest.cpp" 3 4
+t; ::boost::unit_test::unit_test_log.set_checkpoint( ::boost::unit_test::const_string( "FastMathTest.cpp", sizeof( "FastMathTest.cpp" ) - 1 ), static_cast<std::size_t>(25), (::boost::wrap_stringstream().ref() << '"' << 
+# 25 "FastMathTest.cpp"
+"fmifloor" 
+# 25 "FastMathTest.cpp" 3 4
+<< "\" fixture setup").str() ); boost::unit_test::setup_conditional(t); ::boost::unit_test::unit_test_log.set_checkpoint( ::boost::unit_test::const_string( "FastMathTest.cpp", sizeof( "FastMathTest.cpp" ) - 1 ), static_cast<std::size_t>(25), (::boost::wrap_stringstream().ref() << '"' << 
+# 25 "FastMathTest.cpp"
+"fmifloor" 
+# 25 "FastMathTest.cpp" 3 4
+<< "\" test entry").str() ); t.test_method(); ::boost::unit_test::unit_test_log.set_checkpoint( ::boost::unit_test::const_string( "FastMathTest.cpp", sizeof( "FastMathTest.cpp" ) - 1 ), static_cast<std::size_t>(25), (::boost::wrap_stringstream().ref() << '"' << 
+# 25 "FastMathTest.cpp"
+"fmifloor" 
+# 25 "FastMathTest.cpp" 3 4
+<< "\" fixture teardown").str() ); boost::unit_test::teardown_conditional(t); ::boost::unit_test::unit_test_log.set_checkpoint( ::boost::unit_test::const_string( "FastMathTest.cpp", sizeof( "FastMathTest.cpp" ) - 1 ), static_cast<std::size_t>(25), (::boost::wrap_stringstream().ref() << '"' << 
+# 25 "FastMathTest.cpp"
+"fmifloor" 
+# 25 "FastMathTest.cpp" 3 4
+<< "\" fixture dtor").str() ); } struct 
+# 25 "FastMathTest.cpp"
+fmifloor_id 
+# 25 "FastMathTest.cpp" 3 4
+{}; static boost::unit_test::ut_detail::auto_test_unit_registrar 
+# 25 "FastMathTest.cpp"
+fmifloor_registrar250 
+# 25 "FastMathTest.cpp" 3 4
+__attribute__((__unused__))( boost::unit_test::make_test_case( &
+# 25 "FastMathTest.cpp"
+fmifloor_invoker
+# 25 "FastMathTest.cpp" 3 4
+, 
+# 25 "FastMathTest.cpp"
+"fmifloor"
+# 25 "FastMathTest.cpp" 3 4
+, "FastMathTest.cpp", 25 ), boost::unit_test::decorator::collector_t::instance() ); void 
+# 25 "FastMathTest.cpp"
+fmifloor
+# 25 "FastMathTest.cpp" 3 4
+::test_method()
+
+# 26 "FastMathTest.cpp"
+{
+  
+# 27 "FastMathTest.cpp" 3 4
+ (::boost::unit_test::unit_test_log << ::boost::unit_test::log::begin( ::boost::unit_test::const_string( "FastMathTest.cpp", sizeof( "FastMathTest.cpp" ) - 1 ), 27 ))(::boost::unit_test::log_messages) << (::boost::unit_test::lazy_ostream::instance() << 
+# 27 "FastMathTest.cpp"
+ " + Fmi::floor()"
+# 27 "FastMathTest.cpp" 3 4
+ )
+# 27 "FastMathTest.cpp"
+                                      ;
+  
+# 28 "FastMathTest.cpp" 3 4
+ do { ::boost::unit_test::unit_test_log.set_checkpoint( ::boost::unit_test::const_string( "FastMathTest.cpp", sizeof( "FastMathTest.cpp" ) - 1 ), static_cast<std::size_t>(28) ); ::boost::test_tools::tt_detail:: check_frwd ( ::boost::test_tools::tt_detail::equal_impl_frwd(), (::boost::unit_test::lazy_ostream::instance() << ""), ::boost::unit_test::const_string( "FastMathTest.cpp", sizeof( "FastMathTest.cpp" ) - 1 ), static_cast<std::size_t>(28), ::boost::test_tools::tt_detail::CHECK, ::boost::test_tools::tt_detail::CHECK_EQUAL , 
+# 28 "FastMathTest.cpp"
+ std::floor(0.1)
+# 28 "FastMathTest.cpp" 3 4
+ , 
+# 28 "FastMathTest.cpp"
+ "std::floor(0.1)" 
+# 28 "FastMathTest.cpp" 3 4
+ , 
+# 28 "FastMathTest.cpp"
+ Fmi::floor(0.1)
+# 28 "FastMathTest.cpp" 3 4
+ , 
+# 28 "FastMathTest.cpp"
+ "Fmi::floor(0.1)" 
+# 28 "FastMathTest.cpp" 3 4
+ ); } while( ::boost::test_tools::tt_detail::dummy_cond() )
+# 28 "FastMathTest.cpp"
+                                                    ;
+  
+# 29 "FastMathTest.cpp" 3 4
+ do { ::boost::unit_test::unit_test_log.set_checkpoint( ::boost::unit_test::const_string( "FastMathTest.cpp", sizeof( "FastMathTest.cpp" ) - 1 ), static_cast<std::size_t>(29) ); ::boost::test_tools::tt_detail:: check_frwd ( ::boost::test_tools::tt_detail::equal_impl_frwd(), (::boost::unit_test::lazy_ostream::instance() << ""), ::boost::unit_test::const_string( "FastMathTest.cpp", sizeof( "FastMathTest.cpp" ) - 1 ), static_cast<std::size_t>(29), ::boost::test_tools::tt_detail::CHECK, ::boost::test_tools::tt_detail::CHECK_EQUAL , 
+# 29 "FastMathTest.cpp"
+ std::floor(0.5)
+# 29 "FastMathTest.cpp" 3 4
+ , 
+# 29 "FastMathTest.cpp"
+ "std::floor(0.5)" 
+# 29 "FastMathTest.cpp" 3 4
+ , 
+# 29 "FastMathTest.cpp"
+ Fmi::floor(0.5)
+# 29 "FastMathTest.cpp" 3 4
+ , 
+# 29 "FastMathTest.cpp"
+ "Fmi::floor(0.5)" 
+# 29 "FastMathTest.cpp" 3 4
+ ); } while( ::boost::test_tools::tt_detail::dummy_cond() )
+# 29 "FastMathTest.cpp"
+                                                    ;
+  
+# 30 "FastMathTest.cpp" 3 4
+ do { ::boost::unit_test::unit_test_log.set_checkpoint( ::boost::unit_test::const_string( "FastMathTest.cpp", sizeof( "FastMathTest.cpp" ) - 1 ), static_cast<std::size_t>(30) ); ::boost::test_tools::tt_detail:: check_frwd ( ::boost::test_tools::tt_detail::equal_impl_frwd(), (::boost::unit_test::lazy_ostream::instance() << ""), ::boost::unit_test::const_string( "FastMathTest.cpp", sizeof( "FastMathTest.cpp" ) - 1 ), static_cast<std::size_t>(30), ::boost::test_tools::tt_detail::CHECK, ::boost::test_tools::tt_detail::CHECK_EQUAL , 
+# 30 "FastMathTest.cpp"
+ std::floor(1.5)
+# 30 "FastMathTest.cpp" 3 4
+ , 
+# 30 "FastMathTest.cpp"
+ "std::floor(1.5)" 
+# 30 "FastMathTest.cpp" 3 4
+ , 
+# 30 "FastMathTest.cpp"
+ Fmi::floor(1.5)
+# 30 "FastMathTest.cpp" 3 4
+ , 
+# 30 "FastMathTest.cpp"
+ "Fmi::floor(1.5)" 
+# 30 "FastMathTest.cpp" 3 4
+ ); } while( ::boost::test_tools::tt_detail::dummy_cond() )
+# 30 "FastMathTest.cpp"
+                                                    ;
+  
+# 31 "FastMathTest.cpp" 3 4
+ do { ::boost::unit_test::unit_test_log.set_checkpoint( ::boost::unit_test::const_string( "FastMathTest.cpp", sizeof( "FastMathTest.cpp" ) - 1 ), static_cast<std::size_t>(31) ); ::boost::test_tools::tt_detail:: check_frwd ( ::boost::test_tools::tt_detail::equal_impl_frwd(), (::boost::unit_test::lazy_ostream::instance() << ""), ::boost::unit_test::const_string( "FastMathTest.cpp", sizeof( "FastMathTest.cpp" ) - 1 ), static_cast<std::size_t>(31), ::boost::test_tools::tt_detail::CHECK, ::boost::test_tools::tt_detail::CHECK_EQUAL , 
+# 31 "FastMathTest.cpp"
+ std::floor(-0.1)
+# 31 "FastMathTest.cpp" 3 4
+ , 
+# 31 "FastMathTest.cpp"
+ "std::floor(-0.1)" 
+# 31 "FastMathTest.cpp" 3 4
+ , 
+# 31 "FastMathTest.cpp"
+ Fmi::floor(-0.1)
+# 31 "FastMathTest.cpp" 3 4
+ , 
+# 31 "FastMathTest.cpp"
+ "Fmi::floor(-0.1)" 
+# 31 "FastMathTest.cpp" 3 4
+ ); } while( ::boost::test_tools::tt_detail::dummy_cond() )
+# 31 "FastMathTest.cpp"
+                                                      ;
+  
+# 32 "FastMathTest.cpp" 3 4
+ do { ::boost::unit_test::unit_test_log.set_checkpoint( ::boost::unit_test::const_string( "FastMathTest.cpp", sizeof( "FastMathTest.cpp" ) - 1 ), static_cast<std::size_t>(32) ); ::boost::test_tools::tt_detail:: check_frwd ( ::boost::test_tools::tt_detail::equal_impl_frwd(), (::boost::unit_test::lazy_ostream::instance() << ""), ::boost::unit_test::const_string( "FastMathTest.cpp", sizeof( "FastMathTest.cpp" ) - 1 ), static_cast<std::size_t>(32), ::boost::test_tools::tt_detail::CHECK, ::boost::test_tools::tt_detail::CHECK_EQUAL , 
+# 32 "FastMathTest.cpp"
+ std::floor(-0.5)
+# 32 "FastMathTest.cpp" 3 4
+ , 
+# 32 "FastMathTest.cpp"
+ "std::floor(-0.5)" 
+# 32 "FastMathTest.cpp" 3 4
+ , 
+# 32 "FastMathTest.cpp"
+ Fmi::floor(-0.5)
+# 32 "FastMathTest.cpp" 3 4
+ , 
+# 32 "FastMathTest.cpp"
+ "Fmi::floor(-0.5)" 
+# 32 "FastMathTest.cpp" 3 4
+ ); } while( ::boost::test_tools::tt_detail::dummy_cond() )
+# 32 "FastMathTest.cpp"
+                                                      ;
+  
+# 33 "FastMathTest.cpp" 3 4
+ do { ::boost::unit_test::unit_test_log.set_checkpoint( ::boost::unit_test::const_string( "FastMathTest.cpp", sizeof( "FastMathTest.cpp" ) - 1 ), static_cast<std::size_t>(33) ); ::boost::test_tools::tt_detail:: check_frwd ( ::boost::test_tools::tt_detail::equal_impl_frwd(), (::boost::unit_test::lazy_ostream::instance() << ""), ::boost::unit_test::const_string( "FastMathTest.cpp", sizeof( "FastMathTest.cpp" ) - 1 ), static_cast<std::size_t>(33), ::boost::test_tools::tt_detail::CHECK, ::boost::test_tools::tt_detail::CHECK_EQUAL , 
+# 33 "FastMathTest.cpp"
+ std::floor(-1.5)
+# 33 "FastMathTest.cpp" 3 4
+ , 
+# 33 "FastMathTest.cpp"
+ "std::floor(-1.5)" 
+# 33 "FastMathTest.cpp" 3 4
+ , 
+# 33 "FastMathTest.cpp"
+ Fmi::floor(-1.5)
+# 33 "FastMathTest.cpp" 3 4
+ , 
+# 33 "FastMathTest.cpp"
+ "Fmi::floor(-1.5)" 
+# 33 "FastMathTest.cpp" 3 4
+ ); } while( ::boost::test_tools::tt_detail::dummy_cond() )
+# 33 "FastMathTest.cpp"
+                                                      ;
+}
+
+
+# 36 "FastMathTest.cpp" 3 4
+struct 
+# 36 "FastMathTest.cpp"
+fmiceil 
+# 36 "FastMathTest.cpp" 3 4
+: public BOOST_AUTO_TEST_CASE_FIXTURE { void test_method(); }; static void 
+# 36 "FastMathTest.cpp"
+fmiceil_invoker
+# 36 "FastMathTest.cpp" 3 4
+() { ::boost::unit_test::unit_test_log.set_checkpoint( ::boost::unit_test::const_string( "FastMathTest.cpp", sizeof( "FastMathTest.cpp" ) - 1 ), static_cast<std::size_t>(36), (::boost::wrap_stringstream().ref() << '"' << 
+# 36 "FastMathTest.cpp"
+"fmiceil" 
+# 36 "FastMathTest.cpp" 3 4
+<< "\" fixture ctor").str() ); 
+# 36 "FastMathTest.cpp"
+fmiceil 
+# 36 "FastMathTest.cpp" 3 4
+t; ::boost::unit_test::unit_test_log.set_checkpoint( ::boost::unit_test::const_string( "FastMathTest.cpp", sizeof( "FastMathTest.cpp" ) - 1 ), static_cast<std::size_t>(36), (::boost::wrap_stringstream().ref() << '"' << 
+# 36 "FastMathTest.cpp"
+"fmiceil" 
+# 36 "FastMathTest.cpp" 3 4
+<< "\" fixture setup").str() ); boost::unit_test::setup_conditional(t); ::boost::unit_test::unit_test_log.set_checkpoint( ::boost::unit_test::const_string( "FastMathTest.cpp", sizeof( "FastMathTest.cpp" ) - 1 ), static_cast<std::size_t>(36), (::boost::wrap_stringstream().ref() << '"' << 
+# 36 "FastMathTest.cpp"
+"fmiceil" 
+# 36 "FastMathTest.cpp" 3 4
+<< "\" test entry").str() ); t.test_method(); ::boost::unit_test::unit_test_log.set_checkpoint( ::boost::unit_test::const_string( "FastMathTest.cpp", sizeof( "FastMathTest.cpp" ) - 1 ), static_cast<std::size_t>(36), (::boost::wrap_stringstream().ref() << '"' << 
+# 36 "FastMathTest.cpp"
+"fmiceil" 
+# 36 "FastMathTest.cpp" 3 4
+<< "\" fixture teardown").str() ); boost::unit_test::teardown_conditional(t); ::boost::unit_test::unit_test_log.set_checkpoint( ::boost::unit_test::const_string( "FastMathTest.cpp", sizeof( "FastMathTest.cpp" ) - 1 ), static_cast<std::size_t>(36), (::boost::wrap_stringstream().ref() << '"' << 
+# 36 "FastMathTest.cpp"
+"fmiceil" 
+# 36 "FastMathTest.cpp" 3 4
+<< "\" fixture dtor").str() ); } struct 
+# 36 "FastMathTest.cpp"
+fmiceil_id 
+# 36 "FastMathTest.cpp" 3 4
+{}; static boost::unit_test::ut_detail::auto_test_unit_registrar 
+# 36 "FastMathTest.cpp"
+fmiceil_registrar361 
+# 36 "FastMathTest.cpp" 3 4
+__attribute__((__unused__))( boost::unit_test::make_test_case( &
+# 36 "FastMathTest.cpp"
+fmiceil_invoker
+# 36 "FastMathTest.cpp" 3 4
+, 
+# 36 "FastMathTest.cpp"
+"fmiceil"
+# 36 "FastMathTest.cpp" 3 4
+, "FastMathTest.cpp", 36 ), boost::unit_test::decorator::collector_t::instance() ); void 
+# 36 "FastMathTest.cpp"
+fmiceil
+# 36 "FastMathTest.cpp" 3 4
+::test_method()
+
+# 37 "FastMathTest.cpp"
+{
+  
+# 38 "FastMathTest.cpp" 3 4
+ (::boost::unit_test::unit_test_log << ::boost::unit_test::log::begin( ::boost::unit_test::const_string( "FastMathTest.cpp", sizeof( "FastMathTest.cpp" ) - 1 ), 38 ))(::boost::unit_test::log_messages) << (::boost::unit_test::lazy_ostream::instance() << 
+# 38 "FastMathTest.cpp"
+ " + Fmi::ceil()"
+# 38 "FastMathTest.cpp" 3 4
+ )
+# 38 "FastMathTest.cpp"
+                                     ;
+  
+# 39 "FastMathTest.cpp" 3 4
+ do { ::boost::unit_test::unit_test_log.set_checkpoint( ::boost::unit_test::const_string( "FastMathTest.cpp", sizeof( "FastMathTest.cpp" ) - 1 ), static_cast<std::size_t>(39) ); ::boost::test_tools::tt_detail:: check_frwd ( ::boost::test_tools::tt_detail::equal_impl_frwd(), (::boost::unit_test::lazy_ostream::instance() << ""), ::boost::unit_test::const_string( "FastMathTest.cpp", sizeof( "FastMathTest.cpp" ) - 1 ), static_cast<std::size_t>(39), ::boost::test_tools::tt_detail::CHECK, ::boost::test_tools::tt_detail::CHECK_EQUAL , 
+# 39 "FastMathTest.cpp"
+ std::ceil(0.1)
+# 39 "FastMathTest.cpp" 3 4
+ , 
+# 39 "FastMathTest.cpp"
+ "std::ceil(0.1)" 
+# 39 "FastMathTest.cpp" 3 4
+ , 
+# 39 "FastMathTest.cpp"
+ Fmi::ceil(0.1)
+# 39 "FastMathTest.cpp" 3 4
+ , 
+# 39 "FastMathTest.cpp"
+ "Fmi::ceil(0.1)" 
+# 39 "FastMathTest.cpp" 3 4
+ ); } while( ::boost::test_tools::tt_detail::dummy_cond() )
+# 39 "FastMathTest.cpp"
+                                                  ;
+  
+# 40 "FastMathTest.cpp" 3 4
+ do { ::boost::unit_test::unit_test_log.set_checkpoint( ::boost::unit_test::const_string( "FastMathTest.cpp", sizeof( "FastMathTest.cpp" ) - 1 ), static_cast<std::size_t>(40) ); ::boost::test_tools::tt_detail:: check_frwd ( ::boost::test_tools::tt_detail::equal_impl_frwd(), (::boost::unit_test::lazy_ostream::instance() << ""), ::boost::unit_test::const_string( "FastMathTest.cpp", sizeof( "FastMathTest.cpp" ) - 1 ), static_cast<std::size_t>(40), ::boost::test_tools::tt_detail::CHECK, ::boost::test_tools::tt_detail::CHECK_EQUAL , 
+# 40 "FastMathTest.cpp"
+ std::ceil(0.5)
+# 40 "FastMathTest.cpp" 3 4
+ , 
+# 40 "FastMathTest.cpp"
+ "std::ceil(0.5)" 
+# 40 "FastMathTest.cpp" 3 4
+ , 
+# 40 "FastMathTest.cpp"
+ Fmi::ceil(0.5)
+# 40 "FastMathTest.cpp" 3 4
+ , 
+# 40 "FastMathTest.cpp"
+ "Fmi::ceil(0.5)" 
+# 40 "FastMathTest.cpp" 3 4
+ ); } while( ::boost::test_tools::tt_detail::dummy_cond() )
+# 40 "FastMathTest.cpp"
+                                                  ;
+  
+# 41 "FastMathTest.cpp" 3 4
+ do { ::boost::unit_test::unit_test_log.set_checkpoint( ::boost::unit_test::const_string( "FastMathTest.cpp", sizeof( "FastMathTest.cpp" ) - 1 ), static_cast<std::size_t>(41) ); ::boost::test_tools::tt_detail:: check_frwd ( ::boost::test_tools::tt_detail::equal_impl_frwd(), (::boost::unit_test::lazy_ostream::instance() << ""), ::boost::unit_test::const_string( "FastMathTest.cpp", sizeof( "FastMathTest.cpp" ) - 1 ), static_cast<std::size_t>(41), ::boost::test_tools::tt_detail::CHECK, ::boost::test_tools::tt_detail::CHECK_EQUAL , 
+# 41 "FastMathTest.cpp"
+ std::ceil(1.5)
+# 41 "FastMathTest.cpp" 3 4
+ , 
+# 41 "FastMathTest.cpp"
+ "std::ceil(1.5)" 
+# 41 "FastMathTest.cpp" 3 4
+ , 
+# 41 "FastMathTest.cpp"
+ Fmi::ceil(1.5)
+# 41 "FastMathTest.cpp" 3 4
+ , 
+# 41 "FastMathTest.cpp"
+ "Fmi::ceil(1.5)" 
+# 41 "FastMathTest.cpp" 3 4
+ ); } while( ::boost::test_tools::tt_detail::dummy_cond() )
+# 41 "FastMathTest.cpp"
+                                                  ;
+  
+# 42 "FastMathTest.cpp" 3 4
+ do { ::boost::unit_test::unit_test_log.set_checkpoint( ::boost::unit_test::const_string( "FastMathTest.cpp", sizeof( "FastMathTest.cpp" ) - 1 ), static_cast<std::size_t>(42) ); ::boost::test_tools::tt_detail:: check_frwd ( ::boost::test_tools::tt_detail::equal_impl_frwd(), (::boost::unit_test::lazy_ostream::instance() << ""), ::boost::unit_test::const_string( "FastMathTest.cpp", sizeof( "FastMathTest.cpp" ) - 1 ), static_cast<std::size_t>(42), ::boost::test_tools::tt_detail::CHECK, ::boost::test_tools::tt_detail::CHECK_EQUAL , 
+# 42 "FastMathTest.cpp"
+ std::ceil(-0.1)
+# 42 "FastMathTest.cpp" 3 4
+ , 
+# 42 "FastMathTest.cpp"
+ "std::ceil(-0.1)" 
+# 42 "FastMathTest.cpp" 3 4
+ , 
+# 42 "FastMathTest.cpp"
+ Fmi::ceil(-0.1)
+# 42 "FastMathTest.cpp" 3 4
+ , 
+# 42 "FastMathTest.cpp"
+ "Fmi::ceil(-0.1)" 
+# 42 "FastMathTest.cpp" 3 4
+ ); } while( ::boost::test_tools::tt_detail::dummy_cond() )
+# 42 "FastMathTest.cpp"
+                                                    ;
+  
+# 43 "FastMathTest.cpp" 3 4
+ do { ::boost::unit_test::unit_test_log.set_checkpoint( ::boost::unit_test::const_string( "FastMathTest.cpp", sizeof( "FastMathTest.cpp" ) - 1 ), static_cast<std::size_t>(43) ); ::boost::test_tools::tt_detail:: check_frwd ( ::boost::test_tools::tt_detail::equal_impl_frwd(), (::boost::unit_test::lazy_ostream::instance() << ""), ::boost::unit_test::const_string( "FastMathTest.cpp", sizeof( "FastMathTest.cpp" ) - 1 ), static_cast<std::size_t>(43), ::boost::test_tools::tt_detail::CHECK, ::boost::test_tools::tt_detail::CHECK_EQUAL , 
+# 43 "FastMathTest.cpp"
+ std::ceil(-0.5)
+# 43 "FastMathTest.cpp" 3 4
+ , 
+# 43 "FastMathTest.cpp"
+ "std::ceil(-0.5)" 
+# 43 "FastMathTest.cpp" 3 4
+ , 
+# 43 "FastMathTest.cpp"
+ Fmi::ceil(-0.5)
+# 43 "FastMathTest.cpp" 3 4
+ , 
+# 43 "FastMathTest.cpp"
+ "Fmi::ceil(-0.5)" 
+# 43 "FastMathTest.cpp" 3 4
+ ); } while( ::boost::test_tools::tt_detail::dummy_cond() )
+# 43 "FastMathTest.cpp"
+                                                    ;
+  
+# 44 "FastMathTest.cpp" 3 4
+ do { ::boost::unit_test::unit_test_log.set_checkpoint( ::boost::unit_test::const_string( "FastMathTest.cpp", sizeof( "FastMathTest.cpp" ) - 1 ), static_cast<std::size_t>(44) ); ::boost::test_tools::tt_detail:: check_frwd ( ::boost::test_tools::tt_detail::equal_impl_frwd(), (::boost::unit_test::lazy_ostream::instance() << ""), ::boost::unit_test::const_string( "FastMathTest.cpp", sizeof( "FastMathTest.cpp" ) - 1 ), static_cast<std::size_t>(44), ::boost::test_tools::tt_detail::CHECK, ::boost::test_tools::tt_detail::CHECK_EQUAL , 
+# 44 "FastMathTest.cpp"
+ std::ceil(-1.5)
+# 44 "FastMathTest.cpp" 3 4
+ , 
+# 44 "FastMathTest.cpp"
+ "std::ceil(-1.5)" 
+# 44 "FastMathTest.cpp" 3 4
+ , 
+# 44 "FastMathTest.cpp"
+ Fmi::ceil(-1.5)
+# 44 "FastMathTest.cpp" 3 4
+ , 
+# 44 "FastMathTest.cpp"
+ "Fmi::ceil(-1.5)" 
+# 44 "FastMathTest.cpp" 3 4
+ ); } while( ::boost::test_tools::tt_detail::dummy_cond() )
+# 44 "FastMathTest.cpp"
+                                                    ;
+}
-- 
2.26.2

