diff --git "a/cpp-compiled/sources/double-conversion/bignum.cc.ii" "b/cpp-compiled/sources/double-conversion/bignum.cc.ii" new file mode 100644--- /dev/null +++ "b/cpp-compiled/sources/double-conversion/bignum.cc.ii" @@ -0,0 +1,20005 @@ +# 0 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" +# 1 "/tmp/tmpl_i20ey9/double-conversion/build//" +# 0 "" +# 0 "" +# 1 "/usr/include/stdc-predef.h" 1 3 4 +# 0 "" 2 +# 1 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" +# 28 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" +# 1 "/usr/include/c++/13/algorithm" 1 3 +# 58 "/usr/include/c++/13/algorithm" 3 + +# 59 "/usr/include/c++/13/algorithm" 3 + +# 1 "/usr/include/c++/13/bits/stl_algobase.h" 1 3 +# 59 "/usr/include/c++/13/bits/stl_algobase.h" 3 +# 1 "/usr/include/aarch64-linux-gnu/c++/13/bits/c++config.h" 1 3 +# 306 "/usr/include/aarch64-linux-gnu/c++/13/bits/c++config.h" 3 + +# 306 "/usr/include/aarch64-linux-gnu/c++/13/bits/c++config.h" 3 +namespace std +{ + typedef long unsigned int size_t; + typedef long int ptrdiff_t; + + + typedef decltype(nullptr) nullptr_t; + + +#pragma GCC visibility push(default) + + + extern "C++" __attribute__ ((__noreturn__, __always_inline__)) + inline void __terminate() noexcept + { + void terminate() noexcept __attribute__ ((__noreturn__)); + terminate(); + } +#pragma GCC visibility pop +} +# 339 "/usr/include/aarch64-linux-gnu/c++/13/bits/c++config.h" 3 +namespace std +{ + inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { } +} +namespace __gnu_cxx +{ + inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { } +} +# 532 "/usr/include/aarch64-linux-gnu/c++/13/bits/c++config.h" 3 +namespace std +{ +#pragma GCC visibility push(default) + + + + + constexpr inline bool + __is_constant_evaluated() noexcept + { + + + + + + return __builtin_is_constant_evaluated(); + + + + } +#pragma GCC visibility pop +} +# 679 "/usr/include/aarch64-linux-gnu/c++/13/bits/c++config.h" 3 +# 1 "/usr/include/aarch64-linux-gnu/c++/13/bits/os_defines.h" 1 3 +# 39 "/usr/include/aarch64-linux-gnu/c++/13/bits/os_defines.h" 3 +# 1 "/usr/include/features.h" 1 3 4 +# 394 "/usr/include/features.h" 3 4 +# 1 "/usr/include/features-time64.h" 1 3 4 +# 20 "/usr/include/features-time64.h" 3 4 +# 1 "/usr/include/aarch64-linux-gnu/bits/wordsize.h" 1 3 4 +# 21 "/usr/include/features-time64.h" 2 3 4 +# 1 "/usr/include/aarch64-linux-gnu/bits/timesize.h" 1 3 4 +# 22 "/usr/include/features-time64.h" 2 3 4 +# 395 "/usr/include/features.h" 2 3 4 +# 502 "/usr/include/features.h" 3 4 +# 1 "/usr/include/aarch64-linux-gnu/sys/cdefs.h" 1 3 4 +# 576 "/usr/include/aarch64-linux-gnu/sys/cdefs.h" 3 4 +# 1 "/usr/include/aarch64-linux-gnu/bits/wordsize.h" 1 3 4 +# 577 "/usr/include/aarch64-linux-gnu/sys/cdefs.h" 2 3 4 +# 1 "/usr/include/aarch64-linux-gnu/bits/long-double.h" 1 3 4 +# 578 "/usr/include/aarch64-linux-gnu/sys/cdefs.h" 2 3 4 +# 503 "/usr/include/features.h" 2 3 4 +# 526 "/usr/include/features.h" 3 4 +# 1 "/usr/include/aarch64-linux-gnu/gnu/stubs.h" 1 3 4 + + + + +# 1 "/usr/include/aarch64-linux-gnu/bits/wordsize.h" 1 3 4 +# 6 "/usr/include/aarch64-linux-gnu/gnu/stubs.h" 2 3 4 + + +# 1 "/usr/include/aarch64-linux-gnu/gnu/stubs-lp64.h" 1 3 4 +# 9 "/usr/include/aarch64-linux-gnu/gnu/stubs.h" 2 3 4 +# 527 "/usr/include/features.h" 2 3 4 +# 40 "/usr/include/aarch64-linux-gnu/c++/13/bits/os_defines.h" 2 3 +# 680 "/usr/include/aarch64-linux-gnu/c++/13/bits/c++config.h" 2 3 + + +# 1 "/usr/include/aarch64-linux-gnu/c++/13/bits/cpu_defines.h" 1 3 +# 683 "/usr/include/aarch64-linux-gnu/c++/13/bits/c++config.h" 2 3 +# 882 "/usr/include/aarch64-linux-gnu/c++/13/bits/c++config.h" 3 +# 1 "/usr/include/c++/13/pstl/pstl_config.h" 1 3 +# 883 "/usr/include/aarch64-linux-gnu/c++/13/bits/c++config.h" 2 3 +# 60 "/usr/include/c++/13/bits/stl_algobase.h" 2 3 +# 1 "/usr/include/c++/13/bits/functexcept.h" 1 3 +# 40 "/usr/include/c++/13/bits/functexcept.h" 3 +# 1 "/usr/include/c++/13/bits/exception_defines.h" 1 3 +# 41 "/usr/include/c++/13/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_array_new_length(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__)); +# 140 "/usr/include/c++/13/bits/functexcept.h" 3 + +} +# 61 "/usr/include/c++/13/bits/stl_algobase.h" 2 3 +# 1 "/usr/include/c++/13/bits/cpp_type_traits.h" 1 3 +# 35 "/usr/include/c++/13/bits/cpp_type_traits.h" 3 + +# 36 "/usr/include/c++/13/bits/cpp_type_traits.h" 3 +# 67 "/usr/include/c++/13/bits/cpp_type_traits.h" 3 +extern "C++" { + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + struct __true_type { }; + struct __false_type { }; + + template + struct __truth_type + { typedef __false_type __type; }; + + template<> + struct __truth_type + { typedef __true_type __type; }; + + + + template + struct __traitor + { + enum { __value = bool(_Sp::__value) || bool(_Tp::__value) }; + typedef typename __truth_type<__value>::__type __type; + }; + + + template + struct __are_same + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template + struct __are_same<_Tp, _Tp> + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template + struct __is_void + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template<> + struct __is_void + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + + + template + struct __is_integer + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + + + + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; +# 184 "/usr/include/c++/13/bits/cpp_type_traits.h" 3 + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; +# 272 "/usr/include/c++/13/bits/cpp_type_traits.h" 3 +__extension__ template<> struct __is_integer<__int128> { enum { __value = 1 }; typedef __true_type __type; }; __extension__ template<> struct __is_integer { enum { __value = 1 }; typedef __true_type __type; }; +# 289 "/usr/include/c++/13/bits/cpp_type_traits.h" 3 + template + struct __is_floating + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + + template<> + struct __is_floating + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_floating + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_floating + { + enum { __value = 1 }; + typedef __true_type __type; + }; +# 366 "/usr/include/c++/13/bits/cpp_type_traits.h" 3 + template + struct __is_pointer + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template + struct __is_pointer<_Tp*> + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + + + template + struct __is_arithmetic + : public __traitor<__is_integer<_Tp>, __is_floating<_Tp> > + { }; + + + + + template + struct __is_scalar + : public __traitor<__is_arithmetic<_Tp>, __is_pointer<_Tp> > + { }; + + + + + template + struct __is_char + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template<> + struct __is_char + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template<> + struct __is_char + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template + struct __is_byte + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template<> + struct __is_byte + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_byte + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_byte + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + enum class byte : unsigned char; + + template<> + struct __is_byte + { + enum { __value = 1 }; + typedef __true_type __type; + }; +# 470 "/usr/include/c++/13/bits/cpp_type_traits.h" 3 + template struct iterator_traits; + + + template + struct __is_nonvolatile_trivially_copyable + { + enum { __value = __is_trivially_copyable(_Tp) }; + }; + + + + + template + struct __is_nonvolatile_trivially_copyable + { + enum { __value = 0 }; + }; + + + template + struct __memcpyable + { + enum { __value = 0 }; + }; + + template + struct __memcpyable<_Tp*, _Tp*> + : __is_nonvolatile_trivially_copyable<_Tp> + { }; + + template + struct __memcpyable<_Tp*, const _Tp*> + : __is_nonvolatile_trivially_copyable<_Tp> + { }; + + + + + + + template + struct __memcmpable + { + enum { __value = 0 }; + }; + + + template + struct __memcmpable<_Tp*, _Tp*> + : __is_nonvolatile_trivially_copyable<_Tp> + { }; + + template + struct __memcmpable + : __is_nonvolatile_trivially_copyable<_Tp> + { }; + + template + struct __memcmpable<_Tp*, const _Tp*> + : __is_nonvolatile_trivially_copyable<_Tp> + { }; + + + + + + + + template::__value + + > + struct __is_memcmp_ordered + { + static const bool __value = _Tp(-1) > _Tp(1); + }; + + template + struct __is_memcmp_ordered<_Tp, false> + { + static const bool __value = false; + }; + + + template + struct __is_memcmp_ordered_with + { + static const bool __value = __is_memcmp_ordered<_Tp>::__value + && __is_memcmp_ordered<_Up>::__value; + }; + + template + struct __is_memcmp_ordered_with<_Tp, _Up, false> + { + static const bool __value = false; + }; +# 579 "/usr/include/c++/13/bits/cpp_type_traits.h" 3 + template<> + struct __is_memcmp_ordered_with + { static constexpr bool __value = true; }; + + template + struct __is_memcmp_ordered_with<_Tp, std::byte, _SameSize> + { static constexpr bool __value = false; }; + + template + struct __is_memcmp_ordered_with + { static constexpr bool __value = false; }; + + + + + + template + struct __is_move_iterator + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + + + template + + inline _Iterator + __miter_base(_Iterator __it) + { return __it; } + + +} +} +# 62 "/usr/include/c++/13/bits/stl_algobase.h" 2 3 +# 1 "/usr/include/c++/13/ext/type_traits.h" 1 3 +# 32 "/usr/include/c++/13/ext/type_traits.h" 3 + +# 33 "/usr/include/c++/13/ext/type_traits.h" 3 + + + + +extern "C++" { + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + + + + template + struct __enable_if + { }; + + template + struct __enable_if + { typedef _Tp __type; }; + + + + template + struct __conditional_type + { typedef _Iftrue __type; }; + + template + struct __conditional_type + { typedef _Iffalse __type; }; + + + + template + struct __add_unsigned + { + private: + typedef __enable_if::__value, _Tp> __if_type; + + public: + typedef typename __if_type::__type __type; + }; + + template<> + struct __add_unsigned + { typedef unsigned char __type; }; + + template<> + struct __add_unsigned + { typedef unsigned char __type; }; + + template<> + struct __add_unsigned + { typedef unsigned short __type; }; + + template<> + struct __add_unsigned + { typedef unsigned int __type; }; + + template<> + struct __add_unsigned + { typedef unsigned long __type; }; + + template<> + struct __add_unsigned + { typedef unsigned long long __type; }; + + + template<> + struct __add_unsigned; + + template<> + struct __add_unsigned; + + + + template + struct __remove_unsigned + { + private: + typedef __enable_if::__value, _Tp> __if_type; + + public: + typedef typename __if_type::__type __type; + }; + + template<> + struct __remove_unsigned + { typedef signed char __type; }; + + template<> + struct __remove_unsigned + { typedef signed char __type; }; + + template<> + struct __remove_unsigned + { typedef short __type; }; + + template<> + struct __remove_unsigned + { typedef int __type; }; + + template<> + struct __remove_unsigned + { typedef long __type; }; + + template<> + struct __remove_unsigned + { typedef long long __type; }; + + + template<> + struct __remove_unsigned; + + template<> + struct __remove_unsigned; + + + + template + constexpr + inline bool + __is_null_pointer(_Type* __ptr) + { return __ptr == 0; } + + template + constexpr + inline bool + __is_null_pointer(_Type) + { return false; } + + + constexpr bool + __is_null_pointer(std::nullptr_t) + { return true; } + + + + + template::__value> + struct __promote + { typedef double __type; }; + + + + + template + struct __promote<_Tp, false> + { }; + + template<> + struct __promote + { typedef long double __type; }; + + template<> + struct __promote + { typedef double __type; }; + + template<> + struct __promote + { typedef float __type; }; +# 225 "/usr/include/c++/13/ext/type_traits.h" 3 + template + using __promoted_t = decltype((typename __promote<_Tp>::__type(0) + ...)); + + + + template + using __promote_2 = __promote<__promoted_t<_Tp, _Up>>; + + template + using __promote_3 = __promote<__promoted_t<_Tp, _Up, _Vp>>; + + template + using __promote_4 = __promote<__promoted_t<_Tp, _Up, _Vp, _Wp>>; +# 269 "/usr/include/c++/13/ext/type_traits.h" 3 + +} +} +# 63 "/usr/include/c++/13/bits/stl_algobase.h" 2 3 +# 1 "/usr/include/c++/13/ext/numeric_traits.h" 1 3 +# 32 "/usr/include/c++/13/ext/numeric_traits.h" 3 + +# 33 "/usr/include/c++/13/ext/numeric_traits.h" 3 + + + + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + +# 50 "/usr/include/c++/13/ext/numeric_traits.h" 3 + template + struct __is_integer_nonstrict + : public std::__is_integer<_Tp> + { + using std::__is_integer<_Tp>::__value; + + + enum { __width = __value ? sizeof(_Tp) * 8 : 0 }; + }; + + template + struct __numeric_traits_integer + { + + static_assert(__is_integer_nonstrict<_Value>::__value, + "invalid specialization"); + + + + + static const bool __is_signed = (_Value)(-1) < 0; + static const int __digits + = __is_integer_nonstrict<_Value>::__width - __is_signed; + + + static const _Value __max = __is_signed + ? (((((_Value)1 << (__digits - 1)) - 1) << 1) + 1) + : ~(_Value)0; + static const _Value __min = __is_signed ? -__max - 1 : (_Value)0; + }; + + template + const _Value __numeric_traits_integer<_Value>::__min; + + template + const _Value __numeric_traits_integer<_Value>::__max; + + template + const bool __numeric_traits_integer<_Value>::__is_signed; + + template + const int __numeric_traits_integer<_Value>::__digits; +# 137 "/usr/include/c++/13/ext/numeric_traits.h" 3 + template + using __int_traits = __numeric_traits_integer<_Tp>; +# 157 "/usr/include/c++/13/ext/numeric_traits.h" 3 + template + struct __numeric_traits_floating + { + + static const int __max_digits10 = (2 + (std::__are_same<_Value, float>::__value ? 24 : std::__are_same<_Value, double>::__value ? 53 : 113) * 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 : 33); + static const int __max_exponent10 = (std::__are_same<_Value, float>::__value ? 38 : std::__are_same<_Value, double>::__value ? 308 : 4932); + }; + + template + const int __numeric_traits_floating<_Value>::__max_digits10; + + template + const bool __numeric_traits_floating<_Value>::__is_signed; + + template + const int __numeric_traits_floating<_Value>::__digits10; + + template + const int __numeric_traits_floating<_Value>::__max_exponent10; + + + + + + + template + struct __numeric_traits + : public __numeric_traits_integer<_Value> + { }; + + template<> + struct __numeric_traits + : public __numeric_traits_floating + { }; + + template<> + struct __numeric_traits + : public __numeric_traits_floating + { }; + + template<> + struct __numeric_traits + : public __numeric_traits_floating + { }; +# 238 "/usr/include/c++/13/ext/numeric_traits.h" 3 + +} +# 64 "/usr/include/c++/13/bits/stl_algobase.h" 2 3 +# 1 "/usr/include/c++/13/bits/stl_pair.h" 1 3 +# 60 "/usr/include/c++/13/bits/stl_pair.h" 3 +# 1 "/usr/include/c++/13/type_traits" 1 3 +# 32 "/usr/include/c++/13/type_traits" 3 + +# 33 "/usr/include/c++/13/type_traits" 3 + + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template + class reference_wrapper; +# 61 "/usr/include/c++/13/type_traits" 3 + template + struct integral_constant + { + static constexpr _Tp value = __v; + typedef _Tp value_type; + typedef integral_constant<_Tp, __v> type; + constexpr operator value_type() const noexcept { return value; } + + + + + constexpr value_type operator()() const noexcept { return value; } + + }; + + + + + + + + using true_type = integral_constant; + + + using false_type = integral_constant; + + + + template + using __bool_constant = integral_constant; + + + + + + + template + using bool_constant = integral_constant; + + + + + + + template + struct enable_if + { }; + + + template + struct enable_if + { typedef _Tp type; }; + + + template + using __enable_if_t = typename enable_if<_Cond, _Tp>::type; + + template + struct __conditional + { + template + using type = _Tp; + }; + + template<> + struct __conditional + { + template + using type = _Up; + }; + + + template + using __conditional_t + = typename __conditional<_Cond>::template type<_If, _Else>; + + + template + struct __type_identity + { using type = _Type; }; + + template + using __type_identity_t = typename __type_identity<_Tp>::type; + + namespace __detail + { + + template + using __first_t = _Tp; + + + template + auto __or_fn(int) -> __first_t...>; + + template + auto __or_fn(...) -> true_type; + + template + auto __and_fn(int) -> __first_t...>; + + template + auto __and_fn(...) -> false_type; + } + + + + + template + struct __or_ + : decltype(__detail::__or_fn<_Bn...>(0)) + { }; + + template + struct __and_ + : decltype(__detail::__and_fn<_Bn...>(0)) + { }; + + template + struct __not_ + : __bool_constant + { }; + + + + + + template + inline constexpr bool __or_v = __or_<_Bn...>::value; + template + inline constexpr bool __and_v = __and_<_Bn...>::value; + + namespace __detail + { + template + struct __disjunction_impl + { using type = _B1; }; + + template + struct __disjunction_impl<__enable_if_t, _B1, _B2, _Bn...> + { using type = typename __disjunction_impl::type; }; + + template + struct __conjunction_impl + { using type = _B1; }; + + template + struct __conjunction_impl<__enable_if_t, _B1, _B2, _Bn...> + { using type = typename __conjunction_impl::type; }; + } + + + + + template + struct conjunction + : __detail::__conjunction_impl::type + { }; + + template<> + struct conjunction<> + : true_type + { }; + + template + struct disjunction + : __detail::__disjunction_impl::type + { }; + + template<> + struct disjunction<> + : false_type + { }; + + template + struct negation + : __not_<_Pp>::type + { }; + + + + + template + inline constexpr bool conjunction_v = conjunction<_Bn...>::value; + + template + inline constexpr bool disjunction_v = disjunction<_Bn...>::value; + + template + inline constexpr bool negation_v = negation<_Pp>::value; + + + + + + template + struct is_reference; + template + struct is_function; + template + struct is_void; + template + struct remove_cv; + template + struct is_const; + + + template + struct __is_array_unknown_bounds; + + + + + template + constexpr true_type __is_complete_or_unbounded(__type_identity<_Tp>) + { return {}; } + + template + 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 + using __remove_cv_t = typename remove_cv<_Tp>::type; + + + + + + template + struct is_void + : public false_type { }; + + template<> + struct is_void + : public true_type { }; + + template<> + struct is_void + : public true_type { }; + + template<> + struct is_void + : public true_type { }; + + template<> + struct is_void + : public true_type { }; + + + template + struct __is_integral_helper + : public false_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + + + + template<> + struct __is_integral_helper + : public true_type { }; + + + + + + + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + + + + __extension__ + template<> + struct __is_integral_helper<__int128> + : public true_type { }; + + __extension__ + template<> + struct __is_integral_helper + : public true_type { }; +# 440 "/usr/include/c++/13/type_traits" 3 + template + struct is_integral + : public __is_integral_helper<__remove_cv_t<_Tp>>::type + { }; + + + template + struct __is_floating_point_helper + : public false_type { }; + + template<> + struct __is_floating_point_helper + : public true_type { }; + + template<> + struct __is_floating_point_helper + : public true_type { }; + + template<> + struct __is_floating_point_helper + : public true_type { }; +# 500 "/usr/include/c++/13/type_traits" 3 + template + struct is_floating_point + : public __is_floating_point_helper<__remove_cv_t<_Tp>>::type + { }; + + + template + struct is_array + : public false_type { }; + + template + struct is_array<_Tp[_Size]> + : public true_type { }; + + template + struct is_array<_Tp[]> + : public true_type { }; + + template + struct __is_pointer_helper + : public false_type { }; + + template + struct __is_pointer_helper<_Tp*> + : public true_type { }; + + + template + struct is_pointer + : public __is_pointer_helper<__remove_cv_t<_Tp>>::type + { }; + + + template + struct is_lvalue_reference + : public false_type { }; + + template + struct is_lvalue_reference<_Tp&> + : public true_type { }; + + + template + struct is_rvalue_reference + : public false_type { }; + + template + struct is_rvalue_reference<_Tp&&> + : public true_type { }; + + template + struct __is_member_object_pointer_helper + : public false_type { }; + + template + struct __is_member_object_pointer_helper<_Tp _Cp::*> + : public __not_>::type { }; + + + template + struct is_member_object_pointer + : public __is_member_object_pointer_helper<__remove_cv_t<_Tp>>::type + { }; + + template + struct __is_member_function_pointer_helper + : public false_type { }; + + template + struct __is_member_function_pointer_helper<_Tp _Cp::*> + : public is_function<_Tp>::type { }; + + + template + struct is_member_function_pointer + : public __is_member_function_pointer_helper<__remove_cv_t<_Tp>>::type + { }; + + + template + struct is_enum + : public integral_constant + { }; + + + template + struct is_union + : public integral_constant + { }; + + + template + struct is_class + : public integral_constant + { }; + + + template + struct is_function + : public __bool_constant::value> { }; + + template + struct is_function<_Tp&> + : public false_type { }; + + template + struct is_function<_Tp&&> + : public false_type { }; + + + + + template + struct is_null_pointer + : public false_type { }; + + template<> + struct is_null_pointer + : public true_type { }; + + template<> + struct is_null_pointer + : public true_type { }; + + template<> + struct is_null_pointer + : public true_type { }; + + template<> + struct is_null_pointer + : public true_type { }; + + + + template + struct __is_nullptr_t + : public is_null_pointer<_Tp> + { } __attribute__ ((__deprecated__ ("use '" "std::is_null_pointer" "' instead"))); + + + + + template + struct is_reference + : public false_type + { }; + + template + struct is_reference<_Tp&> + : public true_type + { }; + + template + struct is_reference<_Tp&&> + : public true_type + { }; + + + template + struct is_arithmetic + : public __or_, is_floating_point<_Tp>>::type + { }; + + + template + struct is_fundamental + : public __or_, is_void<_Tp>, + is_null_pointer<_Tp>>::type + { }; + + + template + struct is_object + : public __not_<__or_, is_reference<_Tp>, + is_void<_Tp>>>::type + { }; + + template + struct is_member_pointer; + + + template + struct is_scalar + : public __or_, is_enum<_Tp>, is_pointer<_Tp>, + is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type + { }; + + + template + struct is_compound + : public __not_>::type { }; + + + template + struct __is_member_pointer_helper + : public false_type { }; + + template + struct __is_member_pointer_helper<_Tp _Cp::*> + : public true_type { }; + + + + template + struct is_member_pointer + : public __is_member_pointer_helper<__remove_cv_t<_Tp>>::type + { }; + + template + struct is_same; + + + template + using __is_one_of = __or_...>; + + + __extension__ + template + using __is_signed_integer = __is_one_of<__remove_cv_t<_Tp>, + signed char, signed short, signed int, signed long, + signed long long + + , signed __int128 +# 733 "/usr/include/c++/13/type_traits" 3 + >; + + + __extension__ + template + using __is_unsigned_integer = __is_one_of<__remove_cv_t<_Tp>, + unsigned char, unsigned short, unsigned int, unsigned long, + unsigned long long + + , unsigned __int128 +# 753 "/usr/include/c++/13/type_traits" 3 + >; + + + template + using __is_standard_integer + = __or_<__is_signed_integer<_Tp>, __is_unsigned_integer<_Tp>>; + + + template using __void_t = void; + + + + + + template + struct is_const + : public false_type { }; + + template + struct is_const<_Tp const> + : public true_type { }; + + + template + struct is_volatile + : public false_type { }; + + template + struct is_volatile<_Tp volatile> + : public true_type { }; + + + template + struct is_trivial + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_copyable + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_standard_layout + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + + + + template + struct + + is_pod + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + + + template + struct + [[__deprecated__]] + is_literal_type + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_empty + : public integral_constant + { }; + + + template + struct is_polymorphic + : public integral_constant + { }; + + + + + + template + struct is_final + : public integral_constant + { }; + + + + template + struct is_abstract + : public integral_constant + { }; + + + template::value> + struct __is_signed_helper + : public false_type { }; + + template + struct __is_signed_helper<_Tp, true> + : public integral_constant + { }; + + + + template + struct is_signed + : public __is_signed_helper<_Tp>::type + { }; + + + template + struct is_unsigned + : public __and_, __not_>>::type + { }; + + + template + _Up + __declval(int); + + template + _Tp + __declval(long); + + + template + auto declval() noexcept -> decltype(__declval<_Tp>(0)); + + template + struct remove_all_extents; + + + template + struct __is_array_known_bounds + : public false_type + { }; + + template + struct __is_array_known_bounds<_Tp[_Size]> + : public true_type + { }; + + template + struct __is_array_unknown_bounds + : public false_type + { }; + + template + struct __is_array_unknown_bounds<_Tp[]> + : public true_type + { }; +# 936 "/usr/include/c++/13/type_traits" 3 + struct __do_is_destructible_impl + { + template().~_Tp())> + static true_type __test(int); + + template + static false_type __test(...); + }; + + template + struct __is_destructible_impl + : public __do_is_destructible_impl + { + typedef decltype(__test<_Tp>(0)) type; + }; + + template, + __is_array_unknown_bounds<_Tp>, + is_function<_Tp>>::value, + bool = __or_, is_scalar<_Tp>>::value> + struct __is_destructible_safe; + + template + struct __is_destructible_safe<_Tp, false, false> + : public __is_destructible_impl::type>::type + { }; + + template + struct __is_destructible_safe<_Tp, true, false> + : public false_type { }; + + template + struct __is_destructible_safe<_Tp, false, true> + : public true_type { }; + + + + template + 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 + static __bool_constant().~_Tp())> + __test(int); + + template + static false_type __test(...); + }; + + template + struct __is_nt_destructible_impl + : public __do_is_nt_destructible_impl + { + typedef decltype(__test<_Tp>(0)) type; + }; + + template, + __is_array_unknown_bounds<_Tp>, + is_function<_Tp>>::value, + bool = __or_, is_scalar<_Tp>>::value> + struct __is_nt_destructible_safe; + + template + struct __is_nt_destructible_safe<_Tp, false, false> + : public __is_nt_destructible_impl::type>::type + { }; + + template + struct __is_nt_destructible_safe<_Tp, true, false> + : public false_type { }; + + template + struct __is_nt_destructible_safe<_Tp, false, true> + : public true_type { }; + + + + template + 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 + using __is_constructible_impl + = __bool_constant<__is_constructible(_Tp, _Args...)>; + + + + template + 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 + struct is_default_constructible + : public __is_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 + struct __add_lvalue_reference_helper + { using type = _Tp; }; + + template + struct __add_lvalue_reference_helper<_Tp, __void_t<_Tp&>> + { using type = _Tp&; }; + + template + using __add_lval_ref_t = typename __add_lvalue_reference_helper<_Tp>::type; + + + + template + struct is_copy_constructible + : public __is_constructible_impl<_Tp, __add_lval_ref_t> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct __add_rvalue_reference_helper + { using type = _Tp; }; + + template + struct __add_rvalue_reference_helper<_Tp, __void_t<_Tp&&>> + { using type = _Tp&&; }; + + template + using __add_rval_ref_t = typename __add_rvalue_reference_helper<_Tp>::type; + + + + template + struct is_move_constructible + : public __is_constructible_impl<_Tp, __add_rval_ref_t<_Tp>> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + using __is_nothrow_constructible_impl + = __bool_constant<__is_nothrow_constructible(_Tp, _Args...)>; + + + + template + struct is_nothrow_constructible + : public __is_nothrow_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 + struct is_nothrow_default_constructible + : public __is_nothrow_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 + struct is_nothrow_copy_constructible + : public __is_nothrow_constructible_impl<_Tp, __add_lval_ref_t> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_move_constructible + : public __is_nothrow_constructible_impl<_Tp, __add_rval_ref_t<_Tp>> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + using __is_assignable_impl = __bool_constant<__is_assignable(_Tp, _Up)>; + + + + template + struct is_assignable + : public __is_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 + struct is_copy_assignable + : public __is_assignable_impl<__add_lval_ref_t<_Tp>, + __add_lval_ref_t> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_move_assignable + : public __is_assignable_impl<__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + using __is_nothrow_assignable_impl + = __bool_constant<__is_nothrow_assignable(_Tp, _Up)>; + + + + template + 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 + struct is_nothrow_copy_assignable + : public __is_nothrow_assignable_impl<__add_lval_ref_t<_Tp>, + __add_lval_ref_t> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_move_assignable + : public __is_nothrow_assignable_impl<__add_lval_ref_t<_Tp>, + __add_rval_ref_t<_Tp>> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + using __is_trivially_constructible_impl + = __bool_constant<__is_trivially_constructible(_Tp, _Args...)>; + + + + template + struct is_trivially_constructible + : public __is_trivially_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 + struct is_trivially_default_constructible + : public __is_trivially_constructible_impl<_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 + static void __helper(const _Tp&); + + template + static true_type __test(const _Tp&, + decltype(__helper({}))* = 0); + + static false_type __test(...); + }; + + template + struct __is_implicitly_default_constructible_impl + : public __do_is_implicitly_default_constructible_impl + { + typedef decltype(__test(declval<_Tp>())) type; + }; + + template + struct __is_implicitly_default_constructible_safe + : public __is_implicitly_default_constructible_impl<_Tp>::type + { }; + + template + struct __is_implicitly_default_constructible + : public __and_<__is_constructible_impl<_Tp>, + __is_implicitly_default_constructible_safe<_Tp>>::type + { }; + + + template + struct is_trivially_copy_constructible + : public __is_trivially_constructible_impl<_Tp, __add_lval_ref_t> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_move_constructible + : public __is_trivially_constructible_impl<_Tp, __add_rval_ref_t<_Tp>> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + using __is_trivially_assignable_impl + = __bool_constant<__is_trivially_assignable(_Tp, _Up)>; + + + + template + struct is_trivially_assignable + : public __is_trivially_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 + struct is_trivially_copy_assignable + : public __is_trivially_assignable_impl<__add_lval_ref_t<_Tp>, + __add_lval_ref_t> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_move_assignable + : public __is_trivially_assignable_impl<__add_lval_ref_t<_Tp>, + __add_rval_ref_t<_Tp>> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_destructible + : public __and_<__is_destructible_safe<_Tp>, + __bool_constant<__has_trivial_destructor(_Tp)>>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + template + struct has_virtual_destructor + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + + + template + struct alignment_of + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct rank + : public integral_constant { }; + + template + struct rank<_Tp[_Size]> + : public integral_constant::value> { }; + + template + struct rank<_Tp[]> + : public integral_constant::value> { }; + + + template + struct extent + : public integral_constant { }; + + template + struct extent<_Tp[_Size], 0> + : public integral_constant { }; + + template + struct extent<_Tp[_Size], _Uint> + : public extent<_Tp, _Uint - 1>::type { }; + + template + struct extent<_Tp[], 0> + : public integral_constant { }; + + template + struct extent<_Tp[], _Uint> + : public extent<_Tp, _Uint - 1>::type { }; + + + + + + template + struct is_same + + : public integral_constant + + + + { }; +# 1409 "/usr/include/c++/13/type_traits" 3 + template + struct is_base_of + : public integral_constant + { }; + + + template + struct is_convertible + : public __bool_constant<__is_convertible(_From, _To)> + { }; +# 1458 "/usr/include/c++/13/type_traits" 3 + template + using __is_array_convertible + = is_convertible<_FromElementType(*)[], _ToElementType(*)[]>; +# 1522 "/usr/include/c++/13/type_traits" 3 + template + struct remove_const + { typedef _Tp type; }; + + template + struct remove_const<_Tp const> + { typedef _Tp type; }; + + + template + struct remove_volatile + { typedef _Tp type; }; + + template + struct remove_volatile<_Tp volatile> + { typedef _Tp type; }; + + + + template + struct remove_cv + { using type = __remove_cv(_Tp); }; +# 1563 "/usr/include/c++/13/type_traits" 3 + template + struct add_const + { using type = _Tp const; }; + + + template + struct add_volatile + { using type = _Tp volatile; }; + + + template + struct add_cv + { using type = _Tp const volatile; }; + + + + + + + template + using remove_const_t = typename remove_const<_Tp>::type; + + + template + using remove_volatile_t = typename remove_volatile<_Tp>::type; + + + template + using remove_cv_t = typename remove_cv<_Tp>::type; + + + template + using add_const_t = typename add_const<_Tp>::type; + + + template + using add_volatile_t = typename add_volatile<_Tp>::type; + + + template + using add_cv_t = typename add_cv<_Tp>::type; + + + + + + + template + struct remove_reference + { using type = __remove_reference(_Tp); }; +# 1628 "/usr/include/c++/13/type_traits" 3 + template + struct add_lvalue_reference + { using type = __add_lval_ref_t<_Tp>; }; + + + template + struct add_rvalue_reference + { using type = __add_rval_ref_t<_Tp>; }; + + + + template + using remove_reference_t = typename remove_reference<_Tp>::type; + + + template + using add_lvalue_reference_t = typename add_lvalue_reference<_Tp>::type; + + + template + using add_rvalue_reference_t = typename add_rvalue_reference<_Tp>::type; + + + + + + + + template + struct __cv_selector; + + template + struct __cv_selector<_Unqualified, false, false> + { typedef _Unqualified __type; }; + + template + struct __cv_selector<_Unqualified, false, true> + { typedef volatile _Unqualified __type; }; + + template + struct __cv_selector<_Unqualified, true, false> + { typedef const _Unqualified __type; }; + + template + struct __cv_selector<_Unqualified, true, true> + { typedef const volatile _Unqualified __type; }; + + template::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 + struct __make_unsigned + { typedef _Tp __type; }; + + template<> + struct __make_unsigned + { typedef unsigned char __type; }; + + template<> + struct __make_unsigned + { typedef unsigned char __type; }; + + template<> + struct __make_unsigned + { typedef unsigned short __type; }; + + template<> + struct __make_unsigned + { typedef unsigned int __type; }; + + template<> + struct __make_unsigned + { typedef unsigned long __type; }; + + template<> + struct __make_unsigned + { typedef unsigned long long __type; }; + + + __extension__ + template<> + struct __make_unsigned<__int128> + { typedef unsigned __int128 __type; }; +# 1741 "/usr/include/c++/13/type_traits" 3 + template::value, + bool _IsEnum = is_enum<_Tp>::value> + class __make_unsigned_selector; + + template + 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 struct _List { }; + + template + struct _List<_Tp, _Up...> : _List<_Up...> + { static constexpr size_t __size = sizeof(_Tp); }; + + template + struct __select; + + template + struct __select<_Sz, _List<_Uint, _UInts...>, true> + { using __type = _Uint; }; + + template + struct __select<_Sz, _List<_Uint, _UInts...>, false> + : __select<_Sz, _List<_UInts...>> + { }; + }; + + + template + class __make_unsigned_selector<_Tp, false, true> + : __make_unsigned_selector_base + { + + using _UInts = _List; + + using __unsigned_type = typename __select::__type; + + public: + using __type + = typename __match_cv_qualifiers<_Tp, __unsigned_type>::__type; + }; + + + + + + template<> + struct __make_unsigned + { + using __type + = typename __make_unsigned_selector::__type; + }; +# 1815 "/usr/include/c++/13/type_traits" 3 + template<> + struct __make_unsigned + { + using __type + = typename __make_unsigned_selector::__type; + }; + + template<> + struct __make_unsigned + { + using __type + = typename __make_unsigned_selector::__type; + }; + + + + + + + template + struct make_unsigned + { typedef typename __make_unsigned_selector<_Tp>::__type type; }; + + + template<> struct make_unsigned; + template<> struct make_unsigned; + template<> struct make_unsigned; + template<> struct make_unsigned; + + + + + template + struct __make_signed + { typedef _Tp __type; }; + + template<> + struct __make_signed + { typedef signed char __type; }; + + template<> + struct __make_signed + { typedef signed char __type; }; + + template<> + struct __make_signed + { typedef signed short __type; }; + + template<> + struct __make_signed + { typedef signed int __type; }; + + template<> + struct __make_signed + { typedef signed long __type; }; + + template<> + struct __make_signed + { typedef signed long long __type; }; + + + __extension__ + template<> + struct __make_signed + { typedef __int128 __type; }; +# 1901 "/usr/include/c++/13/type_traits" 3 + template::value, + bool _IsEnum = is_enum<_Tp>::value> + class __make_signed_selector; + + template + 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 + 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 + { + using __type + = typename __make_signed_selector::__type; + }; +# 1947 "/usr/include/c++/13/type_traits" 3 + template<> + struct __make_signed + { + using __type + = typename __make_signed_selector::__type; + }; + + template<> + struct __make_signed + { + using __type + = typename __make_signed_selector::__type; + }; + + + + + + + template + struct make_signed + { typedef typename __make_signed_selector<_Tp>::__type type; }; + + + template<> struct make_signed; + template<> struct make_signed; + template<> struct make_signed; + template<> struct make_signed; + + + + template + using make_signed_t = typename make_signed<_Tp>::type; + + + template + using make_unsigned_t = typename make_unsigned<_Tp>::type; + + + + + + template + struct remove_extent + { typedef _Tp type; }; + + template + struct remove_extent<_Tp[_Size]> + { typedef _Tp type; }; + + template + struct remove_extent<_Tp[]> + { typedef _Tp type; }; + + + template + struct remove_all_extents + { typedef _Tp type; }; + + template + struct remove_all_extents<_Tp[_Size]> + { typedef typename remove_all_extents<_Tp>::type type; }; + + template + struct remove_all_extents<_Tp[]> + { typedef typename remove_all_extents<_Tp>::type type; }; + + + + template + using remove_extent_t = typename remove_extent<_Tp>::type; + + + template + using remove_all_extents_t = typename remove_all_extents<_Tp>::type; + + + + + template + struct __remove_pointer_helper + { typedef _Tp type; }; + + template + struct __remove_pointer_helper<_Tp, _Up*> + { typedef _Up type; }; + + + template + struct remove_pointer + : public __remove_pointer_helper<_Tp, __remove_cv_t<_Tp>> + { }; + + template + struct __add_pointer_helper + { using type = _Tp; }; + + template + struct __add_pointer_helper<_Tp, __void_t<_Tp*>> + { using type = _Tp*; }; + + + template + struct add_pointer + : public __add_pointer_helper<_Tp> + { }; + + template + struct add_pointer<_Tp&> + { using type = _Tp*; }; + + template + struct add_pointer<_Tp&&> + { using type = _Tp*; }; + + + + template + using remove_pointer_t = typename remove_pointer<_Tp>::type; + + + template + using add_pointer_t = typename add_pointer<_Tp>::type; + + + template + struct __aligned_storage_msa + { + union __type + { + unsigned char __data[_Len]; + struct __attribute__((__aligned__)) { } __align; + }; + }; +# 2095 "/usr/include/c++/13/type_traits" 3 + template::__type)> + struct + + aligned_storage + { + union type + { + unsigned char __data[_Len]; + struct __attribute__((__aligned__((_Align)))) { } __align; + }; + }; + + template + struct __strictest_alignment + { + static const size_t _S_alignment = 0; + static const size_t _S_size = 0; + }; + + template + 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; + }; + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" +# 2141 "/usr/include/c++/13/type_traits" 3 + template + 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 + const size_t aligned_union<_Len, _Types...>::alignment_value; +#pragma GCC diagnostic pop + + + + + + template + struct __decay_selector + : __conditional_t::value, + remove_cv<_Up>, + add_pointer<_Up>> + { }; + + template + struct __decay_selector<_Up[_Nm]> + { using type = _Up*; }; + + template + struct __decay_selector<_Up[]> + { using type = _Up*; }; + + + + + template + struct decay + { using type = typename __decay_selector<_Tp>::type; }; + + template + struct decay<_Tp&> + { using type = typename __decay_selector<_Tp>::type; }; + + template + struct decay<_Tp&&> + { using type = typename __decay_selector<_Tp>::type; }; + + + + + template + struct __strip_reference_wrapper + { + typedef _Tp __type; + }; + + template + struct __strip_reference_wrapper > + { + typedef _Tp& __type; + }; + + + template + using __decay_t = typename decay<_Tp>::type; + + template + using __decay_and_strip = __strip_reference_wrapper<__decay_t<_Tp>>; + + + + + + template + using _Require = __enable_if_t<__and_<_Cond...>::value>; + + + template + using __remove_cvref_t + = typename remove_cv::type>::type; + + + + + template + struct conditional + { typedef _Iftrue type; }; + + + template + struct conditional + { typedef _Iffalse type; }; + + + template + struct common_type; +# 2256 "/usr/include/c++/13/type_traits" 3 + template + struct __success_type + { typedef _Tp type; }; + + struct __failure_type + { }; + + struct __do_common_type_impl + { + template + using __cond_t + = decltype(true ? std::declval<_Tp>() : std::declval<_Up>()); + + + + template + static __success_type<__decay_t<__cond_t<_Tp, _Up>>> + _S_test(int); +# 2283 "/usr/include/c++/13/type_traits" 3 + template + static __failure_type + _S_test_2(...); + + template + static decltype(_S_test_2<_Tp, _Up>(0)) + _S_test(...); + }; + + + template<> + struct common_type<> + { }; + + + template + struct common_type<_Tp0> + : public common_type<_Tp0, _Tp0> + { }; + + + template, typename _Dp2 = __decay_t<_Tp2>> + struct __common_type_impl + { + + + using type = common_type<_Dp1, _Dp2>; + }; + + template + struct __common_type_impl<_Tp1, _Tp2, _Tp1, _Tp2> + : private __do_common_type_impl + { + + + using type = decltype(_S_test<_Tp1, _Tp2>(0)); + }; + + + template + struct common_type<_Tp1, _Tp2> + : public __common_type_impl<_Tp1, _Tp2>::type + { }; + + template + struct __common_type_pack + { }; + + template + struct __common_type_fold; + + + template + struct common_type<_Tp1, _Tp2, _Rp...> + : public __common_type_fold, + __common_type_pack<_Rp...>> + { }; + + + + + template + struct __common_type_fold<_CTp, __common_type_pack<_Rp...>, + __void_t> + : public common_type + { }; + + + template + struct __common_type_fold<_CTp, _Rp, void> + { }; + + template::value> + struct __underlying_type_impl + { + using type = __underlying_type(_Tp); + }; + + template + struct __underlying_type_impl<_Tp, false> + { }; + + + + template + struct underlying_type + : public __underlying_type_impl<_Tp> + { }; + + + template + struct __declval_protector + { + static const bool __stop = false; + }; + + + + + + + template + auto declval() noexcept -> decltype(__declval<_Tp>(0)) + { + static_assert(__declval_protector<_Tp>::__stop, + "declval() must not be used!"); + return __declval<_Tp>(0); + } + + + template + struct result_of; + + + + + + + struct __invoke_memfun_ref { }; + struct __invoke_memfun_deref { }; + struct __invoke_memobj_ref { }; + struct __invoke_memobj_deref { }; + struct __invoke_other { }; + + + template + struct __result_of_success : __success_type<_Tp> + { using __invoke_type = _Tag; }; + + + struct __result_of_memfun_ref_impl + { + template + static __result_of_success().*std::declval<_Fp>())(std::declval<_Args>()...) + ), __invoke_memfun_ref> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + 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 + static __result_of_success()).*std::declval<_Fp>())(std::declval<_Args>()...) + ), __invoke_memfun_deref> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + 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 + static __result_of_success().*std::declval<_Fp>() + ), __invoke_memobj_ref> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + 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 + static __result_of_success()).*std::declval<_Fp>() + ), __invoke_memobj_deref> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_memobj_deref + : private __result_of_memobj_deref_impl + { + typedef decltype(_S_test<_MemPtr, _Arg>(0)) type; + }; + + template + struct __result_of_memobj; + + template + struct __result_of_memobj<_Res _Class::*, _Arg> + { + typedef __remove_cvref_t<_Arg> _Argval; + typedef _Res _Class::* _MemPtr; + typedef typename __conditional_t<__or_, + is_base_of<_Class, _Argval>>::value, + __result_of_memobj_ref<_MemPtr, _Arg>, + __result_of_memobj_deref<_MemPtr, _Arg> + >::type type; + }; + + template + struct __result_of_memfun; + + template + struct __result_of_memfun<_Res _Class::*, _Arg, _Args...> + { + typedef typename remove_reference<_Arg>::type _Argval; + typedef _Res _Class::* _MemPtr; + typedef typename __conditional_t::value, + __result_of_memfun_ref<_MemPtr, _Arg, _Args...>, + __result_of_memfun_deref<_MemPtr, _Arg, _Args...> + >::type type; + }; + + + + + + + template> + struct __inv_unwrap + { + using type = _Tp; + }; + + template + struct __inv_unwrap<_Tp, reference_wrapper<_Up>> + { + using type = _Up&; + }; + + template + struct __result_of_impl + { + typedef __failure_type type; + }; + + template + struct __result_of_impl + : public __result_of_memobj<__decay_t<_MemPtr>, + typename __inv_unwrap<_Arg>::type> + { }; + + template + struct __result_of_impl + : public __result_of_memfun<__decay_t<_MemPtr>, + typename __inv_unwrap<_Arg>::type, _Args...> + { }; + + + struct __result_of_other_impl + { + template + static __result_of_success()(std::declval<_Args>()...) + ), __invoke_other> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_impl + : private __result_of_other_impl + { + typedef decltype(_S_test<_Functor, _ArgTypes...>(0)) type; + }; + + + template + 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 + struct result_of<_Functor(_ArgTypes...)> + : public __invoke_result<_Functor, _ArgTypes...> + { } __attribute__ ((__deprecated__ ("use '" "std::invoke_result" "' instead"))); + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + + template::__type)> + using aligned_storage_t = typename aligned_storage<_Len, _Align>::type; + + template + using aligned_union_t = typename aligned_union<_Len, _Types...>::type; +#pragma GCC diagnostic pop + + + template + using decay_t = typename decay<_Tp>::type; + + + template + using enable_if_t = typename enable_if<_Cond, _Tp>::type; + + + template + using conditional_t = typename conditional<_Cond, _Iftrue, _Iffalse>::type; + + + template + using common_type_t = typename common_type<_Tp...>::type; + + + template + using underlying_type_t = typename underlying_type<_Tp>::type; + + + template + using result_of_t = typename result_of<_Tp>::type; + + + + + + template using void_t = void; +# 2659 "/usr/include/c++/13/type_traits" 3 + template class _Op, typename... _Args> + struct __detector + { + using type = _Default; + using __is_detected = false_type; + }; + + + template class _Op, + typename... _Args> + struct __detector<_Default, __void_t<_Op<_Args...>>, _Op, _Args...> + { + using type = _Op<_Args...>; + using __is_detected = true_type; + }; + + template class _Op, + typename... _Args> + using __detected_or = __detector<_Default, void, _Op, _Args...>; + + + + template class _Op, + typename... _Args> + using __detected_or_t + = typename __detected_or<_Default, _Op, _Args...>::type; +# 2701 "/usr/include/c++/13/type_traits" 3 + template + struct __is_swappable; + + template + struct __is_nothrow_swappable; + + template + struct __is_tuple_like_impl : false_type + { }; + + + template + struct __is_tuple_like + : public __is_tuple_like_impl<__remove_cvref_t<_Tp>>::type + { }; + + + template + + inline + _Require<__not_<__is_tuple_like<_Tp>>, + is_move_constructible<_Tp>, + is_move_assignable<_Tp>> + swap(_Tp&, _Tp&) + noexcept(__and_, + is_nothrow_move_assignable<_Tp>>::value); + + template + + 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(), std::declval<_Tp&>()))> + static true_type __test(int); + + template + static false_type __test(...); + }; + + struct __do_is_nothrow_swappable_impl + { + template + static __bool_constant< + noexcept(swap(std::declval<_Tp&>(), std::declval<_Tp&>())) + > __test(int); + + template + static false_type __test(...); + }; + + } + + template + struct __is_swappable_impl + : public __swappable_details::__do_is_swappable_impl + { + typedef decltype(__test<_Tp>(0)) type; + }; + + template + struct __is_nothrow_swappable_impl + : public __swappable_details::__do_is_nothrow_swappable_impl + { + typedef decltype(__test<_Tp>(0)) type; + }; + + template + struct __is_swappable + : public __is_swappable_impl<_Tp>::type + { }; + + template + struct __is_nothrow_swappable + : public __is_nothrow_swappable_impl<_Tp>::type + { }; + + + + + + + + template + 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 + 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 + inline constexpr bool is_swappable_v = + is_swappable<_Tp>::value; + + + template + 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(), std::declval<_Up>())), + typename + = decltype(swap(std::declval<_Up>(), std::declval<_Tp>()))> + static true_type __test(int); + + template + static false_type __test(...); + }; + + struct __do_is_nothrow_swappable_with_impl + { + template + static __bool_constant< + noexcept(swap(std::declval<_Tp>(), std::declval<_Up>())) + && + noexcept(swap(std::declval<_Up>(), std::declval<_Tp>())) + > __test(int); + + template + static false_type __test(...); + }; + + } + + template + struct __is_swappable_with_impl + : public __swappable_with_details::__do_is_swappable_with_impl + { + typedef decltype(__test<_Tp, _Up>(0)) type; + }; + + + template + struct __is_swappable_with_impl<_Tp&, _Tp&> + : public __swappable_details::__do_is_swappable_impl + { + typedef decltype(__test<_Tp&>(0)) type; + }; + + template + struct __is_nothrow_swappable_with_impl + : public __swappable_with_details::__do_is_nothrow_swappable_with_impl + { + typedef decltype(__test<_Tp, _Up>(0)) type; + }; + + + template + struct __is_nothrow_swappable_with_impl<_Tp&, _Tp&> + : public __swappable_details::__do_is_nothrow_swappable_impl + { + typedef decltype(__test<_Tp&>(0)) type; + }; + + + + template + struct is_swappable_with + : public __is_swappable_with_impl<_Tp, _Up>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "first template argument must be a complete class or an unbounded array"); + static_assert(std::__is_complete_or_unbounded(__type_identity<_Up>{}), + "second template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_swappable_with + : public __is_nothrow_swappable_with_impl<_Tp, _Up>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "first template argument must be a complete class or an unbounded array"); + static_assert(std::__is_complete_or_unbounded(__type_identity<_Up>{}), + "second template argument must be a complete class or an unbounded array"); + }; + + + + template + inline constexpr bool is_swappable_with_v = + is_swappable_with<_Tp, _Up>::value; + + + template + inline constexpr bool is_nothrow_swappable_with_v = + is_nothrow_swappable_with<_Tp, _Up>::value; +# 2924 "/usr/include/c++/13/type_traits" 3 + template::value, typename = void> + struct __is_invocable_impl + : false_type + { + using __nothrow_conv = false_type; + }; + + + template + struct __is_invocable_impl<_Result, _Ret, + true, + __void_t> + : true_type + { + using __nothrow_conv = true_type; + }; + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wctor-dtor-privacy" + + template + struct __is_invocable_impl<_Result, _Ret, + false, + __void_t> + { + private: + + using _Res_t = typename _Result::type; + + + + static _Res_t _S_get() noexcept; + + + template + static void _S_conv(__type_identity_t<_Tp>) noexcept; + + + template(_S_get())), + typename = decltype(_S_conv<_Tp>(_S_get())), + + bool _Dangle = __reference_converts_from_temporary(_Tp, _Res_t) + + + + > + static __bool_constant<_Nothrow && !_Dangle> + _S_test(int); + + template + static false_type + _S_test(...); + + public: + + using type = decltype(_S_test<_Ret, true>(1)); + + + using __nothrow_conv = decltype(_S_test<_Ret>(1)); + }; +#pragma GCC diagnostic pop + + template + struct __is_invocable + : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type + { }; + + template + 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 + constexpr bool __call_is_nt(__invoke_memfun_deref) + { + return noexcept(((*std::declval<_Tp>()).*std::declval<_Fn>())( + std::declval<_Args>()...)); + } + + template + constexpr bool __call_is_nt(__invoke_memobj_ref) + { + using _Up = typename __inv_unwrap<_Tp>::type; + return noexcept(std::declval<_Up>().*std::declval<_Fn>()); + } + + template + constexpr bool __call_is_nt(__invoke_memobj_deref) + { + return noexcept((*std::declval<_Tp>()).*std::declval<_Fn>()); + } + + template + constexpr bool __call_is_nt(__invoke_other) + { + return noexcept(std::declval<_Fn>()(std::declval<_Args>()...)); + } + + template + struct __call_is_nothrow + : __bool_constant< + std::__call_is_nt<_Fn, _Args...>(typename _Result::__invoke_type{}) + > + { }; + + template + using __call_is_nothrow_ + = __call_is_nothrow<__invoke_result<_Fn, _Args...>, _Fn, _Args...>; + + + template + 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 + + + + + + + template + struct invoke_result + : public __invoke_result<_Functor, _ArgTypes...> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Functor>{}), + "_Functor must be a complete class or an unbounded array"); + static_assert((std::__is_complete_or_unbounded( + __type_identity<_ArgTypes>{}) && ...), + "each argument type must be a complete class or an unbounded array"); + }; + + + template + using invoke_result_t = typename invoke_result<_Fn, _Args...>::type; + + + template + 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"); + static_assert((std::__is_complete_or_unbounded( + __type_identity<_ArgTypes>{}) && ...), + "each argument type must be a complete class or an unbounded array"); + }; + + + template + 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"); + static_assert((std::__is_complete_or_unbounded( + __type_identity<_ArgTypes>{}) && ...), + "each argument type must be a complete class or an unbounded array"); + static_assert(std::__is_complete_or_unbounded(__type_identity<_Ret>{}), + "_Ret must be a complete class or an unbounded array"); + }; + + + template + 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"); + static_assert((std::__is_complete_or_unbounded( + __type_identity<_ArgTypes>{}) && ...), + "each argument type must be a complete class or an unbounded array"); + }; + + + + + + template + using __is_nt_invocable_impl + = typename __is_invocable_impl<_Result, _Ret>::__nothrow_conv; + + + + template + struct is_nothrow_invocable_r + : __and_<__is_nt_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>, + __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"); + static_assert((std::__is_complete_or_unbounded( + __type_identity<_ArgTypes>{}) && ...), + "each argument type must be a complete class or an unbounded array"); + static_assert(std::__is_complete_or_unbounded(__type_identity<_Ret>{}), + "_Ret must be a complete class or an unbounded array"); + }; +# 3155 "/usr/include/c++/13/type_traits" 3 +template + inline constexpr bool is_void_v = is_void<_Tp>::value; +template + inline constexpr bool is_null_pointer_v = is_null_pointer<_Tp>::value; +template + inline constexpr bool is_integral_v = is_integral<_Tp>::value; +template + inline constexpr bool is_floating_point_v = is_floating_point<_Tp>::value; + +template + inline constexpr bool is_array_v = false; +template + inline constexpr bool is_array_v<_Tp[]> = true; +template + inline constexpr bool is_array_v<_Tp[_Num]> = true; + +template + inline constexpr bool is_pointer_v = is_pointer<_Tp>::value; +template + inline constexpr bool is_lvalue_reference_v = false; +template + inline constexpr bool is_lvalue_reference_v<_Tp&> = true; +template + inline constexpr bool is_rvalue_reference_v = false; +template + inline constexpr bool is_rvalue_reference_v<_Tp&&> = true; +template + inline constexpr bool is_member_object_pointer_v = + is_member_object_pointer<_Tp>::value; +template + inline constexpr bool is_member_function_pointer_v = + is_member_function_pointer<_Tp>::value; +template + inline constexpr bool is_enum_v = __is_enum(_Tp); +template + inline constexpr bool is_union_v = __is_union(_Tp); +template + inline constexpr bool is_class_v = __is_class(_Tp); +template + inline constexpr bool is_function_v = is_function<_Tp>::value; +template + inline constexpr bool is_reference_v = false; +template + inline constexpr bool is_reference_v<_Tp&> = true; +template + inline constexpr bool is_reference_v<_Tp&&> = true; +template + inline constexpr bool is_arithmetic_v = is_arithmetic<_Tp>::value; +template + inline constexpr bool is_fundamental_v = is_fundamental<_Tp>::value; +template + inline constexpr bool is_object_v = is_object<_Tp>::value; +template + inline constexpr bool is_scalar_v = is_scalar<_Tp>::value; +template + inline constexpr bool is_compound_v = is_compound<_Tp>::value; +template + inline constexpr bool is_member_pointer_v = is_member_pointer<_Tp>::value; +template + inline constexpr bool is_const_v = false; +template + inline constexpr bool is_const_v = true; +template + inline constexpr bool is_volatile_v = false; +template + inline constexpr bool is_volatile_v = true; + +template + inline constexpr bool is_trivial_v = __is_trivial(_Tp); +template + inline constexpr bool is_trivially_copyable_v = __is_trivially_copyable(_Tp); +template + inline constexpr bool is_standard_layout_v = __is_standard_layout(_Tp); +template + + inline constexpr bool is_pod_v = __is_pod(_Tp); +template + [[__deprecated__]] + inline constexpr bool is_literal_type_v = __is_literal_type(_Tp); +template + inline constexpr bool is_empty_v = __is_empty(_Tp); +template + inline constexpr bool is_polymorphic_v = __is_polymorphic(_Tp); +template + inline constexpr bool is_abstract_v = __is_abstract(_Tp); +template + inline constexpr bool is_final_v = __is_final(_Tp); + +template + inline constexpr bool is_signed_v = is_signed<_Tp>::value; +template + inline constexpr bool is_unsigned_v = is_unsigned<_Tp>::value; + +template + inline constexpr bool is_constructible_v = __is_constructible(_Tp, _Args...); +template + inline constexpr bool is_default_constructible_v = __is_constructible(_Tp); +template + inline constexpr bool is_copy_constructible_v + = __is_constructible(_Tp, __add_lval_ref_t); +template + inline constexpr bool is_move_constructible_v + = __is_constructible(_Tp, __add_rval_ref_t<_Tp>); + +template + inline constexpr bool is_assignable_v = __is_assignable(_Tp, _Up); +template + inline constexpr bool is_copy_assignable_v + = __is_assignable(__add_lval_ref_t<_Tp>, __add_lval_ref_t); +template + inline constexpr bool is_move_assignable_v + = __is_assignable(__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>); + +template + inline constexpr bool is_destructible_v = is_destructible<_Tp>::value; + +template + inline constexpr bool is_trivially_constructible_v + = __is_trivially_constructible(_Tp, _Args...); +template + inline constexpr bool is_trivially_default_constructible_v + = __is_trivially_constructible(_Tp); +template + inline constexpr bool is_trivially_copy_constructible_v + = __is_trivially_constructible(_Tp, __add_lval_ref_t); +template + inline constexpr bool is_trivially_move_constructible_v + = __is_trivially_constructible(_Tp, __add_rval_ref_t<_Tp>); + +template + inline constexpr bool is_trivially_assignable_v + = __is_trivially_assignable(_Tp, _Up); +template + inline constexpr bool is_trivially_copy_assignable_v + = __is_trivially_assignable(__add_lval_ref_t<_Tp>, + __add_lval_ref_t); +template + inline constexpr bool is_trivially_move_assignable_v + = __is_trivially_assignable(__add_lval_ref_t<_Tp>, + __add_rval_ref_t<_Tp>); +template + inline constexpr bool is_trivially_destructible_v = + is_trivially_destructible<_Tp>::value; +template + inline constexpr bool is_nothrow_constructible_v + = __is_nothrow_constructible(_Tp, _Args...); +template + inline constexpr bool is_nothrow_default_constructible_v + = __is_nothrow_constructible(_Tp); +template + inline constexpr bool is_nothrow_copy_constructible_v + = __is_nothrow_constructible(_Tp, __add_lval_ref_t); +template + inline constexpr bool is_nothrow_move_constructible_v + = __is_nothrow_constructible(_Tp, __add_rval_ref_t<_Tp>); + +template + inline constexpr bool is_nothrow_assignable_v + = __is_nothrow_assignable(_Tp, _Up); +template + inline constexpr bool is_nothrow_copy_assignable_v + = __is_nothrow_assignable(__add_lval_ref_t<_Tp>, + __add_lval_ref_t); +template + inline constexpr bool is_nothrow_move_assignable_v + = __is_nothrow_assignable(__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>); + +template + inline constexpr bool is_nothrow_destructible_v = + is_nothrow_destructible<_Tp>::value; + +template + inline constexpr bool has_virtual_destructor_v + = __has_virtual_destructor(_Tp); + +template + inline constexpr size_t alignment_of_v = alignment_of<_Tp>::value; + +template + inline constexpr size_t rank_v = 0; +template + inline constexpr size_t rank_v<_Tp[_Size]> = 1 + rank_v<_Tp>; +template + inline constexpr size_t rank_v<_Tp[]> = 1 + rank_v<_Tp>; + +template + inline constexpr size_t extent_v = 0; +template + inline constexpr size_t extent_v<_Tp[_Size], 0> = _Size; +template + inline constexpr size_t extent_v<_Tp[_Size], _Idx> = extent_v<_Tp, _Idx - 1>; +template + inline constexpr size_t extent_v<_Tp[], 0> = 0; +template + inline constexpr size_t extent_v<_Tp[], _Idx> = extent_v<_Tp, _Idx - 1>; + + +template + inline constexpr bool is_same_v = __is_same(_Tp, _Up); + + + + + + +template + inline constexpr bool is_base_of_v = __is_base_of(_Base, _Derived); + +template + inline constexpr bool is_convertible_v = __is_convertible(_From, _To); + + + + +template + inline constexpr bool is_invocable_v = is_invocable<_Fn, _Args...>::value; +template + inline constexpr bool is_nothrow_invocable_v + = is_nothrow_invocable<_Fn, _Args...>::value; +template + inline constexpr bool is_invocable_r_v + = is_invocable_r<_Ret, _Fn, _Args...>::value; +template + inline constexpr bool is_nothrow_invocable_r_v + = is_nothrow_invocable_r<_Ret, _Fn, _Args...>::value; + + + + + + + template + struct has_unique_object_representations + : bool_constant<__has_unique_object_representations( + remove_cv_t> + )> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + inline constexpr bool has_unique_object_representations_v + = has_unique_object_representations<_Tp>::value; + + + + + + + template + struct is_aggregate + : bool_constant<__is_aggregate(remove_cv_t<_Tp>)> + { }; + + + + + + template + inline constexpr bool is_aggregate_v = __is_aggregate(remove_cv_t<_Tp>); +# 3833 "/usr/include/c++/13/type_traits" 3 + +} +# 61 "/usr/include/c++/13/bits/stl_pair.h" 2 3 +# 1 "/usr/include/c++/13/bits/move.h" 1 3 +# 40 "/usr/include/c++/13/bits/move.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + + template + inline constexpr _Tp* + __addressof(_Tp& __r) noexcept + { return __builtin_addressof(__r); } +# 67 "/usr/include/c++/13/bits/move.h" 3 + template + [[__nodiscard__]] + constexpr _Tp&& + forward(typename std::remove_reference<_Tp>::type& __t) noexcept + { return static_cast<_Tp&&>(__t); } + + + + + + + + template + [[__nodiscard__]] + constexpr _Tp&& + forward(typename std::remove_reference<_Tp>::type&& __t) noexcept + { + static_assert(!std::is_lvalue_reference<_Tp>::value, + "std::forward must not be used to convert an rvalue to an lvalue"); + return static_cast<_Tp&&>(__t); + } + + + + + + + template + [[__nodiscard__]] + constexpr typename std::remove_reference<_Tp>::type&& + move(_Tp&& __t) noexcept + { return static_cast::type&&>(__t); } + + + template + struct __move_if_noexcept_cond + : public __and_<__not_>, + is_copy_constructible<_Tp>>::type { }; +# 114 "/usr/include/c++/13/bits/move.h" 3 + template + [[__nodiscard__]] + constexpr + __conditional_t<__move_if_noexcept_cond<_Tp>::value, const _Tp&, _Tp&&> + move_if_noexcept(_Tp& __x) noexcept + { return std::move(__x); } +# 135 "/usr/include/c++/13/bits/move.h" 3 + template + [[__nodiscard__]] + inline constexpr _Tp* + addressof(_Tp& __r) noexcept + { return std::__addressof(__r); } + + + + template + const _Tp* addressof(const _Tp&&) = delete; + + + template + + inline _Tp + __exchange(_Tp& __obj, _Up&& __new_val) + { + _Tp __old_val = std::move(__obj); + __obj = std::forward<_Up>(__new_val); + return __old_val; + } +# 179 "/usr/include/c++/13/bits/move.h" 3 + template + + 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_assignable<_Tp>>::value) + + { + + + + + _Tp __tmp = std::move(__a); + __a = std::move(__b); + __b = std::move(__tmp); + } + + + + + template + + 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]); + } + + + +} +# 62 "/usr/include/c++/13/bits/stl_pair.h" 2 3 +# 1 "/usr/include/c++/13/bits/utility.h" 1 3 +# 36 "/usr/include/c++/13/bits/utility.h" 3 + +# 37 "/usr/include/c++/13/bits/utility.h" 3 + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + template + struct tuple_size; + + + + + + template::type, + typename = typename enable_if::value>::type, + size_t = tuple_size<_Tp>::value> + using __enable_if_has_tuple_size = _Tp; + + template + struct tuple_size> + : public tuple_size<_Tp> { }; + + template + struct tuple_size> + : public tuple_size<_Tp> { }; + + template + struct tuple_size> + : public tuple_size<_Tp> { }; + + + template + inline constexpr size_t tuple_size_v = tuple_size<_Tp>::value; + + + + template + struct tuple_element; + + + template + using __tuple_element_t = typename tuple_element<__i, _Tp>::type; + + template + struct tuple_element<__i, const _Tp> + { + using type = const __tuple_element_t<__i, _Tp>; + }; + + template + struct tuple_element<__i, volatile _Tp> + { + using type = volatile __tuple_element_t<__i, _Tp>; + }; + + template + struct tuple_element<__i, const volatile _Tp> + { + using type = const volatile __tuple_element_t<__i, _Tp>; + }; + + + + + + template + constexpr size_t + __find_uniq_type_in_pack() + { + constexpr size_t __sz = sizeof...(_Types); + constexpr bool __found[__sz] = { __is_same(_Tp, _Types) ... }; + size_t __n = __sz; + for (size_t __i = 0; __i < __sz; ++__i) + { + if (__found[__i]) + { + if (__n < __sz) + return __sz; + __n = __i; + } + } + return __n; + } +# 134 "/usr/include/c++/13/bits/utility.h" 3 + template + using tuple_element_t = typename tuple_element<__i, _Tp>::type; + + + + + template struct _Index_tuple { }; + + + template + struct _Build_index_tuple + { +# 154 "/usr/include/c++/13/bits/utility.h" 3 + using __type = _Index_tuple<__integer_pack(_Num)...>; + + }; + + + + + + + template + struct integer_sequence + { + + + + typedef _Tp value_type; + static constexpr size_t size() noexcept { return sizeof...(_Idx); } + }; + + + template + using make_integer_sequence + + + + = integer_sequence<_Tp, __integer_pack(_Tp(_Num))...>; + + + + template + using index_sequence = integer_sequence; + + + template + using make_index_sequence = make_integer_sequence; + + + template + using index_sequence_for = make_index_sequence; + + + + struct in_place_t { + explicit in_place_t() = default; + }; + + inline constexpr in_place_t in_place{}; + + template struct in_place_type_t + { + explicit in_place_type_t() = default; + }; + + template + inline constexpr in_place_type_t<_Tp> in_place_type{}; + + template struct in_place_index_t + { + explicit in_place_index_t() = default; + }; + + template + inline constexpr in_place_index_t<_Idx> in_place_index{}; + + template + inline constexpr bool __is_in_place_type_v = false; + + template + inline constexpr bool __is_in_place_type_v> = true; + + template + using __is_in_place_type = bool_constant<__is_in_place_type_v<_Tp>>; + + + + + template + struct _Nth_type + { }; + + template + struct _Nth_type<0, _Tp0, _Rest...> + { using type = _Tp0; }; + + template + struct _Nth_type<1, _Tp0, _Tp1, _Rest...> + { using type = _Tp1; }; + + template + struct _Nth_type<2, _Tp0, _Tp1, _Tp2, _Rest...> + { using type = _Tp2; }; + + template + + + + struct _Nth_type<_Np, _Tp0, _Tp1, _Tp2, _Rest...> + : _Nth_type<_Np - 3, _Rest...> + { }; + + + template + struct _Nth_type<0, _Tp0, _Tp1, _Tp2, _Rest...> + { using type = _Tp0; }; + + template + struct _Nth_type<1, _Tp0, _Tp1, _Tp2, _Rest...> + { using type = _Tp1; }; + + + + + + + +} +# 63 "/usr/include/c++/13/bits/stl_pair.h" 2 3 + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 80 "/usr/include/c++/13/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 + class tuple; + + template + struct _Index_tuple; + + + + + + + + template + struct _PCC + { + template + static constexpr bool _ConstructiblePair() + { + return __and_, + is_constructible<_T2, const _U2&>>::value; + } + + template + static constexpr bool _ImplicitlyConvertiblePair() + { + return __and_, + is_convertible>::value; + } + + template + static constexpr bool _MoveConstructiblePair() + { + return __and_, + is_constructible<_T2, _U2&&>>::value; + } + + template + static constexpr bool _ImplicitlyMoveConvertiblePair() + { + return __and_, + is_convertible<_U2&&, _T2>>::value; + } + }; + + template + struct _PCC + { + template + static constexpr bool _ConstructiblePair() + { + return false; + } + + template + static constexpr bool _ImplicitlyConvertiblePair() + { + return false; + } + + template + static constexpr bool _MoveConstructiblePair() + { + return false; + } + + template + static constexpr bool _ImplicitlyMoveConvertiblePair() + { + return false; + } + }; + + + + template class __pair_base + { + + template friend struct pair; + __pair_base() = default; + ~__pair_base() = default; + __pair_base(const __pair_base&) = default; + __pair_base& operator=(const __pair_base&) = delete; + + }; +# 186 "/usr/include/c++/13/bits/stl_pair.h" 3 + template + struct pair + : public __pair_base<_T1, _T2> + { + typedef _T1 first_type; + typedef _T2 second_type; + + _T1 first; + _T2 second; + + + constexpr pair(const pair&) = default; + constexpr pair(pair&&) = default; + + template + + pair(piecewise_construct_t, tuple<_Args1...>, tuple<_Args2...>); + + + 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); + } +# 234 "/usr/include/c++/13/bits/stl_pair.h" 3 + private: + template + + pair(tuple<_Args1...>&, tuple<_Args2...>&, + _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>); + public: +# 525 "/usr/include/c++/13/bits/stl_pair.h" 3 + template , + __is_implicitly_default_constructible<_U2>> + ::value, bool>::type = true> + constexpr pair() + : first(), second() { } + + template , + 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() { } + + + + using _PCCP = _PCC; + + + + template() + && _PCCP::template + _ImplicitlyConvertiblePair<_U1, _U2>(), + bool>::type=true> + constexpr pair(const _T1& __a, const _T2& __b) + : first(__a), second(__b) { } + + + template() + && !_PCCP::template + _ImplicitlyConvertiblePair<_U1, _U2>(), + bool>::type=false> + explicit constexpr pair(const _T1& __a, const _T2& __b) + : first(__a), second(__b) { } + + + + template + using _PCCFP = _PCC::value + || !is_same<_T2, _U2>::value, + _T1, _T2>; + + + template::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::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) + { ; } +# 609 "/usr/include/c++/13/bits/stl_pair.h" 3 + private: + + + + struct __zero_as_null_pointer_constant + { + __zero_as_null_pointer_constant(int __zero_as_null_pointer_constant::*) + { } + template::value>> + __zero_as_null_pointer_constant(_Tp) = delete; + }; + + public: + + + + + template>, + is_pointer<_T2>, + is_constructible<_T1, _U1>, + __not_>, + is_convertible<_U1, _T1>>::value, + bool> = true> + __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initialize std::pair of move-only " "type and pointer"))) + constexpr + pair(_U1&& __x, __zero_as_null_pointer_constant, ...) + : first(std::forward<_U1>(__x)), second(nullptr) + { ; } + + template>, + is_pointer<_T2>, + is_constructible<_T1, _U1>, + __not_>, + __not_>>::value, + bool> = false> + __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initialize std::pair of move-only " "type and pointer"))) + explicit constexpr + pair(_U1&& __x, __zero_as_null_pointer_constant, ...) + : first(std::forward<_U1>(__x)), second(nullptr) + { ; } + + template, + __not_>, + is_constructible<_T2, _U2>, + __not_>, + is_convertible<_U2, _T2>>::value, + bool> = true> + __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initialize std::pair of move-only " "type and pointer"))) + constexpr + pair(__zero_as_null_pointer_constant, _U2&& __y, ...) + : first(nullptr), second(std::forward<_U2>(__y)) + { ; } + + template, + __not_>, + is_constructible<_T2, _U2>, + __not_>, + __not_>>::value, + bool> = false> + __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initialize std::pair of move-only " "type and pointer"))) + explicit constexpr + pair(__zero_as_null_pointer_constant, _U2&& __y, ...) + : first(nullptr), second(std::forward<_U2>(__y)) + { ; } + + + + template() + && _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() + && !_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::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::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)) + { ; } + + + + pair& + operator=(__conditional_t<__and_, + is_copy_assignable<_T2>>::value, + const pair&, const __nonesuch&> __p) + { + first = __p.first; + second = __p.second; + return *this; + } + + pair& + operator=(__conditional_t<__and_, + is_move_assignable<_T2>>::value, + pair&&, __nonesuch&&> __p) + noexcept(__and_, + is_nothrow_move_assignable<_T2>>::value) + { + first = std::forward(__p.first); + second = std::forward(__p.second); + return *this; + } + + template + typename enable_if<__and_, + is_assignable<_T2&, const _U2&>>::value, + pair&>::type + operator=(const pair<_U1, _U2>& __p) + { + first = __p.first; + second = __p.second; + return *this; + } + + template + typename enable_if<__and_, + 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; + } +# 801 "/usr/include/c++/13/bits/stl_pair.h" 3 + }; + + + + + template pair(_T1, _T2) -> pair<_T1, _T2>; + + + + template + inline constexpr bool + operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return __x.first == __y.first && __x.second == __y.second; } +# 833 "/usr/include/c++/13/bits/stl_pair.h" 3 + template + 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 + inline constexpr bool + operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return !(__x == __y); } + + + template + inline constexpr bool + operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return __y < __x; } + + + template + inline constexpr bool + operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return !(__y < __x); } + + + template + inline constexpr bool + operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return !(__x < __y); } +# 870 "/usr/include/c++/13/bits/stl_pair.h" 3 + template + 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); } +# 893 "/usr/include/c++/13/bits/stl_pair.h" 3 + template + typename enable_if, + __is_swappable<_T2>>::value>::type + swap(pair<_T1, _T2>&, pair<_T1, _T2>&) = delete; +# 919 "/usr/include/c++/13/bits/stl_pair.h" 3 + template + constexpr pair::__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)); + } +# 942 "/usr/include/c++/13/bits/stl_pair.h" 3 + template + struct __is_tuple_like_impl> : true_type + { }; + + + + template + struct tuple_size> + : public integral_constant { }; + + + template + struct tuple_element<0, pair<_Tp1, _Tp2>> + { typedef _Tp1 type; }; + + + template + struct tuple_element<1, pair<_Tp1, _Tp2>> + { typedef _Tp2 type; }; + + + template + inline constexpr size_t tuple_size_v> = 2; + + template + inline constexpr size_t tuple_size_v> = 2; + + template + inline constexpr bool __is_pair = false; + + template + inline constexpr bool __is_pair> = true; + + + + template + struct __pair_get; + + template<> + struct __pair_get<0> + { + template + static constexpr _Tp1& + __get(pair<_Tp1, _Tp2>& __pair) noexcept + { return __pair.first; } + + template + static constexpr _Tp1&& + __move_get(pair<_Tp1, _Tp2>&& __pair) noexcept + { return std::forward<_Tp1>(__pair.first); } + + template + static constexpr const _Tp1& + __const_get(const pair<_Tp1, _Tp2>& __pair) noexcept + { return __pair.first; } + + template + static constexpr const _Tp1&& + __const_move_get(const pair<_Tp1, _Tp2>&& __pair) noexcept + { return std::forward(__pair.first); } + }; + + template<> + struct __pair_get<1> + { + template + static constexpr _Tp2& + __get(pair<_Tp1, _Tp2>& __pair) noexcept + { return __pair.second; } + + template + static constexpr _Tp2&& + __move_get(pair<_Tp1, _Tp2>&& __pair) noexcept + { return std::forward<_Tp2>(__pair.second); } + + template + static constexpr const _Tp2& + __const_get(const pair<_Tp1, _Tp2>& __pair) noexcept + { return __pair.second; } + + template + static constexpr const _Tp2&& + __const_move_get(const pair<_Tp1, _Tp2>&& __pair) noexcept + { return std::forward(__pair.second); } + }; + + + + + + + template + constexpr typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type& + get(pair<_Tp1, _Tp2>& __in) noexcept + { return __pair_get<_Int>::__get(__in); } + + template + constexpr typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&& + get(pair<_Tp1, _Tp2>&& __in) noexcept + { return __pair_get<_Int>::__move_get(std::move(__in)); } + + template + constexpr const typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type& + get(const pair<_Tp1, _Tp2>& __in) noexcept + { return __pair_get<_Int>::__const_get(__in); } + + template + constexpr const typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&& + get(const pair<_Tp1, _Tp2>&& __in) noexcept + { return __pair_get<_Int>::__const_move_get(std::move(__in)); } + + + + + + template + constexpr _Tp& + get(pair<_Tp, _Up>& __p) noexcept + { return __p.first; } + + template + constexpr const _Tp& + get(const pair<_Tp, _Up>& __p) noexcept + { return __p.first; } + + template + constexpr _Tp&& + get(pair<_Tp, _Up>&& __p) noexcept + { return std::move(__p.first); } + + template + constexpr const _Tp&& + get(const pair<_Tp, _Up>&& __p) noexcept + { return std::move(__p.first); } + + template + constexpr _Tp& + get(pair<_Up, _Tp>& __p) noexcept + { return __p.second; } + + template + constexpr const _Tp& + get(const pair<_Up, _Tp>& __p) noexcept + { return __p.second; } + + template + constexpr _Tp&& + get(pair<_Up, _Tp>&& __p) noexcept + { return std::move(__p.second); } + + template + constexpr const _Tp&& + get(const pair<_Up, _Tp>&& __p) noexcept + { return std::move(__p.second); } +# 1118 "/usr/include/c++/13/bits/stl_pair.h" 3 + +} +# 65 "/usr/include/c++/13/bits/stl_algobase.h" 2 3 +# 1 "/usr/include/c++/13/bits/stl_iterator_base_types.h" 1 3 +# 62 "/usr/include/c++/13/bits/stl_iterator_base_types.h" 3 + +# 63 "/usr/include/c++/13/bits/stl_iterator_base_types.h" 3 +# 74 "/usr/include/c++/13/bits/stl_iterator_base_types.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 93 "/usr/include/c++/13/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++/13/bits/stl_iterator_base_types.h" 3 + template + struct [[__deprecated__]] iterator + { + + typedef _Category iterator_category; + + typedef _Tp value_type; + + typedef _Distance difference_type; + + typedef _Pointer pointer; + + typedef _Reference reference; + }; +# 149 "/usr/include/c++/13/bits/stl_iterator_base_types.h" 3 + template + struct iterator_traits; + + + + + template> + struct __iterator_traits { }; + + + + template + struct __iterator_traits<_Iterator, + __void_t> + { + 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 + struct iterator_traits + : public __iterator_traits<_Iterator> { }; +# 209 "/usr/include/c++/13/bits/stl_iterator_base_types.h" 3 + template + 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 + struct iterator_traits + { + 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 + __attribute__((__always_inline__)) + inline constexpr + typename iterator_traits<_Iter>::iterator_category + __iterator_category(const _Iter&) + { return typename iterator_traits<_Iter>::iterator_category(); } + + + + + template + using __iter_category_t + = typename iterator_traits<_Iter>::iterator_category; + + template + using _RequireInputIter = + __enable_if_t, + input_iterator_tag>::value>; + + template> + struct __is_random_access_iter + : is_base_of + { + typedef is_base_of _Base; + enum { __value = _Base::value }; + }; + + + + + + + + +} +# 66 "/usr/include/c++/13/bits/stl_algobase.h" 2 3 +# 1 "/usr/include/c++/13/bits/stl_iterator_base_funcs.h" 1 3 +# 62 "/usr/include/c++/13/bits/stl_iterator_base_funcs.h" 3 + +# 63 "/usr/include/c++/13/bits/stl_iterator_base_funcs.h" 3 + +# 1 "/usr/include/c++/13/bits/concept_check.h" 1 3 +# 33 "/usr/include/c++/13/bits/concept_check.h" 3 + +# 34 "/usr/include/c++/13/bits/concept_check.h" 3 +# 65 "/usr/include/c++/13/bits/stl_iterator_base_funcs.h" 2 3 +# 1 "/usr/include/c++/13/debug/assertions.h" 1 3 +# 66 "/usr/include/c++/13/bits/stl_iterator_base_funcs.h" 2 3 + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + template struct _List_iterator; + template struct _List_const_iterator; + + + template + 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 + __attribute__((__always_inline__)) + inline constexpr + typename iterator_traits<_RandomAccessIterator>::difference_type + __distance(_RandomAccessIterator __first, _RandomAccessIterator __last, + random_access_iterator_tag) + { + + + + return __last - __first; + } + + + + template + ptrdiff_t + __distance(std::_List_iterator<_Tp>, + std::_List_iterator<_Tp>, + input_iterator_tag); + + template + ptrdiff_t + __distance(std::_List_const_iterator<_Tp>, + std::_List_const_iterator<_Tp>, + input_iterator_tag); + + + + + template + void + __distance(_OutputIterator, _OutputIterator, output_iterator_tag) = delete; +# 144 "/usr/include/c++/13/bits/stl_iterator_base_funcs.h" 3 + template + [[__nodiscard__]] __attribute__((__always_inline__)) + inline constexpr + typename iterator_traits<_InputIterator>::difference_type + distance(_InputIterator __first, _InputIterator __last) + { + + return std::__distance(__first, __last, + std::__iterator_category(__first)); + } + + template + inline constexpr void + __advance(_InputIterator& __i, _Distance __n, input_iterator_tag) + { + + + do { if (std::__is_constant_evaluated() && !bool(__n >= 0)) __builtin_unreachable(); } while (false); + while (__n--) + ++__i; + } + + template + inline constexpr void + __advance(_BidirectionalIterator& __i, _Distance __n, + bidirectional_iterator_tag) + { + + + + if (__n > 0) + while (__n--) + ++__i; + else + while (__n++) + --__i; + } + + template + 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; + } + + + + template + void + __advance(_OutputIterator&, _Distance, output_iterator_tag) = delete; +# 217 "/usr/include/c++/13/bits/stl_iterator_base_funcs.h" 3 + template + __attribute__((__always_inline__)) + 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 + [[__nodiscard__]] [[__gnu__::__always_inline__]] + inline constexpr _InputIterator + next(_InputIterator __x, typename + iterator_traits<_InputIterator>::difference_type __n = 1) + { + + + std::advance(__x, __n); + return __x; + } + + template + [[__nodiscard__]] [[__gnu__::__always_inline__]] + inline constexpr _BidirectionalIterator + prev(_BidirectionalIterator __x, typename + iterator_traits<_BidirectionalIterator>::difference_type __n = 1) + { + + + + std::advance(__x, -__n); + return __x; + } + + + + +} +# 67 "/usr/include/c++/13/bits/stl_algobase.h" 2 3 +# 1 "/usr/include/c++/13/bits/stl_iterator.h" 1 3 +# 67 "/usr/include/c++/13/bits/stl_iterator.h" 3 +# 1 "/usr/include/c++/13/bits/ptr_traits.h" 1 3 +# 49 "/usr/include/c++/13/bits/ptr_traits.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + class __undefined; + + + + template + struct __get_first_arg + { using type = __undefined; }; + + template class _SomeTemplate, typename _Tp, + typename... _Types> + struct __get_first_arg<_SomeTemplate<_Tp, _Types...>> + { using type = _Tp; }; + + + + template + struct __replace_first_arg + { }; + + template class _SomeTemplate, typename _Up, + typename _Tp, typename... _Types> + struct __replace_first_arg<_SomeTemplate<_Tp, _Types...>, _Up> + { using type = _SomeTemplate<_Up, _Types...>; }; + + + template + struct __ptr_traits_elem : __get_first_arg<_Ptr> + { }; + + + + + + + + template + struct __ptr_traits_elem<_Ptr, __void_t> + { using type = typename _Ptr::element_type; }; + + + template + using __ptr_traits_elem_t = typename __ptr_traits_elem<_Ptr>::type; + + + + + template::value> + struct __ptr_traits_ptr_to + { + using pointer = _Ptr; + using element_type = _Elt; + + + + + + + + static pointer + pointer_to(element_type& __r) + + + + + + { return pointer::pointer_to(__r); } + }; + + + template + struct __ptr_traits_ptr_to<_Ptr, _Elt, true> + { }; + + + template + struct __ptr_traits_ptr_to<_Tp*, _Tp, false> + { + using pointer = _Tp*; + using element_type = _Tp; + + + + + + + static pointer + pointer_to(element_type& __r) noexcept + { return std::addressof(__r); } + }; + + template + struct __ptr_traits_impl : __ptr_traits_ptr_to<_Ptr, _Elt> + { + private: + template + using __diff_t = typename _Tp::difference_type; + + template + using __rebind = __type_identity>; + + public: + + using pointer = _Ptr; + + + using element_type = _Elt; + + + using difference_type = __detected_or_t; + + + template + using rebind = typename __detected_or_t<__replace_first_arg<_Ptr, _Up>, + __rebind, _Ptr, _Up>::type; + }; + + + + template + struct __ptr_traits_impl<_Ptr, __undefined> + { }; + + + + + + + + template + struct pointer_traits : __ptr_traits_impl<_Ptr, __ptr_traits_elem_t<_Ptr>> + { }; + + + + + + + + template + struct pointer_traits<_Tp*> : __ptr_traits_ptr_to<_Tp*, _Tp> + { + + typedef _Tp* pointer; + + typedef _Tp element_type; + + typedef ptrdiff_t difference_type; + + template using rebind = _Up*; + }; + + + template + using __ptr_rebind = typename pointer_traits<_Ptr>::template rebind<_Tp>; + + template + constexpr _Tp* + __to_address(_Tp* __ptr) noexcept + { + static_assert(!std::is_function<_Tp>::value, "not a function pointer"); + return __ptr; + } + + + template + constexpr typename std::pointer_traits<_Ptr>::element_type* + __to_address(const _Ptr& __ptr) + { return std::__to_address(__ptr.operator->()); } +# 266 "/usr/include/c++/13/bits/ptr_traits.h" 3 + +} +# 68 "/usr/include/c++/13/bits/stl_iterator.h" 2 3 +# 88 "/usr/include/c++/13/bits/stl_iterator.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 113 "/usr/include/c++/13/bits/stl_iterator.h" 3 + +# 113 "/usr/include/c++/13/bits/stl_iterator.h" 3 +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" +# 135 "/usr/include/c++/13/bits/stl_iterator.h" 3 + template + class reverse_iterator + : public 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> + { + template + friend class reverse_iterator; +# 154 "/usr/include/c++/13/bits/stl_iterator.h" 3 + protected: + _Iterator current; + + typedef iterator_traits<_Iterator> __traits_type; + + public: + typedef _Iterator iterator_type; + typedef typename __traits_type::pointer pointer; + + typedef typename __traits_type::difference_type difference_type; + typedef typename __traits_type::reference reference; +# 185 "/usr/include/c++/13/bits/stl_iterator.h" 3 + constexpr + reverse_iterator() + noexcept(noexcept(_Iterator())) + : current() + { } + + + + + explicit constexpr + reverse_iterator(iterator_type __x) + noexcept(noexcept(_Iterator(__x))) + : current(__x) + { } + + + + + constexpr + reverse_iterator(const reverse_iterator& __x) + noexcept(noexcept(_Iterator(__x.current))) + : current(__x.current) + { } + + + reverse_iterator& operator=(const reverse_iterator&) = default; + + + + + + + template + + + + constexpr + reverse_iterator(const reverse_iterator<_Iter>& __x) + noexcept(noexcept(_Iterator(__x.current))) + : current(__x.current) + { } + + + template + + + + + constexpr + reverse_iterator& + operator=(const reverse_iterator<_Iter>& __x) + noexcept(noexcept(current = __x.current)) + { + current = __x.current; + return *this; + } + + + + + + [[__nodiscard__]] + constexpr iterator_type + base() const + noexcept(noexcept(_Iterator(current))) + { return current; } +# 262 "/usr/include/c++/13/bits/stl_iterator.h" 3 + [[__nodiscard__]] + constexpr reference + operator*() const + { + _Iterator __tmp = current; + return *--__tmp; + } + + + + + + + [[__nodiscard__]] + 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; + } + + + + + + + [[__nodiscard__]] + constexpr reverse_iterator + operator+(difference_type __n) const + { return reverse_iterator(current - __n); } + + + + + + + + constexpr reverse_iterator& + operator+=(difference_type __n) + { + current -= __n; + return *this; + } + + + + + + + [[__nodiscard__]] + constexpr reverse_iterator + operator-(difference_type __n) const + { return reverse_iterator(current + __n); } + + + + + + + + constexpr reverse_iterator& + operator-=(difference_type __n) + { + current += __n; + return *this; + } + + + + + + + [[__nodiscard__]] + constexpr reference + operator[](difference_type __n) const + { return *(*this + __n); } +# 422 "/usr/include/c++/13/bits/stl_iterator.h" 3 + private: + template + static constexpr _Tp* + _S_to_pointer(_Tp* __p) + { return __p; } + + template + static constexpr pointer + _S_to_pointer(_Tp __t) + { return __t.operator->(); } + }; +# 445 "/usr/include/c++/13/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline constexpr bool + operator==(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return __x.base() == __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator<(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return __y.base() < __x.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator!=(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return !(__x == __y); } + + template + [[__nodiscard__]] + inline constexpr bool + operator>(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return __y < __x; } + + template + [[__nodiscard__]] + inline constexpr bool + operator<=(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return !(__y < __x); } + + template + [[__nodiscard__]] + inline constexpr bool + operator>=(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return !(__x < __y); } + + + + + template + [[__nodiscard__]] + inline constexpr bool + operator==(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() == __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator<(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() > __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator!=(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() != __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator>(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() < __y.base(); } + + template + inline constexpr bool + operator<=(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() >= __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator>=(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() <= __y.base(); } +# 622 "/usr/include/c++/13/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + 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 + [[__nodiscard__]] + 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 + inline constexpr reverse_iterator<_Iterator> + __make_reverse_iterator(_Iterator __i) + { return reverse_iterator<_Iterator>(__i); } + + + + + + + + template + [[__nodiscard__]] + inline constexpr reverse_iterator<_Iterator> + make_reverse_iterator(_Iterator __i) + { return reverse_iterator<_Iterator>(__i); } +# 666 "/usr/include/c++/13/bits/stl_iterator.h" 3 + template + + auto + __niter_base(reverse_iterator<_Iterator> __it) + -> decltype(__make_reverse_iterator(__niter_base(__it.base()))) + { return __make_reverse_iterator(__niter_base(__it.base())); } + + template + struct __is_move_iterator > + : __is_move_iterator<_Iterator> + { }; + + template + + auto + __miter_base(reverse_iterator<_Iterator> __it) + -> decltype(__make_reverse_iterator(__miter_base(__it.base()))) + { return __make_reverse_iterator(__miter_base(__it.base())); } +# 697 "/usr/include/c++/13/bits/stl_iterator.h" 3 + template + class back_insert_iterator + : public iterator + { + protected: + _Container* container; + + public: + + typedef _Container container_type; + + + + + + explicit + back_insert_iterator(_Container& __x) + : container(std::__addressof(__x)) { } +# 735 "/usr/include/c++/13/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; + } + + + + [[__nodiscard__]] + back_insert_iterator& + operator*() + { return *this; } + + + + back_insert_iterator& + operator++() + { return *this; } + + + + back_insert_iterator + operator++(int) + { return *this; } + }; +# 782 "/usr/include/c++/13/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline back_insert_iterator<_Container> + back_inserter(_Container& __x) + { return back_insert_iterator<_Container>(__x); } +# 798 "/usr/include/c++/13/bits/stl_iterator.h" 3 + template + class front_insert_iterator + : public iterator + { + protected: + _Container* container; + + public: + + typedef _Container container_type; + + + + + + explicit + front_insert_iterator(_Container& __x) + : container(std::__addressof(__x)) { } +# 836 "/usr/include/c++/13/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; + } + + + + [[__nodiscard__]] + front_insert_iterator& + operator*() + { return *this; } + + + + front_insert_iterator& + operator++() + { return *this; } + + + + front_insert_iterator + operator++(int) + { return *this; } + }; +# 883 "/usr/include/c++/13/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline front_insert_iterator<_Container> + front_inserter(_Container& __x) + { return front_insert_iterator<_Container>(__x); } +# 903 "/usr/include/c++/13/bits/stl_iterator.h" 3 + template + class insert_iterator + : public iterator + { + + + + typedef typename _Container::iterator _Iter; + + protected: + _Container* container; + _Iter iter; + + public: + + typedef _Container container_type; +# 928 "/usr/include/c++/13/bits/stl_iterator.h" 3 + + insert_iterator(_Container& __x, _Iter __i) + : container(std::__addressof(__x)), iter(__i) {} +# 964 "/usr/include/c++/13/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; + } + + + + [[__nodiscard__]] + insert_iterator& + operator*() + { return *this; } + + + + insert_iterator& + operator++() + { return *this; } + + + + insert_iterator& + operator++(int) + { return *this; } + }; + +#pragma GCC diagnostic pop +# 1023 "/usr/include/c++/13/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline insert_iterator<_Container> + inserter(_Container& __x, typename _Container::iterator __i) + { return insert_iterator<_Container>(__x, __i); } + + + + + +} + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + +# 1046 "/usr/include/c++/13/bits/stl_iterator.h" 3 + template + class __normal_iterator + { + protected: + _Iterator _M_current; + + typedef std::iterator_traits<_Iterator> __traits_type; + + + template + using __convertible_from + = std::__enable_if_t::value>; + + + 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> + + __normal_iterator(const __normal_iterator<_Iter, _Container>& __i) + noexcept +# 1094 "/usr/include/c++/13/bits/stl_iterator.h" 3 + : _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; } + }; +# 1214 "/usr/include/c++/13/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline bool + operator==(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() == __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator==(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() == __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() != __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator!=(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() != __rhs.base(); } + + + template + [[__nodiscard__]] + inline bool + operator<(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() < __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator<(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() < __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator>(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() > __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator>(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() > __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() <= __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator<=(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() <= __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() >= __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator>=(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() >= __rhs.base(); } + + + + + + + template + + + [[__nodiscard__]] + 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 + [[__nodiscard__]] + 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 + [[__nodiscard__]] + 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 + + _Iterator + __niter_base(__gnu_cxx::__normal_iterator<_Iterator, _Container> __it) + noexcept(std::is_nothrow_copy_constructible<_Iterator>::value) + { return __it.base(); } + + + + + + + template + constexpr auto + __to_address(const __gnu_cxx::__normal_iterator<_Iterator, + _Container>& __it) noexcept + -> decltype(std::__to_address(__it.base())) + { return std::__to_address(__it.base()); } +# 1421 "/usr/include/c++/13/bits/stl_iterator.h" 3 + namespace __detail + { +# 1437 "/usr/include/c++/13/bits/stl_iterator.h" 3 + } +# 1448 "/usr/include/c++/13/bits/stl_iterator.h" 3 + template + class move_iterator + + + + { + _Iterator _M_current; + + using __traits_type = iterator_traits<_Iterator>; + + using __base_ref = typename __traits_type::reference; + + + template + friend class move_iterator; +# 1487 "/usr/include/c++/13/bits/stl_iterator.h" 3 + public: + using iterator_type = _Iterator; +# 1501 "/usr/include/c++/13/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; + + + using reference + = __conditional_t::value, + typename remove_reference<__base_ref>::type&&, + __base_ref>; + + + constexpr + move_iterator() + : _M_current() { } + + explicit constexpr + move_iterator(iterator_type __i) + : _M_current(std::move(__i)) { } + + template + + + + constexpr + move_iterator(const move_iterator<_Iter>& __i) + : _M_current(__i._M_current) { } + + template + + + + + constexpr + move_iterator& operator=(const move_iterator<_Iter>& __i) + { + _M_current = __i._M_current; + return *this; + } + + + [[__nodiscard__]] + constexpr iterator_type + base() const + { return _M_current; } +# 1559 "/usr/include/c++/13/bits/stl_iterator.h" 3 + [[__nodiscard__]] + constexpr reference + operator*() const + + + + { return static_cast(*_M_current); } + + + [[__nodiscard__]] + 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; + } + + [[__nodiscard__]] + 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; + } + + [[__nodiscard__]] + 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; + } + + [[__nodiscard__]] + constexpr reference + operator[](difference_type __n) const + + + + { return std::move(_M_current[__n]); } +# 1673 "/usr/include/c++/13/bits/stl_iterator.h" 3 + }; + + template + [[__nodiscard__]] + inline constexpr bool + operator==(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return __x.base() == __y.base(); } +# 1694 "/usr/include/c++/13/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline constexpr bool + operator!=(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + { return !(__x == __y); } + + + template + [[__nodiscard__]] + inline constexpr bool + operator<(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return __x.base() < __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator<=(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return !(__y < __x); } + + template + [[__nodiscard__]] + inline constexpr bool + operator>(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return __y < __x; } + + template + [[__nodiscard__]] + inline constexpr bool + operator>=(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return !(__x < __y); } + + + + + template + [[__nodiscard__]] + inline constexpr bool + operator==(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return __x.base() == __y.base(); } +# 1760 "/usr/include/c++/13/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline constexpr bool + operator!=(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return !(__x == __y); } + + template + [[__nodiscard__]] + inline constexpr bool + operator<(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return __x.base() < __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator<=(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return !(__y < __x); } + + template + [[__nodiscard__]] + inline constexpr bool + operator>(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return __y < __x; } + + template + [[__nodiscard__]] + inline constexpr bool + operator>=(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return !(__x < __y); } + + + + template + [[__nodiscard__]] + 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 + [[__nodiscard__]] + inline constexpr move_iterator<_Iterator> + operator+(typename move_iterator<_Iterator>::difference_type __n, + const move_iterator<_Iterator>& __x) + { return __x + __n; } + + template + [[__nodiscard__]] + inline constexpr move_iterator<_Iterator> + make_move_iterator(_Iterator __i) + { return move_iterator<_Iterator>(std::move(__i)); } + + template::value_type>::value, + _Iterator, move_iterator<_Iterator>>> + inline constexpr _ReturnType + __make_move_if_noexcept_iterator(_Iterator __i) + { return _ReturnType(__i); } + + + + template::value, + const _Tp*, move_iterator<_Tp*>>> + inline constexpr _ReturnType + __make_move_if_noexcept_iterator(_Tp* __i) + { return _ReturnType(__i); } +# 2951 "/usr/include/c++/13/bits/stl_iterator.h" 3 + template + + auto + __niter_base(move_iterator<_Iterator> __it) + -> decltype(make_move_iterator(__niter_base(__it.base()))) + { return make_move_iterator(__niter_base(__it.base())); } + + template + struct __is_move_iterator > + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template + + auto + __miter_base(move_iterator<_Iterator> __it) + -> decltype(__miter_base(__it.base())) + { return __miter_base(__it.base()); } +# 2983 "/usr/include/c++/13/bits/stl_iterator.h" 3 + template + using __iter_key_t = remove_const_t< + typename iterator_traits<_InputIterator>::value_type::first_type>; + + template + using __iter_val_t + = typename iterator_traits<_InputIterator>::value_type::second_type; + + template + struct pair; + + template + using __iter_to_alloc_t + = pair, __iter_val_t<_InputIterator>>; + + + +} +# 68 "/usr/include/c++/13/bits/stl_algobase.h" 2 3 + +# 1 "/usr/include/c++/13/debug/debug.h" 1 3 +# 48 "/usr/include/c++/13/debug/debug.h" 3 +namespace std +{ + namespace __debug { } +} + + + + +namespace __gnu_debug +{ + using namespace std::__debug; + + template + struct _Safe_iterator; +} +# 70 "/usr/include/c++/13/bits/stl_algobase.h" 2 3 + +# 1 "/usr/include/c++/13/bits/predefined_ops.h" 1 3 +# 35 "/usr/include/c++/13/bits/predefined_ops.h" 3 +namespace __gnu_cxx +{ +namespace __ops +{ + struct _Iter_less_iter + { + template + 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 + + 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 + + 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 + + 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 + + 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 + struct _Iter_comp_iter + { + _Compare _M_comp; + + explicit constexpr + _Iter_comp_iter(_Compare __comp) + : _M_comp(std::move(__comp)) + { } + + template + constexpr + bool + operator()(_Iterator1 __it1, _Iterator2 __it2) + { return bool(_M_comp(*__it1, *__it2)); } + }; + + template + constexpr + inline _Iter_comp_iter<_Compare> + __iter_comp_iter(_Compare __comp) + { return _Iter_comp_iter<_Compare>(std::move(__comp)); } + + template + 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 + + bool + operator()(_Iterator __it, _Value& __val) + { return bool(_M_comp(*__it, __val)); } + }; + + template + + inline _Iter_comp_val<_Compare> + __iter_comp_val(_Compare __comp) + { return _Iter_comp_val<_Compare>(std::move(__comp)); } + + template + + inline _Iter_comp_val<_Compare> + __iter_comp_val(_Iter_comp_iter<_Compare> __comp) + { return _Iter_comp_val<_Compare>(std::move(__comp)); } + + template + 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 + + bool + operator()(_Value& __val, _Iterator __it) + { return bool(_M_comp(__val, *__it)); } + }; + + template + + inline _Val_comp_iter<_Compare> + __val_comp_iter(_Compare __comp) + { return _Val_comp_iter<_Compare>(std::move(__comp)); } + + template + + inline _Val_comp_iter<_Compare> + __val_comp_iter(_Iter_comp_iter<_Compare> __comp) + { return _Val_comp_iter<_Compare>(std::move(__comp)); } + + template + struct _Iter_equals_val + { + _Value& _M_value; + + + explicit + _Iter_equals_val(_Value& __value) + : _M_value(__value) + { } + + template + + bool + operator()(_Iterator __it) + { return *__it == _M_value; } + }; + + template + + inline _Iter_equals_val<_Value> + __iter_equals_val(_Value& __val) + { return _Iter_equals_val<_Value>(__val); } + + template + struct _Iter_equals_iter + { + _Iterator1 _M_it1; + + + explicit + _Iter_equals_iter(_Iterator1 __it1) + : _M_it1(__it1) + { } + + template + + bool + operator()(_Iterator2 __it2) + { return *__it2 == *_M_it1; } + }; + + template + + inline _Iter_equals_iter<_Iterator> + __iter_comp_iter(_Iter_equal_to_iter, _Iterator __it) + { return _Iter_equals_iter<_Iterator>(__it); } + + template + struct _Iter_pred + { + _Predicate _M_pred; + + + explicit + _Iter_pred(_Predicate __pred) + : _M_pred(std::move(__pred)) + { } + + template + + bool + operator()(_Iterator __it) + { return bool(_M_pred(*__it)); } + }; + + template + + inline _Iter_pred<_Predicate> + __pred_iter(_Predicate __pred) + { return _Iter_pred<_Predicate>(std::move(__pred)); } + + template + 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 + + bool + operator()(_Iterator __it) + { return bool(_M_comp(*__it, _M_value)); } + }; + + template + _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 + 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 + + bool + operator()(_Iterator2 __it2) + { return bool(_M_comp(*__it2, *_M_it1)); } + }; + + template + + 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 + struct _Iter_negate + { + _Predicate _M_pred; + + + explicit + _Iter_negate(_Predicate __pred) + : _M_pred(std::move(__pred)) + { } + + template + + bool + operator()(_Iterator __it) + { return !bool(_M_pred(*__it)); } + }; + + template + + inline _Iter_negate<_Predicate> + __negate(_Iter_pred<_Predicate> __pred) + { return _Iter_negate<_Predicate>(std::move(__pred._M_pred)); } + +} +} +# 72 "/usr/include/c++/13/bits/stl_algobase.h" 2 3 + + + + +# 1 "/usr/include/c++/13/bit" 1 3 +# 32 "/usr/include/c++/13/bit" 3 + +# 33 "/usr/include/c++/13/bit" 3 +# 55 "/usr/include/c++/13/bit" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 149 "/usr/include/c++/13/bit" 3 + template + constexpr _Tp + __rotl(_Tp __x, int __s) noexcept + { + constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; + if constexpr ((_Nd & (_Nd - 1)) == 0) + { + + + constexpr unsigned __uNd = _Nd; + const unsigned __r = __s; + return (__x << (__r % __uNd)) | (__x >> ((-__r) % __uNd)); + } + const int __r = __s % _Nd; + if (__r == 0) + return __x; + else if (__r > 0) + return (__x << __r) | (__x >> ((_Nd - __r) % _Nd)); + else + return (__x >> -__r) | (__x << ((_Nd + __r) % _Nd)); + } + + template + constexpr _Tp + __rotr(_Tp __x, int __s) noexcept + { + constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; + if constexpr ((_Nd & (_Nd - 1)) == 0) + { + + + constexpr unsigned __uNd = _Nd; + const unsigned __r = __s; + return (__x >> (__r % __uNd)) | (__x << ((-__r) % __uNd)); + } + const int __r = __s % _Nd; + if (__r == 0) + return __x; + else if (__r > 0) + return (__x >> __r) | (__x << ((_Nd - __r) % _Nd)); + else + return (__x << -__r) | (__x >> ((_Nd + __r) % _Nd)); + } + + template + constexpr int + __countl_zero(_Tp __x) noexcept + { + using __gnu_cxx::__int_traits; + constexpr auto _Nd = __int_traits<_Tp>::__digits; + + if (__x == 0) + return _Nd; + + constexpr auto _Nd_ull = __int_traits::__digits; + constexpr auto _Nd_ul = __int_traits::__digits; + constexpr auto _Nd_u = __int_traits::__digits; + + if constexpr (_Nd <= _Nd_u) + { + constexpr int __diff = _Nd_u - _Nd; + return __builtin_clz(__x) - __diff; + } + else if constexpr (_Nd <= _Nd_ul) + { + constexpr int __diff = _Nd_ul - _Nd; + return __builtin_clzl(__x) - __diff; + } + else if constexpr (_Nd <= _Nd_ull) + { + constexpr int __diff = _Nd_ull - _Nd; + return __builtin_clzll(__x) - __diff; + } + else + { + static_assert(_Nd <= (2 * _Nd_ull), + "Maximum supported integer size is 128-bit"); + + unsigned long long __high = __x >> _Nd_ull; + if (__high != 0) + { + constexpr int __diff = (2 * _Nd_ull) - _Nd; + return __builtin_clzll(__high) - __diff; + } + constexpr auto __max_ull = __int_traits::__max; + unsigned long long __low = __x & __max_ull; + return (_Nd - _Nd_ull) + __builtin_clzll(__low); + } + } + + template + constexpr int + __countl_one(_Tp __x) noexcept + { + return std::__countl_zero<_Tp>((_Tp)~__x); + } + + template + constexpr int + __countr_zero(_Tp __x) noexcept + { + using __gnu_cxx::__int_traits; + constexpr auto _Nd = __int_traits<_Tp>::__digits; + + if (__x == 0) + return _Nd; + + constexpr auto _Nd_ull = __int_traits::__digits; + constexpr auto _Nd_ul = __int_traits::__digits; + constexpr auto _Nd_u = __int_traits::__digits; + + if constexpr (_Nd <= _Nd_u) + return __builtin_ctz(__x); + else if constexpr (_Nd <= _Nd_ul) + return __builtin_ctzl(__x); + else if constexpr (_Nd <= _Nd_ull) + return __builtin_ctzll(__x); + else + { + static_assert(_Nd <= (2 * _Nd_ull), + "Maximum supported integer size is 128-bit"); + + constexpr auto __max_ull = __int_traits::__max; + unsigned long long __low = __x & __max_ull; + if (__low != 0) + return __builtin_ctzll(__low); + unsigned long long __high = __x >> _Nd_ull; + return __builtin_ctzll(__high) + _Nd_ull; + } + } + + template + constexpr int + __countr_one(_Tp __x) noexcept + { + return std::__countr_zero((_Tp)~__x); + } + + template + constexpr int + __popcount(_Tp __x) noexcept + { + using __gnu_cxx::__int_traits; + constexpr auto _Nd = __int_traits<_Tp>::__digits; + + constexpr auto _Nd_ull = __int_traits::__digits; + constexpr auto _Nd_ul = __int_traits::__digits; + constexpr auto _Nd_u = __int_traits::__digits; + + if constexpr (_Nd <= _Nd_u) + return __builtin_popcount(__x); + else if constexpr (_Nd <= _Nd_ul) + return __builtin_popcountl(__x); + else if constexpr (_Nd <= _Nd_ull) + return __builtin_popcountll(__x); + else + { + static_assert(_Nd <= (2 * _Nd_ull), + "Maximum supported integer size is 128-bit"); + + constexpr auto __max_ull = __int_traits::__max; + unsigned long long __low = __x & __max_ull; + unsigned long long __high = __x >> _Nd_ull; + return __builtin_popcountll(__low) + __builtin_popcountll(__high); + } + } + + template + constexpr bool + __has_single_bit(_Tp __x) noexcept + { return std::__popcount(__x) == 1; } + + template + constexpr _Tp + __bit_ceil(_Tp __x) noexcept + { + using __gnu_cxx::__int_traits; + constexpr auto _Nd = __int_traits<_Tp>::__digits; + if (__x == 0 || __x == 1) + return 1; + auto __shift_exponent = _Nd - std::__countl_zero((_Tp)(__x - 1u)); + + + + + if (!std::__is_constant_evaluated()) + { + do { if (std::__is_constant_evaluated() && !bool(__shift_exponent != __int_traits<_Tp>::__digits)) __builtin_unreachable(); } while (false); + } + + using __promoted_type = decltype(__x << 1); + if constexpr (!is_same<__promoted_type, _Tp>::value) + { + + + + + + const int __extra_exp = sizeof(__promoted_type) / sizeof(_Tp) / 2; + __shift_exponent |= (__shift_exponent & _Nd) << __extra_exp; + } + return (_Tp)1u << __shift_exponent; + } + + template + constexpr _Tp + __bit_floor(_Tp __x) noexcept + { + constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; + if (__x == 0) + return 0; + return (_Tp)1u << (_Nd - std::__countl_zero((_Tp)(__x >> 1))); + } + + template + constexpr int + __bit_width(_Tp __x) noexcept + { + constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; + return _Nd - std::__countl_zero(__x); + } +# 478 "/usr/include/c++/13/bit" 3 + +} +# 77 "/usr/include/c++/13/bits/stl_algobase.h" 2 3 + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + template + constexpr + inline int + __memcmp(const _Tp* __first1, const _Up* __first2, size_t __num) + { + + static_assert(sizeof(_Tp) == sizeof(_Up), "can be compared with memcmp"); +# 108 "/usr/include/c++/13/bits/stl_algobase.h" 3 + return __builtin_memcmp(__first1, __first2, sizeof(_Tp) * __num); + } +# 152 "/usr/include/c++/13/bits/stl_algobase.h" 3 + template + + inline void + iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b) + { + + + + +# 185 "/usr/include/c++/13/bits/stl_algobase.h" 3 + swap(*__a, *__b); + + } +# 201 "/usr/include/c++/13/bits/stl_algobase.h" 3 + template + + _ForwardIterator2 + swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2) + { + + + + + + ; + + for (; __first1 != __last1; ++__first1, (void)++__first2) + std::iter_swap(__first1, __first2); + return __first2; + } +# 230 "/usr/include/c++/13/bits/stl_algobase.h" 3 + template + constexpr + inline const _Tp& + min(const _Tp& __a, const _Tp& __b) + { + + + + if (__b < __a) + return __b; + return __a; + } +# 254 "/usr/include/c++/13/bits/stl_algobase.h" 3 + template + constexpr + inline const _Tp& + max(const _Tp& __a, const _Tp& __b) + { + + + + if (__a < __b) + return __b; + return __a; + } +# 278 "/usr/include/c++/13/bits/stl_algobase.h" 3 + template + constexpr + inline const _Tp& + min(const _Tp& __a, const _Tp& __b, _Compare __comp) + { + + if (__comp(__b, __a)) + return __b; + return __a; + } +# 300 "/usr/include/c++/13/bits/stl_algobase.h" 3 + template + constexpr + inline const _Tp& + max(const _Tp& __a, const _Tp& __b, _Compare __comp) + { + + if (__comp(__a, __b)) + return __b; + return __a; + } + + + + template + + inline _Iterator + __niter_base(_Iterator __it) + noexcept(std::is_nothrow_copy_constructible<_Iterator>::value) + { return __it; } + + template + _Ite + __niter_base(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, + std::random_access_iterator_tag>&); + + + + + template + + inline _From + __niter_wrap(_From __from, _To __res) + { return __from + (__res - std::__niter_base(__from)); } + + + template + + inline _Iterator + __niter_wrap(const _Iterator&, _Iterator __res) + { return __res; } + + + + + + + + template + struct __copy_move + { + template + + static _OI + __copy_m(_II __first, _II __last, _OI __result) + { + for (; __first != __last; ++__result, (void)++__first) + *__result = *__first; + return __result; + } + }; + + + template + struct __copy_move + { + template + + 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 + { + template + + 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 + static void + __assign_one(_Tp* __to, _Up* __from) + { *__to = *__from; } + }; + + + template<> + struct __copy_move + { + template + + 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 + static void + __assign_one(_Tp* __to, _Up* __from) + { *__to = std::move(*__from); } + }; + + + template + struct __copy_move<_IsMove, true, random_access_iterator_tag> + { + template + + static _Up* + __copy_m(_Tp* __first, _Tp* __last, _Up* __result) + { + const ptrdiff_t _Num = __last - __first; + if (__builtin_expect(_Num > 1, true)) + __builtin_memmove(__result, __first, sizeof(_Tp) * _Num); + else if (_Num == 1) + std::__copy_move<_IsMove, false, random_access_iterator_tag>:: + __assign_one(__result, __first); + return __result + _Num; + } + }; + + + + template + struct _Deque_iterator; + + struct _Bit_iterator; + + + + + + + template + struct char_traits; + + template + class istreambuf_iterator; + + template + class ostreambuf_iterator; + + template + 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 + 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 + 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 + typename __gnu_cxx::__enable_if< + __is_char<_CharT>::__value, + std::_Deque_iterator<_CharT, _CharT&, _CharT*> >::__type + __copy_move_a2( + istreambuf_iterator<_CharT, char_traits<_CharT> >, + istreambuf_iterator<_CharT, char_traits<_CharT> >, + std::_Deque_iterator<_CharT, _CharT&, _CharT*>); + + + template + + 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 + _OI + __copy_move_a1(std::_Deque_iterator<_Tp, _Ref, _Ptr>, + std::_Deque_iterator<_Tp, _Ref, _Ptr>, + _OI); + + template + 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 + 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 + + inline _OI + __copy_move_a1(_II __first, _II __last, _OI __result) + { return std::__copy_move_a2<_IsMove>(__first, __last, __result); } + + template + + 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 + _OI + __copy_move_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + _OI); + + template + __gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat> + __copy_move_a(_II, _II, + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&); + + template + ::__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>&); + + template + + _OutputIterator + __copy_n_a(_InputIterator __first, _Size __n, _OutputIterator __result, + bool) + { + if (__n > 0) + { + while (true) + { + *__result = *__first; + ++__result; + if (--__n > 0) + ++__first; + else + break; + } + } + return __result; + } + + + template + typename __gnu_cxx::__enable_if< + __is_char<_CharT>::__value, _CharT*>::__type + __copy_n_a(istreambuf_iterator<_CharT, char_traits<_CharT> >, + _Size, _CharT*, bool); + + template + typename __gnu_cxx::__enable_if< + __is_char<_CharT>::__value, + std::_Deque_iterator<_CharT, _CharT&, _CharT*> >::__type + __copy_n_a(istreambuf_iterator<_CharT, char_traits<_CharT> >, _Size, + std::_Deque_iterator<_CharT, _CharT&, _CharT*>, + bool); +# 621 "/usr/include/c++/13/bits/stl_algobase.h" 3 + template + + 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); + } +# 654 "/usr/include/c++/13/bits/stl_algobase.h" 3 + template + + inline _OI + move(_II __first, _II __last, _OI __result) + { + + + + + ; + + return std::__copy_move_a(std::__miter_base(__first), + std::__miter_base(__last), __result); + } + + + + + + + template + struct __copy_move_backward + { + template + + static _BI2 + __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) + { + while (__first != __last) + *--__result = *--__last; + return __result; + } + }; + + + template + struct __copy_move_backward + { + template + + 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 + { + template + + 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 + { + template + + 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 + struct __copy_move_backward<_IsMove, true, random_access_iterator_tag> + { + template + + static _Up* + __copy_move_b(_Tp* __first, _Tp* __last, _Up* __result) + { + const ptrdiff_t _Num = __last - __first; + if (__builtin_expect(_Num > 1, true)) + __builtin_memmove(__result - _Num, __first, sizeof(_Tp) * _Num); + else if (_Num == 1) + std::__copy_move<_IsMove, false, random_access_iterator_tag>:: + __assign_one(__result - 1, __first); + return __result - _Num; + } + }; + + template + + 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 + + inline _BI2 + __copy_move_backward_a1(_BI1 __first, _BI1 __last, _BI2 __result) + { return std::__copy_move_backward_a2<_IsMove>(__first, __last, __result); } + + template + _OI + __copy_move_backward_a1(std::_Deque_iterator<_Tp, _Ref, _Ptr>, + std::_Deque_iterator<_Tp, _Ref, _Ptr>, + _OI); + + template + 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 + 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 + + 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 + _OI + __copy_move_backward_a( + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + _OI); + + template + __gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat> + __copy_move_backward_a(_II, _II, + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&); + + template + ::__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>&); +# 854 "/usr/include/c++/13/bits/stl_algobase.h" 3 + template + + 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); + } +# 889 "/usr/include/c++/13/bits/stl_algobase.h" 3 + template + + inline _BI2 + move_backward(_BI1 __first, _BI1 __last, _BI2 __result) + { + + + + + + ; + + return std::__copy_move_backward_a(std::__miter_base(__first), + std::__miter_base(__last), + __result); + } + + + + + + + template + + inline typename + __gnu_cxx::__enable_if::__value, void>::__type + __fill_a1(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __value) + { + for (; __first != __last; ++__first) + *__first = __value; + } + + template + + 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 + + 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; +# 950 "/usr/include/c++/13/bits/stl_algobase.h" 3 + if (const size_t __len = __last - __first) + __builtin_memset(__first, static_cast(__tmp), __len); + } + + template + + 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 + void + __fill_a1(const std::_Deque_iterator<_Tp, _Tp&, _Tp*>&, + const std::_Deque_iterator<_Tp, _Tp&, _Tp*>&, + const _VTp&); + + + void + __fill_a1(std::_Bit_iterator, std::_Bit_iterator, + const bool&); + + template + + inline void + __fill_a(_FIte __first, _FIte __last, const _Tp& __value) + { std::__fill_a1(__first, __last, __value); } + + template + void + __fill_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + const _Tp&); +# 997 "/usr/include/c++/13/bits/stl_algobase.h" 3 + template + + 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; } + + + __extension__ inline constexpr __int128 + __size_to_integer(__int128 __n) { return __n; } + __extension__ inline constexpr unsigned __int128 + __size_to_integer(unsigned __int128 __n) { return __n; } +# 1049 "/usr/include/c++/13/bits/stl_algobase.h" 3 + inline constexpr long long + __size_to_integer(float __n) { return (long long)__n; } + inline constexpr long long + __size_to_integer(double __n) { return (long long)__n; } + inline constexpr long long + __size_to_integer(long double __n) { return (long long)__n; } + + + + + + template + + inline typename + __gnu_cxx::__enable_if::__value, _OutputIterator>::__type + __fill_n_a1(_OutputIterator __first, _Size __n, const _Tp& __value) + { + for (; __n > 0; --__n, (void) ++__first) + *__first = __value; + return __first; + } + + template + + 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 + ::__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 + + 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 + + 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 + + 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; + } +# 1149 "/usr/include/c++/13/bits/stl_algobase.h" 3 + template + + 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 + struct __equal + { + template + + 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 + { + template + + 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 __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 + bool + __equal_aux1(std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>); + + template + typename __gnu_cxx::__enable_if< + __is_random_access_iter<_II>::__value, bool>::__type + __equal_aux1(_II, _II, + std::_Deque_iterator<_Tp, _Ref, _Ptr>); + + template + + 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 + + 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 + bool + __equal_aux(const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, + const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, + _II2); + + template + bool + __equal_aux(_II1, _II1, + const ::__gnu_debug::_Safe_iterator<_II2, _Seq2, _Cat2>&); + + template + 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 + struct __lc_rai + { + template + + static _II1 + __newlast1(_II1, _II1 __last1, _II2, _II2) + { return __last1; } + + template + + static bool + __cnd2(_II __first, _II __last) + { return __first != __last; } + }; + + template<> + struct __lc_rai + { + template + + 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 + static bool + __cnd2(_RAI, _RAI) + { return true; } + }; + + template + + 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 + struct __lexicographical_compare + { + template + + 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 + + static int + __3way(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) + { + while (__first1 != __last1) + { + if (__first2 == __last2) + return +1; + if (*__first1 < *__first2) + return -1; + if (*__first2 < *__first1) + return +1; + ++__first1; + ++__first2; + } + return int(__first2 == __last2) - 1; + } + }; + + template<> + struct __lexicographical_compare + { + template + + static bool + __lc(const _Tp* __first1, const _Tp* __last1, + const _Up* __first2, const _Up* __last2) + { return __3way(__first1, __last1, __first2, __last2) < 0; } + + template + + static ptrdiff_t + __3way(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; + return ptrdiff_t(__len1 - __len2); + } + }; + + template + + inline bool + __lexicographical_compare_aux1(_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_memcmp_ordered_with<_ValueType1, _ValueType2>::__value + && __is_pointer<_II1>::__value + && __is_pointer<_II2>::__value + + + + + + + + ); + + return std::__lexicographical_compare<__simple>::__lc(__first1, __last1, + __first2, __last2); + } + + template + bool + __lexicographical_compare_aux1( + std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + _Tp2*, _Tp2*); + + template + bool + __lexicographical_compare_aux1(_Tp1*, _Tp1*, + std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>, + std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>); + + template + bool + __lexicographical_compare_aux1( + std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>, + std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>); + + template + + inline bool + __lexicographical_compare_aux(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2) + { + return std::__lexicographical_compare_aux1(std::__niter_base(__first1), + std::__niter_base(__last1), + std::__niter_base(__first2), + std::__niter_base(__last2)); + } + + template + bool + __lexicographical_compare_aux( + const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, + const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, + _II2, _II2); + + template + bool + __lexicographical_compare_aux( + _II1, _II1, + const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&, + const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&); + + template + bool + __lexicographical_compare_aux( + const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, + const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, + const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&, + const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&); + + template + + _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; + } +# 1495 "/usr/include/c++/13/bits/stl_algobase.h" 3 + template + + inline _ForwardIterator + lower_bound(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val) + { + + + + + ; + + return std::__lower_bound(__first, __last, __val, + __gnu_cxx::__ops::__iter_less_val()); + } + + + + template + inline constexpr _Tp + __lg(_Tp __n) + { + + return std::__bit_width(make_unsigned_t<_Tp>(__n)) - 1; +# 1528 "/usr/include/c++/13/bits/stl_algobase.h" 3 + } + + +# 1544 "/usr/include/c++/13/bits/stl_algobase.h" 3 + template + + inline bool + equal(_II1 __first1, _II1 __last1, _II2 __first2) + { + + + + + + + ; + + return std::__equal_aux(__first1, __last1, __first2); + } +# 1575 "/usr/include/c++/13/bits/stl_algobase.h" 3 + template + + 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 + + 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<_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 + + 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<_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; + } +# 1665 "/usr/include/c++/13/bits/stl_algobase.h" 3 + template + + inline bool + equal(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) + { + + + + + + + ; + ; + + return std::__equal4(__first1, __last1, __first2, __last2); + } +# 1698 "/usr/include/c++/13/bits/stl_algobase.h" 3 + template + + inline bool + equal(_IIter1 __first1, _IIter1 __last1, + _IIter2 __first2, _IIter2 __last2, _BinaryPredicate __binary_pred) + { + + + + ; + ; + + return std::__equal4(__first1, __last1, __first2, __last2, + __binary_pred); + } +# 1730 "/usr/include/c++/13/bits/stl_algobase.h" 3 + template + + inline bool + lexicographical_compare(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2) + { + + + + + + + + + + ; + ; + + return std::__lexicographical_compare_aux(__first1, __last1, + __first2, __last2); + } +# 1765 "/usr/include/c++/13/bits/stl_algobase.h" 3 + template + + 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)); + } +# 1880 "/usr/include/c++/13/bits/stl_algobase.h" 3 + template + + 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); + } +# 1908 "/usr/include/c++/13/bits/stl_algobase.h" 3 + template + + inline pair<_InputIterator1, _InputIterator2> + mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2) + { + + + + + + + ; + + return std::__mismatch(__first1, __last1, __first2, + __gnu_cxx::__ops::__iter_equal_to_iter()); + } +# 1942 "/usr/include/c++/13/bits/stl_algobase.h" 3 + template + + 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 + + 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); + } +# 1991 "/usr/include/c++/13/bits/stl_algobase.h" 3 + template + + 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()); + } +# 2027 "/usr/include/c++/13/bits/stl_algobase.h" 3 + template + + 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 + + inline _InputIterator + __find_if(_InputIterator __first, _InputIterator __last, + _Predicate __pred, input_iterator_tag) + { + while (__first != __last && !__pred(__first)) + ++__first; + return __first; + } + + + template + + _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 + + inline _Iterator + __find_if(_Iterator __first, _Iterator __last, _Predicate __pred) + { + return __find_if(__first, __last, __pred, + std::__iterator_category(__first)); + } + + template + + 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 + + _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; + } + + + template + + 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; + } +# 2204 "/usr/include/c++/13/bits/stl_algobase.h" 3 + template + + inline bool + is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2) + { + + + + + + + ; + + return std::__is_permutation(__first1, __last1, __first2, + __gnu_cxx::__ops::__iter_equal_to_iter()); + } + + + +} +# 61 "/usr/include/c++/13/algorithm" 2 3 +# 1 "/usr/include/c++/13/bits/stl_algo.h" 1 3 +# 59 "/usr/include/c++/13/bits/stl_algo.h" 3 +# 1 "/usr/include/c++/13/bits/algorithmfwd.h" 1 3 +# 33 "/usr/include/c++/13/bits/algorithmfwd.h" 3 + +# 34 "/usr/include/c++/13/bits/algorithmfwd.h" 3 + + + + + +# 1 "/usr/include/c++/13/initializer_list" 1 3 +# 33 "/usr/include/c++/13/initializer_list" 3 + +# 34 "/usr/include/c++/13/initializer_list" 3 + + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + template + 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 + constexpr const _Tp* + begin(initializer_list<_Tp> __ils) noexcept + { return __ils.begin(); } + + + + + + + + template + constexpr const _Tp* + end(initializer_list<_Tp> __ils) noexcept + { return __ils.end(); } +} +# 40 "/usr/include/c++/13/bits/algorithmfwd.h" 2 3 + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 199 "/usr/include/c++/13/bits/algorithmfwd.h" 3 + template + + bool + all_of(_IIter, _IIter, _Predicate); + + template + + bool + any_of(_IIter, _IIter, _Predicate); + + + template + + bool + binary_search(_FIter, _FIter, const _Tp&); + + template + + bool + binary_search(_FIter, _FIter, const _Tp&, _Compare); + + + template + constexpr + const _Tp& + clamp(const _Tp&, const _Tp&, const _Tp&); + + template + constexpr + const _Tp& + clamp(const _Tp&, const _Tp&, const _Tp&, _Compare); + + + template + + _OIter + copy(_IIter, _IIter, _OIter); + + template + + _BIter2 + copy_backward(_BIter1, _BIter1, _BIter2); + + + template + + _OIter + copy_if(_IIter, _IIter, _OIter, _Predicate); + + template + + _OIter + copy_n(_IIter, _Size, _OIter); + + + + + + template + + pair<_FIter, _FIter> + equal_range(_FIter, _FIter, const _Tp&); + + template + + pair<_FIter, _FIter> + equal_range(_FIter, _FIter, const _Tp&, _Compare); + + template + + void + fill(_FIter, _FIter, const _Tp&); + + template + + _OIter + fill_n(_OIter, _Size, const _Tp&); + + + + template + + _FIter1 + find_end(_FIter1, _FIter1, _FIter2, _FIter2); + + template + + _FIter1 + find_end(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate); + + + + + + template + + _IIter + find_if_not(_IIter, _IIter, _Predicate); + + + + + + + template + + bool + includes(_IIter1, _IIter1, _IIter2, _IIter2); + + template + + bool + includes(_IIter1, _IIter1, _IIter2, _IIter2, _Compare); + + template + void + inplace_merge(_BIter, _BIter, _BIter); + + template + void + inplace_merge(_BIter, _BIter, _BIter, _Compare); + + + template + + bool + is_heap(_RAIter, _RAIter); + + template + + bool + is_heap(_RAIter, _RAIter, _Compare); + + template + + _RAIter + is_heap_until(_RAIter, _RAIter); + + template + + _RAIter + is_heap_until(_RAIter, _RAIter, _Compare); + + template + + bool + is_partitioned(_IIter, _IIter, _Predicate); + + template + + bool + is_permutation(_FIter1, _FIter1, _FIter2); + + template + + bool + is_permutation(_FIter1, _FIter1, _FIter2, _BinaryPredicate); + + template + + bool + is_sorted(_FIter, _FIter); + + template + + bool + is_sorted(_FIter, _FIter, _Compare); + + template + + _FIter + is_sorted_until(_FIter, _FIter); + + template + + _FIter + is_sorted_until(_FIter, _FIter, _Compare); + + + template + + void + iter_swap(_FIter1, _FIter2); + + template + + _FIter + lower_bound(_FIter, _FIter, const _Tp&); + + template + + _FIter + lower_bound(_FIter, _FIter, const _Tp&, _Compare); + + template + + void + make_heap(_RAIter, _RAIter); + + template + + void + make_heap(_RAIter, _RAIter, _Compare); + + template + constexpr + const _Tp& + max(const _Tp&, const _Tp&); + + template + constexpr + const _Tp& + max(const _Tp&, const _Tp&, _Compare); + + + + + template + constexpr + const _Tp& + min(const _Tp&, const _Tp&); + + template + constexpr + const _Tp& + min(const _Tp&, const _Tp&, _Compare); + + + + + template + constexpr + pair + minmax(const _Tp&, const _Tp&); + + template + constexpr + pair + minmax(const _Tp&, const _Tp&, _Compare); + + template + constexpr + pair<_FIter, _FIter> + minmax_element(_FIter, _FIter); + + template + constexpr + pair<_FIter, _FIter> + minmax_element(_FIter, _FIter, _Compare); + + template + constexpr + _Tp + min(initializer_list<_Tp>); + + template + constexpr + _Tp + min(initializer_list<_Tp>, _Compare); + + template + constexpr + _Tp + max(initializer_list<_Tp>); + + template + constexpr + _Tp + max(initializer_list<_Tp>, _Compare); + + template + constexpr + pair<_Tp, _Tp> + minmax(initializer_list<_Tp>); + + template + constexpr + pair<_Tp, _Tp> + minmax(initializer_list<_Tp>, _Compare); + + + + + template + + bool + next_permutation(_BIter, _BIter); + + template + + bool + next_permutation(_BIter, _BIter, _Compare); + + + template + + bool + none_of(_IIter, _IIter, _Predicate); + + + + + + template + + _RAIter + partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter); + + template + + _RAIter + partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter, _Compare); + + + + + template + + pair<_OIter1, _OIter2> + partition_copy(_IIter, _IIter, _OIter1, _OIter2, _Predicate); + + template + + _FIter + partition_point(_FIter, _FIter, _Predicate); + + + template + + void + pop_heap(_RAIter, _RAIter); + + template + + void + pop_heap(_RAIter, _RAIter, _Compare); + + template + + bool + prev_permutation(_BIter, _BIter); + + template + + bool + prev_permutation(_BIter, _BIter, _Compare); + + template + + void + push_heap(_RAIter, _RAIter); + + template + + void + push_heap(_RAIter, _RAIter, _Compare); + + + + template + + _FIter + remove(_FIter, _FIter, const _Tp&); + + template + + _FIter + remove_if(_FIter, _FIter, _Predicate); + + template + + _OIter + remove_copy(_IIter, _IIter, _OIter, const _Tp&); + + template + + _OIter + remove_copy_if(_IIter, _IIter, _OIter, _Predicate); + + + + template + + _OIter + replace_copy(_IIter, _IIter, _OIter, const _Tp&, const _Tp&); + + template + + _OIter + replace_copy_if(_Iter, _Iter, _OIter, _Predicate, const _Tp&); + + + + template + + void + reverse(_BIter, _BIter); + + template + + _OIter + reverse_copy(_BIter, _BIter, _OIter); + +inline namespace _V2 { + + template + + _FIter + rotate(_FIter, _FIter, _FIter); + +} + + template + + _OIter + rotate_copy(_FIter, _FIter, _FIter, _OIter); +# 626 "/usr/include/c++/13/bits/algorithmfwd.h" 3 + template + void + shuffle(_RAIter, _RAIter, _UGenerator&&); + + + template + + void + sort_heap(_RAIter, _RAIter); + + template + + void + sort_heap(_RAIter, _RAIter, _Compare); + + + template + _BIter + stable_partition(_BIter, _BIter, _Predicate); +# 661 "/usr/include/c++/13/bits/algorithmfwd.h" 3 + template + + _FIter2 + swap_ranges(_FIter1, _FIter1, _FIter2); + + + + template + + _FIter + unique(_FIter, _FIter); + + template + + _FIter + unique(_FIter, _FIter, _BinaryPredicate); + + + + template + + _FIter + upper_bound(_FIter, _FIter, const _Tp&); + + template + + _FIter + upper_bound(_FIter, _FIter, const _Tp&, _Compare); + + + + template + + _FIter + adjacent_find(_FIter, _FIter); + + template + + _FIter + adjacent_find(_FIter, _FIter, _BinaryPredicate); + + template + + typename iterator_traits<_IIter>::difference_type + count(_IIter, _IIter, const _Tp&); + + template + + typename iterator_traits<_IIter>::difference_type + count_if(_IIter, _IIter, _Predicate); + + template + + bool + equal(_IIter1, _IIter1, _IIter2); + + template + + bool + equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate); + + template + + _IIter + find(_IIter, _IIter, const _Tp&); + + template + + _FIter1 + find_first_of(_FIter1, _FIter1, _FIter2, _FIter2); + + template + + _FIter1 + find_first_of(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate); + + template + + _IIter + find_if(_IIter, _IIter, _Predicate); + + template + + _Funct + for_each(_IIter, _IIter, _Funct); + + template + + void + generate(_FIter, _FIter, _Generator); + + template + + _OIter + generate_n(_OIter, _Size, _Generator); + + template + + bool + lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2); + + template + + bool + lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Compare); + + template + constexpr + _FIter + max_element(_FIter, _FIter); + + template + constexpr + _FIter + max_element(_FIter, _FIter, _Compare); + + template + + _OIter + merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); + + template + + _OIter + merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); + + template + constexpr + _FIter + min_element(_FIter, _FIter); + + template + constexpr + _FIter + min_element(_FIter, _FIter, _Compare); + + template + + pair<_IIter1, _IIter2> + mismatch(_IIter1, _IIter1, _IIter2); + + template + + pair<_IIter1, _IIter2> + mismatch(_IIter1, _IIter1, _IIter2, _BinaryPredicate); + + template + + void + nth_element(_RAIter, _RAIter, _RAIter); + + template + + void + nth_element(_RAIter, _RAIter, _RAIter, _Compare); + + template + + void + partial_sort(_RAIter, _RAIter, _RAIter); + + template + + void + partial_sort(_RAIter, _RAIter, _RAIter, _Compare); + + template + + _BIter + partition(_BIter, _BIter, _Predicate); + + + template + __attribute__ ((__deprecated__ ("use '" "std::shuffle" "' instead"))) + void + random_shuffle(_RAIter, _RAIter); + + template + __attribute__ ((__deprecated__ ("use '" "std::shuffle" "' instead"))) + void + random_shuffle(_RAIter, _RAIter, + + _Generator&&); + + + + + + template + + void + replace(_FIter, _FIter, const _Tp&, const _Tp&); + + template + + void + replace_if(_FIter, _FIter, _Predicate, const _Tp&); + + template + + _FIter1 + search(_FIter1, _FIter1, _FIter2, _FIter2); + + template + + _FIter1 + search(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate); + + template + + _FIter + search_n(_FIter, _FIter, _Size, const _Tp&); + + template + + _FIter + search_n(_FIter, _FIter, _Size, const _Tp&, _BinaryPredicate); + + template + + _OIter + set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); + + template + + _OIter + set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); + + template + + _OIter + set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); + + template + + _OIter + set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); + + template + + _OIter + set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); + + template + + _OIter + set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, + _OIter, _Compare); + + template + + _OIter + set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); + + template + + _OIter + set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); + + template + + void + sort(_RAIter, _RAIter); + + template + + void + sort(_RAIter, _RAIter, _Compare); + + template + void + stable_sort(_RAIter, _RAIter); + + template + void + stable_sort(_RAIter, _RAIter, _Compare); + + template + + _OIter + transform(_IIter, _IIter, _OIter, _UnaryOperation); + + template + + _OIter + transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation); + + template + + _OIter + unique_copy(_IIter, _IIter, _OIter); + + template + + _OIter + unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate); + + + +} +# 60 "/usr/include/c++/13/bits/stl_algo.h" 2 3 + +# 1 "/usr/include/c++/13/bits/stl_heap.h" 1 3 +# 63 "/usr/include/c++/13/bits/stl_heap.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + + template + + _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 + + 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 + + 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 + + inline bool + __is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) + { return std::__is_heap(__first, std::distance(__first, __last)); } + + template + + inline bool + __is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Compare __comp) + { + return std::__is_heap(__first, std::move(__comp), + std::distance(__first, __last)); + } + + + + + template + + 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); + } +# 159 "/usr/include/c++/13/bits/stl_heap.h" 3 + template + + 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); + } +# 195 "/usr/include/c++/13/bits/stl_heap.h" 3 + template + + 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 + + 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 + + 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); + } +# 280 "/usr/include/c++/13/bits/stl_heap.h" 3 + template + + 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); + } + } +# 314 "/usr/include/c++/13/bits/stl_heap.h" 3 + template + + 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 + + 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--; + } + } +# 372 "/usr/include/c++/13/bits/stl_heap.h" 3 + template + + inline void + make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) + { + + + + + + ; + ; + + __gnu_cxx::__ops::_Iter_less_iter __comp; + std::__make_heap(__first, __last, __comp); + } +# 399 "/usr/include/c++/13/bits/stl_heap.h" 3 + template + + 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 + + void + __sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Compare& __comp) + { + while (__last - __first > 1) + { + --__last; + std::__pop_heap(__first, __last, __last, __comp); + } + } +# 437 "/usr/include/c++/13/bits/stl_heap.h" 3 + template + + inline void + sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) + { + + + + + + ; + ; + ; + + __gnu_cxx::__ops::_Iter_less_iter __comp; + std::__sort_heap(__first, __last, __comp); + } +# 465 "/usr/include/c++/13/bits/stl_heap.h" 3 + template + + 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); + } +# 494 "/usr/include/c++/13/bits/stl_heap.h" 3 + template + + 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); + } +# 523 "/usr/include/c++/13/bits/stl_heap.h" 3 + template + + 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); + } +# 548 "/usr/include/c++/13/bits/stl_heap.h" 3 + template + + inline bool + is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) + { return std::is_heap_until(__first, __last) == __last; } +# 562 "/usr/include/c++/13/bits/stl_heap.h" 3 + template + + 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++/13/bits/stl_algo.h" 2 3 + + + +# 1 "/usr/include/c++/13/bits/uniform_int_dist.h" 1 3 +# 41 "/usr/include/c++/13/bits/uniform_int_dist.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 64 "/usr/include/c++/13/bits/uniform_int_dist.h" 3 + namespace __detail + { + + + + template + constexpr bool + _Power_of_2(_Tp __x) + { + return ((__x - 1) & __x) == 0; + } + } +# 87 "/usr/include/c++/13/bits/uniform_int_dist.h" 3 + template + 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 = __gnu_cxx::__int_traits<_IntType>::__max) + : _M_a(__a), _M_b(__b) + { + do { if (std::__is_constant_evaluated() && !bool(_M_a <= _M_b)) __builtin_unreachable(); } while (false); + } + + 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 + = __gnu_cxx::__int_traits<_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 + result_type + operator()(_UniformRandomBitGenerator& __urng) + { return this->operator()(__urng, _M_param); } + + template + result_type + operator()(_UniformRandomBitGenerator& __urng, + const param_type& __p); + + template + void + __generate(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomBitGenerator& __urng) + { this->__generate(__f, __t, __urng, _M_param); } + + template + void + __generate(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomBitGenerator& __urng, + const param_type& __p) + { this->__generate_impl(__f, __t, __urng, __p); } + + template + void + __generate(result_type* __f, result_type* __t, + _UniformRandomBitGenerator& __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 + void + __generate_impl(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomBitGenerator& __urng, + const param_type& __p); + + param_type _M_param; + + + + + template + static _Up + _S_nd(_Urbg& __g, _Up __range) + { + using _Up_traits = __gnu_cxx::__int_traits<_Up>; + using _Wp_traits = __gnu_cxx::__int_traits<_Wp>; + static_assert(!_Up_traits::__is_signed, "U must be unsigned"); + static_assert(!_Wp_traits::__is_signed, "W must be unsigned"); + static_assert(_Wp_traits::__digits == (2 * _Up_traits::__digits), + "W must be twice as wide as U"); + + + + + _Wp __product = _Wp(__g()) * _Wp(__range); + _Up __low = _Up(__product); + if (__low < __range) + { + _Up __threshold = -__range % __range; + while (__low < __threshold) + { + __product = _Wp(__g()) * _Wp(__range); + __low = _Up(__product); + } + } + return __product >> _Up_traits::__digits; + } + }; + + template + template + typename uniform_int_distribution<_IntType>::result_type + uniform_int_distribution<_IntType>:: + operator()(_UniformRandomBitGenerator& __urng, + const param_type& __param) + { + typedef typename _UniformRandomBitGenerator::result_type _Gresult_type; + typedef typename make_unsigned::type __utype; + typedef typename common_type<_Gresult_type, __utype>::type __uctype; + + constexpr __uctype __urngmin = _UniformRandomBitGenerator::min(); + constexpr __uctype __urngmax = _UniformRandomBitGenerator::max(); + static_assert( __urngmin < __urngmax, + "Uniform random bit generator must define min() < max()"); + constexpr __uctype __urngrange = __urngmax - __urngmin; + + const __uctype __urange + = __uctype(__param.b()) - __uctype(__param.a()); + + __uctype __ret; + if (__urngrange > __urange) + { + + + const __uctype __uerange = __urange + 1; + + + + if constexpr (__urngrange == 0xffffffffffffffffUL) + { + + + long unsigned int __u64erange = __uerange; + __ret = __extension__ _S_nd(__urng, + __u64erange); + } + else + + if constexpr (__urngrange == 0xffffffffU) + { + + + unsigned int __u32erange = __uerange; + __ret = _S_nd(__urng, __u32erange); + } + else + + { + + const __uctype __scaling = __urngrange / __uerange; + const __uctype __past = __uerange * __scaling; + do + __ret = __uctype(__urng()) - __urngmin; + while (__ret >= __past); + __ret /= __scaling; + } + } + else if (__urngrange < __urange) + { +# 359 "/usr/include/c++/13/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 + template + void + uniform_int_distribution<_IntType>:: + __generate_impl(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomBitGenerator& __urng, + const param_type& __param) + { + + typedef typename _UniformRandomBitGenerator::result_type _Gresult_type; + typedef typename make_unsigned::type __utype; + typedef typename common_type<_Gresult_type, __utype>::type __uctype; + + static_assert( __urng.min() < __urng.max(), + "Uniform random bit generator must define min() < max()"); + + constexpr __uctype __urngmin = __urng.min(); + constexpr __uctype __urngmax = __urng.max(); + constexpr __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) + { +# 444 "/usr/include/c++/13/bits/uniform_int_dist.h" 3 + __uctype __tmp; + while (__f != __t) + { + do + { + constexpr __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(); + } + + + + +} +# 66 "/usr/include/c++/13/bits/stl_algo.h" 2 3 + + + +# 1 "/usr/include/c++/13/bits/stl_tempbuf.h" 1 3 +# 59 "/usr/include/c++/13/bits/stl_tempbuf.h" 3 +# 1 "/usr/include/c++/13/new" 1 3 +# 38 "/usr/include/c++/13/new" 3 + +# 39 "/usr/include/c++/13/new" 3 + + +# 1 "/usr/include/c++/13/bits/exception.h" 1 3 +# 34 "/usr/include/c++/13/bits/exception.h" 3 + +# 35 "/usr/include/c++/13/bits/exception.h" 3 + + + +extern "C++" { + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 59 "/usr/include/c++/13/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; + }; + + + +} + +} +# 42 "/usr/include/c++/13/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++/13/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__, __alloc_size__ (1), __malloc__)); +[[__nodiscard__]] void* operator new[](std::size_t, const std::nothrow_t&) noexcept + __attribute__((__externally_visible__, __alloc_size__ (1), __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__, __alloc_size__ (1), __malloc__)); +[[__nodiscard__]] void* operator new(std::size_t, std::align_val_t, const std::nothrow_t&) + noexcept __attribute__((__externally_visible__, __alloc_size__ (1), __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__, __alloc_size__ (1), __malloc__)); +[[__nodiscard__]] void* operator new[](std::size_t, std::align_val_t, const std::nothrow_t&) + noexcept __attribute__((__externally_visible__, __alloc_size__ (1), __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 +{ + + + + template + [[nodiscard]] constexpr _Tp* + launder(_Tp* __p) noexcept + { return __builtin_launder(__p); } + + + + + template + void launder(_Ret (*)(_Args...) noexcept (_NE)) = delete; + template + 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; + + + + + inline constexpr size_t hardware_destructive_interference_size = 256; + inline constexpr size_t hardware_constructive_interference_size = 64; + +} +# 236 "/usr/include/c++/13/new" 3 +#pragma GCC visibility pop +# 60 "/usr/include/c++/13/bits/stl_tempbuf.h" 2 3 + +# 1 "/usr/include/c++/13/bits/stl_construct.h" 1 3 +# 73 "/usr/include/c++/13/bits/stl_construct.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + template + 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++/13/bits/stl_construct.h" 3 + template + + inline void + _Construct(_Tp* __p, _Args&&... __args) + { +# 119 "/usr/include/c++/13/bits/stl_construct.h" 3 + ::new((void*)__p) _Tp(std::forward<_Args>(__args)...); + } +# 132 "/usr/include/c++/13/bits/stl_construct.h" 3 + template + inline void + _Construct_novalue(_T1* __p) + { ::new((void*)__p) _T1; } + + template + void + _Destroy(_ForwardIterator __first, _ForwardIterator __last); + + + + + template + constexpr inline void + _Destroy(_Tp* __pointer) + { + + + + __pointer->~_Tp(); + + } + + template + struct _Destroy_aux + { + template + static void + __destroy(_ForwardIterator __first, _ForwardIterator __last) + { + for (; __first != __last; ++__first) + std::_Destroy(std::__addressof(*__first)); + } + }; + + template<> + struct _Destroy_aux + { + template + static void + __destroy(_ForwardIterator, _ForwardIterator) { } + }; + + + + + + + template + 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 + struct _Destroy_n_aux + { + template + 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 + { + template + static _ForwardIterator + __destroy_n(_ForwardIterator __first, _Size __count) + { + std::advance(__first, __count); + return __first; + } + }; + + + + + + + template + 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 + inline void + destroy(_ForwardIterator __first, _ForwardIterator __last) + { + std::_Destroy(__first, __last); + } + + template + inline _ForwardIterator + destroy_n(_ForwardIterator __first, _Size __count) + { + return std::_Destroy_n(__first, __count); + } + + + +} +# 62 "/usr/include/c++/13/bits/stl_tempbuf.h" 2 3 + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + namespace __detail + { + template + inline void + __return_temporary_buffer(_Tp* __p, + size_t __len __attribute__((__unused__))) + { + + ::operator delete(__p, __len * sizeof(_Tp)); + + + + } + } +# 101 "/usr/include/c++/13/bits/stl_tempbuf.h" 3 + template + [[__deprecated__]] + pair<_Tp*, ptrdiff_t> + get_temporary_buffer(ptrdiff_t __len) noexcept + { + const ptrdiff_t __max = + __gnu_cxx::__numeric_traits::__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 = __len == 1 ? 0 : ((__len + 1) / 2); + } + return std::pair<_Tp*, ptrdiff_t>(static_cast<_Tp*>(0), 0); + } +# 129 "/usr/include/c++/13/bits/stl_tempbuf.h" 3 + template + inline void + return_temporary_buffer(_Tp* __p) + { ::operator delete(__p); } + + + + + + + template + 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 + struct __uninitialized_construct_buf_dispatch + { + template + 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 + { + template + static void + __ucr(_Pointer, _Pointer, _ForwardIterator) { } + }; +# 247 "/usr/include/c++/13/bits/stl_tempbuf.h" 3 + template + 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); + } + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + template + _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 __p( + std::get_temporary_buffer(_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; + } + } + } +#pragma GCC diagnostic pop + + +} +# 70 "/usr/include/c++/13/bits/stl_algo.h" 2 3 + +# 1 "/usr/include/c++/13/cstdlib" 1 3 +# 39 "/usr/include/c++/13/cstdlib" 3 + +# 40 "/usr/include/c++/13/cstdlib" 3 +# 79 "/usr/include/c++/13/cstdlib" 3 +# 1 "/usr/include/stdlib.h" 1 3 4 +# 26 "/usr/include/stdlib.h" 3 4 +# 1 "/usr/include/aarch64-linux-gnu/bits/libc-header-start.h" 1 3 4 +# 27 "/usr/include/stdlib.h" 2 3 4 + + + + + +# 1 "/usr/lib/gcc/aarch64-linux-gnu/13/include/stddef.h" 1 3 4 +# 214 "/usr/lib/gcc/aarch64-linux-gnu/13/include/stddef.h" 3 4 +typedef long unsigned int size_t; +# 33 "/usr/include/stdlib.h" 2 3 4 + +extern "C" { + + + + + +# 1 "/usr/include/aarch64-linux-gnu/bits/waitflags.h" 1 3 4 +# 41 "/usr/include/stdlib.h" 2 3 4 +# 1 "/usr/include/aarch64-linux-gnu/bits/waitstatus.h" 1 3 4 +# 42 "/usr/include/stdlib.h" 2 3 4 +# 56 "/usr/include/stdlib.h" 3 4 +# 1 "/usr/include/aarch64-linux-gnu/bits/floatn.h" 1 3 4 +# 23 "/usr/include/aarch64-linux-gnu/bits/floatn.h" 3 4 +# 1 "/usr/include/aarch64-linux-gnu/bits/long-double.h" 1 3 4 +# 24 "/usr/include/aarch64-linux-gnu/bits/floatn.h" 2 3 4 +# 95 "/usr/include/aarch64-linux-gnu/bits/floatn.h" 3 4 +# 1 "/usr/include/aarch64-linux-gnu/bits/floatn-common.h" 1 3 4 +# 24 "/usr/include/aarch64-linux-gnu/bits/floatn-common.h" 3 4 +# 1 "/usr/include/aarch64-linux-gnu/bits/long-double.h" 1 3 4 +# 25 "/usr/include/aarch64-linux-gnu/bits/floatn-common.h" 2 3 4 +# 96 "/usr/include/aarch64-linux-gnu/bits/floatn.h" 2 3 4 +# 57 "/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; + + + + + +__extension__ typedef struct + { + long long int quot; + long long int rem; + } lldiv_t; +# 98 "/usr/include/stdlib.h" 3 4 +extern size_t __ctype_get_mb_cur_max (void) noexcept (true) ; + + + +extern double atof (const char *__nptr) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + +extern int atoi (const char *__nptr) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + +extern long int atol (const char *__nptr) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + + + +__extension__ extern long long int atoll (const char *__nptr) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + + + +extern double strtod (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern float strtof (const char *__restrict __nptr, + char **__restrict __endptr) noexcept (true) __attribute__ ((__nonnull__ (1))); + +extern long double strtold (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); +# 141 "/usr/include/stdlib.h" 3 4 +extern _Float32 strtof32 (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern _Float64 strtof64 (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern _Float128 strtof128 (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern _Float32x strtof32x (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern _Float64x strtof64x (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); +# 177 "/usr/include/stdlib.h" 3 4 +extern long int strtol (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); + +extern unsigned long int strtoul (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +__extension__ +extern long long int strtoq (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); + +__extension__ +extern unsigned long long int strtouq (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + +__extension__ +extern long long int strtoll (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); + +__extension__ +extern unsigned long long int strtoull (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + + +extern long int strtol (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtol") + + + __attribute__ ((__nonnull__ (1))); +extern unsigned long int strtoul (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoul") + + + + __attribute__ ((__nonnull__ (1))); + +__extension__ +extern long long int strtoq (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoll") + + + __attribute__ ((__nonnull__ (1))); +__extension__ +extern unsigned long long int strtouq (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoull") + + + + __attribute__ ((__nonnull__ (1))); + +__extension__ +extern long long int strtoll (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoll") + + + __attribute__ ((__nonnull__ (1))); +__extension__ +extern unsigned long long int strtoull (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoull") + + + + __attribute__ ((__nonnull__ (1))); +# 278 "/usr/include/stdlib.h" 3 4 +extern int strfromd (char *__dest, size_t __size, const char *__format, + double __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); + +extern int strfromf (char *__dest, size_t __size, const char *__format, + float __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); + +extern int strfroml (char *__dest, size_t __size, const char *__format, + long double __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); +# 298 "/usr/include/stdlib.h" 3 4 +extern int strfromf32 (char *__dest, size_t __size, const char * __format, + _Float32 __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); + + + +extern int strfromf64 (char *__dest, size_t __size, const char * __format, + _Float64 __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); + + + +extern int strfromf128 (char *__dest, size_t __size, const char * __format, + _Float128 __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); + + + +extern int strfromf32x (char *__dest, size_t __size, const char * __format, + _Float32x __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); + + + +extern int strfromf64x (char *__dest, size_t __size, const char * __format, + _Float64x __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); +# 338 "/usr/include/stdlib.h" 3 4 +# 1 "/usr/include/aarch64-linux-gnu/bits/types/locale_t.h" 1 3 4 +# 22 "/usr/include/aarch64-linux-gnu/bits/types/locale_t.h" 3 4 +# 1 "/usr/include/aarch64-linux-gnu/bits/types/__locale_t.h" 1 3 4 +# 27 "/usr/include/aarch64-linux-gnu/bits/types/__locale_t.h" 3 4 +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/aarch64-linux-gnu/bits/types/locale_t.h" 2 3 4 + +typedef __locale_t locale_t; +# 339 "/usr/include/stdlib.h" 2 3 4 + +extern long int strtol_l (const char *__restrict __nptr, + char **__restrict __endptr, int __base, + locale_t __loc) noexcept (true) __attribute__ ((__nonnull__ (1, 4))); + +extern unsigned long int strtoul_l (const char *__restrict __nptr, + char **__restrict __endptr, + int __base, locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 4))); + +__extension__ +extern long long int strtoll_l (const char *__restrict __nptr, + char **__restrict __endptr, int __base, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 4))); + +__extension__ +extern unsigned long long int strtoull_l (const char *__restrict __nptr, + char **__restrict __endptr, + int __base, locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 4))); + + + + + +extern long int strtol_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_strtol_l") + + + + __attribute__ ((__nonnull__ (1, 4))); +extern unsigned long int strtoul_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_strtoul_l") + + + + + __attribute__ ((__nonnull__ (1, 4))); +__extension__ +extern long long int strtoll_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_strtoll_l") + + + + + __attribute__ ((__nonnull__ (1, 4))); +__extension__ +extern unsigned long long int strtoull_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_strtoull_l") + + + + + __attribute__ ((__nonnull__ (1, 4))); +# 415 "/usr/include/stdlib.h" 3 4 +extern double strtod_l (const char *__restrict __nptr, + char **__restrict __endptr, locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + +extern float strtof_l (const char *__restrict __nptr, + char **__restrict __endptr, locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + +extern long double strtold_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); +# 436 "/usr/include/stdlib.h" 3 4 +extern _Float32 strtof32_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + + + +extern _Float64 strtof64_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + + + +extern _Float128 strtof128_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + + + +extern _Float32x strtof32x_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + + + +extern _Float64x strtof64x_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); +# 505 "/usr/include/stdlib.h" 3 4 +extern char *l64a (long int __n) noexcept (true) ; + + +extern long int a64l (const char *__s) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + + + + +# 1 "/usr/include/aarch64-linux-gnu/sys/types.h" 1 3 4 +# 27 "/usr/include/aarch64-linux-gnu/sys/types.h" 3 4 +extern "C" { + +# 1 "/usr/include/aarch64-linux-gnu/bits/types.h" 1 3 4 +# 27 "/usr/include/aarch64-linux-gnu/bits/types.h" 3 4 +# 1 "/usr/include/aarch64-linux-gnu/bits/wordsize.h" 1 3 4 +# 28 "/usr/include/aarch64-linux-gnu/bits/types.h" 2 3 4 +# 1 "/usr/include/aarch64-linux-gnu/bits/timesize.h" 1 3 4 +# 29 "/usr/include/aarch64-linux-gnu/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; +# 141 "/usr/include/aarch64-linux-gnu/bits/types.h" 3 4 +# 1 "/usr/include/aarch64-linux-gnu/bits/typesizes.h" 1 3 4 +# 142 "/usr/include/aarch64-linux-gnu/bits/types.h" 2 3 4 +# 1 "/usr/include/aarch64-linux-gnu/bits/time64.h" 1 3 4 +# 143 "/usr/include/aarch64-linux-gnu/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 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 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; +# 30 "/usr/include/aarch64-linux-gnu/sys/types.h" 2 3 4 + + + +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; + + +typedef __loff_t loff_t; + + + + +typedef __ino_t ino_t; + + + + + + +typedef __ino64_t ino64_t; + + + + +typedef __dev_t dev_t; + + + + +typedef __gid_t gid_t; + + + + +typedef __mode_t mode_t; + + + + +typedef __nlink_t nlink_t; + + + + +typedef __uid_t uid_t; + + + + + +typedef __off_t off_t; + + + + + + +typedef __off64_t off64_t; + + + + +typedef __pid_t pid_t; + + + + + +typedef __id_t id_t; + + + + +typedef __ssize_t ssize_t; + + + + + +typedef __daddr_t daddr_t; +typedef __caddr_t caddr_t; + + + + + +typedef __key_t key_t; + + + + +# 1 "/usr/include/aarch64-linux-gnu/bits/types/clock_t.h" 1 3 4 + + + + + + +typedef __clock_t clock_t; +# 127 "/usr/include/aarch64-linux-gnu/sys/types.h" 2 3 4 + +# 1 "/usr/include/aarch64-linux-gnu/bits/types/clockid_t.h" 1 3 4 + + + + + + +typedef __clockid_t clockid_t; +# 129 "/usr/include/aarch64-linux-gnu/sys/types.h" 2 3 4 +# 1 "/usr/include/aarch64-linux-gnu/bits/types/time_t.h" 1 3 4 +# 10 "/usr/include/aarch64-linux-gnu/bits/types/time_t.h" 3 4 +typedef __time_t time_t; +# 130 "/usr/include/aarch64-linux-gnu/sys/types.h" 2 3 4 +# 1 "/usr/include/aarch64-linux-gnu/bits/types/timer_t.h" 1 3 4 + + + + + + +typedef __timer_t timer_t; +# 131 "/usr/include/aarch64-linux-gnu/sys/types.h" 2 3 4 + + + +typedef __useconds_t useconds_t; + + + +typedef __suseconds_t suseconds_t; + + + + + +# 1 "/usr/lib/gcc/aarch64-linux-gnu/13/include/stddef.h" 1 3 4 +# 145 "/usr/include/aarch64-linux-gnu/sys/types.h" 2 3 4 + + + +typedef unsigned long int ulong; +typedef unsigned short int ushort; +typedef unsigned int uint; + + + + +# 1 "/usr/include/aarch64-linux-gnu/bits/stdint-intn.h" 1 3 4 +# 24 "/usr/include/aarch64-linux-gnu/bits/stdint-intn.h" 3 4 +typedef __int8_t int8_t; +typedef __int16_t int16_t; +typedef __int32_t int32_t; +typedef __int64_t int64_t; +# 156 "/usr/include/aarch64-linux-gnu/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__))); +# 176 "/usr/include/aarch64-linux-gnu/sys/types.h" 3 4 +# 1 "/usr/include/endian.h" 1 3 4 +# 24 "/usr/include/endian.h" 3 4 +# 1 "/usr/include/aarch64-linux-gnu/bits/endian.h" 1 3 4 +# 35 "/usr/include/aarch64-linux-gnu/bits/endian.h" 3 4 +# 1 "/usr/include/aarch64-linux-gnu/bits/endianness.h" 1 3 4 +# 36 "/usr/include/aarch64-linux-gnu/bits/endian.h" 2 3 4 +# 25 "/usr/include/endian.h" 2 3 4 +# 35 "/usr/include/endian.h" 3 4 +# 1 "/usr/include/aarch64-linux-gnu/bits/byteswap.h" 1 3 4 +# 33 "/usr/include/aarch64-linux-gnu/bits/byteswap.h" 3 4 +static __inline __uint16_t +__bswap_16 (__uint16_t __bsx) +{ + + return __builtin_bswap16 (__bsx); + + + +} + + + + + + +static __inline __uint32_t +__bswap_32 (__uint32_t __bsx) +{ + + return __builtin_bswap32 (__bsx); + + + +} +# 69 "/usr/include/aarch64-linux-gnu/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/aarch64-linux-gnu/bits/uintn-identity.h" 1 3 4 +# 32 "/usr/include/aarch64-linux-gnu/bits/uintn-identity.h" 3 4 +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 +# 177 "/usr/include/aarch64-linux-gnu/sys/types.h" 2 3 4 + + +# 1 "/usr/include/aarch64-linux-gnu/sys/select.h" 1 3 4 +# 30 "/usr/include/aarch64-linux-gnu/sys/select.h" 3 4 +# 1 "/usr/include/aarch64-linux-gnu/bits/select.h" 1 3 4 +# 31 "/usr/include/aarch64-linux-gnu/sys/select.h" 2 3 4 + + +# 1 "/usr/include/aarch64-linux-gnu/bits/types/sigset_t.h" 1 3 4 + + + +# 1 "/usr/include/aarch64-linux-gnu/bits/types/__sigset_t.h" 1 3 4 + + + + +typedef struct +{ + unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))]; +} __sigset_t; +# 5 "/usr/include/aarch64-linux-gnu/bits/types/sigset_t.h" 2 3 4 + + +typedef __sigset_t sigset_t; +# 34 "/usr/include/aarch64-linux-gnu/sys/select.h" 2 3 4 + + + +# 1 "/usr/include/aarch64-linux-gnu/bits/types/struct_timeval.h" 1 3 4 + + + + + + + +struct timeval +{ + + + + + __time_t tv_sec; + __suseconds_t tv_usec; + +}; +# 38 "/usr/include/aarch64-linux-gnu/sys/select.h" 2 3 4 + +# 1 "/usr/include/aarch64-linux-gnu/bits/types/struct_timespec.h" 1 3 4 +# 11 "/usr/include/aarch64-linux-gnu/bits/types/struct_timespec.h" 3 4 +struct timespec +{ + + + + __time_t tv_sec; + + + + + __syscall_slong_t tv_nsec; +# 31 "/usr/include/aarch64-linux-gnu/bits/types/struct_timespec.h" 3 4 +}; +# 40 "/usr/include/aarch64-linux-gnu/sys/select.h" 2 3 4 +# 49 "/usr/include/aarch64-linux-gnu/sys/select.h" 3 4 +typedef long int __fd_mask; +# 59 "/usr/include/aarch64-linux-gnu/sys/select.h" 3 4 +typedef struct + { + + + + __fd_mask fds_bits[1024 / (8 * (int) sizeof (__fd_mask))]; + + + + + + } fd_set; + + + + + + +typedef __fd_mask fd_mask; +# 91 "/usr/include/aarch64-linux-gnu/sys/select.h" 3 4 +extern "C" { +# 102 "/usr/include/aarch64-linux-gnu/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); +# 127 "/usr/include/aarch64-linux-gnu/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); +# 153 "/usr/include/aarch64-linux-gnu/sys/select.h" 3 4 +} +# 180 "/usr/include/aarch64-linux-gnu/sys/types.h" 2 3 4 + + + + + +typedef __blksize_t blksize_t; + + + + + + +typedef __blkcnt_t blkcnt_t; + + + +typedef __fsblkcnt_t fsblkcnt_t; + + + +typedef __fsfilcnt_t fsfilcnt_t; +# 219 "/usr/include/aarch64-linux-gnu/sys/types.h" 3 4 +typedef __blkcnt64_t blkcnt64_t; +typedef __fsblkcnt64_t fsblkcnt64_t; +typedef __fsfilcnt64_t fsfilcnt64_t; + + + + + +# 1 "/usr/include/aarch64-linux-gnu/bits/pthreadtypes.h" 1 3 4 +# 23 "/usr/include/aarch64-linux-gnu/bits/pthreadtypes.h" 3 4 +# 1 "/usr/include/aarch64-linux-gnu/bits/thread-shared-types.h" 1 3 4 +# 44 "/usr/include/aarch64-linux-gnu/bits/thread-shared-types.h" 3 4 +# 1 "/usr/include/aarch64-linux-gnu/bits/pthreadtypes-arch.h" 1 3 4 +# 45 "/usr/include/aarch64-linux-gnu/bits/thread-shared-types.h" 2 3 4 + +# 1 "/usr/include/aarch64-linux-gnu/bits/atomic_wide_counter.h" 1 3 4 +# 25 "/usr/include/aarch64-linux-gnu/bits/atomic_wide_counter.h" 3 4 +typedef union +{ + __extension__ unsigned long long int __value64; + struct + { + unsigned int __low; + unsigned int __high; + } __value32; +} __atomic_wide_counter; +# 47 "/usr/include/aarch64-linux-gnu/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; +# 76 "/usr/include/aarch64-linux-gnu/bits/thread-shared-types.h" 3 4 +# 1 "/usr/include/aarch64-linux-gnu/bits/struct_mutex.h" 1 3 4 +# 27 "/usr/include/aarch64-linux-gnu/bits/struct_mutex.h" 3 4 +struct __pthread_mutex_s +{ + int __lock ; + unsigned int __count; + int __owner; + + unsigned int __nusers; +# 58 "/usr/include/aarch64-linux-gnu/bits/struct_mutex.h" 3 4 + int __kind; + + + + + int __spins; + __pthread_list_t __list; +# 74 "/usr/include/aarch64-linux-gnu/bits/struct_mutex.h" 3 4 +}; +# 77 "/usr/include/aarch64-linux-gnu/bits/thread-shared-types.h" 2 3 4 +# 89 "/usr/include/aarch64-linux-gnu/bits/thread-shared-types.h" 3 4 +# 1 "/usr/include/aarch64-linux-gnu/bits/struct_rwlock.h" 1 3 4 +# 23 "/usr/include/aarch64-linux-gnu/bits/struct_rwlock.h" 3 4 +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; + unsigned long int __pad1; + unsigned long int __pad2; + unsigned int __flags; +}; +# 90 "/usr/include/aarch64-linux-gnu/bits/thread-shared-types.h" 2 3 4 + + + + +struct __pthread_cond_s +{ + __atomic_wide_counter __wseq; + __atomic_wide_counter __g1_start; + 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; +# 24 "/usr/include/aarch64-linux-gnu/bits/pthreadtypes.h" 2 3 4 + + + +typedef unsigned long int pthread_t; + + + + +typedef union +{ + char __size[8]; + int __align; +} pthread_mutexattr_t; + + + + +typedef union +{ + char __size[8]; + int __align; +} pthread_condattr_t; + + + +typedef unsigned int pthread_key_t; + + + +typedef int pthread_once_t; + + +union pthread_attr_t +{ + char __size[64]; + long int __align; +}; + +typedef union pthread_attr_t pthread_attr_t; + + + + +typedef union +{ + struct __pthread_mutex_s __data; + char __size[48]; + 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[8]; + int __align; +} pthread_barrierattr_t; +# 228 "/usr/include/aarch64-linux-gnu/sys/types.h" 2 3 4 + + +} +# 515 "/usr/include/stdlib.h" 2 3 4 + + + + + + +extern long int random (void) noexcept (true); + + +extern void srandom (unsigned int __seed) noexcept (true); + + + + + +extern char *initstate (unsigned int __seed, char *__statebuf, + size_t __statelen) noexcept (true) __attribute__ ((__nonnull__ (2))); + + + +extern char *setstate (char *__statebuf) noexcept (true) __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) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + +extern int srandom_r (unsigned int __seed, struct random_data *__buf) + noexcept (true) __attribute__ ((__nonnull__ (2))); + +extern int initstate_r (unsigned int __seed, char *__restrict __statebuf, + size_t __statelen, + struct random_data *__restrict __buf) + noexcept (true) __attribute__ ((__nonnull__ (2, 4))); + +extern int setstate_r (char *__restrict __statebuf, + struct random_data *__restrict __buf) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + + + +extern int rand (void) noexcept (true); + +extern void srand (unsigned int __seed) noexcept (true); + + + +extern int rand_r (unsigned int *__seed) noexcept (true); + + + + + + + +extern double drand48 (void) noexcept (true); +extern double erand48 (unsigned short int __xsubi[3]) noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern long int lrand48 (void) noexcept (true); +extern long int nrand48 (unsigned short int __xsubi[3]) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern long int mrand48 (void) noexcept (true); +extern long int jrand48 (unsigned short int __xsubi[3]) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern void srand48 (long int __seedval) noexcept (true); +extern unsigned short int *seed48 (unsigned short int __seed16v[3]) + noexcept (true) __attribute__ ((__nonnull__ (1))); +extern void lcong48 (unsigned short int __param[7]) noexcept (true) __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) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); +extern int erand48_r (unsigned short int __xsubi[3], + struct drand48_data *__restrict __buffer, + double *__restrict __result) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int lrand48_r (struct drand48_data *__restrict __buffer, + long int *__restrict __result) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); +extern int nrand48_r (unsigned short int __xsubi[3], + struct drand48_data *__restrict __buffer, + long int *__restrict __result) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int mrand48_r (struct drand48_data *__restrict __buffer, + long int *__restrict __result) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); +extern int jrand48_r (unsigned short int __xsubi[3], + struct drand48_data *__restrict __buffer, + long int *__restrict __result) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int srand48_r (long int __seedval, struct drand48_data *__buffer) + noexcept (true) __attribute__ ((__nonnull__ (2))); + +extern int seed48_r (unsigned short int __seed16v[3], + struct drand48_data *__buffer) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + +extern int lcong48_r (unsigned short int __param[7], + struct drand48_data *__buffer) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern __uint32_t arc4random (void) + noexcept (true) ; + + +extern void arc4random_buf (void *__buf, size_t __size) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern __uint32_t arc4random_uniform (__uint32_t __upper_bound) + noexcept (true) ; + + + + +extern void *malloc (size_t __size) noexcept (true) __attribute__ ((__malloc__)) + __attribute__ ((__alloc_size__ (1))) ; + +extern void *calloc (size_t __nmemb, size_t __size) + noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__alloc_size__ (1, 2))) ; + + + + + + +extern void *realloc (void *__ptr, size_t __size) + noexcept (true) __attribute__ ((__warn_unused_result__)) __attribute__ ((__alloc_size__ (2))); + + +extern void free (void *__ptr) noexcept (true); + + + + + + + +extern void *reallocarray (void *__ptr, size_t __nmemb, size_t __size) + noexcept (true) __attribute__ ((__warn_unused_result__)) + __attribute__ ((__alloc_size__ (2, 3))) + __attribute__ ((__malloc__ (__builtin_free, 1))); + + +extern void *reallocarray (void *__ptr, size_t __nmemb, size_t __size) + noexcept (true) __attribute__ ((__malloc__ (reallocarray, 1))); + + + +# 1 "/usr/include/alloca.h" 1 3 4 +# 24 "/usr/include/alloca.h" 3 4 +# 1 "/usr/lib/gcc/aarch64-linux-gnu/13/include/stddef.h" 1 3 4 +# 25 "/usr/include/alloca.h" 2 3 4 + +extern "C" { + + + + + +extern void *alloca (size_t __size) noexcept (true); + + + + + +} +# 707 "/usr/include/stdlib.h" 2 3 4 + + + + + +extern void *valloc (size_t __size) noexcept (true) __attribute__ ((__malloc__)) + __attribute__ ((__alloc_size__ (1))) ; + + + + +extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size) + noexcept (true) __attribute__ ((__nonnull__ (1))) ; + + + + +extern void *aligned_alloc (size_t __alignment, size_t __size) + noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__alloc_align__ (1))) + __attribute__ ((__alloc_size__ (2))) ; + + + +extern void abort (void) noexcept (true) __attribute__ ((__noreturn__)); + + + +extern int atexit (void (*__func) (void)) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + +extern "C++" int at_quick_exit (void (*__func) (void)) + noexcept (true) __asm ("at_quick_exit") __attribute__ ((__nonnull__ (1))); +# 749 "/usr/include/stdlib.h" 3 4 +extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + +extern void exit (int __status) noexcept (true) __attribute__ ((__noreturn__)); + + + + + +extern void quick_exit (int __status) noexcept (true) __attribute__ ((__noreturn__)); + + + + + +extern void _Exit (int __status) noexcept (true) __attribute__ ((__noreturn__)); + + + + +extern char *getenv (const char *__name) noexcept (true) __attribute__ ((__nonnull__ (1))) ; + + + + +extern char *secure_getenv (const char *__name) + noexcept (true) __attribute__ ((__nonnull__ (1))) ; + + + + + + +extern int putenv (char *__string) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + +extern int setenv (const char *__name, const char *__value, int __replace) + noexcept (true) __attribute__ ((__nonnull__ (2))); + + +extern int unsetenv (const char *__name) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + + +extern int clearenv (void) noexcept (true); +# 814 "/usr/include/stdlib.h" 3 4 +extern char *mktemp (char *__template) noexcept (true) __attribute__ ((__nonnull__ (1))); +# 827 "/usr/include/stdlib.h" 3 4 +extern int mkstemp (char *__template) __attribute__ ((__nonnull__ (1))) ; +# 837 "/usr/include/stdlib.h" 3 4 +extern int mkstemp64 (char *__template) __attribute__ ((__nonnull__ (1))) ; +# 849 "/usr/include/stdlib.h" 3 4 +extern int mkstemps (char *__template, int __suffixlen) __attribute__ ((__nonnull__ (1))) ; +# 859 "/usr/include/stdlib.h" 3 4 +extern int mkstemps64 (char *__template, int __suffixlen) + __attribute__ ((__nonnull__ (1))) ; +# 870 "/usr/include/stdlib.h" 3 4 +extern char *mkdtemp (char *__template) noexcept (true) __attribute__ ((__nonnull__ (1))) ; +# 881 "/usr/include/stdlib.h" 3 4 +extern int mkostemp (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ; +# 891 "/usr/include/stdlib.h" 3 4 +extern int mkostemp64 (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ; +# 901 "/usr/include/stdlib.h" 3 4 +extern int mkostemps (char *__template, int __suffixlen, int __flags) + __attribute__ ((__nonnull__ (1))) ; +# 913 "/usr/include/stdlib.h" 3 4 +extern int mkostemps64 (char *__template, int __suffixlen, int __flags) + __attribute__ ((__nonnull__ (1))) ; +# 923 "/usr/include/stdlib.h" 3 4 +extern int system (const char *__command) ; + + + + + +extern char *canonicalize_file_name (const char *__name) + noexcept (true) __attribute__ ((__nonnull__ (1))) __attribute__ ((__malloc__)) + __attribute__ ((__malloc__ (__builtin_free, 1))) ; +# 940 "/usr/include/stdlib.h" 3 4 +extern char *realpath (const char *__restrict __name, + char *__restrict __resolved) noexcept (true) ; + + + + + + +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) noexcept (true) __attribute__ ((__const__)) ; +extern long int labs (long int __x) noexcept (true) __attribute__ ((__const__)) ; + + +__extension__ extern long long int llabs (long long int __x) + noexcept (true) __attribute__ ((__const__)) ; + + + + + + +extern div_t div (int __numer, int __denom) + noexcept (true) __attribute__ ((__const__)) ; +extern ldiv_t ldiv (long int __numer, long int __denom) + noexcept (true) __attribute__ ((__const__)) ; + + +__extension__ extern lldiv_t lldiv (long long int __numer, + long long int __denom) + noexcept (true) __attribute__ ((__const__)) ; +# 1012 "/usr/include/stdlib.h" 3 4 +extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt, + int *__restrict __sign) noexcept (true) __attribute__ ((__nonnull__ (3, 4))) ; + + + + +extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt, + int *__restrict __sign) noexcept (true) __attribute__ ((__nonnull__ (3, 4))) ; + + + + +extern char *gcvt (double __value, int __ndigit, char *__buf) + noexcept (true) __attribute__ ((__nonnull__ (3))) ; + + + + +extern char *qecvt (long double __value, int __ndigit, + int *__restrict __decpt, int *__restrict __sign) + noexcept (true) __attribute__ ((__nonnull__ (3, 4))) ; +extern char *qfcvt (long double __value, int __ndigit, + int *__restrict __decpt, int *__restrict __sign) + noexcept (true) __attribute__ ((__nonnull__ (3, 4))) ; +extern char *qgcvt (long double __value, int __ndigit, char *__buf) + noexcept (true) __attribute__ ((__nonnull__ (3))) ; + + + + +extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt, + int *__restrict __sign, char *__restrict __buf, + size_t __len) noexcept (true) __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) noexcept (true) __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) + noexcept (true) __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) + noexcept (true) __attribute__ ((__nonnull__ (3, 4, 5))); + + + + + +extern int mblen (const char *__s, size_t __n) noexcept (true); + + +extern int mbtowc (wchar_t *__restrict __pwc, + const char *__restrict __s, size_t __n) noexcept (true); + + +extern int wctomb (char *__s, wchar_t __wchar) noexcept (true); + + + +extern size_t mbstowcs (wchar_t *__restrict __pwcs, + const char *__restrict __s, size_t __n) noexcept (true) + __attribute__ ((__access__ (__read_only__, 2))); + +extern size_t wcstombs (char *__restrict __s, + const wchar_t *__restrict __pwcs, size_t __n) + noexcept (true) + __attribute__ ((__access__ (__write_only__, 1, 3))) + __attribute__ ((__access__ (__read_only__, 2))); + + + + + + +extern int rpmatch (const char *__response) noexcept (true) __attribute__ ((__nonnull__ (1))) ; +# 1099 "/usr/include/stdlib.h" 3 4 +extern int getsubopt (char **__restrict __optionp, + char *const *__restrict __tokens, + char **__restrict __valuep) + noexcept (true) __attribute__ ((__nonnull__ (1, 2, 3))) ; + + + + + + + +extern int posix_openpt (int __oflag) ; + + + + + + + +extern int grantpt (int __fd) noexcept (true); + + + +extern int unlockpt (int __fd) noexcept (true); + + + + +extern char *ptsname (int __fd) noexcept (true) ; + + + + + + +extern int ptsname_r (int __fd, char *__buf, size_t __buflen) + noexcept (true) __attribute__ ((__nonnull__ (2))) __attribute__ ((__access__ (__write_only__, 2, 3))); + + +extern int getpt (void); + + + + + + +extern int getloadavg (double __loadavg[], int __nelem) + noexcept (true) __attribute__ ((__nonnull__ (1))); +# 1155 "/usr/include/stdlib.h" 3 4 +# 1 "/usr/include/aarch64-linux-gnu/bits/stdlib-float.h" 1 3 4 +# 1156 "/usr/include/stdlib.h" 2 3 4 +# 1167 "/usr/include/stdlib.h" 3 4 +} +# 80 "/usr/include/c++/13/cstdlib" 2 3 + +# 1 "/usr/include/c++/13/bits/std_abs.h" 1 3 +# 33 "/usr/include/c++/13/bits/std_abs.h" 3 + +# 34 "/usr/include/c++/13/bits/std_abs.h" 3 +# 46 "/usr/include/c++/13/bits/std_abs.h" 3 +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++/13/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); } + + + + __extension__ inline constexpr __int128 + abs(__int128 __x) { return __x >= 0 ? __x : -__x; } +# 150 "/usr/include/c++/13/bits/std_abs.h" 3 + +} +} +# 82 "/usr/include/c++/13/cstdlib" 2 3 +# 125 "/usr/include/c++/13/cstdlib" 3 +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) noexcept { return ldiv(__i, __j); } + + + + +} +# 199 "/usr/include/c++/13/cstdlib" 3 +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; +# 231 "/usr/include/c++/13/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; +} + + + +} +# 72 "/usr/include/c++/13/bits/stl_algo.h" 2 3 + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + template + + 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 + + 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 + + _InputIterator + __find_if_not_n(_InputIterator __first, _Distance& __len, _Predicate __pred) + { + for (; __len; --__len, (void) ++__first) + if (!__pred(__first)) + break; + return __first; + } +# 144 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + _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 + + _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 + + _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 + + _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 + + _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 + + _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; + } + } +# 370 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + 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()); + } +# 419 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + 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)); + } +# 455 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + inline bool + all_of(_InputIterator __first, _InputIterator __last, _Predicate __pred) + { return __last == std::find_if_not(__first, __last, __pred); } +# 473 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + inline bool + none_of(_InputIterator __first, _InputIterator __last, _Predicate __pred) + { return __last == std::find_if(__first, __last, __pred); } +# 492 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + inline bool + any_of(_InputIterator __first, _InputIterator __last, _Predicate __pred) + { return !std::none_of(__first, __last, __pred); } +# 508 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + inline _InputIterator + find_if_not(_InputIterator __first, _InputIterator __last, + _Predicate __pred) + { + + + + + ; + return std::__find_if_not(__first, __last, + __gnu_cxx::__ops::__pred_iter(__pred)); + } +# 533 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + 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); + } +# 555 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + _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 + + _OutputIterator + __remove_copy_if(_InputIterator __first, _InputIterator __last, + _OutputIterator __result, _Predicate __pred) + { + for (; __first != __last; ++__first) + if (!__pred(__first)) + { + *__result = *__first; + ++__result; + } + return __result; + } +# 622 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + 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)); + } +# 655 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + 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)); + } +# 690 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + _OutputIterator + copy_if(_InputIterator __first, _InputIterator __last, + _OutputIterator __result, _Predicate __pred) + { + + + + + + + ; + + for (; __first != __last; ++__first) + if (__pred(*__first)) + { + *__result = *__first; + ++__result; + } + return __result; + } + + template + + _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), true)); + } + + template + + inline _OutputIterator + __copy_n(_RandomAccessIterator __first, _Size __n, + _OutputIterator __result, random_access_iterator_tag) + { return std::copy(__first, __first + __n, __result); } +# 746 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + inline _OutputIterator + copy_n(_InputIterator __first, _Size __n, _OutputIterator __result) + { + + + + + + const auto __n2 = std::__size_to_integer(__n); + if (__n2 <= 0) + return __result; + + ; + ; + + return std::__copy_n(__first, __n2, __result, + std::__iterator_category(__first)); + } +# 782 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + 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); + } +# 833 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + inline _ForwardIterator + remove(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __value) + { + + + + + + ; + + return std::__remove_if(__first, __last, + __gnu_cxx::__ops::__iter_equals_val(__value)); + } +# 867 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + inline _ForwardIterator + remove_if(_ForwardIterator __first, _ForwardIterator __last, + _Predicate __pred) + { + + + + + + ; + + return std::__remove_if(__first, __last, + __gnu_cxx::__ops::__pred_iter(__pred)); + } + + template + + _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 + + _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; + } +# 936 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + inline _ForwardIterator + unique(_ForwardIterator __first, _ForwardIterator __last) + { + + + + + + ; + + return std::__unique(__first, __last, + __gnu_cxx::__ops::__iter_equal_to_iter()); + } +# 967 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + inline _ForwardIterator + unique(_ForwardIterator __first, _ForwardIterator __last, + _BinaryPredicate __binary_pred) + { + + + + + + + ; + + return std::__unique(__first, __last, + __gnu_cxx::__ops::__iter_comp_iter(__binary_pred)); + } + + + + + + + + template + + _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 + + _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 + + _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 + + 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 + + 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; + } + } +# 1128 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + inline void + reverse(_BidirectionalIterator __first, _BidirectionalIterator __last) + { + + + + ; + std::__reverse(__first, __last, std::__iterator_category(__first)); + } +# 1156 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + _OutputIterator + reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last, + _OutputIterator __result) + { + + + + + + ; + + while (__first != __last) + { + --__last; + *__result = *__last; + ++__result; + } + return __result; + } + + + + + + template + + _EuclideanRingElement + __gcd(_EuclideanRingElement __m, _EuclideanRingElement __n) + { + while (__n != 0) + { + _EuclideanRingElement __t = __m % __n; + __m = __n; + __n = __t; + } + return __m; + } + +inline namespace _V2 { + + + template + + _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 + + _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 + + _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); + } + } + } +# 1387 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + inline _ForwardIterator + rotate(_ForwardIterator __first, _ForwardIterator __middle, + _ForwardIterator __last) + { + + + + ; + ; + + return std::__rotate(__first, __middle, __last, + std::__iterator_category(__first)); + } + +} +# 1425 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + inline _OutputIterator + rotate_copy(_ForwardIterator __first, _ForwardIterator __middle, + _ForwardIterator __last, _OutputIterator __result) + { + + + + + ; + ; + + return std::copy(__first, __middle, + std::copy(__middle, __last, __result)); + } + + + template + + _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 + + _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; + } + } +# 1506 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + _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 + _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())); + } +# 1608 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + inline _ForwardIterator + stable_partition(_ForwardIterator __first, _ForwardIterator __last, + _Predicate __pred) + { + + + + + + ; + + return std::__stable_partition(__first, __last, + __gnu_cxx::__ops::__pred_iter(__pred)); + } + + + + + + template + + 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 + + _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; + } +# 1701 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + inline _RandomAccessIterator + partial_sort_copy(_InputIterator __first, _InputIterator __last, + _RandomAccessIterator __result_first, + _RandomAccessIterator __result_last) + { +# 1716 "/usr/include/c++/13/bits/stl_algo.h" 3 + + + + + + + ; + ; + ; + + return std::__partial_sort_copy(__first, __last, + __result_first, __result_last, + __gnu_cxx::__ops::__iter_less_iter()); + } +# 1751 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + inline _RandomAccessIterator + partial_sort_copy(_InputIterator __first, _InputIterator __last, + _RandomAccessIterator __result_first, + _RandomAccessIterator __result_last, + _Compare __comp) + { +# 1768 "/usr/include/c++/13/bits/stl_algo.h" 3 + + + + + + + + + + ; + ; + ; + + return std::__partial_sort_copy(__first, __last, + __result_first, __result_last, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + + + + template + + 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 + + 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 + + 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 + + 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 + + _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 + + 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 + + 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 + + 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 + + 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 + + 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); + } +# 2002 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + 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 + + _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; + } +# 2058 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + inline _ForwardIterator + upper_bound(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val) + { + + + + + ; + + return std::__upper_bound(__first, __last, __val, + __gnu_cxx::__ops::__val_less_iter()); + } +# 2089 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + 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 + + 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); + } +# 2162 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + 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()); + } +# 2199 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + 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)); + } +# 2233 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + 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); + } +# 2267 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + 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 + 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 + 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 + _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 + void + __merge_adaptive(_BidirectionalIterator __first, + _BidirectionalIterator __middle, + _BidirectionalIterator __last, + _Distance __len1, _Distance __len2, + _Pointer __buffer, _Compare __comp) + { + if (__len1 <= __len2) + { + _Pointer __buffer_end = std::move(__first, __middle, __buffer); + std::__move_merge_adaptive(__buffer, __buffer_end, __middle, __last, + __first, __comp); + } + else + { + _Pointer __buffer_end = std::move(__middle, __last, __buffer); + std::__move_merge_adaptive_backward(__first, __middle, __buffer, + __buffer_end, __last, __comp); + } + } + + template + void + __merge_adaptive_resize(_BidirectionalIterator __first, + _BidirectionalIterator __middle, + _BidirectionalIterator __last, + _Distance __len1, _Distance __len2, + _Pointer __buffer, _Distance __buffer_size, + _Compare __comp) + { + if (__len1 <= __buffer_size || __len2 <= __buffer_size) + std::__merge_adaptive(__first, __middle, __last, + __len1, __len2, __buffer, __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, + _Distance(__len1 - __len11), __len22, + __buffer, __buffer_size); + std::__merge_adaptive_resize(__first, __first_cut, __new_middle, + __len11, __len22, + __buffer, __buffer_size, __comp); + std::__merge_adaptive_resize(__new_middle, __second_cut, __last, + _Distance(__len1 - __len11), + _Distance(__len2 - __len22), + __buffer, __buffer_size, __comp); + } + } + + + template + 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 + 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, std::min(__len1, __len2)); + + if (__builtin_expect(__buf.size() == __buf.requested_size(), true)) + std::__merge_adaptive + (__first, __middle, __last, __len1, __len2, __buf.begin(), __comp); + else if (__builtin_expect(__buf.begin() == 0, false)) + std::__merge_without_buffer + (__first, __middle, __last, __len1, __len2, __comp); + else + std::__merge_adaptive_resize + (__first, __middle, __last, __len1, __len2, __buf.begin(), + _DistanceType(__buf.size()), __comp); + + + + + } +# 2582 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + inline void + inplace_merge(_BidirectionalIterator __first, + _BidirectionalIterator __middle, + _BidirectionalIterator __last) + { + + + + + + ; + ; + ; + + std::__inplace_merge(__first, __middle, __last, + __gnu_cxx::__ops::__iter_less_iter()); + } +# 2623 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + 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 + _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 + 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 + + 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 + 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 + void + __stable_sort_adaptive(_RandomAccessIterator __first, + _RandomAccessIterator __middle, + _RandomAccessIterator __last, + _Pointer __buffer, _Compare __comp) + { + std::__merge_sort_with_buffer(__first, __middle, __buffer, __comp); + std::__merge_sort_with_buffer(__middle, __last, __buffer, __comp); + + std::__merge_adaptive(__first, __middle, __last, + __middle - __first, __last - __middle, + __buffer, __comp); + } + + template + void + __stable_sort_adaptive_resize(_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_resize(__first, __middle, __buffer, + __buffer_size, __comp); + std::__stable_sort_adaptive_resize(__middle, __last, __buffer, + __buffer_size, __comp); + std::__merge_adaptive_resize(__first, __middle, __last, + _Distance(__middle - __first), + _Distance(__last - __middle), + __buffer, __buffer_size, + __comp); + } + else + std::__stable_sort_adaptive(__first, __middle, __last, + __buffer, __comp); + } + + + template + 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); + } +# 2809 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + bool + __includes(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _Compare __comp) + { + while (__first1 != __last1 && __first2 != __last2) + { + if (__comp(__first2, __first1)) + return false; + if (!__comp(__first1, __first2)) + ++__first2; + ++__first1; + } + + return __first2 == __last2; + } +# 2847 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + inline bool + includes(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2) + { + + + + + + + + + + ; + ; + ; + ; + + return std::__includes(__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::__iter_less_iter()); + } +# 2892 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + 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)); + } +# 2928 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + 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; + } + } + } +# 2978 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + inline bool + next_permutation(_BidirectionalIterator __first, + _BidirectionalIterator __last) + { + + + + + + ; + ; + + return std::__next_permutation + (__first, __last, __gnu_cxx::__ops::__iter_less_iter()); + } +# 3011 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + inline bool + next_permutation(_BidirectionalIterator __first, + _BidirectionalIterator __last, _Compare __comp) + { + + + + + + + ; + ; + + return std::__next_permutation + (__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + template + + 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; + } + } + } +# 3081 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + inline bool + prev_permutation(_BidirectionalIterator __first, + _BidirectionalIterator __last) + { + + + + + + ; + ; + + return std::__prev_permutation(__first, __last, + __gnu_cxx::__ops::__iter_less_iter()); + } +# 3114 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + inline bool + prev_permutation(_BidirectionalIterator __first, + _BidirectionalIterator __last, _Compare __comp) + { + + + + + + + ; + ; + + return std::__prev_permutation(__first, __last, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + + + + template + + _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; + } +# 3166 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + 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); + } +# 3201 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + 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); + } +# 3230 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + inline bool + is_sorted(_ForwardIterator __first, _ForwardIterator __last) + { return std::is_sorted_until(__first, __last) == __last; } +# 3245 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + inline bool + is_sorted(_ForwardIterator __first, _ForwardIterator __last, + _Compare __comp) + { return std::is_sorted_until(__first, __last, __comp) == __last; } + + template + + _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; + } +# 3276 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + inline _ForwardIterator + is_sorted_until(_ForwardIterator __first, _ForwardIterator __last) + { + + + + + ; + ; + + return std::__is_sorted_until(__first, __last, + __gnu_cxx::__ops::__iter_less_iter()); + } +# 3301 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + 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)); + } +# 3327 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + constexpr + inline pair + minmax(const _Tp& __a, const _Tp& __b) + { + + + + return __b < __a ? pair(__b, __a) + : pair(__a, __b); + } +# 3348 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + constexpr + inline pair + minmax(const _Tp& __a, const _Tp& __b, _Compare __comp) + { + return __comp(__b, __a) ? pair(__b, __a) + : pair(__a, __b); + } + + template + 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); + } +# 3428 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + constexpr + inline pair<_ForwardIterator, _ForwardIterator> + minmax_element(_ForwardIterator __first, _ForwardIterator __last) + { + + + + + ; + ; + + return std::__minmax_element(__first, __last, + __gnu_cxx::__ops::__iter_less_iter()); + } +# 3456 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + 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 + constexpr + inline pair<_Tp, _Tp> + minmax(initializer_list<_Tp> __l) + { + ; + pair __p = + std::__minmax_element(__l.begin(), __l.end(), + __gnu_cxx::__ops::__iter_less_iter()); + return std::make_pair(*__p.first, *__p.second); + } + + template + constexpr + inline pair<_Tp, _Tp> + minmax(initializer_list<_Tp> __l, _Compare __comp) + { + ; + pair __p = + std::__minmax_element(__l.begin(), __l.end(), + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + return std::make_pair(*__p.first, *__p.second); + } +# 3512 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + 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 + + 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; + } +# 3607 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + 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()); + } +# 3635 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + 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)); + } +# 3665 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + constexpr const _Tp& + clamp(const _Tp& __val, const _Tp& __lo, const _Tp& __hi) + { + do { if (std::__is_constant_evaluated() && !bool(!(__hi < __lo))) __builtin_unreachable(); } while (false); + return std::min(std::max(__val, __lo), __hi); + } +# 3685 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + constexpr const _Tp& + clamp(const _Tp& __val, const _Tp& __lo, const _Tp& __hi, _Compare __comp) + { + do { if (std::__is_constant_evaluated() && !bool(!__comp(__hi, __lo))) __builtin_unreachable(); } while (false); + return std::min(std::max(__val, __lo, __comp), __hi, __comp); + } +# 3717 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + 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); + } +# 3739 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + 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::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))); + } + + + + + +# 3824 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + _Function + for_each(_InputIterator __first, _InputIterator __last, _Function __f) + { + + + ; + for (; __first != __last; ++__first) + __f(*__first); + return __f; + } +# 3850 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + _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) + { + 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; + } + } +# 3886 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + inline _InputIterator + find(_InputIterator __first, _InputIterator __last, + const _Tp& __val) + { + + + + + ; + return std::__find_if(__first, __last, + __gnu_cxx::__ops::__iter_equals_val(__val)); + } +# 3911 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + inline _InputIterator + find_if(_InputIterator __first, _InputIterator __last, + _Predicate __pred) + { + + + + + ; + + return std::__find_if(__first, __last, + __gnu_cxx::__ops::__pred_iter(__pred)); + } +# 3943 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + _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; + } +# 3984 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + _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; + } +# 4017 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + inline _ForwardIterator + adjacent_find(_ForwardIterator __first, _ForwardIterator __last) + { + + + + + ; + + return std::__adjacent_find(__first, __last, + __gnu_cxx::__ops::__iter_equal_to_iter()); + } +# 4043 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + 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)); + } +# 4069 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + 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)); + } +# 4093 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + 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)); + } +# 4134 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + 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()); + } +# 4174 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + 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)); + } +# 4210 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + 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)); + } +# 4244 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + 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)); + } +# 4270 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + inline _ForwardIterator + search(_ForwardIterator __first, _ForwardIterator __last, + const _Searcher& __searcher) + { return __searcher(__first, __last).first; } +# 4294 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + _OutputIterator + transform(_InputIterator __first, _InputIterator __last, + _OutputIterator __result, _UnaryOperation __unary_op) + { + + + + + + ; + + for (; __first != __last; ++__first, (void)++__result) + *__result = __unary_op(*__first); + return __result; + } +# 4332 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + _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; + } +# 4366 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + 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; + } +# 4399 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + void + replace_if(_ForwardIterator __first, _ForwardIterator __last, + _Predicate __pred, const _Tp& __new_value) + { + + + + + + + + ; + + for (; __first != __last; ++__first) + if (__pred(*__first)) + *__first = __new_value; + } +# 4431 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + void + generate(_ForwardIterator __first, _ForwardIterator __last, + _Generator __gen) + { + + + + + ; + + for (; __first != __last; ++__first) + *__first = __gen(); + } +# 4464 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + _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; + } +# 4499 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + 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)); + } +# 4539 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + 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)); + } +# 4578 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + __attribute__ ((__deprecated__ ("use '" "std::shuffle" "' instead"))) + 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); + } + } +# 4617 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + __attribute__ ((__deprecated__ ("use '" "std::shuffle" "' instead"))) + 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); + } + } +# 4659 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + inline _ForwardIterator + partition(_ForwardIterator __first, _ForwardIterator __last, + _Predicate __pred) + { + + + + + + ; + + return std::__partition(__first, __last, __pred, + std::__iterator_category(__first)); + } +# 4694 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + inline void + partial_sort(_RandomAccessIterator __first, + _RandomAccessIterator __middle, + _RandomAccessIterator __last) + { + + + + + + ; + ; + ; + + std::__partial_sort(__first, __middle, __last, + __gnu_cxx::__ops::__iter_less_iter()); + } +# 4733 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + 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)); + } +# 4770 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + 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()); + } +# 4810 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + 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)); + } +# 4848 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + inline void + sort(_RandomAccessIterator __first, _RandomAccessIterator __last) + { + + + + + + ; + ; + + std::__sort(__first, __last, __gnu_cxx::__ops::__iter_less_iter()); + } +# 4879 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + inline void + sort(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Compare __comp) + { + + + + + + + ; + ; + + std::__sort(__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + template + + _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)); + } +# 4942 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + 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()); + } +# 4993 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + 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 + 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; + + if (__first == __last) + return; + + + typedef _Temporary_buffer<_RandomAccessIterator, _ValueType> _TmpBuf; + + + _TmpBuf __buf(__first, (__last - __first + 1) / 2); + + if (__builtin_expect(__buf.requested_size() == __buf.size(), true)) + std::__stable_sort_adaptive(__first, + __first + _DistanceType(__buf.size()), + __last, __buf.begin(), __comp); + else if (__builtin_expect(__buf.begin() == 0, false)) + std::__inplace_stable_sort(__first, __last, __comp); + else + std::__stable_sort_adaptive_resize(__first, __last, __buf.begin(), + _DistanceType(__buf.size()), __comp); + + + + } +# 5071 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + inline void + stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last) + { + + + + + + ; + ; + + std::__stable_sort(__first, __last, + __gnu_cxx::__ops::__iter_less_iter()); + } +# 5105 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + inline void + stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Compare __comp) + { + + + + + + + ; + ; + + std::__stable_sort(__first, __last, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + template + + _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)); + } +# 5175 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + 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()); + } +# 5226 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + 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 + + _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; + } +# 5299 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + 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()); + } +# 5349 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + 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 + + _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); + } +# 5424 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + 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()); + } +# 5476 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + 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 + + _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)); + } +# 5557 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + 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()); + } +# 5609 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + + 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 + 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; + } +# 5663 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + constexpr + _ForwardIterator + inline min_element(_ForwardIterator __first, _ForwardIterator __last) + { + + + + + ; + ; + + return std::__min_element(__first, __last, + __gnu_cxx::__ops::__iter_less_iter()); + } +# 5688 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + 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 + 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; + } +# 5727 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + constexpr + inline _ForwardIterator + max_element(_ForwardIterator __first, _ForwardIterator __last) + { + + + + + ; + ; + + return std::__max_element(__first, __last, + __gnu_cxx::__ops::__iter_less_iter()); + } +# 5752 "/usr/include/c++/13/bits/stl_algo.h" 3 + template + 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 + constexpr + inline _Tp + min(initializer_list<_Tp> __l) + { + ; + return *std::__min_element(__l.begin(), __l.end(), + __gnu_cxx::__ops::__iter_less_iter()); + } + + template + constexpr + inline _Tp + min(initializer_list<_Tp> __l, _Compare __comp) + { + ; + return *std::__min_element(__l.begin(), __l.end(), + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + template + constexpr + inline _Tp + max(initializer_list<_Tp> __l) + { + ; + return *std::__max_element(__l.begin(), __l.end(), + __gnu_cxx::__ops::__iter_less_iter()); + } + + template + constexpr + inline _Tp + max(initializer_list<_Tp> __l, _Compare __comp) + { + ; + return *std::__max_element(__l.begin(), __l.end(), + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + + + + template + _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 + _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; + + if (__first == __last) + return __out; + + __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; + } + + + + + template + _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<__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)); + } + + + + + +} +# 62 "/usr/include/c++/13/algorithm" 2 3 +# 73 "/usr/include/c++/13/algorithm" 3 +# 1 "/usr/include/c++/13/pstl/glue_algorithm_defs.h" 1 3 +# 15 "/usr/include/c++/13/pstl/glue_algorithm_defs.h" 3 +# 1 "/usr/include/c++/13/pstl/execution_defs.h" 1 3 +# 15 "/usr/include/c++/13/pstl/execution_defs.h" 3 +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{}; + } +}; + + +inline constexpr sequenced_policy seq{}; +inline constexpr parallel_policy par{}; +inline constexpr parallel_unsequenced_policy par_unseq{}; +inline constexpr unsequenced_policy unseq{}; + + +template +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 +constexpr bool is_execution_policy_v = __pstl::execution::is_execution_policy<_Tp>::value; + + +} +} + +namespace __internal +{ +template + +using __enable_if_execution_policy = + typename std::enable_if<__pstl::execution::is_execution_policy>::value, + _Tp>::type; + + + + + +} + +} +# 16 "/usr/include/c++/13/pstl/glue_algorithm_defs.h" 2 3 + +namespace std +{ + + + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> +any_of(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred); + + + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> +all_of(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred); + + + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> +none_of(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred); + + + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> +for_each(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Function __f); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +for_each_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n, _Function __f); + + + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +find_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +find_if_not(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +find(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value); + + + +template +__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 +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1> +find_end(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, + _ForwardIterator2 __s_last); + + + +template +__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 +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1> +find_first_of(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, + _ForwardIterator2 __s_first, _ForwardIterator2 __s_last); + + + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +adjacent_find(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +adjacent_find(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred); + + + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, + typename iterator_traits<_ForwardIterator>::difference_type> +count(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, + typename iterator_traits<_ForwardIterator>::difference_type> +count_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred); + + + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1> +search(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, + _ForwardIterator2 __s_last, _BinaryPredicate __pred); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1> +search(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first, + _ForwardIterator2 __s_last); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +search_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Size __count, + const _Tp& __value, _BinaryPredicate __pred); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +search_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Size __count, + const _Tp& __value); + + + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> +copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> +copy_n(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _Size __n, _ForwardIterator2 __result); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> +copy_if(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 result, + _Predicate __pred); + + + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> +swap_ranges(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2); + + + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> +transform(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result, + _UnaryOperation __op); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +transform(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator __result, _BinaryOperation __op); + + + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> +replace_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred, + const _Tp& __new_value); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> +replace(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __old_value, + const _Tp& __new_value); + +template +__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 +__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 +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> +fill(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +fill_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __count, const _Tp& __value); + + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> +generate(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Generator __g); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +generate_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size count, _Generator __g); + + + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> +remove_copy_if(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, + _ForwardIterator2 __result, _Predicate __pred); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> +remove_copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result, + const _Tp& __value); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +remove_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +remove(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value); + + + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +unique(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +unique(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> +unique_copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result, + _BinaryPredicate __pred); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> +unique_copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result); + + + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> +reverse(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +reverse_copy(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last, + _ForwardIterator __d_first); + + + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +rotate(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> +rotate_copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __middle, _ForwardIterator1 __last, + _ForwardIterator2 __result); + + + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> +is_partitioned(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +partition(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _BidirectionalIterator> +stable_partition(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last, + _UnaryPredicate __pred); + +template +__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 +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> +sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> +sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last); + + + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> +stable_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> +stable_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last); + + + +template +__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 +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>> +mismatch(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _BinaryPredicate __pred); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>> +mismatch(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator2 __last2); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>> +mismatch(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2); + + + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> +equal(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _BinaryPredicate __p); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> +equal(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> +equal(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator2 __last2, _BinaryPredicate __p); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> +equal(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator2 __last2); + + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> +move(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __d_first); + + + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> +partial_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __middle, + _RandomAccessIterator __last, _Compare __comp); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> +partial_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __middle, + _RandomAccessIterator __last); + + + +template +__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 +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _RandomAccessIterator> +partial_sort_copy(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, + _RandomAccessIterator __d_first, _RandomAccessIterator __d_last); + + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +is_sorted_until(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +is_sorted_until(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> +is_sorted(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> +is_sorted(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last); + + + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> +nth_element(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __nth, + _RandomAccessIterator __last, _Compare __comp); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> +nth_element(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __nth, + _RandomAccessIterator __last); + + +template +__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 +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +merge(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator2 __last2, _ForwardIterator __d_first); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> +inplace_merge(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __middle, + _BidirectionalIterator __last, _Compare __comp); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> +inplace_merge(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __middle, + _BidirectionalIterator __last); + + + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> +includes(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator2 __last2, _Compare __comp); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> +includes(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator2 __last2); + + + +template +__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 +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +set_union(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, + _ForwardIterator2 __last2, _ForwardIterator __result); + + + +template +__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 +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +set_intersection(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result); + + + +template +__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 +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +set_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result); + + + +template +__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 +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +set_symmetric_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result); + + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _RandomAccessIterator> +is_heap_until(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _RandomAccessIterator> +is_heap_until(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> +is_heap(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> +is_heap(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last); + + + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +min_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +min_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +max_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +max_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator, _ForwardIterator>> +minmax_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator, _ForwardIterator>> +minmax_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last); + + + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> +lexicographical_compare(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, _Compare __comp); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> +lexicographical_compare(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2); + +} +# 74 "/usr/include/c++/13/algorithm" 2 3 +# 29 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 2 +# 1 "/usr/include/c++/13/cstring" 1 3 +# 39 "/usr/include/c++/13/cstring" 3 + +# 40 "/usr/include/c++/13/cstring" 3 + + +# 1 "/usr/include/string.h" 1 3 4 +# 26 "/usr/include/string.h" 3 4 +# 1 "/usr/include/aarch64-linux-gnu/bits/libc-header-start.h" 1 3 4 +# 27 "/usr/include/string.h" 2 3 4 + +extern "C" { + + + + +# 1 "/usr/lib/gcc/aarch64-linux-gnu/13/include/stddef.h" 1 3 4 +# 34 "/usr/include/string.h" 2 3 4 +# 43 "/usr/include/string.h" 3 4 +extern void *memcpy (void *__restrict __dest, const void *__restrict __src, + size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern void *memmove (void *__dest, const void *__src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + + + +extern void *memccpy (void *__restrict __dest, const void *__restrict __src, + int __c, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__access__ (__write_only__, 1, 4))); + + + + +extern void *memset (void *__s, int __c, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int memcmp (const void *__s1, const void *__s2, size_t __n) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +# 80 "/usr/include/string.h" 3 4 +extern int __memcmpeq (const void *__s1, const void *__s2, size_t __n) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + + +extern "C++" +{ +extern void *memchr (void *__s, int __c, size_t __n) + noexcept (true) __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern const void *memchr (const void *__s, int __c, size_t __n) + noexcept (true) __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +# 105 "/usr/include/string.h" 3 4 +} +# 115 "/usr/include/string.h" 3 4 +extern "C++" void *rawmemchr (void *__s, int __c) + noexcept (true) __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern "C++" const void *rawmemchr (const void *__s, int __c) + noexcept (true) __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); + + + + + + + +extern "C++" void *memrchr (void *__s, int __c, size_t __n) + noexcept (true) __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) + noexcept (true) __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) + __attribute__ ((__access__ (__read_only__, 1, 3))); +# 141 "/usr/include/string.h" 3 4 +extern char *strcpy (char *__restrict __dest, const char *__restrict __src) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + +extern char *strncpy (char *__restrict __dest, + const char *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern char *strcat (char *__restrict __dest, const char *__restrict __src) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + +extern char *strncat (char *__restrict __dest, const char *__restrict __src, + size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int strcmp (const char *__s1, const char *__s2) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + +extern int strncmp (const char *__s1, const char *__s2, size_t __n) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern int strcoll (const char *__s1, const char *__s2) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + +extern size_t strxfrm (char *__restrict __dest, + const char *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (2))) __attribute__ ((__access__ (__write_only__, 1, 3))); + + + + + + +extern int strcoll_l (const char *__s1, const char *__s2, locale_t __l) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3))); + + +extern size_t strxfrm_l (char *__dest, const char *__src, size_t __n, + locale_t __l) noexcept (true) __attribute__ ((__nonnull__ (2, 4))) + __attribute__ ((__access__ (__write_only__, 1, 3))); + + + + + +extern char *strdup (const char *__s) + noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1))); + + + + + + +extern char *strndup (const char *__string, size_t __n) + noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1))); +# 224 "/usr/include/string.h" 3 4 +extern "C++" +{ +extern char *strchr (char *__s, int __c) + noexcept (true) __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern const char *strchr (const char *__s, int __c) + noexcept (true) __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +# 244 "/usr/include/string.h" 3 4 +} + + + + + + +extern "C++" +{ +extern char *strrchr (char *__s, int __c) + noexcept (true) __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern const char *strrchr (const char *__s, int __c) + noexcept (true) __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +# 271 "/usr/include/string.h" 3 4 +} +# 281 "/usr/include/string.h" 3 4 +extern "C++" char *strchrnul (char *__s, int __c) + noexcept (true) __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern "C++" const char *strchrnul (const char *__s, int __c) + noexcept (true) __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +# 293 "/usr/include/string.h" 3 4 +extern size_t strcspn (const char *__s, const char *__reject) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern size_t strspn (const char *__s, const char *__accept) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern "C++" +{ +extern char *strpbrk (char *__s, const char *__accept) + noexcept (true) __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +extern const char *strpbrk (const char *__s, const char *__accept) + noexcept (true) __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +# 321 "/usr/include/string.h" 3 4 +} + + + + + + +extern "C++" +{ +extern char *strstr (char *__haystack, const char *__needle) + noexcept (true) __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +extern const char *strstr (const char *__haystack, const char *__needle) + noexcept (true) __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +# 348 "/usr/include/string.h" 3 4 +} + + + + + + + +extern char *strtok (char *__restrict __s, const char *__restrict __delim) + noexcept (true) __attribute__ ((__nonnull__ (2))); + + + +extern char *__strtok_r (char *__restrict __s, + const char *__restrict __delim, + char **__restrict __save_ptr) + noexcept (true) __attribute__ ((__nonnull__ (2, 3))); + +extern char *strtok_r (char *__restrict __s, const char *__restrict __delim, + char **__restrict __save_ptr) + noexcept (true) __attribute__ ((__nonnull__ (2, 3))); + + + + + +extern "C++" char *strcasestr (char *__haystack, const char *__needle) + noexcept (true) __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +extern "C++" const char *strcasestr (const char *__haystack, + const char *__needle) + noexcept (true) __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +# 389 "/usr/include/string.h" 3 4 +extern void *memmem (const void *__haystack, size_t __haystacklen, + const void *__needle, size_t __needlelen) + noexcept (true) __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) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); +extern void *mempcpy (void *__restrict __dest, + const void *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + + +extern size_t strlen (const char *__s) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); + + + + +extern size_t strnlen (const char *__string, size_t __maxlen) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); + + + + +extern char *strerror (int __errnum) noexcept (true); +# 444 "/usr/include/string.h" 3 4 +extern char *strerror_r (int __errnum, char *__buf, size_t __buflen) + noexcept (true) __attribute__ ((__nonnull__ (2))) __attribute__ ((__access__ (__write_only__, 2, 3))); + + + + +extern const char *strerrordesc_np (int __err) noexcept (true); + +extern const char *strerrorname_np (int __err) noexcept (true); + + + + + +extern char *strerror_l (int __errnum, locale_t __l) noexcept (true); + + + +# 1 "/usr/include/strings.h" 1 3 4 +# 23 "/usr/include/strings.h" 3 4 +# 1 "/usr/lib/gcc/aarch64-linux-gnu/13/include/stddef.h" 1 3 4 +# 24 "/usr/include/strings.h" 2 3 4 + + + + + + +extern "C" { + + + +extern int bcmp (const void *__s1, const void *__s2, size_t __n) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern void bcopy (const void *__src, void *__dest, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern void bzero (void *__s, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern "C++" +{ +extern char *index (char *__s, int __c) + noexcept (true) __asm ("index") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern const char *index (const char *__s, int __c) + noexcept (true) __asm ("index") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +# 66 "/usr/include/strings.h" 3 4 +} + + + + + + + +extern "C++" +{ +extern char *rindex (char *__s, int __c) + noexcept (true) __asm ("rindex") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern const char *rindex (const char *__s, int __c) + noexcept (true) __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) noexcept (true) __attribute__ ((__const__)); + + + + + +extern int ffsl (long int __l) noexcept (true) __attribute__ ((__const__)); +__extension__ extern int ffsll (long long int __ll) + noexcept (true) __attribute__ ((__const__)); + + + +extern int strcasecmp (const char *__s1, const char *__s2) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern int strncasecmp (const char *__s1, const char *__s2, size_t __n) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + + + + + +extern int strcasecmp_l (const char *__s1, const char *__s2, locale_t __loc) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3))); + + + +extern int strncasecmp_l (const char *__s1, const char *__s2, + size_t __n, locale_t __loc) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 4))); + + +} +# 463 "/usr/include/string.h" 2 3 4 + + + +extern void explicit_bzero (void *__s, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1))) + __attribute__ ((__access__ (__write_only__, 1, 2))); + + + +extern char *strsep (char **__restrict __stringp, + const char *__restrict __delim) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + + +extern char *strsignal (int __sig) noexcept (true); + + + +extern const char *sigabbrev_np (int __sig) noexcept (true); + + +extern const char *sigdescr_np (int __sig) noexcept (true); + + + +extern char *__stpcpy (char *__restrict __dest, const char *__restrict __src) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); +extern char *stpcpy (char *__restrict __dest, const char *__restrict __src) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + +extern char *__stpncpy (char *__restrict __dest, + const char *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); +extern char *stpncpy (char *__restrict __dest, + const char *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + + +extern size_t strlcpy (char *__restrict __dest, + const char *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__access__ (__write_only__, 1, 3))); + + + +extern size_t strlcat (char *__restrict __dest, + const char *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__access__ (__read_write__, 1, 3))); + + + + +extern int strverscmp (const char *__s1, const char *__s2) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern char *strfry (char *__string) noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern void *memfrob (void *__s, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1))) + __attribute__ ((__access__ (__read_write__, 1, 2))); + + + + + + + +extern "C++" char *basename (char *__filename) + noexcept (true) __asm ("basename") __attribute__ ((__nonnull__ (1))); +extern "C++" const char *basename (const char *__filename) + noexcept (true) __asm ("basename") __attribute__ ((__nonnull__ (1))); +# 552 "/usr/include/string.h" 3 4 +} +# 43 "/usr/include/c++/13/cstring" 2 3 +# 71 "/usr/include/c++/13/cstring" 3 +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++/13/cstring" 3 + +} +} +# 30 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 2 + +# 1 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.h" 1 +# 31 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.h" +# 1 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" 1 +# 34 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" +# 1 "/usr/include/c++/13/cstdlib" 1 3 +# 39 "/usr/include/c++/13/cstdlib" 3 + +# 40 "/usr/include/c++/13/cstdlib" 3 +# 35 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" 2 +# 1 "/usr/include/c++/13/cstring" 1 3 +# 39 "/usr/include/c++/13/cstring" 3 + +# 40 "/usr/include/c++/13/cstring" 3 +# 36 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" 2 +# 44 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" +# 1 "/usr/include/c++/13/cassert" 1 3 +# 41 "/usr/include/c++/13/cassert" 3 + +# 42 "/usr/include/c++/13/cassert" 3 + + +# 1 "/usr/include/assert.h" 1 3 4 +# 66 "/usr/include/assert.h" 3 4 +extern "C" { + + +extern void __assert_fail (const char *__assertion, const char *__file, + unsigned int __line, const char *__function) + noexcept (true) __attribute__ ((__noreturn__)); + + +extern void __assert_perror_fail (int __errnum, const char *__file, + unsigned int __line, const char *__function) + noexcept (true) __attribute__ ((__noreturn__)); + + + + +extern void __assert (const char *__assertion, const char *__file, int __line) + noexcept (true) __attribute__ ((__noreturn__)); + + +} +# 45 "/usr/include/c++/13/cassert" 2 3 +# 45 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" 2 +# 186 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" +# 1 "/usr/lib/gcc/aarch64-linux-gnu/13/include/stdint.h" 1 3 4 +# 9 "/usr/lib/gcc/aarch64-linux-gnu/13/include/stdint.h" 3 4 +# 1 "/usr/include/stdint.h" 1 3 4 +# 26 "/usr/include/stdint.h" 3 4 +# 1 "/usr/include/aarch64-linux-gnu/bits/libc-header-start.h" 1 3 4 +# 27 "/usr/include/stdint.h" 2 3 4 + +# 1 "/usr/include/aarch64-linux-gnu/bits/wchar.h" 1 3 4 +# 29 "/usr/include/stdint.h" 2 3 4 +# 1 "/usr/include/aarch64-linux-gnu/bits/wordsize.h" 1 3 4 +# 30 "/usr/include/stdint.h" 2 3 4 + + + + + + + +# 1 "/usr/include/aarch64-linux-gnu/bits/stdint-uintn.h" 1 3 4 +# 24 "/usr/include/aarch64-linux-gnu/bits/stdint-uintn.h" 3 4 +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 + + + +# 1 "/usr/include/aarch64-linux-gnu/bits/stdint-least.h" 1 3 4 +# 25 "/usr/include/aarch64-linux-gnu/bits/stdint-least.h" 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; +# 42 "/usr/include/stdint.h" 2 3 4 + + + + + +typedef signed char int_fast8_t; + +typedef long int int_fast16_t; +typedef long int int_fast32_t; +typedef long int int_fast64_t; +# 60 "/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; +# 76 "/usr/include/stdint.h" 3 4 +typedef long int intptr_t; + + +typedef unsigned long int uintptr_t; +# 90 "/usr/include/stdint.h" 3 4 +typedef __intmax_t intmax_t; +typedef __uintmax_t uintmax_t; +# 10 "/usr/lib/gcc/aarch64-linux-gnu/13/include/stdint.h" 2 3 4 +# 187 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" 2 + + + + +# 190 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" +typedef uint16_t uc16; +# 239 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" +namespace double_conversion { + +inline int StrLength(const char* string) { + size_t length = strlen(string); + +# 243 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" 3 4 + (static_cast ( +# 243 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" + length == static_cast(static_cast(length)) +# 243 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" 3 4 + ) ? void (0) : __assert_fail ( +# 243 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" + "length == static_cast(static_cast(length))" +# 243 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" 3 4 + , __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)) +# 243 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" + ; + return static_cast(length); +} + + +template +class Vector { + public: + Vector() : start_(nullptr), length_(0) {} + Vector(T* data, int len) : start_(data), length_(len) { + +# 253 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" 3 4 + (static_cast ( +# 253 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" + len == 0 || (len > 0 && data != nullptr) +# 253 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" 3 4 + ) ? void (0) : __assert_fail ( +# 253 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" + "len == 0 || (len > 0 && data != nullptr)" +# 253 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" 3 4 + , __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)) +# 253 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" + ; + } + + + + Vector SubVector(int from, int to) { + +# 259 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" 3 4 + (static_cast ( +# 259 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" + to <= length_ +# 259 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" 3 4 + ) ? void (0) : __assert_fail ( +# 259 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" + "to <= length_" +# 259 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" 3 4 + , __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)) +# 259 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" + ; + +# 260 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" 3 4 + (static_cast ( +# 260 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" + from < to +# 260 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" 3 4 + ) ? void (0) : __assert_fail ( +# 260 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" + "from < to" +# 260 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" 3 4 + , __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)) +# 260 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" + ; + +# 261 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" 3 4 + (static_cast ( +# 261 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" + 0 <= from +# 261 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" 3 4 + ) ? void (0) : __assert_fail ( +# 261 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" + "0 <= from" +# 261 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" 3 4 + , __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)) +# 261 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" + ; + return Vector(start() + from, to - from); + } + + + int length() const { return length_; } + + + bool is_empty() const { return length_ == 0; } + + + T* start() const { return start_; } + + + T& operator[](int index) const { + +# 276 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" 3 4 + (static_cast ( +# 276 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" + 0 <= index && index < length_ +# 276 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" 3 4 + ) ? void (0) : __assert_fail ( +# 276 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" + "0 <= index && index < length_" +# 276 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" 3 4 + , __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)) +# 276 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" + ; + return start_[index]; + } + + T& first() { return start_[0]; } + + T& last() { return start_[length_ - 1]; } + + void pop_back() { + +# 285 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" 3 4 + (static_cast ( +# 285 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" + !is_empty() +# 285 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" 3 4 + ) ? void (0) : __assert_fail ( +# 285 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" + "!is_empty()" +# 285 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" 3 4 + , __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)) +# 285 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" + ; + --length_; + } + + private: + T* start_; + int length_; +}; + + + + + +class StringBuilder { + public: + StringBuilder(char* buffer, int buffer_size) + : buffer_(buffer, buffer_size), position_(0) { } + + ~StringBuilder() { if (!is_finalized()) Finalize(); } + + int size() const { return buffer_.length(); } + + + int position() const { + +# 309 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" 3 4 + (static_cast ( +# 309 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" + !is_finalized() +# 309 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" 3 4 + ) ? void (0) : __assert_fail ( +# 309 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" + "!is_finalized()" +# 309 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" 3 4 + , __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)) +# 309 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" + ; + return position_; + } + + + void Reset() { position_ = 0; } + + + + + void AddCharacter(char c) { + +# 320 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" 3 4 + (static_cast ( +# 320 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" + c != '\0' +# 320 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" 3 4 + ) ? void (0) : __assert_fail ( +# 320 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" + "c != '\\0'" +# 320 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" 3 4 + , __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)) +# 320 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" + ; + +# 321 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" 3 4 + (static_cast ( +# 321 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" + !is_finalized() && position_ < buffer_.length() +# 321 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" 3 4 + ) ? void (0) : __assert_fail ( +# 321 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" + "!is_finalized() && position_ < buffer_.length()" +# 321 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" 3 4 + , __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)) +# 321 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" + ; + buffer_[position_++] = c; + } + + + + void AddString(const char* s) { + AddSubstring(s, StrLength(s)); + } + + + + void AddSubstring(const char* s, int n) { + +# 334 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" 3 4 + (static_cast ( +# 334 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" + !is_finalized() && position_ + n < buffer_.length() +# 334 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" 3 4 + ) ? void (0) : __assert_fail ( +# 334 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" + "!is_finalized() && position_ + n < buffer_.length()" +# 334 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" 3 4 + , __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)) +# 334 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" + ; + +# 335 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" 3 4 + (static_cast ( +# 335 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" + static_cast(n) <= strlen(s) +# 335 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" 3 4 + ) ? void (0) : __assert_fail ( +# 335 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" + "static_cast(n) <= strlen(s)" +# 335 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" 3 4 + , __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)) +# 335 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" + ; + memmove(&buffer_[position_], s, static_cast(n)); + position_ += n; + } + + + + + void AddPadding(char c, int count) { + for (int i = 0; i < count; i++) { + AddCharacter(c); + } + } + + + char* Finalize() { + +# 351 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" 3 4 + (static_cast ( +# 351 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" + !is_finalized() && position_ < buffer_.length() +# 351 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" 3 4 + ) ? void (0) : __assert_fail ( +# 351 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" + "!is_finalized() && position_ < buffer_.length()" +# 351 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" 3 4 + , __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)) +# 351 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" + ; + buffer_[position_] = '\0'; + + + +# 355 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" 3 4 + (static_cast ( +# 355 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" + strlen(buffer_.start()) == static_cast(position_) +# 355 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" 3 4 + ) ? void (0) : __assert_fail ( +# 355 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" + "strlen(buffer_.start()) == static_cast(position_)" +# 355 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" 3 4 + , __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)) +# 355 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" + ; + position_ = -1; + +# 357 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" 3 4 + (static_cast ( +# 357 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" + is_finalized() +# 357 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" 3 4 + ) ? void (0) : __assert_fail ( +# 357 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" + "is_finalized()" +# 357 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" 3 4 + , __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)) +# 357 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" + ; + return buffer_.start(); + } + + private: + Vector buffer_; + int position_; + + bool is_finalized() const { return position_ < 0; } + + StringBuilder(); StringBuilder(const StringBuilder&); void operator=(const StringBuilder&); +}; +# 394 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/utils.h" +template +Dest BitCast(const Source& source) { + + + + static_assert(sizeof(Dest) == sizeof(Source), + "source and destination size mismatch"); + + + + + + Dest dest; + memmove(&dest, &source, sizeof(dest)); + return dest; +} + +template +Dest BitCast(Source* source) { + return BitCast(reinterpret_cast(source)); +} + +} +# 32 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.h" 2 + +namespace double_conversion { + +class Bignum { + public: + + + + static const int kMaxSignificantBits = 3584; + + Bignum() : used_bigits_(0), exponent_(0) {} + + void AssignUInt16(const uint16_t value); + void AssignUInt64(uint64_t value); + void AssignBignum(const Bignum& other); + + void AssignDecimalString(const Vector value); + void AssignHexString(const Vector value); + + void AssignPowerUInt16(uint16_t base, const int exponent); + + void AddUInt64(const uint64_t operand); + void AddBignum(const Bignum& other); + + void SubtractBignum(const Bignum& other); + + void Square(); + void ShiftLeft(const int shift_amount); + void MultiplyByUInt32(const uint32_t factor); + void MultiplyByUInt64(const uint64_t factor); + void MultiplyByPowerOfTen(const int exponent); + void Times10() { return MultiplyByUInt32(10); } + + + + + uint16_t DivideModuloIntBignum(const Bignum& other); + + bool ToHexString(char* buffer, const int buffer_size) const; + + + + + + static int Compare(const Bignum& a, const Bignum& b); + static bool Equal(const Bignum& a, const Bignum& b) { + return Compare(a, b) == 0; + } + static bool LessEqual(const Bignum& a, const Bignum& b) { + return Compare(a, b) <= 0; + } + static bool Less(const Bignum& a, const Bignum& b) { + return Compare(a, b) < 0; + } + + static int PlusCompare(const Bignum& a, const Bignum& b, const Bignum& c); + + static bool PlusEqual(const Bignum& a, const Bignum& b, const Bignum& c) { + return PlusCompare(a, b, c) == 0; + } + + static bool PlusLessEqual(const Bignum& a, const Bignum& b, const Bignum& c) { + return PlusCompare(a, b, c) <= 0; + } + + static bool PlusLess(const Bignum& a, const Bignum& b, const Bignum& c) { + return PlusCompare(a, b, c) < 0; + } + private: + typedef uint32_t Chunk; + typedef uint64_t DoubleChunk; + + static const int kChunkSize = sizeof(Chunk) * 8; + static const int kDoubleChunkSize = sizeof(DoubleChunk) * 8; + + + static const int kBigitSize = 28; + static const Chunk kBigitMask = (1 << kBigitSize) - 1; + + + static const int kBigitCapacity = kMaxSignificantBits / kBigitSize; + + static void EnsureCapacity(const int size) { + if (size > kBigitCapacity) { + (abort()); + } + } + void Align(const Bignum& other); + void Clamp(); + bool IsClamped() const { + return used_bigits_ == 0 || RawBigit(used_bigits_ - 1) != 0; + } + void Zero() { + used_bigits_ = 0; + exponent_ = 0; + } + + + + void BigitsShiftLeft(const int shift_amount); + + int BigitLength() const { return used_bigits_ + exponent_; } + Chunk& RawBigit(const int index); + const Chunk& RawBigit(const int index) const; + Chunk BigitOrZero(const int index) const; + void SubtractTimes(const Bignum& other, const int factor); + + + + + + int16_t used_bigits_; + int16_t exponent_; + Chunk bigits_buffer_[kBigitCapacity]; + + Bignum(const Bignum&); void operator=(const Bignum&); +}; + +} +# 32 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 2 + + +namespace double_conversion { + +Bignum::Chunk& Bignum::RawBigit(const int index) { + +# 37 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + (static_cast ( +# 37 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + static_cast(index) < kBigitCapacity +# 37 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + ) ? void (0) : __assert_fail ( +# 37 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + "static_cast(index) < kBigitCapacity" +# 37 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + , __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)) +# 37 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + ; + return bigits_buffer_[index]; +} + + +const Bignum::Chunk& Bignum::RawBigit(const int index) const { + +# 43 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + (static_cast ( +# 43 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + static_cast(index) < kBigitCapacity +# 43 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + ) ? void (0) : __assert_fail ( +# 43 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + "static_cast(index) < kBigitCapacity" +# 43 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + , __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)) +# 43 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + ; + return bigits_buffer_[index]; +} + + +template +static int BitSize(const S value) { + (void) value; + return 8 * sizeof(value); +} + + +void Bignum::AssignUInt16(const uint16_t value) { + +# 56 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + (static_cast ( +# 56 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + kBigitSize >= BitSize(value) +# 56 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + ) ? void (0) : __assert_fail ( +# 56 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + "kBigitSize >= BitSize(value)" +# 56 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + , __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)) +# 56 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + ; + Zero(); + if (value > 0) { + RawBigit(0) = value; + used_bigits_ = 1; + } +} + + +void Bignum::AssignUInt64(uint64_t value) { + Zero(); + for(int i = 0; value > 0; ++i) { + RawBigit(i) = value & kBigitMask; + value >>= kBigitSize; + ++used_bigits_; + } +} + + +void Bignum::AssignBignum(const Bignum& other) { + exponent_ = other.exponent_; + for (int i = 0; i < other.used_bigits_; ++i) { + RawBigit(i) = other.RawBigit(i); + } + used_bigits_ = other.used_bigits_; +} + + +static uint64_t ReadUInt64(const Vector buffer, + const int from, + const int digits_to_read) { + uint64_t result = 0; + for (int i = from; i < from + digits_to_read; ++i) { + const int digit = buffer[i] - '0'; + +# 90 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + (static_cast ( +# 90 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + 0 <= digit && digit <= 9 +# 90 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + ) ? void (0) : __assert_fail ( +# 90 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + "0 <= digit && digit <= 9" +# 90 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + , __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)) +# 90 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + ; + result = result * 10 + digit; + } + return result; +} + + +void Bignum::AssignDecimalString(const Vector value) { + + static const int kMaxUint64DecimalDigits = 19; + Zero(); + int length = value.length(); + unsigned pos = 0; + + while (length >= kMaxUint64DecimalDigits) { + const uint64_t digits = ReadUInt64(value, pos, kMaxUint64DecimalDigits); + pos += kMaxUint64DecimalDigits; + length -= kMaxUint64DecimalDigits; + MultiplyByPowerOfTen(kMaxUint64DecimalDigits); + AddUInt64(digits); + } + const uint64_t digits = ReadUInt64(value, pos, length); + MultiplyByPowerOfTen(length); + AddUInt64(digits); + Clamp(); +} + + +static uint64_t HexCharValue(const int c) { + if ('0' <= c && c <= '9') { + return c - '0'; + } + if ('a' <= c && c <= 'f') { + return 10 + c - 'a'; + } + +# 125 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + (static_cast ( +# 125 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + 'A' <= c && c <= 'F' +# 125 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + ) ? void (0) : __assert_fail ( +# 125 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + "'A' <= c && c <= 'F'" +# 125 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + , __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)) +# 125 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + ; + return 10 + c - 'A'; +} + + + + +void Bignum::AssignHexString(Vector value) { + Zero(); + + EnsureCapacity(((value.length() * 4) + kBigitSize - 1) / kBigitSize); + +# 136 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + (static_cast ( +# 136 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + sizeof(uint64_t) * 8 >= kBigitSize + 4 +# 136 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + ) ? void (0) : __assert_fail ( +# 136 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + "sizeof(uint64_t) * 8 >= kBigitSize + 4" +# 136 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + , __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)) +# 136 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + ; + + + uint64_t tmp = 0; + for (int cnt = 0; !value.is_empty(); value.pop_back()) { + tmp |= (HexCharValue(value.last()) << cnt); + if ((cnt += 4) >= kBigitSize) { + RawBigit(used_bigits_++) = (tmp & kBigitMask); + cnt -= kBigitSize; + tmp >>= kBigitSize; + } + } + if (tmp > 0) { + +# 149 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + (static_cast ( +# 149 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + tmp <= kBigitMask +# 149 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + ) ? void (0) : __assert_fail ( +# 149 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + "tmp <= kBigitMask" +# 149 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + , __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)) +# 149 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + ; + RawBigit(used_bigits_++) = static_cast(tmp & kBigitMask); + } + Clamp(); +} + + +void Bignum::AddUInt64(const uint64_t operand) { + if (operand == 0) { + return; + } + Bignum other; + other.AssignUInt64(operand); + AddBignum(other); +} + + +void Bignum::AddBignum(const Bignum& other) { + +# 167 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + (static_cast ( +# 167 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + IsClamped() +# 167 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + ) ? void (0) : __assert_fail ( +# 167 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + "IsClamped()" +# 167 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + , __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)) +# 167 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + ; + +# 168 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + (static_cast ( +# 168 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + other.IsClamped() +# 168 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + ) ? void (0) : __assert_fail ( +# 168 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + "other.IsClamped()" +# 168 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + , __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)) +# 168 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + ; + + + + Align(other); +# 186 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + EnsureCapacity(1 + (std::max)(BigitLength(), other.BigitLength()) - exponent_); + Chunk carry = 0; + int bigit_pos = other.exponent_ - exponent_; + +# 189 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + (static_cast ( +# 189 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + bigit_pos >= 0 +# 189 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + ) ? void (0) : __assert_fail ( +# 189 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + "bigit_pos >= 0" +# 189 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + , __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)) +# 189 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + ; + for (int i = used_bigits_; i < bigit_pos; ++i) { + RawBigit(i) = 0; + } + for (int i = 0; i < other.used_bigits_; ++i) { + const Chunk my = (bigit_pos < used_bigits_) ? RawBigit(bigit_pos) : 0; + const Chunk sum = my + other.RawBigit(i) + carry; + RawBigit(bigit_pos) = sum & kBigitMask; + carry = sum >> kBigitSize; + ++bigit_pos; + } + while (carry != 0) { + const Chunk my = (bigit_pos < used_bigits_) ? RawBigit(bigit_pos) : 0; + const Chunk sum = my + carry; + RawBigit(bigit_pos) = sum & kBigitMask; + carry = sum >> kBigitSize; + ++bigit_pos; + } + used_bigits_ = static_cast(std::max(bigit_pos, static_cast(used_bigits_))); + +# 208 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + (static_cast ( +# 208 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + IsClamped() +# 208 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + ) ? void (0) : __assert_fail ( +# 208 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + "IsClamped()" +# 208 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + , __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)) +# 208 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + ; +} + + +void Bignum::SubtractBignum(const Bignum& other) { + +# 213 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + (static_cast ( +# 213 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + IsClamped() +# 213 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + ) ? void (0) : __assert_fail ( +# 213 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + "IsClamped()" +# 213 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + , __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)) +# 213 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + ; + +# 214 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + (static_cast ( +# 214 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + other.IsClamped() +# 214 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + ) ? void (0) : __assert_fail ( +# 214 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + "other.IsClamped()" +# 214 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + , __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)) +# 214 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + ; + + +# 216 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + (static_cast ( +# 216 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + LessEqual(other, *this) +# 216 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + ) ? void (0) : __assert_fail ( +# 216 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + "LessEqual(other, *this)" +# 216 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + , __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)) +# 216 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + ; + + Align(other); + + const int offset = other.exponent_ - exponent_; + Chunk borrow = 0; + int i; + for (i = 0; i < other.used_bigits_; ++i) { + +# 224 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + (static_cast ( +# 224 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + (borrow == 0) || (borrow == 1) +# 224 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + ) ? void (0) : __assert_fail ( +# 224 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + "(borrow == 0) || (borrow == 1)" +# 224 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + , __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)) +# 224 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + ; + const Chunk difference = RawBigit(i + offset) - other.RawBigit(i) - borrow; + RawBigit(i + offset) = difference & kBigitMask; + borrow = difference >> (kChunkSize - 1); + } + while (borrow != 0) { + const Chunk difference = RawBigit(i + offset) - borrow; + RawBigit(i + offset) = difference & kBigitMask; + borrow = difference >> (kChunkSize - 1); + ++i; + } + Clamp(); +} + + +void Bignum::ShiftLeft(const int shift_amount) { + if (used_bigits_ == 0) { + return; + } + exponent_ += static_cast(shift_amount / kBigitSize); + const int local_shift = shift_amount % kBigitSize; + EnsureCapacity(used_bigits_ + 1); + BigitsShiftLeft(local_shift); +} + + +void Bignum::MultiplyByUInt32(const uint32_t factor) { + if (factor == 1) { + return; + } + if (factor == 0) { + Zero(); + return; + } + if (used_bigits_ == 0) { + return; + } + + + +# 263 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + (static_cast ( +# 263 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + kDoubleChunkSize >= kBigitSize + 32 + 1 +# 263 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + ) ? void (0) : __assert_fail ( +# 263 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + "kDoubleChunkSize >= kBigitSize + 32 + 1" +# 263 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + , __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)) +# 263 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + ; + DoubleChunk carry = 0; + for (int i = 0; i < used_bigits_; ++i) { + const DoubleChunk product = static_cast(factor) * RawBigit(i) + carry; + RawBigit(i) = static_cast(product & kBigitMask); + carry = (product >> kBigitSize); + } + while (carry != 0) { + EnsureCapacity(used_bigits_ + 1); + RawBigit(used_bigits_) = carry & kBigitMask; + used_bigits_++; + carry >>= kBigitSize; + } +} + + +void Bignum::MultiplyByUInt64(const uint64_t factor) { + if (factor == 1) { + return; + } + if (factor == 0) { + Zero(); + return; + } + if (used_bigits_ == 0) { + return; + } + +# 290 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + (static_cast ( +# 290 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + kBigitSize < 32 +# 290 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + ) ? void (0) : __assert_fail ( +# 290 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + "kBigitSize < 32" +# 290 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + , __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)) +# 290 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + ; + uint64_t carry = 0; + const uint64_t low = factor & 0xFFFFFFFF; + const uint64_t high = factor >> 32; + for (int i = 0; i < used_bigits_; ++i) { + const uint64_t product_low = low * RawBigit(i); + const uint64_t product_high = high * RawBigit(i); + const uint64_t tmp = (carry & kBigitMask) + product_low; + RawBigit(i) = tmp & kBigitMask; + carry = (carry >> kBigitSize) + (tmp >> kBigitSize) + + (product_high << (32 - kBigitSize)); + } + while (carry != 0) { + EnsureCapacity(used_bigits_ + 1); + RawBigit(used_bigits_) = carry & kBigitMask; + used_bigits_++; + carry >>= kBigitSize; + } +} + + +void Bignum::MultiplyByPowerOfTen(const int exponent) { + static const uint64_t kFive27 = (((static_cast(0x6765c793) << 32) + 0xfa10079du)); + static const uint16_t kFive1 = 5; + static const uint16_t kFive2 = kFive1 * 5; + static const uint16_t kFive3 = kFive2 * 5; + static const uint16_t kFive4 = kFive3 * 5; + static const uint16_t kFive5 = kFive4 * 5; + static const uint16_t kFive6 = kFive5 * 5; + static const uint32_t kFive7 = kFive6 * 5; + static const uint32_t kFive8 = kFive7 * 5; + static const uint32_t kFive9 = kFive8 * 5; + static const uint32_t kFive10 = kFive9 * 5; + static const uint32_t kFive11 = kFive10 * 5; + static const uint32_t kFive12 = kFive11 * 5; + static const uint32_t kFive13 = kFive12 * 5; + static const uint32_t kFive1_to_12[] = + { kFive1, kFive2, kFive3, kFive4, kFive5, kFive6, + kFive7, kFive8, kFive9, kFive10, kFive11, kFive12 }; + + +# 330 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + (static_cast ( +# 330 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + exponent >= 0 +# 330 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + ) ? void (0) : __assert_fail ( +# 330 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + "exponent >= 0" +# 330 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + , __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)) +# 330 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + ; + + if (exponent == 0) { + return; + } + if (used_bigits_ == 0) { + return; + } + + int remaining_exponent = exponent; + while (remaining_exponent >= 27) { + MultiplyByUInt64(kFive27); + remaining_exponent -= 27; + } + while (remaining_exponent >= 13) { + MultiplyByUInt32(kFive13); + remaining_exponent -= 13; + } + if (remaining_exponent > 0) { + MultiplyByUInt32(kFive1_to_12[remaining_exponent - 1]); + } + ShiftLeft(exponent); +} + + +void Bignum::Square() { + +# 356 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + (static_cast ( +# 356 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + IsClamped() +# 356 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + ) ? void (0) : __assert_fail ( +# 356 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + "IsClamped()" +# 356 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + , __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)) +# 356 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + ; + const int product_length = 2 * used_bigits_; + EnsureCapacity(product_length); +# 372 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + if ((1 << (2 * (kChunkSize - kBigitSize))) <= used_bigits_) { + (abort()); + } + DoubleChunk accumulator = 0; + + const int copy_offset = used_bigits_; + for (int i = 0; i < used_bigits_; ++i) { + RawBigit(copy_offset + i) = RawBigit(i); + } + + for (int i = 0; i < used_bigits_; ++i) { + + + int bigit_index1 = i; + int bigit_index2 = 0; + + while (bigit_index1 >= 0) { + const Chunk chunk1 = RawBigit(copy_offset + bigit_index1); + const Chunk chunk2 = RawBigit(copy_offset + bigit_index2); + accumulator += static_cast(chunk1) * chunk2; + bigit_index1--; + bigit_index2++; + } + RawBigit(i) = static_cast(accumulator) & kBigitMask; + accumulator >>= kBigitSize; + } + for (int i = used_bigits_; i < product_length; ++i) { + int bigit_index1 = used_bigits_ - 1; + int bigit_index2 = i - bigit_index1; + + + while (bigit_index2 < used_bigits_) { + const Chunk chunk1 = RawBigit(copy_offset + bigit_index1); + const Chunk chunk2 = RawBigit(copy_offset + bigit_index2); + accumulator += static_cast(chunk1) * chunk2; + bigit_index1--; + bigit_index2++; + } + + + + RawBigit(i) = static_cast(accumulator) & kBigitMask; + accumulator >>= kBigitSize; + } + + + +# 418 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + (static_cast ( +# 418 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + accumulator == 0 +# 418 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + ) ? void (0) : __assert_fail ( +# 418 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + "accumulator == 0" +# 418 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + , __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)) +# 418 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + ; + + + used_bigits_ = static_cast(product_length); + exponent_ *= 2; + Clamp(); +} + + +void Bignum::AssignPowerUInt16(uint16_t base, const int power_exponent) { + +# 428 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + (static_cast ( +# 428 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + base != 0 +# 428 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + ) ? void (0) : __assert_fail ( +# 428 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + "base != 0" +# 428 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + , __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)) +# 428 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + ; + +# 429 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + (static_cast ( +# 429 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + power_exponent >= 0 +# 429 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + ) ? void (0) : __assert_fail ( +# 429 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + "power_exponent >= 0" +# 429 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + , __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)) +# 429 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + ; + if (power_exponent == 0) { + AssignUInt16(1); + return; + } + Zero(); + int shifts = 0; + + + + while ((base & 1) == 0) { + base >>= 1; + shifts++; + } + int bit_size = 0; + int tmp_base = base; + while (tmp_base != 0) { + tmp_base >>= 1; + bit_size++; + } + const int final_size = bit_size * power_exponent; + + EnsureCapacity(final_size / kBigitSize + 2); + + + int mask = 1; + while (power_exponent >= mask) mask <<= 1; + + + + + mask >>= 2; + uint64_t this_value = base; + + bool delayed_multiplication = false; + const uint64_t max_32bits = 0xFFFFFFFF; + while (mask != 0 && this_value <= max_32bits) { + this_value = this_value * this_value; + + + if ((power_exponent & mask) != 0) { + +# 470 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + (static_cast ( +# 470 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + bit_size > 0 +# 470 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + ) ? void (0) : __assert_fail ( +# 470 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + "bit_size > 0" +# 470 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + , __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)) +# 470 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + ; + const uint64_t base_bits_mask = + ~((static_cast(1) << (64 - bit_size)) - 1); + const bool high_bits_zero = (this_value & base_bits_mask) == 0; + if (high_bits_zero) { + this_value *= base; + } else { + delayed_multiplication = true; + } + } + mask >>= 1; + } + AssignUInt64(this_value); + if (delayed_multiplication) { + MultiplyByUInt32(base); + } + + + while (mask != 0) { + Square(); + if ((power_exponent & mask) != 0) { + MultiplyByUInt32(base); + } + mask >>= 1; + } + + + ShiftLeft(shifts * power_exponent); +} + + + +uint16_t Bignum::DivideModuloIntBignum(const Bignum& other) { + +# 503 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + (static_cast ( +# 503 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + IsClamped() +# 503 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + ) ? void (0) : __assert_fail ( +# 503 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + "IsClamped()" +# 503 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + , __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)) +# 503 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + ; + +# 504 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + (static_cast ( +# 504 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + other.IsClamped() +# 504 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + ) ? void (0) : __assert_fail ( +# 504 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + "other.IsClamped()" +# 504 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + , __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)) +# 504 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + ; + +# 505 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + (static_cast ( +# 505 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + other.used_bigits_ > 0 +# 505 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + ) ? void (0) : __assert_fail ( +# 505 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + "other.used_bigits_ > 0" +# 505 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + , __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)) +# 505 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + ; + + + + if (BigitLength() < other.BigitLength()) { + return 0; + } + + Align(other); + + uint16_t result = 0; + + + + while (BigitLength() > other.BigitLength()) { + + + + +# 523 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + (static_cast ( +# 523 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + other.RawBigit(other.used_bigits_ - 1) >= ((1 << kBigitSize) / 16) +# 523 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + ) ? void (0) : __assert_fail ( +# 523 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + "other.RawBigit(other.used_bigits_ - 1) >= ((1 << kBigitSize) / 16)" +# 523 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + , __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)) +# 523 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + ; + +# 524 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + (static_cast ( +# 524 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + RawBigit(used_bigits_ - 1) < 0x10000 +# 524 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + ) ? void (0) : __assert_fail ( +# 524 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + "RawBigit(used_bigits_ - 1) < 0x10000" +# 524 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + , __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)) +# 524 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + ; + + + result += static_cast(RawBigit(used_bigits_ - 1)); + SubtractTimes(other, RawBigit(used_bigits_ - 1)); + } + + +# 531 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + (static_cast ( +# 531 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + BigitLength() == other.BigitLength() +# 531 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + ) ? void (0) : __assert_fail ( +# 531 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + "BigitLength() == other.BigitLength()" +# 531 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + , __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)) +# 531 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + ; + + + + + const Chunk this_bigit = RawBigit(used_bigits_ - 1); + const Chunk other_bigit = other.RawBigit(other.used_bigits_ - 1); + + if (other.used_bigits_ == 1) { + + int quotient = this_bigit / other_bigit; + RawBigit(used_bigits_ - 1) = this_bigit - other_bigit * quotient; + +# 543 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + (static_cast ( +# 543 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + quotient < 0x10000 +# 543 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + ) ? void (0) : __assert_fail ( +# 543 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + "quotient < 0x10000" +# 543 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + , __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)) +# 543 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + ; + result += static_cast(quotient); + Clamp(); + return result; + } + + const int division_estimate = this_bigit / (other_bigit + 1); + +# 550 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + (static_cast ( +# 550 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + division_estimate < 0x10000 +# 550 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + ) ? void (0) : __assert_fail ( +# 550 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + "division_estimate < 0x10000" +# 550 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + , __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)) +# 550 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + ; + result += static_cast(division_estimate); + SubtractTimes(other, division_estimate); + + if (other_bigit * (division_estimate + 1) > this_bigit) { + + + return result; + } + + while (LessEqual(other, *this)) { + SubtractBignum(other); + result++; + } + return result; +} + + +template +static int SizeInHexChars(S number) { + +# 570 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + (static_cast ( +# 570 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + number > 0 +# 570 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + ) ? void (0) : __assert_fail ( +# 570 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + "number > 0" +# 570 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + , __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)) +# 570 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + ; + int result = 0; + while (number != 0) { + number >>= 4; + result++; + } + return result; +} + + +static char HexCharOfValue(const int value) { + +# 581 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + (static_cast ( +# 581 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + 0 <= value && value <= 16 +# 581 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + ) ? void (0) : __assert_fail ( +# 581 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + "0 <= value && value <= 16" +# 581 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + , __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)) +# 581 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + ; + if (value < 10) { + return static_cast(value + '0'); + } + return static_cast(value - 10 + 'A'); +} + + +bool Bignum::ToHexString(char* buffer, const int buffer_size) const { + +# 590 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + (static_cast ( +# 590 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + IsClamped() +# 590 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + ) ? void (0) : __assert_fail ( +# 590 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + "IsClamped()" +# 590 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + , __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)) +# 590 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + ; + + +# 592 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + (static_cast ( +# 592 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + kBigitSize % 4 == 0 +# 592 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + ) ? void (0) : __assert_fail ( +# 592 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + "kBigitSize % 4 == 0" +# 592 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + , __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)) +# 592 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + ; + static const int kHexCharsPerBigit = kBigitSize / 4; + + if (used_bigits_ == 0) { + if (buffer_size < 2) { + return false; + } + buffer[0] = '0'; + buffer[1] = '\0'; + return true; + } + + const int needed_chars = (BigitLength() - 1) * kHexCharsPerBigit + + SizeInHexChars(RawBigit(used_bigits_ - 1)) + 1; + if (needed_chars > buffer_size) { + return false; + } + int string_index = needed_chars - 1; + buffer[string_index--] = '\0'; + for (int i = 0; i < exponent_; ++i) { + for (int j = 0; j < kHexCharsPerBigit; ++j) { + buffer[string_index--] = '0'; + } + } + for (int i = 0; i < used_bigits_ - 1; ++i) { + Chunk current_bigit = RawBigit(i); + for (int j = 0; j < kHexCharsPerBigit; ++j) { + buffer[string_index--] = HexCharOfValue(current_bigit & 0xF); + current_bigit >>= 4; + } + } + + Chunk most_significant_bigit = RawBigit(used_bigits_ - 1); + while (most_significant_bigit != 0) { + buffer[string_index--] = HexCharOfValue(most_significant_bigit & 0xF); + most_significant_bigit >>= 4; + } + return true; +} + + +Bignum::Chunk Bignum::BigitOrZero(const int index) const { + if (index >= BigitLength()) { + return 0; + } + if (index < exponent_) { + return 0; + } + return RawBigit(index - exponent_); +} + + +int Bignum::Compare(const Bignum& a, const Bignum& b) { + +# 645 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + (static_cast ( +# 645 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + a.IsClamped() +# 645 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + ) ? void (0) : __assert_fail ( +# 645 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + "a.IsClamped()" +# 645 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + , __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)) +# 645 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + ; + +# 646 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + (static_cast ( +# 646 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + b.IsClamped() +# 646 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + ) ? void (0) : __assert_fail ( +# 646 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + "b.IsClamped()" +# 646 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + , __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)) +# 646 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + ; + const int bigit_length_a = a.BigitLength(); + const int bigit_length_b = b.BigitLength(); + if (bigit_length_a < bigit_length_b) { + return -1; + } + if (bigit_length_a > bigit_length_b) { + return +1; + } + for (int i = bigit_length_a - 1; i >= (std::min)(a.exponent_, b.exponent_); --i) { + const Chunk bigit_a = a.BigitOrZero(i); + const Chunk bigit_b = b.BigitOrZero(i); + if (bigit_a < bigit_b) { + return -1; + } + if (bigit_a > bigit_b) { + return +1; + } + + } + return 0; +} + + +int Bignum::PlusCompare(const Bignum& a, const Bignum& b, const Bignum& c) { + +# 671 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + (static_cast ( +# 671 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + a.IsClamped() +# 671 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + ) ? void (0) : __assert_fail ( +# 671 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + "a.IsClamped()" +# 671 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + , __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)) +# 671 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + ; + +# 672 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + (static_cast ( +# 672 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + b.IsClamped() +# 672 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + ) ? void (0) : __assert_fail ( +# 672 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + "b.IsClamped()" +# 672 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + , __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)) +# 672 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + ; + +# 673 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + (static_cast ( +# 673 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + c.IsClamped() +# 673 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + ) ? void (0) : __assert_fail ( +# 673 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + "c.IsClamped()" +# 673 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + , __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)) +# 673 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + ; + if (a.BigitLength() < b.BigitLength()) { + return PlusCompare(b, a, c); + } + if (a.BigitLength() + 1 < c.BigitLength()) { + return -1; + } + if (a.BigitLength() > c.BigitLength()) { + return +1; + } + + + + if (a.exponent_ >= b.BigitLength() && a.BigitLength() < c.BigitLength()) { + return -1; + } + + Chunk borrow = 0; + + const int min_exponent = (std::min)((std::min)(a.exponent_, b.exponent_), c.exponent_); + for (int i = c.BigitLength() - 1; i >= min_exponent; --i) { + const Chunk chunk_a = a.BigitOrZero(i); + const Chunk chunk_b = b.BigitOrZero(i); + const Chunk chunk_c = c.BigitOrZero(i); + const Chunk sum = chunk_a + chunk_b; + if (sum > chunk_c + borrow) { + return +1; + } else { + borrow = chunk_c + borrow - sum; + if (borrow > 1) { + return -1; + } + borrow <<= kBigitSize; + } + } + if (borrow == 0) { + return 0; + } + return -1; +} + + +void Bignum::Clamp() { + while (used_bigits_ > 0 && RawBigit(used_bigits_ - 1) == 0) { + used_bigits_--; + } + if (used_bigits_ == 0) { + + exponent_ = 0; + } +} + + +void Bignum::Align(const Bignum& other) { + if (exponent_ > other.exponent_) { + + + + + + + const int zero_bigits = exponent_ - other.exponent_; + EnsureCapacity(used_bigits_ + zero_bigits); + for (int i = used_bigits_ - 1; i >= 0; --i) { + RawBigit(i + zero_bigits) = RawBigit(i); + } + for (int i = 0; i < zero_bigits; ++i) { + RawBigit(i) = 0; + } + used_bigits_ += static_cast(zero_bigits); + exponent_ -= static_cast(zero_bigits); + + +# 745 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + (static_cast ( +# 745 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + used_bigits_ >= 0 +# 745 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + ) ? void (0) : __assert_fail ( +# 745 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + "used_bigits_ >= 0" +# 745 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + , __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)) +# 745 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + ; + +# 746 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + (static_cast ( +# 746 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + exponent_ >= 0 +# 746 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + ) ? void (0) : __assert_fail ( +# 746 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + "exponent_ >= 0" +# 746 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + , __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)) +# 746 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + ; + } +} + + +void Bignum::BigitsShiftLeft(const int shift_amount) { + +# 752 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + (static_cast ( +# 752 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + shift_amount < kBigitSize +# 752 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + ) ? void (0) : __assert_fail ( +# 752 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + "shift_amount < kBigitSize" +# 752 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + , __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)) +# 752 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + ; + +# 753 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + (static_cast ( +# 753 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + shift_amount >= 0 +# 753 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + ) ? void (0) : __assert_fail ( +# 753 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + "shift_amount >= 0" +# 753 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + , __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)) +# 753 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + ; + Chunk carry = 0; + for (int i = 0; i < used_bigits_; ++i) { + const Chunk new_carry = RawBigit(i) >> (kBigitSize - shift_amount); + RawBigit(i) = ((RawBigit(i) << shift_amount) + carry) & kBigitMask; + carry = new_carry; + } + if (carry != 0) { + RawBigit(used_bigits_) = carry; + used_bigits_++; + } +} + + +void Bignum::SubtractTimes(const Bignum& other, const int factor) { + +# 768 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + (static_cast ( +# 768 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + exponent_ <= other.exponent_ +# 768 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + ) ? void (0) : __assert_fail ( +# 768 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + "exponent_ <= other.exponent_" +# 768 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" 3 4 + , __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)) +# 768 "/tmp/tmpl_i20ey9/double-conversion/double-conversion/bignum.cc" + ; + if (factor < 3) { + for (int i = 0; i < factor; ++i) { + SubtractBignum(other); + } + return; + } + Chunk borrow = 0; + const int exponent_diff = other.exponent_ - exponent_; + for (int i = 0; i < other.used_bigits_; ++i) { + const DoubleChunk product = static_cast(factor) * other.RawBigit(i); + const DoubleChunk remove = borrow + product; + const Chunk difference = RawBigit(i + exponent_diff) - (remove & kBigitMask); + RawBigit(i + exponent_diff) = difference & kBigitMask; + borrow = static_cast((difference >> (kChunkSize - 1)) + + (remove >> kBigitSize)); + } + for (int i = other.used_bigits_ + exponent_diff; i < used_bigits_; ++i) { + if (borrow == 0) { + return; + } + const Chunk difference = RawBigit(i) - borrow; + RawBigit(i) = difference & kBigitMask; + borrow = difference >> (kChunkSize - 1); + } + Clamp(); +} + + +}