0% found this document useful (0 votes)

4 views

Main CPP

Uploaded by

anhnt.22it

Available Formats

Download as TXT, PDF, TXT or read online on Scribd

0% found this document useful (0 votes)

4 views

Main CPP

Uploaded by

anhnt.22it

Available Formats

Download as TXT, PDF, TXT or read online on Scribd

You are on page 1/ 1133

# 0 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/main.

cpp"
# 0 "<built-in>"
# 0 "<command-line>"
# 1 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/main.cpp"
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/print" 1 3
# 32 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/print" 3

# 33 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/print" 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/requires_hosted.h" 1 3
# 31 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/requires_hosted.h" 3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/x86_64-w64-mingw32/bits/c+
+config.h" 1 3
# 33 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/x86_64-w64-mingw32/bits/c+
+config.h" 3

# 34 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/x86_64-w64-mingw32/bits/c+
+config.h" 3
# 308 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/x86_64-w64-mingw32/bits/c+
+config.h" 3

# 308 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/x86_64-w64-mingw32/bits/c+
+config.h" 3
namespace std
{
typedef long long unsigned int size_t;
typedef long 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__,__cold__));
terminate();
}
#pragma GCC visibility pop
}
# 341 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/x86_64-w64-mingw32/bits/c+
+config.h" 3
namespace std
{
inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { }
}
namespace __gnu_cxx
{
inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { }
}
# 534 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/x86_64-w64-mingw32/bits/c+
+config.h" 3
namespace std
{
#pragma GCC visibility push(default)
__attribute__((__always_inline__))
constexpr inline bool
__is_constant_evaluated() noexcept
{

if consteval { return true; } else { return false; }

}
#pragma GCC visibility pop
}
# 573 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/x86_64-w64-mingw32/bits/c+
+config.h" 3
namespace std
{
#pragma GCC visibility push(default)

extern "C++" attribute ((noreturn))

void
__glibcxx_assert_fail
(const char* __file, int __line, const char* __function,
const char* __condition)
noexcept;
#pragma GCC visibility pop
}
# 601 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/x86_64-w64-mingw32/bits/c+
+config.h" 3
namespace std
{
__attribute__((__always_inline__,__visibility__("default")))
inline void
__glibcxx_assert_fail()
{ }
}
# 680 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/x86_64-w64-mingw32/bits/c+
+config.h" 3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/x86_64-w64-mingw32/bits/
os_defines.h" 1 3
# 681 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/x86_64-w64-mingw32/bits/c+
+config.h" 2 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/x86_64-w64-mingw32/bits/
cpu_defines.h" 1 3
# 684 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/x86_64-w64-mingw32/bits/c+
+config.h" 2 3
# 825 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/x86_64-w64-mingw32/bits/c+
+config.h" 3
namespace __gnu_cxx
{
typedef __decltype(0.0bf16) __bfloat16_t;
}
# 887 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/x86_64-w64-mingw32/bits/c+
+config.h" 3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/pstl/pstl_config.h" 1 3
# 888 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/x86_64-w64-mingw32/bits/c+
+config.h" 2 3
# 32 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/requires_hosted.h" 2 3
# 35 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/print" 2 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 1 3
# 47 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 3

# 48 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 3
# 38 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/print" 2 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/format" 1 3
# 32 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/format" 3

# 33 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/format" 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 1 3
# 47 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 3

# 48 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 3
# 40 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/format" 2 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/array" 1 3
# 32 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/array" 3

# 33 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/array" 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/compare" 1 3
# 33 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/compare" 3

# 34 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/compare" 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 1 3
# 47 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 3

# 48 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 3
# 37 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/compare" 2 3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/concepts" 1 3
# 33 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/concepts" 3

# 34 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/concepts" 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 1 3
# 47 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 3

# 48 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 3
# 37 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/concepts" 2 3
# 46 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/concepts" 3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/type_traits" 1 3
# 32 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/type_traits" 3

# 33 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/type_traits" 3
# 63 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/type_traits" 3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 1 3
# 47 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 3

# 48 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 3
# 64 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/type_traits" 2 3

namespace std
{

template<typename _Tp>
class reference_wrapper;
# 86 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/type_traits" 3
template<typename _Tp, _Tp __v>
struct integral_constant
{
static constexpr _Tp value = __v;
using value_type = _Tp;
using type = integral_constant<_Tp, __v>;
constexpr operator value_type() const noexcept { return value; }

constexpr value_type operator()() const noexcept { return value; }

};
# 106 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/type_traits" 3
template<bool __v>
using __bool_constant = integral_constant<bool, __v>;

using true_type = __bool_constant<true>;

using false_type = __bool_constant<false>;

template<bool __v>
using bool_constant = __bool_constant<__v>;
template<bool, typename _Tp = void>
struct enable_if
{ };

template<typename _Tp>
struct enable_if<true, _Tp>
{ using type = _Tp; };

template<bool _Cond, typename _Tp = void>

using __enable_if_t = typename enable_if<_Cond, _Tp>::type;

template<bool>
struct __conditional
{
template<typename _Tp, typename>
using type = _Tp;
};

template<>
struct __conditional<false>
{
template<typename, typename _Up>
using type = _Up;
};

template<bool _Cond, typename _If, typename _Else>

using __conditional_t
= typename __conditional<_Cond>::template type<_If, _Else>;

template <typename _Type>

struct __type_identity
{ using type = _Type; };

template<typename _Tp>
using __type_identity_t = typename __type_identity<_Tp>::type;

namespace __detail
{

template<typename _Tp, typename...>

using __first_t = _Tp;

template<typename... _Bn>
auto __or_fn(int) -> __first_t<false_type,
__enable_if_t<!bool(_Bn::value)>...>;

template<typename... _Bn>
auto __or_fn(...) -> true_type;
template<typename... _Bn>
auto __and_fn(int) -> __first_t<true_type,
__enable_if_t<bool(_Bn::value)>...>;

template<typename... _Bn>
auto __and_fn(...) -> false_type;
}

template<typename... _Bn>
struct __or_
: decltype(__detail::__or_fn<_Bn...>(0))
{ };

template<typename... _Bn>
struct __and_
: decltype(__detail::__and_fn<_Bn...>(0))
{ };

template<typename _Pp>
struct __not_
: __bool_constant<!bool(_Pp::value)>
{ };

template<typename... _Bn>
inline constexpr bool __or_v = __or_<_Bn...>::value;
template<typename... _Bn>
inline constexpr bool __and_v = __and_<_Bn...>::value;

namespace __detail
{
template<typename , typename _B1, typename... _Bn>
struct __disjunction_impl
{ using type = _B1; };

template<typename _B1, typename _B2, typename... _Bn>

struct __disjunction_impl<__enable_if_t<!bool(_B1::value)>, _B1, _B2, _Bn...>
{ using type = typename __disjunction_impl<void, _B2, _Bn...>::type; };

template<typename , typename _B1, typename... _Bn>

struct __conjunction_impl
{ using type = _B1; };

template<typename _B1, typename _B2, typename... _Bn>

struct __conjunction_impl<__enable_if_t<bool(_B1::value)>, _B1, _B2, _Bn...>
{ using type = typename __conjunction_impl<void, _B2, _Bn...>::type; };
}

template<typename... _Bn>
struct conjunction
: __detail::__conjunction_impl<void, _Bn...>::type
{ };
template<>
struct conjunction<>
: true_type
{ };

template<typename... _Bn>
struct disjunction
: __detail::__disjunction_impl<void, _Bn...>::type
{ };

template<>
struct disjunction<>
: false_type
{ };

template<typename _Pp>
struct negation
: __not_<_Pp>::type
{ };

template<typename... _Bn>
inline constexpr bool conjunction_v = conjunction<_Bn...>::value;

template<typename... _Bn>
inline constexpr bool disjunction_v = disjunction<_Bn...>::value;

template<typename _Pp>
inline constexpr bool negation_v = negation<_Pp>::value;

template<typename>
struct is_reference;
template<typename>
struct is_function;
template<typename>
struct is_void;
template<typename>
struct remove_cv;
template<typename>
struct is_const;

template<typename>
struct __is_array_unknown_bounds;

template <typename _Tp, size_t = sizeof(_Tp)>

constexpr true_type __is_complete_or_unbounded(__type_identity<_Tp>)
{ return {}; }
template <typename _TypeIdentity,
typename _NestedType = typename _TypeIdentity::type>
constexpr typename __or_<
is_reference<_NestedType>,
is_function<_NestedType>,
is_void<_NestedType>,
__is_array_unknown_bounds<_NestedType>
>::type __is_complete_or_unbounded(_TypeIdentity)
{ return {}; }

template<typename _Tp>
using __remove_cv_t = typename remove_cv<_Tp>::type;

template<typename _Tp>
struct is_void
: public false_type { };

template<>
struct is_void<void>
: public true_type { };

template<>
struct is_void<const void>
: public true_type { };

template<>
struct is_void<volatile void>
: public true_type { };

template<>
struct is_void<const volatile void>
: public true_type { };

template<typename>
struct __is_integral_helper
: public false_type { };

template<>
struct __is_integral_helper<bool>
: public true_type { };

template<>
struct __is_integral_helper<char>
: public true_type { };

template<>
struct __is_integral_helper<signed char>
: public true_type { };

template<>
struct __is_integral_helper<unsigned char>
: public true_type { };
template<>
struct __is_integral_helper<wchar_t>
: public true_type { };

template<>
struct __is_integral_helper<char8_t>
: public true_type { };

template<>
struct __is_integral_helper<char16_t>
: public true_type { };

template<>
struct __is_integral_helper<char32_t>
: public true_type { };

template<>
struct __is_integral_helper<short>
: public true_type { };

template<>
struct __is_integral_helper<unsigned short>
: public true_type { };

template<>
struct __is_integral_helper<int>
: public true_type { };

template<>
struct __is_integral_helper<unsigned int>
: public true_type { };

template<>
struct __is_integral_helper<long>
: public true_type { };

template<>
struct __is_integral_helper<unsigned long>
: public true_type { };

template<>
struct __is_integral_helper<long long>
: public true_type { };

template<>
struct __is_integral_helper<unsigned long long>
: public true_type { };

__extension__
template<>
struct __is_integral_helper<__int128>
: public true_type { };

__extension__
template<>
struct __is_integral_helper<unsigned __int128>
: public true_type { };
# 460 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/type_traits" 3
template<typename _Tp>
struct is_integral
: public __is_integral_helper<__remove_cv_t<_Tp>>::type
{ };

template<typename>
struct __is_floating_point_helper
: public false_type { };

template<>
struct __is_floating_point_helper<float>
: public true_type { };

template<>
struct __is_floating_point_helper<double>
: public true_type { };

template<>
struct __is_floating_point_helper<long double>
: public true_type { };

template<>
struct __is_floating_point_helper<_Float16>
: public true_type { };

template<>
struct __is_floating_point_helper<_Float32>
: public true_type { };

template<>
struct __is_floating_point_helper<_Float64>
: public true_type { };

template<>
struct __is_floating_point_helper<_Float128>
: public true_type { };

template<>
struct __is_floating_point_helper<__gnu_cxx::__bfloat16_t>
: public true_type { };
template<>
struct __is_floating_point_helper<__float128>
: public true_type { };

template<typename _Tp>
struct is_floating_point
: public __is_floating_point_helper<__remove_cv_t<_Tp>>::type
{ };

template<typename _Tp>
struct is_array
: public __bool_constant<__is_array(_Tp)>
{ };
# 545 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/type_traits" 3
template<typename>
struct __is_pointer_helper
: public false_type { };

template<typename _Tp>
struct __is_pointer_helper<_Tp*>
: public true_type { };

template<typename _Tp>
struct is_pointer
: public __is_pointer_helper<__remove_cv_t<_Tp>>::type
{ };

template<typename>
struct is_lvalue_reference
: public false_type { };

template<typename _Tp>
struct is_lvalue_reference<_Tp&>
: public true_type { };

template<typename>
struct is_rvalue_reference
: public false_type { };

template<typename _Tp>
struct is_rvalue_reference<_Tp&&>
: public true_type { };

template<typename _Tp>
struct is_member_object_pointer
: public __bool_constant<__is_member_object_pointer(_Tp)>
{ };
# 601 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/type_traits" 3
template<typename _Tp>
struct is_member_function_pointer
: public __bool_constant<__is_member_function_pointer(_Tp)>
{ };
# 622 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/type_traits" 3
template<typename _Tp>
struct is_enum
: public __bool_constant<__is_enum(_Tp)>
{ };

template<typename _Tp>
struct is_union
: public __bool_constant<__is_union(_Tp)>
{ };

template<typename _Tp>
struct is_class
: public __bool_constant<__is_class(_Tp)>
{ };

template<typename _Tp>
struct is_function
: public __bool_constant<__is_function(_Tp)>
{ };
# 661 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/type_traits" 3
template<typename _Tp>
struct is_null_pointer
: public false_type { };

template<>
struct is_null_pointer<std::nullptr_t>
: public true_type { };

template<>
struct is_null_pointer<const std::nullptr_t>
: public true_type { };

template<>
struct is_null_pointer<volatile std::nullptr_t>
: public true_type { };

template<>
struct is_null_pointer<const volatile std::nullptr_t>
: public true_type { };

template<typename _Tp>
struct __is_nullptr_t
: public is_null_pointer<_Tp>
{ } __attribute__ ((__deprecated__ ("use '" "std::is_null_pointer" "'
instead")));
template<typename _Tp>
struct is_reference
: public __bool_constant<__is_reference(_Tp)>
{ };
# 715 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/type_traits" 3
template<typename _Tp>
struct is_arithmetic
: public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type
{ };

template<typename _Tp>
struct is_fundamental
: public __or_<is_arithmetic<_Tp>, is_void<_Tp>,
is_null_pointer<_Tp>>::type
{ };

template<typename _Tp>
struct is_object
: public __bool_constant<__is_object(_Tp)>
{ };
# 741 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/type_traits" 3
template<typename>
struct is_member_pointer;

template<typename _Tp>
struct is_scalar
: public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type
{ };

template<typename _Tp>
struct is_compound
: public __bool_constant<!is_fundamental<_Tp>::value> { };

template<typename _Tp>
struct is_member_pointer
: public __bool_constant<__is_member_pointer(_Tp)>
{ };
# 779 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/type_traits" 3
template<typename, typename>
struct is_same;

template<typename _Tp, typename... _Types>

using __is_one_of = __or_<is_same<_Tp, _Types>...>;

__extension__
template<typename _Tp>
using __is_signed_integer = __is_one_of<__remove_cv_t<_Tp>,
signed char, signed short, signed int, signed long,
signed long long

, signed __int128
# 804 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/type_traits" 3
>;

__extension__
template<typename _Tp>
using __is_unsigned_integer = __is_one_of<__remove_cv_t<_Tp>,
unsigned char, unsigned short, unsigned int, unsigned long,
unsigned long long

, unsigned __int128
# 824 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/type_traits" 3
>;

template<typename _Tp>
using __is_standard_integer
= __or_<__is_signed_integer<_Tp>, __is_unsigned_integer<_Tp>>;

template<typename...> using __void_t = void;

template<typename>
struct is_const
: public false_type { };

template<typename _Tp>
struct is_const<_Tp const>
: public true_type { };

template<typename>
struct is_volatile
: public false_type { };

template<typename _Tp>
struct is_volatile<_Tp volatile>
: public true_type { };

template<typename _Tp>
struct is_trivial
: public __bool_constant<__is_trivial(_Tp)>
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};

template<typename _Tp>
struct is_trivially_copyable
: public __bool_constant<__is_trivially_copyable(_Tp)>
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};

template<typename _Tp>
struct is_standard_layout
: public __bool_constant<__is_standard_layout(_Tp)>
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};

template<typename _Tp>
struct
__attribute__ ((__deprecated__ ("use '" "is_standard_layout && is_trivial" "'
instead")))
is_pod
: public __bool_constant<__is_pod(_Tp)>
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};

template<typename _Tp>
struct
[[__deprecated__]]
is_literal_type
: public __bool_constant<__is_literal_type(_Tp)>
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};

template<typename _Tp>
struct is_empty
: public __bool_constant<__is_empty(_Tp)>
{ };

template<typename _Tp>
struct is_polymorphic
: public __bool_constant<__is_polymorphic(_Tp)>
{ };
template<typename _Tp>
struct is_final
: public __bool_constant<__is_final(_Tp)>
{ };

template<typename _Tp>
struct is_abstract
: public __bool_constant<__is_abstract(_Tp)>
{ };

template<typename _Tp,
bool = is_arithmetic<_Tp>::value>
struct __is_signed_helper
: public false_type { };

template<typename _Tp>
struct __is_signed_helper<_Tp, true>
: public __bool_constant<_Tp(-1) < _Tp(0)>
{ };

template<typename _Tp>
struct is_signed
: public __is_signed_helper<_Tp>::type
{ };

template<typename _Tp>
struct is_unsigned
: public __and_<is_arithmetic<_Tp>, __not_<is_signed<_Tp>>>::type
{ };

template<typename _Tp, typename _Up = _Tp&&>

_Up
__declval(int);

template<typename _Tp>
_Tp
__declval(long);

template<typename _Tp>
auto declval() noexcept -> decltype(__declval<_Tp>(0));

template<typename>
struct remove_all_extents;

template<typename _Tp>
struct __is_array_known_bounds
: public false_type
{ };
template<typename _Tp, size_t _Size>
struct __is_array_known_bounds<_Tp[_Size]>
: public true_type
{ };

template<typename _Tp>
struct __is_array_unknown_bounds
: public false_type
{ };

template<typename _Tp>
struct __is_array_unknown_bounds<_Tp[]>
: public true_type
{ };
# 1006 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/type_traits" 3
struct __do_is_destructible_impl
{
template<typename _Tp, typename = decltype(declval<_Tp&>().~_Tp())>
static true_type __test(int);

template<typename>
static false_type __test(...);
};

template<typename _Tp>
struct __is_destructible_impl
: public __do_is_destructible_impl
{
using type = decltype(__test<_Tp>(0));
};

template<typename _Tp,
bool = __or_<is_void<_Tp>,
__is_array_unknown_bounds<_Tp>,
is_function<_Tp>>::value,
bool = __or_<is_reference<_Tp>, is_scalar<_Tp>>::value>
struct __is_destructible_safe;

template<typename _Tp>
struct __is_destructible_safe<_Tp, false, false>
: public __is_destructible_impl<typename
remove_all_extents<_Tp>::type>::type
{ };

template<typename _Tp>
struct __is_destructible_safe<_Tp, true, false>
: public false_type { };

template<typename _Tp>
struct __is_destructible_safe<_Tp, false, true>
: public true_type { };

template<typename _Tp>
struct is_destructible
: public __is_destructible_safe<_Tp>::type
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};

struct __do_is_nt_destructible_impl
{
template<typename _Tp>
static __bool_constant<noexcept(declval<_Tp&>().~_Tp())>
__test(int);

template<typename>
static false_type __test(...);
};

template<typename _Tp>
struct __is_nt_destructible_impl
: public __do_is_nt_destructible_impl
{
using type = decltype(__test<_Tp>(0));
};

template<typename _Tp,
bool = __or_<is_void<_Tp>,
__is_array_unknown_bounds<_Tp>,
is_function<_Tp>>::value,
bool = __or_<is_reference<_Tp>, is_scalar<_Tp>>::value>
struct __is_nt_destructible_safe;

template<typename _Tp>
struct __is_nt_destructible_safe<_Tp, false, false>
: public __is_nt_destructible_impl<typename
remove_all_extents<_Tp>::type>::type
{ };

template<typename _Tp>
struct __is_nt_destructible_safe<_Tp, true, false>
: public false_type { };

template<typename _Tp>
struct __is_nt_destructible_safe<_Tp, false, true>
: public true_type { };

template<typename _Tp>
struct is_nothrow_destructible
: public __is_nt_destructible_safe<_Tp>::type
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
template<typename _Tp, typename... _Args>
using __is_constructible_impl
= __bool_constant<__is_constructible(_Tp, _Args...)>;

template<typename _Tp, typename... _Args>

struct is_constructible
: public __is_constructible_impl<_Tp, _Args...>
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};

template<typename _Tp>
struct is_default_constructible
: public __is_constructible_impl<_Tp>
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};

template<typename _Tp, typename = void>

struct __add_lvalue_reference_helper
{ using type = _Tp; };

template<typename _Tp>
struct __add_lvalue_reference_helper<_Tp, __void_t<_Tp&>>
{ using type = _Tp&; };

template<typename _Tp>
using __add_lval_ref_t = typename __add_lvalue_reference_helper<_Tp>::type;

template<typename _Tp>
struct is_copy_constructible
: public __is_constructible_impl<_Tp, __add_lval_ref_t<const _Tp>>
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};

template<typename _Tp, typename = void>

struct __add_rvalue_reference_helper
{ using type = _Tp; };

template<typename _Tp>
struct __add_rvalue_reference_helper<_Tp, __void_t<_Tp&&>>
{ using type = _Tp&&; };

template<typename _Tp>
using __add_rval_ref_t = typename __add_rvalue_reference_helper<_Tp>::type;
template<typename _Tp>
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<typename _Tp, typename... _Args>

using __is_nothrow_constructible_impl
= __bool_constant<__is_nothrow_constructible(_Tp, _Args...)>;

template<typename _Tp, typename... _Args>

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<typename _Tp>
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<typename _Tp>
struct is_nothrow_copy_constructible
: public __is_nothrow_constructible_impl<_Tp, __add_lval_ref_t<const _Tp>>
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};

template<typename _Tp>
struct is_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<typename _Tp, typename _Up>

using __is_assignable_impl = __bool_constant<__is_assignable(_Tp, _Up)>;

template<typename _Tp, typename _Up>

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<typename _Tp>
struct is_copy_assignable
: public __is_assignable_impl<__add_lval_ref_t<_Tp>,
__add_lval_ref_t<const _Tp>>
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};

template<typename _Tp>
struct is_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<typename _Tp, typename _Up>

using __is_nothrow_assignable_impl
= __bool_constant<__is_nothrow_assignable(_Tp, _Up)>;

template<typename _Tp, typename _Up>

struct is_nothrow_assignable
: public __is_nothrow_assignable_impl<_Tp, _Up>
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};

template<typename _Tp>
struct is_nothrow_copy_assignable
: public __is_nothrow_assignable_impl<__add_lval_ref_t<_Tp>,
__add_lval_ref_t<const _Tp>>
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};

template<typename _Tp>
struct is_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<typename _Tp, typename... _Args>
using __is_trivially_constructible_impl
= __bool_constant<__is_trivially_constructible(_Tp, _Args...)>;

template<typename _Tp, typename... _Args>

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<typename _Tp>
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");
};

template<typename _Tp>
constexpr bool __is_implicitly_default_constructible_v
= requires (void(&__f)(_Tp)) { __f({}); };

template<typename _Tp>
struct __is_implicitly_default_constructible
: __bool_constant<__is_implicitly_default_constructible_v<_Tp>>
{ };
# 1351 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/type_traits" 3
template<typename _Tp>
struct is_trivially_copy_constructible
: public __is_trivially_constructible_impl<_Tp, __add_lval_ref_t<const _Tp>>
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};

template<typename _Tp>
struct is_trivially_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<typename _Tp, typename _Up>

using __is_trivially_assignable_impl
= __bool_constant<__is_trivially_assignable(_Tp, _Up)>;

template<typename _Tp, typename _Up>

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<typename _Tp>
struct is_trivially_copy_assignable
: public __is_trivially_assignable_impl<__add_lval_ref_t<_Tp>,
__add_lval_ref_t<const _Tp>>
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};

template<typename _Tp>
struct is_trivially_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<typename _Tp>
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<typename _Tp>
struct has_virtual_destructor
: public __bool_constant<__has_virtual_destructor(_Tp)>
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};

template<typename _Tp>
struct alignment_of
: public integral_constant<std::size_t, alignof(_Tp)>
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};
template<typename>
struct rank
: public integral_constant<std::size_t, 0> { };

template<typename _Tp, std::size_t _Size>

struct rank<_Tp[_Size]>
: public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };

template<typename _Tp>
struct rank<_Tp[]>
: public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };

template<typename, unsigned _Uint = 0>

struct extent
: public integral_constant<size_t, 0> { };

template<typename _Tp, size_t _Size>

struct extent<_Tp[_Size], 0>
: public integral_constant<size_t, _Size> { };

template<typename _Tp, unsigned _Uint, size_t _Size>

struct extent<_Tp[_Size], _Uint>
: public extent<_Tp, _Uint - 1>::type { };

template<typename _Tp>
struct extent<_Tp[], 0>
: public integral_constant<size_t, 0> { };

template<typename _Tp, unsigned _Uint>

struct extent<_Tp[], _Uint>
: public extent<_Tp, _Uint - 1>::type { };

template<typename _Tp, typename _Up>

struct is_same
: public __bool_constant<__is_same(_Tp, _Up)>
{ };
# 1491 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/type_traits" 3
template<typename _Base, typename _Derived>
struct is_base_of
: public __bool_constant<__is_base_of(_Base, _Derived)>
{ };

template<typename _From, typename _To>

struct is_convertible
: public __bool_constant<__is_convertible(_From, _To)>
{ };
# 1540 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/type_traits" 3
template<typename _ToElementType, typename _FromElementType>
using __is_array_convertible
= is_convertible<_FromElementType(*)[], _ToElementType(*)[]>;
template<typename _From, typename _To>
inline constexpr bool is_nothrow_convertible_v
= __is_nothrow_convertible(_From, _To);

template<typename _From, typename _To>

struct is_nothrow_convertible
: public bool_constant<is_nothrow_convertible_v<_From, _To>>
{ };
# 1603 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/type_traits" 3
template<typename _Tp>
struct remove_const
{ using type = _Tp; };

template<typename _Tp>
struct remove_const<_Tp const>
{ using type = _Tp; };

template<typename _Tp>
struct remove_volatile
{ using type = _Tp; };

template<typename _Tp>
struct remove_volatile<_Tp volatile>
{ using type = _Tp; };

template<typename _Tp>
struct remove_cv
{ using type = __remove_cv(_Tp); };
# 1644 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/type_traits" 3
template<typename _Tp>
struct add_const
{ using type = _Tp const; };

template<typename _Tp>
struct add_volatile
{ using type = _Tp volatile; };

template<typename _Tp>
struct add_cv
{ using type = _Tp const volatile; };

template<typename _Tp>
using remove_const_t = typename remove_const<_Tp>::type;

template<typename _Tp>
using remove_volatile_t = typename remove_volatile<_Tp>::type;
template<typename _Tp>
using remove_cv_t = typename remove_cv<_Tp>::type;

template<typename _Tp>
using add_const_t = typename add_const<_Tp>::type;

template<typename _Tp>
using add_volatile_t = typename add_volatile<_Tp>::type;

template<typename _Tp>
using add_cv_t = typename add_cv<_Tp>::type;

template<typename _Tp>
struct remove_reference
{ using type = __remove_reference(_Tp); };
# 1706 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/type_traits" 3
template<typename _Tp>
struct add_lvalue_reference
{ using type = __add_lval_ref_t<_Tp>; };

template<typename _Tp>
struct add_rvalue_reference
{ using type = __add_rval_ref_t<_Tp>; };

template<typename _Tp>
using remove_reference_t = typename remove_reference<_Tp>::type;

template<typename _Tp>
using add_lvalue_reference_t = typename add_lvalue_reference<_Tp>::type;

template<typename _Tp>
using add_rvalue_reference_t = typename add_rvalue_reference<_Tp>::type;

template<typename _Unqualified, bool _IsConst, bool _IsVol>

struct __cv_selector;

template<typename _Unqualified>
struct __cv_selector<_Unqualified, false, false>
{ using __type = _Unqualified; };

template<typename _Unqualified>
struct __cv_selector<_Unqualified, false, true>
{ using __type = volatile _Unqualified; };

template<typename _Unqualified>
struct __cv_selector<_Unqualified, true, false>
{ using __type = const _Unqualified; };

template<typename _Unqualified>
struct __cv_selector<_Unqualified, true, true>
{ using __type = const volatile _Unqualified; };

template<typename _Qualified, typename _Unqualified,

bool _IsConst = is_const<_Qualified>::value,
bool _IsVol = is_volatile<_Qualified>::value>
class __match_cv_qualifiers
{
using __match = __cv_selector<_Unqualified, _IsConst, _IsVol>;

public:
using __type = typename __match::__type;
};

template<typename _Tp>
struct __make_unsigned
{ using __type = _Tp; };

template<>
struct __make_unsigned<char>
{ using __type = unsigned char; };

template<>
struct __make_unsigned<signed char>
{ using __type = unsigned char; };

template<>
struct __make_unsigned<short>
{ using __type = unsigned short; };

template<>
struct __make_unsigned<int>
{ using __type = unsigned int; };

template<>
struct __make_unsigned<long>
{ using __type = unsigned long; };

template<>
struct __make_unsigned<long long>
{ using __type = unsigned long long; };

__extension__
template<>
struct __make_unsigned<__int128>
{ using __type = unsigned __int128; };
# 1819 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/type_traits" 3
template<typename _Tp,
bool _IsInt = is_integral<_Tp>::value,
bool _IsEnum = __is_enum(_Tp)>
class __make_unsigned_selector;

template<typename _Tp>
class __make_unsigned_selector<_Tp, true, false>
{
using __unsigned_type
= typename __make_unsigned<__remove_cv_t<_Tp>>::__type;

public:
using __type
= typename __match_cv_qualifiers<_Tp, __unsigned_type>::__type;
};

class __make_unsigned_selector_base
{
protected:
template<typename...> struct _List { };

template<typename _Tp, typename... _Up>

struct _List<_Tp, _Up...> : _List<_Up...>
{ static constexpr size_t __size = sizeof(_Tp); };

template<size_t _Sz, typename _Tp, bool = (_Sz <= _Tp::__size)>

struct __select;

template<size_t _Sz, typename _Uint, typename... _UInts>

struct __select<_Sz, _List<_Uint, _UInts...>, true>
{ using __type = _Uint; };

template<size_t _Sz, typename _Uint, typename... _UInts>

struct __select<_Sz, _List<_Uint, _UInts...>, false>
: __select<_Sz, _List<_UInts...>>
{ };
};

template<typename _Tp>
class __make_unsigned_selector<_Tp, false, true>
: __make_unsigned_selector_base
{

using _UInts = _List<unsigned char, unsigned short, unsigned int,

unsigned long, unsigned long long>;

using __unsigned_type = typename __select<sizeof(_Tp), _UInts>::__type;

public:
using __type
= typename __match_cv_qualifiers<_Tp, __unsigned_type>::__type;
};
template<>
struct __make_unsigned<wchar_t>
{
using __type
= typename __make_unsigned_selector<wchar_t, false, true>::__type;
};

template<>
struct __make_unsigned<char8_t>
{
using __type
= typename __make_unsigned_selector<char8_t, false, true>::__type;
};

template<>
struct __make_unsigned<char16_t>
{
using __type
= typename __make_unsigned_selector<char16_t, false, true>::__type;
};

template<>
struct __make_unsigned<char32_t>
{
using __type
= typename __make_unsigned_selector<char32_t, false, true>::__type;
};

template<typename _Tp>
struct make_unsigned
{ using type = typename __make_unsigned_selector<_Tp>::__type; };

template<> struct make_unsigned<bool>;

template<> struct make_unsigned<bool const>;
template<> struct make_unsigned<bool volatile>;
template<> struct make_unsigned<bool const volatile>;

template<typename _Tp>
struct __make_signed
{ using __type = _Tp; };

template<>
struct __make_signed<char>
{ using __type = signed char; };

template<>
struct __make_signed<unsigned char>
{ using __type = signed char; };
template<>
struct __make_signed<unsigned short>
{ using __type = signed short; };

template<>
struct __make_signed<unsigned int>
{ using __type = signed int; };

template<>
struct __make_signed<unsigned long>
{ using __type = signed long; };

template<>
struct __make_signed<unsigned long long>
{ using __type = signed long long; };

__extension__
template<>
struct __make_signed<unsigned __int128>
{ using __type = __int128; };
# 1979 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/type_traits" 3
template<typename _Tp,
bool _IsInt = is_integral<_Tp>::value,
bool _IsEnum = __is_enum(_Tp)>
class __make_signed_selector;

template<typename _Tp>
class __make_signed_selector<_Tp, true, false>
{
using __signed_type
= typename __make_signed<__remove_cv_t<_Tp>>::__type;

public:
using __type
= typename __match_cv_qualifiers<_Tp, __signed_type>::__type;
};

template<typename _Tp>
class __make_signed_selector<_Tp, false, true>
{
using __unsigned_type = typename __make_unsigned_selector<_Tp>::__type;

public:
using __type = typename __make_signed_selector<__unsigned_type>::__type;
};

template<>
struct __make_signed<wchar_t>
{
using __type
= typename __make_signed_selector<wchar_t, false, true>::__type;
};
template<>
struct __make_signed<char8_t>
{
using __type
= typename __make_signed_selector<char8_t, false, true>::__type;
};

template<>
struct __make_signed<char16_t>
{
using __type
= typename __make_signed_selector<char16_t, false, true>::__type;
};

template<>
struct __make_signed<char32_t>
{
using __type
= typename __make_signed_selector<char32_t, false, true>::__type;
};

template<typename _Tp>
struct make_signed
{ using type = typename __make_signed_selector<_Tp>::__type; };

template<> struct make_signed<bool>;

template<> struct make_signed<bool const>;
template<> struct make_signed<bool volatile>;
template<> struct make_signed<bool const volatile>;

template<typename _Tp>
using make_signed_t = typename make_signed<_Tp>::type;

template<typename _Tp>
using make_unsigned_t = typename make_unsigned<_Tp>::type;

template<typename _Tp>
struct remove_extent
{ using type = _Tp; };

template<typename _Tp, std::size_t _Size>

struct remove_extent<_Tp[_Size]>
{ using type = _Tp; };
template<typename _Tp>
struct remove_extent<_Tp[]>
{ using type = _Tp; };

template<typename _Tp>
struct remove_all_extents
{ using type = _Tp; };

template<typename _Tp, std::size_t _Size>

struct remove_all_extents<_Tp[_Size]>
{ using type = typename remove_all_extents<_Tp>::type; };

template<typename _Tp>
struct remove_all_extents<_Tp[]>
{ using type = typename remove_all_extents<_Tp>::type; };

template<typename _Tp>
using remove_extent_t = typename remove_extent<_Tp>::type;

template<typename _Tp>
using remove_all_extents_t = typename remove_all_extents<_Tp>::type;

template<typename _Tp>
struct remove_pointer
{ using type = __remove_pointer(_Tp); };
# 2124 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/type_traits" 3
template<typename _Tp, typename = void>
struct __add_pointer_helper
{ using type = _Tp; };

template<typename _Tp>
struct __add_pointer_helper<_Tp, __void_t<_Tp*>>
{ using type = _Tp*; };

template<typename _Tp>
struct add_pointer
: public __add_pointer_helper<_Tp>
{ };

template<typename _Tp>
struct add_pointer<_Tp&>
{ using type = _Tp*; };

template<typename _Tp>
struct add_pointer<_Tp&&>
{ using type = _Tp*; };
template<typename _Tp>
using remove_pointer_t = typename remove_pointer<_Tp>::type;

template<typename _Tp>
using add_pointer_t = typename add_pointer<_Tp>::type;

template<std::size_t _Len>
struct __aligned_storage_msa
{
union __type
{
unsigned char __data[_Len];
struct __attribute__((__aligned__)) { } __align;
};
};
# 2179 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/type_traits" 3
template<std::size_t _Len, std::size_t _Align =
__alignof__(typename __aligned_storage_msa<_Len>::__type)>
struct
[[__deprecated__]]
aligned_storage
{
union type
{
unsigned char __data[_Len];
struct __attribute__((__aligned__((_Align)))) { } __align;
};
};

template <typename... _Types>

struct __strictest_alignment
{
static const size_t _S_alignment = 0;
static const size_t _S_size = 0;
};

template <typename _Tp, typename... _Types>

struct __strictest_alignment<_Tp, _Types...>
{
static const size_t _S_alignment =
alignof(_Tp) > __strictest_alignment<_Types...>::_S_alignment
? alignof(_Tp) : __strictest_alignment<_Types...>::_S_alignment;
static const size_t _S_size =
sizeof(_Tp) > __strictest_alignment<_Types...>::_S_size
? sizeof(_Tp) : __strictest_alignment<_Types...>::_S_size;
};

#pragma GCC diagnostic push

#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
# 2225 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/type_traits" 3
template <size_t _Len, typename... _Types>
struct
[[__deprecated__]]
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;

using type = typename aligned_storage<_S_len, alignment_value>::type;

};

template <size_t _Len, typename... _Types>

const size_t aligned_union<_Len, _Types...>::alignment_value;
#pragma GCC diagnostic pop

template<typename _Up>
struct __decay_selector
: __conditional_t<is_const<const _Up>::value,
remove_cv<_Up>,
add_pointer<_Up>>
{ };

template<typename _Up, size_t _Nm>

struct __decay_selector<_Up[_Nm]>
{ using type = _Up*; };

template<typename _Up>
struct __decay_selector<_Up[]>
{ using type = _Up*; };

template<typename _Tp>
struct decay
{ using type = typename __decay_selector<_Tp>::type; };

template<typename _Tp>
struct decay<_Tp&>
{ using type = typename __decay_selector<_Tp>::type; };

template<typename _Tp>
struct decay<_Tp&&>
{ using type = typename __decay_selector<_Tp>::type; };

template<typename _Tp>
struct __strip_reference_wrapper
{
using __type = _Tp;
};
template<typename _Tp>
struct __strip_reference_wrapper<reference_wrapper<_Tp> >
{
using __type = _Tp&;
};

template<typename _Tp>
using __decay_t = typename decay<_Tp>::type;

template<typename _Tp>
using __decay_and_strip = __strip_reference_wrapper<__decay_t<_Tp>>;

template<typename... _Cond>
using _Require = __enable_if_t<__and_<_Cond...>::value>;

template<typename _Tp>
using __remove_cvref_t
= typename remove_cv<typename remove_reference<_Tp>::type>::type;

template<bool _Cond, typename _Iftrue, typename _Iffalse>

struct conditional
{ using type = _Iftrue; };

template<typename _Iftrue, typename _Iffalse>

struct conditional<false, _Iftrue, _Iffalse>
{ using type = _Iffalse; };

template<typename... _Tp>
struct common_type;
# 2340 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/type_traits" 3
template<typename _Tp>
struct __success_type
{ using type = _Tp; };

struct __failure_type
{ };

struct __do_common_type_impl
{
template<typename _Tp, typename _Up>
using __cond_t
= decltype(true ? std::declval<_Tp>() : std::declval<_Up>());

template<typename _Tp, typename _Up>

static __success_type<__decay_t<__cond_t<_Tp, _Up>>>
_S_test(int);
template<typename _Tp, typename _Up>
static __success_type<__remove_cvref_t<__cond_t<const _Tp&, const _Up&>>>
_S_test_2(int);

template<typename, typename>
static __failure_type
_S_test_2(...);

template<typename _Tp, typename _Up>

static decltype(_S_test_2<_Tp, _Up>(0))
_S_test(...);
};

template<>
struct common_type<>
{ };

template<typename _Tp0>
struct common_type<_Tp0>
: public common_type<_Tp0, _Tp0>
{ };

template<typename _Tp1, typename _Tp2,

typename _Dp1 = __decay_t<_Tp1>, typename _Dp2 = __decay_t<_Tp2>>
struct __common_type_impl
{

using type = common_type<_Dp1, _Dp2>;

};

template<typename _Tp1, typename _Tp2>

struct __common_type_impl<_Tp1, _Tp2, _Tp1, _Tp2>
: private __do_common_type_impl
{

using type = decltype(_S_test<_Tp1, _Tp2>(0));

};

template<typename _Tp1, typename _Tp2>

struct common_type<_Tp1, _Tp2>
: public __common_type_impl<_Tp1, _Tp2>::type
{ };

template<typename...>
struct __common_type_pack
{ };

template<typename, typename, typename = void>

struct __common_type_fold;

template<typename _Tp1, typename _Tp2, typename... _Rp>

struct common_type<_Tp1, _Tp2, _Rp...>
: public __common_type_fold<common_type<_Tp1, _Tp2>,
__common_type_pack<_Rp...>>
{ };

template<typename _CTp, typename... _Rp>

struct __common_type_fold<_CTp, __common_type_pack<_Rp...>,
__void_t<typename _CTp::type>>
: public common_type<typename _CTp::type, _Rp...>
{ };

template<typename _CTp, typename _Rp>

struct __common_type_fold<_CTp, _Rp, void>
{ };

template<typename _Tp, bool = __is_enum(_Tp)>

struct __underlying_type_impl
{
using type = __underlying_type(_Tp);
};

template<typename _Tp>
struct __underlying_type_impl<_Tp, false>
{ };

template<typename _Tp>
struct underlying_type
: public __underlying_type_impl<_Tp>
{ };

template<typename _Tp>
struct __declval_protector
{
static const bool __stop = false;
};

template<typename _Tp>
auto declval() noexcept -> decltype(__declval<_Tp>(0))
{
static_assert(__declval_protector<_Tp>::__stop,
"declval() must not be used!");
return __declval<_Tp>(0);
}
template<typename _Signature>
struct result_of;

struct __invoke_memfun_ref { };
struct __invoke_memfun_deref { };
struct __invoke_memobj_ref { };
struct __invoke_memobj_deref { };
struct __invoke_other { };

template<typename _Tp, typename _Tag>

struct __result_of_success : __success_type<_Tp>
{ using __invoke_type = _Tag; };

struct __result_of_memfun_ref_impl
{
template<typename _Fp, typename _Tp1, typename... _Args>
static __result_of_success<decltype(
(std::declval<_Tp1>().*std::declval<_Fp>())(std::declval<_Args>()...)
), __invoke_memfun_ref> _S_test(int);

template<typename...>
static __failure_type _S_test(...);
};

template<typename _MemPtr, typename _Arg, typename... _Args>

struct __result_of_memfun_ref
: private __result_of_memfun_ref_impl
{
using type = decltype(_S_test<_MemPtr, _Arg, _Args...>(0));
};

struct __result_of_memfun_deref_impl
{
template<typename _Fp, typename _Tp1, typename... _Args>
static __result_of_success<decltype(
((*std::declval<_Tp1>()).*std::declval<_Fp>())(std::declval<_Args>()...)
), __invoke_memfun_deref> _S_test(int);

template<typename...>
static __failure_type _S_test(...);
};

template<typename _MemPtr, typename _Arg, typename... _Args>

struct __result_of_memfun_deref
: private __result_of_memfun_deref_impl
{
using type = decltype(_S_test<_MemPtr, _Arg, _Args...>(0));
};

struct __result_of_memobj_ref_impl
{
template<typename _Fp, typename _Tp1>
static __result_of_success<decltype(
std::declval<_Tp1>().*std::declval<_Fp>()
), __invoke_memobj_ref> _S_test(int);

template<typename, typename>
static __failure_type _S_test(...);
};

template<typename _MemPtr, typename _Arg>

struct __result_of_memobj_ref
: private __result_of_memobj_ref_impl
{
using type = decltype(_S_test<_MemPtr, _Arg>(0));
};

struct __result_of_memobj_deref_impl
{
template<typename _Fp, typename _Tp1>
static __result_of_success<decltype(
(*std::declval<_Tp1>()).*std::declval<_Fp>()
), __invoke_memobj_deref> _S_test(int);

template<typename, typename>
static __failure_type _S_test(...);
};

template<typename _MemPtr, typename _Arg>

struct __result_of_memobj_deref
: private __result_of_memobj_deref_impl
{
using type = decltype(_S_test<_MemPtr, _Arg>(0));
};

template<typename _MemPtr, typename _Arg>

struct __result_of_memobj;

template<typename _Res, typename _Class, typename _Arg>

struct __result_of_memobj<_Res _Class::*, _Arg>
{
using _Argval = __remove_cvref_t<_Arg>;
using _MemPtr = _Res _Class::*;
using type = typename __conditional_t<__or_<is_same<_Argval, _Class>,
is_base_of<_Class, _Argval>>::value,
__result_of_memobj_ref<_MemPtr, _Arg>,
__result_of_memobj_deref<_MemPtr, _Arg>
>::type;
};

template<typename _MemPtr, typename _Arg, typename... _Args>

struct __result_of_memfun;

template<typename _Res, typename _Class, typename _Arg, typename... _Args>

struct __result_of_memfun<_Res _Class::*, _Arg, _Args...>
{
using _Argval = typename remove_reference<_Arg>::type;
using _MemPtr = _Res _Class::*;
using type = typename __conditional_t<is_base_of<_Class, _Argval>::value,
__result_of_memfun_ref<_MemPtr, _Arg, _Args...>,
__result_of_memfun_deref<_MemPtr, _Arg, _Args...>
>::type;
};

template<typename _Tp, typename _Up = __remove_cvref_t<_Tp>>

struct __inv_unwrap
{
using type = _Tp;
};

template<typename _Tp, typename _Up>

struct __inv_unwrap<_Tp, reference_wrapper<_Up>>
{
using type = _Up&;
};

template<bool, bool, typename _Functor, typename... _ArgTypes>

struct __result_of_impl
{
using type = __failure_type;
};

template<typename _MemPtr, typename _Arg>

struct __result_of_impl<true, false, _MemPtr, _Arg>
: public __result_of_memobj<__decay_t<_MemPtr>,
typename __inv_unwrap<_Arg>::type>
{ };

template<typename _MemPtr, typename _Arg, typename... _Args>

struct __result_of_impl<false, true, _MemPtr, _Arg, _Args...>
: public __result_of_memfun<__decay_t<_MemPtr>,
typename __inv_unwrap<_Arg>::type, _Args...>
{ };

struct __result_of_other_impl
{
template<typename _Fn, typename... _Args>
static __result_of_success<decltype(
std::declval<_Fn>()(std::declval<_Args>()...)
), __invoke_other> _S_test(int);

template<typename...>
static __failure_type _S_test(...);
};

template<typename _Functor, typename... _ArgTypes>

struct __result_of_impl<false, false, _Functor, _ArgTypes...>
: private __result_of_other_impl
{
using type = decltype(_S_test<_Functor, _ArgTypes...>(0));
};
template<typename _Functor, typename... _ArgTypes>
struct __invoke_result
: public __result_of_impl<
is_member_object_pointer<
typename remove_reference<_Functor>::type
>::value,
is_member_function_pointer<
typename remove_reference<_Functor>::type
>::value,
_Functor, _ArgTypes...
>::type
{ };

template<typename _Fn, typename... _Args>

using __invoke_result_t = typename __invoke_result<_Fn, _Args...>::type;

template<typename _Functor, typename... _ArgTypes>

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<size_t _Len, size_t _Align =

__alignof__(typename __aligned_storage_msa<_Len>::__type)>
using aligned_storage_t [[__deprecated__]] = typename aligned_storage<_Len,
_Align>::type;

template <size_t _Len, typename... _Types>

using aligned_union_t [[__deprecated__]] = typename aligned_union<_Len,
_Types...>::type;
#pragma GCC diagnostic pop

template<typename _Tp>
using decay_t = typename decay<_Tp>::type;

template<bool _Cond, typename _Tp = void>

using enable_if_t = typename enable_if<_Cond, _Tp>::type;

template<bool _Cond, typename _Iftrue, typename _Iffalse>

using conditional_t = typename conditional<_Cond, _Iftrue, _Iffalse>::type;

template<typename... _Tp>
using common_type_t = typename common_type<_Tp...>::type;

template<typename _Tp>
using underlying_type_t = typename underlying_type<_Tp>::type;
template<typename _Tp>
using result_of_t = typename result_of<_Tp>::type;

template<typename...> using void_t = void;

# 2727 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/type_traits" 3
template<typename _Def, template<typename...> class _Op, typename... _Args>
struct __detected_or
{
using type = _Def;
using __is_detected = false_type;
};

template<typename _Def, template<typename...> class _Op, typename... _Args>

requires requires { typename _Op<_Args...>; }
struct __detected_or<_Def, _Op, _Args...>
{
using type = _Op<_Args...>;
using __is_detected = true_type;
};
# 2767 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/type_traits" 3
template<typename _Default, template<typename...> class _Op,
typename... _Args>
using __detected_or_t
= typename __detected_or<_Default, _Op, _Args...>::type;
# 2786 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/type_traits" 3
template <typename _Tp>
struct __is_swappable;

template <typename _Tp>

struct __is_nothrow_swappable;

template<typename>
struct __is_tuple_like_impl : false_type
{ };

template<typename _Tp>
struct __is_tuple_like
: public __is_tuple_like_impl<__remove_cvref_t<_Tp>>::type
{ };

template<typename _Tp>
constexpr
inline
_Require<__not_<__is_tuple_like<_Tp>>,
is_move_constructible<_Tp>,
is_move_assignable<_Tp>>
swap(_Tp&, _Tp&)
noexcept(__and_<is_nothrow_move_constructible<_Tp>,
is_nothrow_move_assignable<_Tp>>::value);

template<typename _Tp, size_t _Nm>

constexpr
inline
__enable_if_t<__is_swappable<_Tp>::value>
swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
noexcept(__is_nothrow_swappable<_Tp>::value);

namespace __swappable_details {
using std::swap;

struct __do_is_swappable_impl
{
template<typename _Tp, typename
= decltype(swap(std::declval<_Tp&>(), std::declval<_Tp&>()))>
static true_type __test(int);

template<typename>
static false_type __test(...);
};

struct __do_is_nothrow_swappable_impl
{
template<typename _Tp>
static __bool_constant<
noexcept(swap(std::declval<_Tp&>(), std::declval<_Tp&>()))
> __test(int);

template<typename>
static false_type __test(...);
};

template<typename _Tp>
struct __is_swappable_impl
: public __swappable_details::__do_is_swappable_impl
{
using type = decltype(__test<_Tp>(0));
};

template<typename _Tp>
struct __is_nothrow_swappable_impl
: public __swappable_details::__do_is_nothrow_swappable_impl
{
using type = decltype(__test<_Tp>(0));
};

template<typename _Tp>
struct __is_swappable
: public __is_swappable_impl<_Tp>::type
{ };

template<typename _Tp>
struct __is_nothrow_swappable
: public __is_nothrow_swappable_impl<_Tp>::type
{ };
template<typename _Tp>
struct is_swappable
: public __is_swappable_impl<_Tp>::type
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};

template<typename _Tp>
struct is_nothrow_swappable
: public __is_nothrow_swappable_impl<_Tp>::type
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};

template<typename _Tp>
inline constexpr bool is_swappable_v =
is_swappable<_Tp>::value;

template<typename _Tp>
inline constexpr bool is_nothrow_swappable_v =
is_nothrow_swappable<_Tp>::value;

namespace __swappable_with_details {
using std::swap;

struct __do_is_swappable_with_impl
{
template<typename _Tp, typename _Up, typename
= decltype(swap(std::declval<_Tp>(), std::declval<_Up>())),
typename
= decltype(swap(std::declval<_Up>(), std::declval<_Tp>()))>
static true_type __test(int);

template<typename, typename>
static false_type __test(...);
};

struct __do_is_nothrow_swappable_with_impl
{
template<typename _Tp, typename _Up>
static __bool_constant<
noexcept(swap(std::declval<_Tp>(), std::declval<_Up>()))
&&
noexcept(swap(std::declval<_Up>(), std::declval<_Tp>()))
> __test(int);

template<typename, typename>
static false_type __test(...);
};

template<typename _Tp, typename _Up>

struct __is_swappable_with_impl
: public __swappable_with_details::__do_is_swappable_with_impl
{
using type = decltype(__test<_Tp, _Up>(0));
};

template<typename _Tp>
struct __is_swappable_with_impl<_Tp&, _Tp&>
: public __swappable_details::__do_is_swappable_impl
{
using type = decltype(__test<_Tp&>(0));
};

template<typename _Tp, typename _Up>

struct __is_nothrow_swappable_with_impl
: public __swappable_with_details::__do_is_nothrow_swappable_with_impl
{
using type = decltype(__test<_Tp, _Up>(0));
};

template<typename _Tp>
struct __is_nothrow_swappable_with_impl<_Tp&, _Tp&>
: public __swappable_details::__do_is_nothrow_swappable_impl
{
using type = decltype(__test<_Tp&>(0));
};

template<typename _Tp, typename _Up>

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<typename _Tp, typename _Up>

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<typename _Tp, typename _Up>
inline constexpr bool is_swappable_with_v =
is_swappable_with<_Tp, _Up>::value;

template<typename _Tp, typename _Up>

inline constexpr bool is_nothrow_swappable_with_v =
is_nothrow_swappable_with<_Tp, _Up>::value;
# 3008 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/type_traits" 3
template<typename _Result, typename _Ret,
bool = is_void<_Ret>::value, typename = void>
struct __is_invocable_impl
: false_type
{
using __nothrow_conv = false_type;
};

template<typename _Result, typename _Ret>

struct __is_invocable_impl<_Result, _Ret,
true,
__void_t<typename _Result::type>>
: true_type
{
using __nothrow_conv = true_type;
};

#pragma GCC diagnostic push

#pragma GCC diagnostic ignored "-Wctor-dtor-privacy"

template<typename _Result, typename _Ret>

struct __is_invocable_impl<_Result, _Ret,
false,
__void_t<typename _Result::type>>
{
private:

using _Res_t = typename _Result::type;

static _Res_t _S_get() noexcept;

template<typename _Tp>
static void _S_conv(__type_identity_t<_Tp>) noexcept;

template<typename _Tp,
bool _Nothrow = noexcept(_S_conv<_Tp>(_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<typename _Tp, bool = false>
static false_type
_S_test(...);

public:

inline constexpr bool is_convertible_v = __is_convertible(_From, _To);

template<typename _Fn, typename... _Args>

inline constexpr bool is_invocable_v = is_invocable<_Fn, _Args...>::value;
template<typename _Fn, typename... _Args>
inline constexpr bool is_nothrow_invocable_v
= is_nothrow_invocable<_Fn, _Args...>::value;
template<typename _Ret, typename _Fn, typename... _Args>
inline constexpr bool is_invocable_r_v
= is_invocable_r<_Ret, _Fn, _Args...>::value;
template<typename _Ret, typename _Fn, typename... _Args>
inline constexpr bool is_nothrow_invocable_r_v
= is_nothrow_invocable_r<_Ret, _Fn, _Args...>::value;

template<typename _Tp>
struct has_unique_object_representations
: bool_constant<__has_unique_object_representations(
remove_cv_t<remove_all_extents_t<_Tp>>
)>
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
};

template<typename _Tp>
inline constexpr bool has_unique_object_representations_v
= has_unique_object_representations<_Tp>::value;

template<typename _Tp>
struct is_aggregate
: bool_constant<__is_aggregate(remove_cv_t<_Tp>)>
{ };
template<typename _Tp>
inline constexpr bool is_aggregate_v = __is_aggregate(remove_cv_t<_Tp>);
# 3581 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/type_traits" 3
template<typename _Tp>
struct remove_cvref
{ using type = __remove_cvref(_Tp); };
# 3598 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/type_traits" 3
template<typename _Tp>
using remove_cvref_t = typename remove_cvref<_Tp>::type;
# 3608 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/type_traits" 3
template<typename _Tp>
struct type_identity { using type = _Tp; };

template<typename _Tp>
using type_identity_t = typename type_identity<_Tp>::type;
# 3621 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/type_traits" 3
template<typename _Tp>
struct unwrap_reference { using type = _Tp; };

template<typename _Tp>
struct unwrap_reference<reference_wrapper<_Tp>> { using type = _Tp&; };

template<typename _Tp>
using unwrap_reference_t = typename unwrap_reference<_Tp>::type;

template<typename _Tp>
struct unwrap_ref_decay { using type = unwrap_reference_t<decay_t<_Tp>>; };

template<typename _Tp>
using unwrap_ref_decay_t = typename unwrap_ref_decay<_Tp>::type;
# 3648 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/type_traits" 3
template<typename _Tp>
inline constexpr bool is_bounded_array_v = __is_bounded_array(_Tp);
# 3661 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/type_traits" 3
template<typename _Tp>
inline constexpr bool is_unbounded_array_v = false;

template<typename _Tp>
inline constexpr bool is_unbounded_array_v<_Tp[]> = true;

template<typename _Tp>
struct is_bounded_array
: public bool_constant<is_bounded_array_v<_Tp>>
{ };

template<typename _Tp>
struct is_unbounded_array
: public bool_constant<is_unbounded_array_v<_Tp>>
{ };
template<typename _Tp, typename _Up>
struct is_layout_compatible
: bool_constant<__is_layout_compatible(_Tp, _Up)>
{ };

template<typename _Tp, typename _Up>

constexpr bool is_layout_compatible_v
= __is_layout_compatible(_Tp, _Up);

template<typename _S1, typename _S2, typename _M1, typename _M2>

constexpr bool
is_corresponding_member(_M1 _S1::*__m1, _M2 _S2::*__m2) noexcept
{ return __builtin_is_corresponding_member(__m1, __m2); }

template<typename _Base, typename _Derived>

struct is_pointer_interconvertible_base_of
: bool_constant<__is_pointer_interconvertible_base_of(_Base, _Derived)>
{ };

template<typename _Base, typename _Derived>

constexpr bool is_pointer_interconvertible_base_of_v
= __is_pointer_interconvertible_base_of(_Base, _Derived);
# 3732 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/type_traits" 3
template<typename _Tp, typename _Mem>
constexpr bool
is_pointer_interconvertible_with_class(_Mem _Tp::*__mp) noexcept
{ return __builtin_is_pointer_interconvertible_with_class(__mp); }
# 3744 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/type_traits" 3
template<typename _Tp>
struct is_scoped_enum
: bool_constant<__is_scoped_enum(_Tp)>
{ };
# 3765 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/type_traits" 3
template<typename _Tp>
inline constexpr bool is_scoped_enum_v = __is_scoped_enum(_Tp);
# 3778 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/type_traits" 3
template<typename _Tp, typename _Up>
struct reference_constructs_from_temporary
: public bool_constant<__reference_constructs_from_temporary(_Tp, _Up)>
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{})
&& std::__is_complete_or_unbounded(__type_identity<_Up>{}),
"template argument must be a complete class or an unbounded array");
};

template<typename _Tp, typename _Up>

struct reference_converts_from_temporary
: public bool_constant<__reference_converts_from_temporary(_Tp, _Up)>
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{})
&& std::__is_complete_or_unbounded(__type_identity<_Up>{}),
"template argument must be a complete class or an unbounded array");
};

template<typename _Tp, typename _Up>

inline constexpr bool reference_constructs_from_temporary_v
= reference_constructs_from_temporary<_Tp, _Up>::value;

template<typename _Tp, typename _Up>

inline constexpr bool reference_converts_from_temporary_v
= reference_converts_from_temporary<_Tp, _Up>::value;

constexpr inline bool

is_constant_evaluated() noexcept
{

if consteval { return true; } else { return false; }

template<typename _From, typename _To>

using __copy_cv = typename __match_cv_qualifiers<_From, _To>::__type;

template<typename _Xp, typename _Yp>

using __cond_res
= decltype(false ? declval<_Xp(&)()>()() : declval<_Yp(&)()>()());

template<typename _Ap, typename _Bp, typename = void>

struct __common_ref_impl
{ };
template<typename _Ap, typename _Bp>
using __common_ref = typename __common_ref_impl<_Ap, _Bp>::type;

template<typename _Xp, typename _Yp>

using __condres_cvref
= __cond_res<__copy_cv<_Xp, _Yp>&, __copy_cv<_Yp, _Xp>&>;

template<typename _Xp, typename _Yp>

struct __common_ref_impl<_Xp&, _Yp&, __void_t<__condres_cvref<_Xp, _Yp>>>
: enable_if<is_reference_v<__condres_cvref<_Xp, _Yp>>,
__condres_cvref<_Xp, _Yp>>
{ };

template<typename _Xp, typename _Yp>

using __common_ref_C = remove_reference_t<__common_ref<_Xp&, _Yp&>>&&;

template<typename _Xp, typename _Yp>

struct __common_ref_impl<_Xp&&, _Yp&&,
_Require<is_convertible<_Xp&&, __common_ref_C<_Xp, _Yp>>,
is_convertible<_Yp&&, __common_ref_C<_Xp, _Yp>>>>
{ using type = __common_ref_C<_Xp, _Yp>; };

template<typename _Xp, typename _Yp>

using __common_ref_D = __common_ref<const _Xp&, _Yp&>;

template<typename _Xp, typename _Yp>

struct __common_ref_impl<_Xp&&, _Yp&,
_Require<is_convertible<_Xp&&, __common_ref_D<_Xp, _Yp>>>>
{ using type = __common_ref_D<_Xp, _Yp>; };

template<typename _Xp, typename _Yp>

struct __common_ref_impl<_Xp&, _Yp&&>
: __common_ref_impl<_Yp&&, _Xp&>
{ };

template<typename _Tp, typename _Up,

template<typename> class _TQual, template<typename> class _UQual>
struct basic_common_reference
{ };

template<typename _Tp>
struct __xref
{ template<typename _Up> using __type = __copy_cv<_Tp, _Up>; };

template<typename _Tp>
struct __xref<_Tp&>
{ template<typename _Up> using __type = __copy_cv<_Tp, _Up>&; };
template<typename _Tp>
struct __xref<_Tp&&>
{ template<typename _Up> using __type = __copy_cv<_Tp, _Up>&&; };

template<typename _Tp1, typename _Tp2>

using __basic_common_ref
= typename basic_common_reference<remove_cvref_t<_Tp1>,
remove_cvref_t<_Tp2>,
__xref<_Tp1>::template __type,
__xref<_Tp2>::template __type>::type;

template<typename... _Tp>
struct common_reference;

template<typename... _Tp>
using common_reference_t = typename common_reference<_Tp...>::type;

template<>
struct common_reference<>
{ };

template<typename _Tp0>
struct common_reference<_Tp0>
{ using type = _Tp0; };

template<typename _Tp1, typename _Tp2, int _Bullet = 1, typename = void>

struct __common_reference_impl
: __common_reference_impl<_Tp1, _Tp2, _Bullet + 1>
{ };

template<typename _Tp1, typename _Tp2>

struct common_reference<_Tp1, _Tp2>
: __common_reference_impl<_Tp1, _Tp2>
{ };

template<typename _Tp1, typename _Tp2>

struct __common_reference_impl<_Tp1&, _Tp2&, 1,
void_t<__common_ref<_Tp1&, _Tp2&>>>
{ using type = __common_ref<_Tp1&, _Tp2&>; };

template<typename _Tp1, typename _Tp2>

struct __common_reference_impl<_Tp1&&, _Tp2&&, 1,
void_t<__common_ref<_Tp1&&, _Tp2&&>>>
{ using type = __common_ref<_Tp1&&, _Tp2&&>; };

template<typename _Tp1, typename _Tp2>

struct __common_reference_impl<_Tp1&, _Tp2&&, 1,
void_t<__common_ref<_Tp1&, _Tp2&&>>>
{ using type = __common_ref<_Tp1&, _Tp2&&>; };

template<typename _Tp1, typename _Tp2>

struct __common_reference_impl<_Tp1&&, _Tp2&, 1,
void_t<__common_ref<_Tp1&&, _Tp2&>>>
{ using type = __common_ref<_Tp1&&, _Tp2&>; };

template<typename _Tp1, typename _Tp2>

struct __common_reference_impl<_Tp1, _Tp2, 2,
void_t<__basic_common_ref<_Tp1, _Tp2>>>
{ using type = __basic_common_ref<_Tp1, _Tp2>; };

template<typename _Tp1, typename _Tp2>

struct __common_reference_impl<_Tp1, _Tp2, 3,
void_t<__cond_res<_Tp1, _Tp2>>>
{ using type = __cond_res<_Tp1, _Tp2>; };

template<typename _Tp1, typename _Tp2>

struct __common_reference_impl<_Tp1, _Tp2, 4,
void_t<common_type_t<_Tp1, _Tp2>>>
{ using type = common_type_t<_Tp1, _Tp2>; };

template<typename _Tp1, typename _Tp2>

struct __common_reference_impl<_Tp1, _Tp2, 5, void>
{ };

template<typename _Tp1, typename _Tp2, typename... _Rest>

struct common_reference<_Tp1, _Tp2, _Rest...>
: __common_type_fold<common_reference<_Tp1, _Tp2>,
__common_type_pack<_Rest...>>
{ };

template<typename _Tp1, typename _Tp2, typename... _Rest>

struct __common_type_fold<common_reference<_Tp1, _Tp2>,
__common_type_pack<_Rest...>,
void_t<common_reference_t<_Tp1, _Tp2>>>
: public common_reference<common_reference_t<_Tp1, _Tp2>, _Rest...>
{ };

}
# 47 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/concepts" 2 3

namespace std
{

namespace __detail
{
template<typename _Tp, typename _Up>
concept __same_as = std::is_same_v<_Tp, _Up>;
}

template<typename _Tp, typename _Up>

concept same_as
= __detail::__same_as<_Tp, _Up> && __detail::__same_as<_Up, _Tp>;

namespace __detail
{
template<typename _Tp, typename _Up>
concept __different_from
= !same_as<remove_cvref_t<_Tp>, remove_cvref_t<_Up>>;
}

template<typename _Derived, typename _Base>

concept derived_from = __is_base_of(_Base, _Derived)
&& is_convertible_v<const volatile _Derived*, const volatile _Base*>;

template<typename _From, typename _To>

concept convertible_to = is_convertible_v<_From, _To>
&& requires { static_cast<_To>(std::declval<_From>()); };

template<typename _Tp, typename _Up>

concept common_reference_with
= same_as<common_reference_t<_Tp, _Up>, common_reference_t<_Up, _Tp>>
&& convertible_to<_Tp, common_reference_t<_Tp, _Up>>
&& convertible_to<_Up, common_reference_t<_Tp, _Up>>;

template<typename _Tp, typename _Up>

concept common_with
= same_as<common_type_t<_Tp, _Up>, common_type_t<_Up, _Tp>>
&& requires {
static_cast<common_type_t<_Tp, _Up>>(std::declval<_Tp>());
static_cast<common_type_t<_Tp, _Up>>(std::declval<_Up>());
}
&& common_reference_with<add_lvalue_reference_t<const _Tp>,
add_lvalue_reference_t<const _Up>>
&& common_reference_with<add_lvalue_reference_t<common_type_t<_Tp, _Up>>,
common_reference_t<
add_lvalue_reference_t<const _Tp>,
add_lvalue_reference_t<const _Up>>>;

template<typename _Tp>
concept integral = is_integral_v<_Tp>;

template<typename _Tp>
concept signed_integral = integral<_Tp> && is_signed_v<_Tp>;

template<typename _Tp>
concept unsigned_integral = integral<_Tp> && !signed_integral<_Tp>;

template<typename _Tp>
concept floating_point = is_floating_point_v<_Tp>;
namespace __detail
{
template<typename _Tp>
using __cref = const remove_reference_t<_Tp>&;

template<typename _Tp>
concept __class_or_enum
= is_class_v<_Tp> || is_union_v<_Tp> || is_enum_v<_Tp>;

template<typename _Tp>
constexpr bool __destructible_impl = false;
template<typename _Tp>
requires requires(_Tp& __t) { { __t.~_Tp() } noexcept; }
constexpr bool __destructible_impl<_Tp> = true;

template<typename _Tp>
constexpr bool __destructible = __destructible_impl<_Tp>;
template<typename _Tp>
constexpr bool __destructible<_Tp&> = true;
template<typename _Tp>
constexpr bool __destructible<_Tp&&> = true;
template<typename _Tp, size_t _Nm>
constexpr bool __destructible<_Tp[_Nm]> = __destructible<_Tp>;

template<typename _Lhs, typename _Rhs>

concept assignable_from
= is_lvalue_reference_v<_Lhs>
&& common_reference_with<__detail::__cref<_Lhs>, __detail::__cref<_Rhs>>
&& requires(_Lhs __lhs, _Rhs&& __rhs) {
{ __lhs = static_cast<_Rhs&&>(__rhs) } -> same_as<_Lhs>;
};

template<typename _Tp>
concept destructible = __detail::__destructible<_Tp>;

template<typename _Tp, typename... _Args>

concept constructible_from
= destructible<_Tp> && is_constructible_v<_Tp, _Args...>;

template<typename _Tp>
concept default_initializable = constructible_from<_Tp>
&& requires
{
_Tp{};
(void) ::new _Tp;
};

template<typename _Tp>
concept move_constructible
= constructible_from<_Tp, _Tp> && convertible_to<_Tp, _Tp>;
template<typename _Tp>
concept copy_constructible
= move_constructible<_Tp>
&& constructible_from<_Tp, _Tp&> && convertible_to<_Tp&, _Tp>
&& constructible_from<_Tp, const _Tp&> && convertible_to<const _Tp&, _Tp>
&& constructible_from<_Tp, const _Tp> && convertible_to<const _Tp, _Tp>;

namespace ranges
{

namespace __swap
{
template<typename _Tp> void swap(_Tp&, _Tp&) = delete;

template<typename _Tp, typename _Up>

concept __adl_swap
= (std::__detail::__class_or_enum<remove_reference_t<_Tp>>
|| std::__detail::__class_or_enum<remove_reference_t<_Up>>)
&& requires(_Tp&& __t, _Up&& __u) {
swap(static_cast<_Tp&&>(__t), static_cast<_Up&&>(__u));
};

struct _Swap
{
private:
template<typename _Tp, typename _Up>
static constexpr bool
_S_noexcept()
{
if constexpr (__adl_swap<_Tp, _Up>)
return noexcept(swap(std::declval<_Tp>(), std::declval<_Up>()));
else
return is_nothrow_move_constructible_v<remove_reference_t<_Tp>>
&& is_nothrow_move_assignable_v<remove_reference_t<_Tp>>;
}

public:
template<typename _Tp, typename _Up>
requires __adl_swap<_Tp, _Up>
|| (same_as<_Tp, _Up> && is_lvalue_reference_v<_Tp>
&& move_constructible<remove_reference_t<_Tp>>
&& assignable_from<_Tp, remove_reference_t<_Tp>>)
constexpr void
operator()(_Tp&& __t, _Up&& __u) const
noexcept(_S_noexcept<_Tp, _Up>())
{
if constexpr (__adl_swap<_Tp, _Up>)
swap(static_cast<_Tp&&>(__t), static_cast<_Up&&>(__u));
else
{
auto __tmp = static_cast<remove_reference_t<_Tp>&&>(__t);
__t = static_cast<remove_reference_t<_Tp>&&>(__u);
__u = static_cast<remove_reference_t<_Tp>&&>(__tmp);
}
}
template<typename _Tp, typename _Up, size_t _Num>
requires requires(const _Swap& __swap, _Tp& __e1, _Up& __e2) {
__swap(__e1, __e2);
}
constexpr void
operator()(_Tp (&__e1)[_Num], _Up (&__e2)[_Num]) const
noexcept(noexcept(std::declval<const _Swap&>()(*__e1, *__e2)))
{
for (size_t __n = 0; __n < _Num; ++__n)
(*this)(__e1[__n], __e2[__n]);
}
};
}

inline namespace _Cpo {

inline constexpr __swap::_Swap swap{};
}
}

template<typename _Tp>
concept swappable
= requires(_Tp& __a, _Tp& __b) { ranges::swap(__a, __b); };

template<typename _Tp, typename _Up>

concept swappable_with = common_reference_with<_Tp, _Up>
&& requires(_Tp&& __t, _Up&& __u) {
ranges::swap(static_cast<_Tp&&>(__t), static_cast<_Tp&&>(__t));
ranges::swap(static_cast<_Up&&>(__u), static_cast<_Up&&>(__u));
ranges::swap(static_cast<_Tp&&>(__t), static_cast<_Up&&>(__u));
ranges::swap(static_cast<_Up&&>(__u), static_cast<_Tp&&>(__t));
};

template<typename _Tp>
concept movable = is_object_v<_Tp> && move_constructible<_Tp>
&& assignable_from<_Tp&, _Tp> && swappable<_Tp>;

template<typename _Tp>
concept copyable = copy_constructible<_Tp> && movable<_Tp>
&& assignable_from<_Tp&, _Tp&> && assignable_from<_Tp&, const _Tp&>
&& assignable_from<_Tp&, const _Tp>;

template<typename _Tp>
concept semiregular = copyable<_Tp> && default_initializable<_Tp>;

namespace __detail
{
template<typename _Tp>
concept __boolean_testable_impl = convertible_to<_Tp, bool>;

template<typename _Tp>
concept __boolean_testable
= __boolean_testable_impl<_Tp>
&& requires(_Tp&& __t)
{ { !static_cast<_Tp&&>(__t) } -> __boolean_testable_impl; };
}

namespace __detail
{
template<typename _Tp, typename _Up>
concept __weakly_eq_cmp_with
= requires(__detail::__cref<_Tp> __t, __detail::__cref<_Up> __u) {
{ __t == __u } -> __boolean_testable;
{ __t != __u } -> __boolean_testable;
{ __u == __t } -> __boolean_testable;
{ __u != __t } -> __boolean_testable;
};
}

template<typename _Tp>
concept equality_comparable = __detail::__weakly_eq_cmp_with<_Tp, _Tp>;

template<typename _Tp, typename _Up>

concept equality_comparable_with
= equality_comparable<_Tp> && equality_comparable<_Up>
&& common_reference_with<__detail::__cref<_Tp>, __detail::__cref<_Up>>
&& equality_comparable<common_reference_t<__detail::__cref<_Tp>,
__detail::__cref<_Up>>>
&& __detail::__weakly_eq_cmp_with<_Tp, _Up>;

namespace __detail
{
template<typename _Tp, typename _Up>
concept __partially_ordered_with
= requires(const remove_reference_t<_Tp>& __t,
const remove_reference_t<_Up>& __u) {
{ __t < __u } -> __boolean_testable;
{ __t > __u } -> __boolean_testable;
{ __t <= __u } -> __boolean_testable;
{ __t >= __u } -> __boolean_testable;
{ __u < __t } -> __boolean_testable;
{ __u > __t } -> __boolean_testable;
{ __u <= __t } -> __boolean_testable;
{ __u >= __t } -> __boolean_testable;
};
}

template<typename _Tp>
concept totally_ordered
= equality_comparable<_Tp>
&& __detail::__partially_ordered_with<_Tp, _Tp>;

template<typename _Tp, typename _Up>

concept totally_ordered_with
= totally_ordered<_Tp> && totally_ordered<_Up>
&& equality_comparable_with<_Tp, _Up>
&& totally_ordered<common_reference_t<__detail::__cref<_Tp>,
__detail::__cref<_Up>>>
&& __detail::__partially_ordered_with<_Tp, _Up>;
template<typename _Tp>
concept regular = semiregular<_Tp> && equality_comparable<_Tp>;

template<typename _Fn, typename... _Args>

concept invocable = is_invocable_v<_Fn, _Args...>;

template<typename _Fn, typename... _Args>

concept regular_invocable = invocable<_Fn, _Args...>;

template<typename _Fn, typename... _Args>

concept predicate = regular_invocable<_Fn, _Args...>
&& __detail::__boolean_testable<invoke_result_t<_Fn, _Args...>>;

template<typename _Rel, typename _Tp, typename _Up>

concept relation
= predicate<_Rel, _Tp, _Tp> && predicate<_Rel, _Up, _Up>
&& predicate<_Rel, _Tp, _Up> && predicate<_Rel, _Up, _Tp>;

template<typename _Rel, typename _Tp, typename _Up>

concept equivalence_relation = relation<_Rel, _Tp, _Up>;

template<typename _Rel, typename _Tp, typename _Up>

concept strict_weak_order = relation<_Rel, _Tp, _Up>;

}
# 41 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/compare" 2 3

namespace std
{

namespace __cmp_cat
{
using type = signed char;

enum class _Ord : type { equivalent = 0, less = -1, greater = 1 };

enum class _Ncmp : type { _Unordered = 2 };

struct __unspec
{
consteval __unspec(__unspec*) noexcept { }
};
}

class partial_ordering
{

__cmp_cat::type _M_value;
constexpr explicit
partial_ordering(__cmp_cat::_Ord __v) noexcept
: _M_value(__cmp_cat::type(__v))
{ }

constexpr explicit
partial_ordering(__cmp_cat::_Ncmp __v) noexcept
: _M_value(__cmp_cat::type(__v))
{ }

friend class weak_ordering;

friend class strong_ordering;

public:

static const partial_ordering less;

static const partial_ordering equivalent;
static const partial_ordering greater;
static const partial_ordering unordered;

[[nodiscard]]
friend constexpr bool
operator==(partial_ordering __v, __cmp_cat::__unspec) noexcept
{ return __v._M_value == 0; }

[[nodiscard]]
friend constexpr bool
operator==(partial_ordering, partial_ordering) noexcept = default;

[[nodiscard]]
friend constexpr bool
operator< (partial_ordering __v, __cmp_cat::__unspec) noexcept
{ return __v._M_value == -1; }

[[nodiscard]]
friend constexpr bool
operator> (partial_ordering __v, __cmp_cat::__unspec) noexcept
{ return __v._M_value == 1; }

[[nodiscard]]
friend constexpr bool
operator<=(partial_ordering __v, __cmp_cat::__unspec) noexcept
{ return __v._M_value <= 0; }

[[nodiscard]]
friend constexpr bool
operator>=(partial_ordering __v, __cmp_cat::__unspec) noexcept
{ return __cmp_cat::type(__v._M_value & 1) == __v._M_value; }

[[nodiscard]]
friend constexpr bool
operator< (__cmp_cat::__unspec, partial_ordering __v) noexcept
{ return __v._M_value == 1; }

[[nodiscard]]
friend constexpr bool
operator> (__cmp_cat::__unspec, partial_ordering __v) noexcept
{ return __v._M_value == -1; }
[[nodiscard]]
friend constexpr bool
operator<=(__cmp_cat::__unspec, partial_ordering __v) noexcept
{ return __cmp_cat::type(__v._M_value & 1) == __v._M_value; }

[[nodiscard]]
friend constexpr bool
operator>=(__cmp_cat::__unspec, partial_ordering __v) noexcept
{ return 0 >= __v._M_value; }

[[nodiscard]]
friend constexpr partial_ordering
operator<=>(partial_ordering __v, __cmp_cat::__unspec) noexcept
{ return __v; }

[[nodiscard]]
friend constexpr partial_ordering
operator<=>(__cmp_cat::__unspec, partial_ordering __v) noexcept
{
if (__v._M_value & 1)
return partial_ordering(__cmp_cat::_Ord(-__v._M_value));
else
return __v;
}
};

inline constexpr partial_ordering

partial_ordering::less(__cmp_cat::_Ord::less);

inline constexpr partial_ordering

partial_ordering::equivalent(__cmp_cat::_Ord::equivalent);

inline constexpr partial_ordering

partial_ordering::greater(__cmp_cat::_Ord::greater);

inline constexpr partial_ordering

partial_ordering::unordered(__cmp_cat::_Ncmp::_Unordered);

class weak_ordering
{
__cmp_cat::type _M_value;

constexpr explicit
weak_ordering(__cmp_cat::_Ord __v) noexcept : _M_value(__cmp_cat::type(__v))
{ }

friend class strong_ordering;

public:

static const weak_ordering less;

static const weak_ordering equivalent;
static const weak_ordering greater;

[[nodiscard]]
constexpr operator partial_ordering() const noexcept
{ return partial_ordering(__cmp_cat::_Ord(_M_value)); }
[[nodiscard]]
friend constexpr bool
operator==(weak_ordering __v, __cmp_cat::__unspec) noexcept
{ return __v._M_value == 0; }

[[nodiscard]]
friend constexpr bool
operator==(weak_ordering, weak_ordering) noexcept = default;

[[nodiscard]]
friend constexpr bool
operator< (weak_ordering __v, __cmp_cat::__unspec) noexcept
{ return __v._M_value < 0; }

[[nodiscard]]
friend constexpr bool
operator> (weak_ordering __v, __cmp_cat::__unspec) noexcept
{ return __v._M_value > 0; }

[[nodiscard]]
friend constexpr bool
operator<=(weak_ordering __v, __cmp_cat::__unspec) noexcept
{ return __v._M_value <= 0; }

[[nodiscard]]
friend constexpr bool
operator>=(weak_ordering __v, __cmp_cat::__unspec) noexcept
{ return __v._M_value >= 0; }

[[nodiscard]]
friend constexpr bool
operator< (__cmp_cat::__unspec, weak_ordering __v) noexcept
{ return 0 < __v._M_value; }

[[nodiscard]]
friend constexpr bool
operator> (__cmp_cat::__unspec, weak_ordering __v) noexcept
{ return 0 > __v._M_value; }

[[nodiscard]]
friend constexpr bool
operator<=(__cmp_cat::__unspec, weak_ordering __v) noexcept
{ return 0 <= __v._M_value; }

[[nodiscard]]
friend constexpr bool
operator>=(__cmp_cat::__unspec, weak_ordering __v) noexcept
{ return 0 >= __v._M_value; }

[[nodiscard]]
friend constexpr weak_ordering
operator<=>(weak_ordering __v, __cmp_cat::__unspec) noexcept
{ return __v; }

[[nodiscard]]
friend constexpr weak_ordering
operator<=>(__cmp_cat::__unspec, weak_ordering __v) noexcept
{ return weak_ordering(__cmp_cat::_Ord(-__v._M_value)); }
};

inline constexpr weak_ordering

weak_ordering::less(__cmp_cat::_Ord::less);

inline constexpr weak_ordering

weak_ordering::equivalent(__cmp_cat::_Ord::equivalent);

inline constexpr weak_ordering

weak_ordering::greater(__cmp_cat::_Ord::greater);

class strong_ordering
{
__cmp_cat::type _M_value;

constexpr explicit
strong_ordering(__cmp_cat::_Ord __v) noexcept
: _M_value(__cmp_cat::type(__v))
{ }

public:

static const strong_ordering less;

static const strong_ordering equal;
static const strong_ordering equivalent;
static const strong_ordering greater;

[[nodiscard]]
constexpr operator partial_ordering() const noexcept
{ return partial_ordering(__cmp_cat::_Ord(_M_value)); }

[[nodiscard]]
constexpr operator weak_ordering() const noexcept
{ return weak_ordering(__cmp_cat::_Ord(_M_value)); }

[[nodiscard]]
friend constexpr bool
operator==(strong_ordering __v, __cmp_cat::__unspec) noexcept
{ return __v._M_value == 0; }

[[nodiscard]]
friend constexpr bool
operator==(strong_ordering, strong_ordering) noexcept = default;

[[nodiscard]]
friend constexpr bool
operator< (strong_ordering __v, __cmp_cat::__unspec) noexcept
{ return __v._M_value < 0; }

[[nodiscard]]
friend constexpr bool
operator> (strong_ordering __v, __cmp_cat::__unspec) noexcept
{ return __v._M_value > 0; }

[[nodiscard]]
friend constexpr bool
operator<=(strong_ordering __v, __cmp_cat::__unspec) noexcept
{ return __v._M_value <= 0; }

[[nodiscard]]
friend constexpr bool
operator>=(strong_ordering __v, __cmp_cat::__unspec) noexcept
{ return __v._M_value >= 0; }

[[nodiscard]]
friend constexpr bool
operator< (__cmp_cat::__unspec, strong_ordering __v) noexcept
{ return 0 < __v._M_value; }

[[nodiscard]]
friend constexpr bool
operator> (__cmp_cat::__unspec, strong_ordering __v) noexcept
{ return 0 > __v._M_value; }

[[nodiscard]]
friend constexpr bool
operator<=(__cmp_cat::__unspec, strong_ordering __v) noexcept
{ return 0 <= __v._M_value; }

[[nodiscard]]
friend constexpr bool
operator>=(__cmp_cat::__unspec, strong_ordering __v) noexcept
{ return 0 >= __v._M_value; }

[[nodiscard]]
friend constexpr strong_ordering
operator<=>(strong_ordering __v, __cmp_cat::__unspec) noexcept
{ return __v; }

[[nodiscard]]
friend constexpr strong_ordering
operator<=>(__cmp_cat::__unspec, strong_ordering __v) noexcept
{ return strong_ordering(__cmp_cat::_Ord(-__v._M_value)); }
};

inline constexpr strong_ordering

strong_ordering::less(__cmp_cat::_Ord::less);

inline constexpr strong_ordering

strong_ordering::equal(__cmp_cat::_Ord::equivalent);

inline constexpr strong_ordering

strong_ordering::equivalent(__cmp_cat::_Ord::equivalent);

inline constexpr strong_ordering

strong_ordering::greater(__cmp_cat::_Ord::greater);

[[nodiscard]]
constexpr bool
is_eq(partial_ordering __cmp) noexcept
{ return __cmp == 0; }
[[nodiscard]]
constexpr bool
is_neq(partial_ordering __cmp) noexcept
{ return __cmp != 0; }

[[nodiscard]]
constexpr bool
is_lt (partial_ordering __cmp) noexcept
{ return __cmp < 0; }

[[nodiscard]]
constexpr bool
is_lteq(partial_ordering __cmp) noexcept
{ return __cmp <= 0; }

[[nodiscard]]
constexpr bool
is_gt (partial_ordering __cmp) noexcept
{ return __cmp > 0; }

[[nodiscard]]
constexpr bool
is_gteq(partial_ordering __cmp) noexcept
{ return __cmp >= 0; }

namespace __detail
{
template<typename _Tp>
inline constexpr unsigned __cmp_cat_id = 1;
template<>
inline constexpr unsigned __cmp_cat_id<partial_ordering> = 2;
template<>
inline constexpr unsigned __cmp_cat_id<weak_ordering> = 4;
template<>
inline constexpr unsigned __cmp_cat_id<strong_ordering> = 8;

template<typename... _Ts>
constexpr auto __common_cmp_cat()
{
constexpr unsigned __cats = (__cmp_cat_id<_Ts> | ...);

if constexpr (__cats & 1)

return;

else if constexpr (bool(cats & cmp_cat_id<partial_ordering>))

return partial_ordering::equivalent;

else if constexpr (bool(cats & cmp_cat_id<weak_ordering>))

return weak_ordering::equivalent;

else
return strong_ordering::equivalent;
}
}

template<typename... _Ts>
struct common_comparison_category
{
using type = decltype(__detail::__common_cmp_cat<_Ts...>());
};

template<typename _Tp>
struct common_comparison_category<_Tp>
{ using type = void; };

template<>
struct common_comparison_category<partial_ordering>
{ using type = partial_ordering; };

template<>
struct common_comparison_category<weak_ordering>
{ using type = weak_ordering; };

template<>
struct common_comparison_category<strong_ordering>
{ using type = strong_ordering; };

template<>
struct common_comparison_category<>
{ using type = strong_ordering; };

template<typename... _Ts>
using common_comparison_category_t
= typename common_comparison_category<_Ts...>::type;

namespace __detail
{
template<typename _Tp, typename _Cat>
concept __compares_as
= same_as<common_comparison_category_t<_Tp, _Cat>, _Cat>;
}

template<typename _Tp, typename _Cat = partial_ordering>

concept three_way_comparable
= __detail::__weakly_eq_cmp_with<_Tp, _Tp>
&& __detail::__partially_ordered_with<_Tp, _Tp>
&& requires(const remove_reference_t<_Tp>& __a,
const remove_reference_t<_Tp>& __b)
{
{ __a <=> __b } -> __detail::__compares_as<_Cat>;
};

template<typename _Tp, typename _Up, typename _Cat = partial_ordering>

concept three_way_comparable_with
= three_way_comparable<_Tp, _Cat>
&& three_way_comparable<_Up, _Cat>
&& common_reference_with<const remove_reference_t<_Tp>&,
const remove_reference_t<_Up>&>
&& three_way_comparable<
common_reference_t<const remove_reference_t<_Tp>&,
const remove_reference_t<_Up>&>, _Cat>
&& __detail::__weakly_eq_cmp_with<_Tp, _Up>
&& __detail::__partially_ordered_with<_Tp, _Up>
&& requires(const remove_reference_t<_Tp>& __t,
const remove_reference_t<_Up>& __u)
{
{ __t <=> __u } -> __detail::__compares_as<_Cat>;
{ __u <=> __t } -> __detail::__compares_as<_Cat>;
};

namespace __detail
{
template<typename _Tp, typename _Up>
using __cmp3way_res_t
= decltype(std::declval<_Tp>() <=> std::declval<_Up>());

template<typename _Tp, typename _Up>

struct __cmp3way_res_impl
{ };

template<typename _Tp, typename _Up>

requires requires { typename __cmp3way_res_t<__cref<_Tp>, __cref<_Up>>; }
struct __cmp3way_res_impl<_Tp, _Up>
{
using type = __cmp3way_res_t<__cref<_Tp>, __cref<_Up>>;
};
}

template<typename _Tp, typename _Up = _Tp>

struct compare_three_way_result
: __detail::__cmp3way_res_impl<_Tp, _Up>
{ };

template<typename _Tp, typename _Up = _Tp>

using compare_three_way_result_t
= typename __detail::__cmp3way_res_impl<_Tp, _Up>::type;

namespace __detail
{

template<typename _Tp, typename _Up>

concept __3way_builtin_ptr_cmp
= requires(_Tp&& __t, _Up&& __u)
{ static_cast<_Tp&&>(__t) <=> static_cast<_Up&&>(__u); }
&& convertible_to<_Tp, const volatile void*>
&& convertible_to<_Up, const volatile void*>
&& ! requires(_Tp&& __t, _Up&& __u)
{ operator<=>(static_cast<_Tp&&>(__t), static_cast<_Up&&>(__u)); }
&& ! requires(_Tp&& __t, _Up&& __u)
{ static_cast<_Tp&&>(__t).operator<=>(static_cast<_Up&&>(__u)); };
}

struct compare_three_way
{
template<typename _Tp, typename _Up>
requires three_way_comparable_with<_Tp, _Up>
constexpr auto
operator() [[nodiscard]] (_Tp&& __t, _Up&& __u) const
noexcept(noexcept(std::declval<_Tp>() <=> std::declval<_Up>()))
{
if constexpr (__detail::__3way_builtin_ptr_cmp<_Tp, _Up>)
{
auto __pt = static_cast<const volatile void*>(__t);
auto __pu = static_cast<const volatile void*>(__u);
if (std::__is_constant_evaluated())
return __pt <=> __pu;
auto __it = reinterpret_cast<long long unsigned int>(__pt);
auto __iu = reinterpret_cast<long long unsigned int>(__pu);
return __it <=> __iu;
}
else
return static_cast<_Tp&&>(__t) <=> static_cast<_Up&&>(__u);
}

using is_transparent = void;

};

namespace __compare
{
template<floating_point _Tp>
constexpr weak_ordering
__fp_weak_ordering(_Tp __e, _Tp __f)
{

auto __cat = [](_Tp __fp) -> int {

const int __sign = __builtin_signbit(__fp) ? -1 : 1;
if (__builtin_isnormal(__fp))
return (__fp == 0 ? 1 : 3) * __sign;
if (__builtin_isnan(__fp))
return 5 * __sign;
if (int __inf = __builtin_isinf_sign(__fp))
return 4 * __inf;
return 2 * __sign;
};

auto po = e <=> __f;

if (is_lt(__po))
return weak_ordering::less;
else if (is_gt(__po))
return weak_ordering::greater;
else if (__po == partial_ordering::equivalent)
return weak_ordering::equivalent;
else
{

auto __isnan_sign = [](_Tp __fp) -> int {

return __builtin_isnan(__fp)
? __builtin_signbit(__fp) ? -1 : 1
: 0;
};
auto __ord = __isnan_sign(__e) <=> __isnan_sign(__f);
if (is_eq(__ord))
return weak_ordering::equivalent;
else if (is_lt(__ord))
return weak_ordering::less;
else
return weak_ordering::greater;
}
}

void strong_order() = delete;

template<typename _Tp, typename _Up>

concept __adl_strong = requires(_Tp&& __t, _Up&& __u)
{
strong_ordering(strong_order(static_cast<_Tp&&>(__t),
static_cast<_Up&&>(__u)));
};

void weak_order() = delete;

template<typename _Tp, typename _Up>

concept __adl_weak = requires(_Tp&& __t, _Up&& __u)
{
weak_ordering(weak_order(static_cast<_Tp&&>(__t),
static_cast<_Up&&>(__u)));
};

void partial_order() = delete;

template<typename _Tp, typename _Up>

concept __adl_partial = requires(_Tp&& __t, _Up&& __u)
{
partial_ordering(partial_order(static_cast<_Tp&&>(__t),
static_cast<_Up&&>(__u)));
};

template<typename _Ord, typename _Tp, typename _Up>

concept __cmp3way = requires(_Tp&& __t, _Up&& __u, compare_three_way __c)
{
_Ord(__c(static_cast<_Tp&&>(__t), static_cast<_Up&&>(__u)));
};

template<typename _Tp, typename _Up>

concept __strongly_ordered
= __adl_strong<_Tp, _Up>
|| floating_point<remove_reference_t<_Tp>>
|| __cmp3way<strong_ordering, _Tp, _Up>;

template<typename _Tp, typename _Up>

concept __decayed_same_as = same_as<decay_t<_Tp>, decay_t<_Up>>;

class _Strong_order
{
template<typename _Tp, typename _Up>
static constexpr bool
_S_noexcept()
{
if constexpr (floating_point<decay_t<_Tp>>)
return true;
else if constexpr (__adl_strong<_Tp, _Up>)
return noexcept(strong_ordering(strong_order(std::declval<_Tp>(),
std::declval<_Up>())));
else if constexpr (__cmp3way<strong_ordering, _Tp, _Up>)
return noexcept(compare_three_way()(std::declval<_Tp>(),
std::declval<_Up>()));
}

friend class _Weak_order;

friend class _Strong_fallback;

enum class _Fp_fmt

{
_Binary16, _Binary32, _Binary64, _Binary128,
_X86_80bit,
_M68k_80bit,
_Dbldbl,
_Bfloat16,
};
# 699 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/compare" 3
template<typename _Tp>
static consteval _Fp_fmt
_S_fp_fmt() noexcept
{

using enum _Fp_fmt;

# 719 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/compare" 3
if constexpr (__is_same(_Tp, long double))
return (-16381) == -16381 ? _X86_80bit : _M68k_80bit;

if constexpr (__is_same(_Tp, __float80))

return _X86_80bit;

if constexpr (__is_same(_Tp, decltype(0.0bf16)))

return _Bfloat16;

constexpr int __width = sizeof(_Tp) * 8;

if constexpr (__width == 16)

return _Binary16;
else if constexpr (__width == 32)
return _Binary32;
else if constexpr (__width == 64)
return _Binary64;
else if constexpr (__width == 128)
return _Binary128;
}

using int64_t = long long int;

using int32_t = int;
using int16_t = short int;
using uint64_t = long long unsigned int;
using uint16_t = short unsigned int;

template<typename _Tp>
struct _Int
{

uint64_t _M_lo;
_Tp _M_hi;

constexpr explicit
_Int(_Tp __hi, uint64_t __lo) noexcept : _M_hi(__hi)
{ _M_lo = __lo; }

constexpr explicit
_Int(uint64_t __lo) noexcept : _M_hi(0)
{ _M_lo = __lo; }

constexpr bool operator==(const _Int&) const = default;

# 781 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/compare" 3
constexpr _Int&
operator^=(const _Int& __rhs) noexcept
{
_M_hi ^= __rhs._M_hi;
_M_lo ^= __rhs._M_lo;
return *this;
}

constexpr strong_ordering
operator<=>(const _Int& __rhs) const noexcept
{
strong_ordering __cmp = _M_hi <=> __rhs._M_hi;
if (__cmp != strong_ordering::equal)
return __cmp;
return _M_lo <=> __rhs._M_lo;
}
};

template<typename _Tp>
static constexpr _Tp
_S_compl(_Tp __t) noexcept
{
constexpr int __width = sizeof(_Tp) * 8;

make_unsigned_t<_Tp> sign = t >> (__width - 1);

return __t ^ (__sign >> 1);
}

template<typename _Tp>
static constexpr _Int<_Tp>
_S_compl(_Int<_Tp> __t) noexcept
{
constexpr int __width = sizeof(_Tp) * 8;
make_unsigned_t<_Tp> __sign = __t._M_hi >> (__width - 1);
__t._M_hi ^= (__sign >> 1 );
uint64_t __sign64 = (_Tp)__sign;
__t._M_lo ^= __sign64;
return __t;
}

template<typename _Tp>
constexpr static auto
_S_fp_bits(_Tp __val) noexcept
{
if constexpr (sizeof(_Tp) == sizeof(int64_t))
return __builtin_bit_cast(int64_t, __val);
else if constexpr (sizeof(_Tp) == sizeof(int32_t))
return __builtin_bit_cast(int32_t, __val);
else if constexpr (sizeof(_Tp) == sizeof(int16_t))
return __builtin_bit_cast(int16_t, __val);
else
{

using enum _Fp_fmt;

constexpr auto __fmt = _S_fp_fmt<_Tp>();

if constexpr (__fmt == _X86_80bit || __fmt == _M68k_80bit)
{
if constexpr (sizeof(_Tp) == 3 * sizeof(int32_t))
{
auto __ival = __builtin_bit_cast(_Int<int32_t>, __val);
return _Int<int16_t>(__ival._M_hi, __ival._M_lo);
}
else
{
auto __ival = __builtin_bit_cast(_Int<int64_t>, __val);
return _Int<int16_t>(__ival._M_hi, __ival._M_lo);
}
}
else if constexpr (sizeof(_Tp) == 2 * sizeof(int64_t))
{

return __builtin_bit_cast(int128, val);

}
else
static_assert(sizeof(_Tp) == sizeof(int64_t),
"unsupported floating-point type");
}
}
template<typename _Tp>
static constexpr strong_ordering
_S_fp_cmp(_Tp __x, _Tp __y) noexcept
{
# 885 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/compare" 3
auto __ix = _S_fp_bits(__x);
auto __iy = _S_fp_bits(__y);

if (__ix == __iy)
return strong_ordering::equal;

using enum _Fp_fmt;

constexpr auto __fmt = _S_fp_fmt<_Tp>();

if constexpr (__fmt == _Dbldbl)

{

struct _Unpacked { double _M_hi; int64_t _M_lo; };

auto __x2 = __builtin_bit_cast(_Unpacked, __x);
auto __y2 = __builtin_bit_cast(_Unpacked, __y);

auto __cmp = _S_fp_cmp(__x2._M_hi, __y2._M_hi);

if (__cmp != strong_ordering::equal)
return __cmp;

if (__builtin_isnan(__x2._M_hi))
return strong_ordering::equal;

if (((__x2._M_lo | __y2._M_lo) & 0x7fffffffffffffffULL) == 0)

return strong_ordering::equal;

return _S_compl(__x2._M_lo) <=> _S_compl(__y2._M_lo);

}
else
{
if constexpr (__fmt == _M68k_80bit)
{

constexpr uint16_t __maxexp = 0x7fff;

if ((__ix._M_hi & __maxexp) == __maxexp)
__ix._M_lo |= 1ull << 63;
if ((__iy._M_hi & __maxexp) == __maxexp)
__iy._M_lo |= 1ull << 63;
}
else
{
# 952 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/compare" 3
}
return _S_compl(__ix) <=> _S_compl(__iy);
}
}

public:
template<typename _Tp, __decayed_same_as<_Tp> _Up>
requires __strongly_ordered<_Tp, _Up>
constexpr strong_ordering
operator() [[nodiscard]] (_Tp&& __e, _Up&& __f) const
noexcept(_S_noexcept<_Tp, _Up>())
{
if constexpr (floating_point<decay_t<_Tp>>)
return _S_fp_cmp(__e, __f);
else if constexpr (__adl_strong<_Tp, _Up>)
return strong_ordering(strong_order(static_cast<_Tp&&>(__e),
static_cast<_Up&&>(__f)));
else if constexpr (__cmp3way<strong_ordering, _Tp, _Up>)
return compare_three_way()(static_cast<_Tp&&>(__e),
static_cast<_Up&&>(__f));
}
};

template<typename _Tp, typename _Up>

concept __weakly_ordered
= floating_point<remove_reference_t<_Tp>>
|| __adl_weak<_Tp, _Up>
|| __cmp3way<weak_ordering, _Tp, _Up>
|| __strongly_ordered<_Tp, _Up>;

class _Weak_order
{
template<typename _Tp, typename _Up>
static constexpr bool
_S_noexcept()
{
if constexpr (floating_point<decay_t<_Tp>>)
return true;
else if constexpr (__adl_weak<_Tp, _Up>)
return noexcept(weak_ordering(weak_order(std::declval<_Tp>(),
std::declval<_Up>())));
else if constexpr (__cmp3way<weak_ordering, _Tp, _Up>)
return noexcept(compare_three_way()(std::declval<_Tp>(),
std::declval<_Up>()));
else if constexpr (__strongly_ordered<_Tp, _Up>)
return _Strong_order::_S_noexcept<_Tp, _Up>();
}

friend class _Partial_order;

friend class _Weak_fallback;

public:
template<typename _Tp, __decayed_same_as<_Tp> _Up>
requires __weakly_ordered<_Tp, _Up>
constexpr weak_ordering
operator() [[nodiscard]] (_Tp&& __e, _Up&& __f) const
noexcept(_S_noexcept<_Tp, _Up>())
{
if constexpr (floating_point<decay_t<_Tp>>)
return __compare::__fp_weak_ordering(__e, __f);
else if constexpr (__adl_weak<_Tp, _Up>)
return weak_ordering(weak_order(static_cast<_Tp&&>(__e),
static_cast<_Up&&>(__f)));
else if constexpr (__cmp3way<weak_ordering, _Tp, _Up>)
return compare_three_way()(static_cast<_Tp&&>(__e),
static_cast<_Up&&>(__f));
else if constexpr (__strongly_ordered<_Tp, _Up>)
return _Strong_order{}(static_cast<_Tp&&>(__e),
static_cast<_Up&&>(__f));
}
};

template<typename _Tp, typename _Up>

concept __partially_ordered
= __adl_partial<_Tp, _Up>
|| __cmp3way<partial_ordering, _Tp, _Up>
|| __weakly_ordered<_Tp, _Up>;

class _Partial_order
{
template<typename _Tp, typename _Up>
static constexpr bool
_S_noexcept()
{
if constexpr (__adl_partial<_Tp, _Up>)
return noexcept(partial_ordering(partial_order(std::declval<_Tp>(),
std::declval<_Up>())));
else if constexpr (__cmp3way<partial_ordering, _Tp, _Up>)
return noexcept(compare_three_way()(std::declval<_Tp>(),
std::declval<_Up>()));
else if constexpr (__weakly_ordered<_Tp, _Up>)
return _Weak_order::_S_noexcept<_Tp, _Up>();
}

friend class _Partial_fallback;

public:
template<typename _Tp, __decayed_same_as<_Tp> _Up>
requires __partially_ordered<_Tp, _Up>
constexpr partial_ordering
operator() [[nodiscard]] (_Tp&& __e, _Up&& __f) const
noexcept(_S_noexcept<_Tp, _Up>())
{
if constexpr (__adl_partial<_Tp, _Up>)
return partial_ordering(partial_order(static_cast<_Tp&&>(__e),
static_cast<_Up&&>(__f)));
else if constexpr (__cmp3way<partial_ordering, _Tp, _Up>)
return compare_three_way()(static_cast<_Tp&&>(__e),
static_cast<_Up&&>(__f));
else if constexpr (__weakly_ordered<_Tp, _Up>)
return _Weak_order{}(static_cast<_Tp&&>(__e),
static_cast<_Up&&>(__f));
}
};

template<typename _Tp, typename _Up>

concept __op_eq_lt = requires(_Tp&& __t, _Up&& __u)
{
{ static_cast<_Tp&&>(__t) == static_cast<_Up&&>(__u) }
-> convertible_to<bool>;
{ static_cast<_Tp&&>(__t) < static_cast<_Up&&>(__u) }
-> convertible_to<bool>;
};

class _Strong_fallback
{
template<typename _Tp, typename _Up>
static constexpr bool
_S_noexcept()
{
if constexpr (__strongly_ordered<_Tp, _Up>)
return _Strong_order::_S_noexcept<_Tp, _Up>();
else
return noexcept(bool(std::declval<_Tp>() == std::declval<_Up>()))
&& noexcept(bool(std::declval<_Tp>() < std::declval<_Up>()));
}

public:
template<typename _Tp, __decayed_same_as<_Tp> _Up>
requires __strongly_ordered<_Tp, _Up> || __op_eq_lt<_Tp, _Up>
constexpr strong_ordering
operator() [[nodiscard]] (_Tp&& __e, _Up&& __f) const
noexcept(_S_noexcept<_Tp, _Up>())
{
if constexpr (__strongly_ordered<_Tp, _Up>)
return _Strong_order{}(static_cast<_Tp&&>(__e),
static_cast<_Up&&>(__f));
else
return static_cast<_Tp&&>(__e) == static_cast<_Up&&>(__f)
? strong_ordering::equal
: static_cast<_Tp&&>(__e) < static_cast<_Up&&>(__f)
? strong_ordering::less
: strong_ordering::greater;
}
};

class _Weak_fallback
{
template<typename _Tp, typename _Up>
static constexpr bool
_S_noexcept()
{
if constexpr (__weakly_ordered<_Tp, _Up>)
return _Weak_order::_S_noexcept<_Tp, _Up>();
else
return noexcept(bool(std::declval<_Tp>() == std::declval<_Up>()))
&& noexcept(bool(std::declval<_Tp>() < std::declval<_Up>()));
}

public:
template<typename _Tp, __decayed_same_as<_Tp> _Up>
requires __weakly_ordered<_Tp, _Up> || __op_eq_lt<_Tp, _Up>
constexpr weak_ordering
operator() [[nodiscard]] (_Tp&& __e, _Up&& __f) const
noexcept(_S_noexcept<_Tp, _Up>())
{
if constexpr (__weakly_ordered<_Tp, _Up>)
return _Weak_order{}(static_cast<_Tp&&>(__e),
static_cast<_Up&&>(__f));
else
return static_cast<_Tp&&>(__e) == static_cast<_Up&&>(__f)
? weak_ordering::equivalent
: static_cast<_Tp&&>(__e) < static_cast<_Up&&>(__f)
? weak_ordering::less
: weak_ordering::greater;
}
};

template<typename _Tp, typename _Up>

concept __op_eq_lt_lt = __op_eq_lt<_Tp, _Up>
&& requires(_Tp&& __t, _Up&& __u)
{
{ static_cast<_Up&&>(__u) < static_cast<_Tp&&>(__t) }
-> convertible_to<bool>;
};

class _Partial_fallback
{
template<typename _Tp, typename _Up>
static constexpr bool
_S_noexcept()
{
if constexpr (__partially_ordered<_Tp, _Up>)
return _Partial_order::_S_noexcept<_Tp, _Up>();
else
return noexcept(bool(std::declval<_Tp>() == std::declval<_Up>()))
&& noexcept(bool(std::declval<_Tp>() < std::declval<_Up>()));
}

public:
template<typename _Tp, __decayed_same_as<_Tp> _Up>
requires __partially_ordered<_Tp, _Up> || __op_eq_lt_lt<_Tp, _Up>
constexpr partial_ordering
operator() [[nodiscard]] (_Tp&& __e, _Up&& __f) const
noexcept(_S_noexcept<_Tp, _Up>())
{
if constexpr (__partially_ordered<_Tp, _Up>)
return _Partial_order{}(static_cast<_Tp&&>(__e),
static_cast<_Up&&>(__f));
else
return static_cast<_Tp&&>(__e) == static_cast<_Up&&>(__f)
? partial_ordering::equivalent
: static_cast<_Tp&&>(__e) < static_cast<_Up&&>(__f)
? partial_ordering::less
: static_cast<_Up&&>(__f) < static_cast<_Tp&&>(__e)
? partial_ordering::greater
: partial_ordering::unordered;
}
};
}

inline namespace _Cpo

{
inline constexpr __compare::_Strong_order strong_order{};

inline constexpr __compare::_Weak_order weak_order{};

inline constexpr __compare::_Partial_order partial_order{};

inline constexpr __compare::_Strong_fallback

compare_strong_order_fallback{};

inline constexpr __compare::_Weak_fallback

compare_weak_order_fallback{};

inline constexpr __compare::_Partial_fallback

compare_partial_order_fallback{};
}

namespace __detail
{

inline constexpr struct _Synth3way

{
template<typename _Tp, typename _Up>
static constexpr bool
_S_noexcept(const _Tp* __t = nullptr, const _Up* __u = nullptr)
{
if constexpr (three_way_comparable_with<_Tp, _Up>)
return noexcept(*__t <=> *__u);
else
return noexcept(*__t < *__u) && noexcept(*__u < *__t);
}

template<typename _Tp, typename _Up>

[[nodiscard]]
constexpr auto
operator()(const _Tp& __t, const _Up& __u) const
noexcept(_S_noexcept<_Tp, _Up>())
requires requires
{
{ __t < __u } -> __boolean_testable;
{ __u < __t } -> __boolean_testable;
}
{
if constexpr (three_way_comparable_with<_Tp, _Up>)
return __t <=> __u;
else
{
if (__t < __u)
return weak_ordering::less;
else if (__u < __t)
return weak_ordering::greater;
else
return weak_ordering::equivalent;
}
}
} __synth3way = {};

template<typename _Tp, typename _Up = _Tp>

using __synth3way_t
= decltype(__detail::__synth3way(std::declval<_Tp&>(),
std::declval<_Up&>()));
}

}
# 39 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/array" 2 3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/initializer_list" 1 3
# 33 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/initializer_list" 3

# 34 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/initializer_list" 3

namespace std
{

template<class _E>
class initializer_list
{
public:
typedef _E value_type;
typedef const _E& reference;
typedef const _E& const_reference;
typedef size_t size_type;
typedef const _E* iterator;
typedef const _E* const_iterator;

private:
iterator _M_array;
size_type _M_len;

constexpr initializer_list(const_iterator __a, size_type __l)

: _M_array(__a), _M_len(__l) { }

public:
constexpr initializer_list() noexcept
: _M_array(0), _M_len(0) { }

constexpr size_type
size() const noexcept { return _M_len; }

constexpr const_iterator
begin() const noexcept { return _M_array; }

constexpr const_iterator
end() const noexcept { return begin() + size(); }
};
template<class _Tp>
constexpr const _Tp*
begin(initializer_list<_Tp> __ils) noexcept
{ return __ils.begin(); }

template<class _Tp>
constexpr const _Tp*
end(initializer_list<_Tp> __ils) noexcept
{ return __ils.end(); }
}
# 40 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/array" 2 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/functexcept.h" 1 3
# 40 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/functexcept.h" 3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/exception_defines.h" 1 3
# 41 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/functexcept.h" 2 3

namespace std
{

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__,__cold__));

void
__throw_bad_typeid(void) __attribute__((__noreturn__,__cold__));

void
__throw_logic_error(const char*) __attribute__((__noreturn__,__cold__));

void
__throw_domain_error(const char*) __attribute__((__noreturn__,__cold__));
void
__throw_invalid_argument(const char*) __attribute__((__noreturn__,__cold__));

void
__throw_length_error(const char*) __attribute__((__noreturn__,__cold__));

void
__throw_out_of_range(const char*) __attribute__((__noreturn__,__cold__));

void
__throw_out_of_range_fmt(const char*, ...) __attribute__((__noreturn__,__cold__))
__attribute__((__format__(__gnu_printf__, 1, 2)));

void
__throw_runtime_error(const char*) __attribute__((__noreturn__,__cold__));

void
__throw_range_error(const char*) __attribute__((__noreturn__,__cold__));

void
__throw_overflow_error(const char*) __attribute__((__noreturn__,__cold__));

void
__throw_underflow_error(const char*) __attribute__((__noreturn__,__cold__));

void
__throw_ios_failure(const char*) __attribute__((__noreturn__,__cold__));

void
__throw_ios_failure(const char*, int) __attribute__((__noreturn__,__cold__));

void
__throw_system_error(int) __attribute__((__noreturn__,__cold__));

void
__throw_future_error(int) __attribute__((__noreturn__,__cold__));

void
__throw_bad_function_call() __attribute__((__noreturn__,__cold__));
# 140 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/functexcept.h" 3

}
# 43 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/array" 2 3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algobase.h" 1 3
# 61 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algobase.h" 3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/cpp_type_traits.h" 1 3
# 35 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/cpp_type_traits.h" 3

# 36 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/cpp_type_traits.h" 3
# 67 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/cpp_type_traits.h" 3
extern "C++" {

namespace std
{
struct __true_type { };
struct __false_type { };

template<bool>
struct __truth_type
{ typedef __false_type __type; };

template<>
struct __truth_type<true>
{ typedef __true_type __type; };

template<class _Sp, class _Tp>

struct __traitor
{
enum { __value = bool(_Sp::__value) || bool(_Tp::__value) };
typedef typename __truth_type<__value>::__type __type;
};

template<typename, typename>
struct __are_same
{
enum { __value = 0 };
typedef __false_type __type;
};

template<typename _Tp>
struct __are_same<_Tp, _Tp>
{
enum { __value = 1 };
typedef __true_type __type;
};

template<typename _Tp>
struct __is_void
{
enum { __value = 0 };
typedef __false_type __type;
};

template<>
struct __is_void<void>
{
enum { __value = 1 };
typedef __true_type __type;
};

template<typename _Tp>
struct __is_integer
{
enum { __value = 0 };
typedef __false_type __type;
};

template<>
struct __is_integer<bool>
{
enum { __value = 1 };
typedef __true_type __type;
};

template<>
struct __is_integer<char>
{
enum { __value = 1 };
typedef __true_type __type;
};

template<>
struct __is_integer<signed char>
{
enum { __value = 1 };
typedef __true_type __type;
};

template<>
struct __is_integer<unsigned char>
{
enum { __value = 1 };
typedef __true_type __type;
};

template<>
struct __is_integer<wchar_t>
{
enum { __value = 1 };
typedef __true_type __type;
};

template<>
struct __is_integer<char8_t>
{
enum { __value = 1 };
typedef __true_type __type;
};

template<>
struct __is_integer<char16_t>
{
enum { __value = 1 };
typedef __true_type __type;
};
template<>
struct __is_integer<char32_t>
{
enum { __value = 1 };
typedef __true_type __type;
};

template<>
struct __is_integer<short>
{
enum { __value = 1 };
typedef __true_type __type;
};

template<>
struct __is_integer<unsigned short>
{
enum { __value = 1 };
typedef __true_type __type;
};

template<>
struct __is_integer<int>
{
enum { __value = 1 };
typedef __true_type __type;
};

template<>
struct __is_integer<unsigned int>
{
enum { __value = 1 };
typedef __true_type __type;
};

template<>
struct __is_integer<long>
{
enum { __value = 1 };
typedef __true_type __type;
};

template<>
struct __is_integer<unsigned long>
{
enum { __value = 1 };
typedef __true_type __type;
};

template<>
struct __is_integer<long long>
{
enum { __value = 1 };
typedef __true_type __type;
};

template<>
struct __is_integer<unsigned long long>
{
enum { __value = 1 };
typedef __true_type __type;
};
# 272 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/cpp_type_traits.h" 3
__extension__ template<> struct __is_integer<__int128> { enum { __value = 1 };
typedef __true_type __type; }; __extension__ template<> struct
__is_integer<unsigned __int128> { enum { __value = 1 }; typedef __true_type __type;
};
# 289 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/cpp_type_traits.h" 3
template<typename _Tp>
struct __is_floating
{
enum { __value = 0 };
typedef __false_type __type;
};

template<>
struct __is_floating<float>
{
enum { __value = 1 };
typedef __true_type __type;
};

template<>
struct __is_floating<double>
{
enum { __value = 1 };
typedef __true_type __type;
};

template<>
struct __is_floating<long double>
{
enum { __value = 1 };
typedef __true_type __type;
};

template<>
struct __is_floating<_Float16>
{
enum { __value = 1 };
typedef __true_type __type;
};

template<>
struct __is_floating<_Float32>
{
enum { __value = 1 };
typedef __true_type __type;
};
template<>
struct __is_floating<_Float64>
{
enum { __value = 1 };
typedef __true_type __type;
};

template<>
struct __is_floating<_Float128>
{
enum { __value = 1 };
typedef __true_type __type;
};

template<>
struct __is_floating<__gnu_cxx::__bfloat16_t>
{
enum { __value = 1 };
typedef __true_type __type;
};

template<typename _Tp>
struct __is_pointer
{
enum { __value = 0 };
typedef __false_type __type;
};

template<typename _Tp>
struct __is_pointer<_Tp*>
{
enum { __value = 1 };
typedef __true_type __type;
};

template<typename _Tp>
struct __is_arithmetic
: public __traitor<__is_integer<_Tp>, __is_floating<_Tp> >
{ };

template<typename _Tp>
struct __is_scalar
: public __traitor<__is_arithmetic<_Tp>, __is_pointer<_Tp> >
{ };
template<typename _Tp>
struct __is_char
{
enum { __value = 0 };
typedef __false_type __type;
};

template<>
struct __is_char<char>
{
enum { __value = 1 };
typedef __true_type __type;
};

template<>
struct __is_char<wchar_t>
{
enum { __value = 1 };
typedef __true_type __type;
};

template<typename _Tp>
struct __is_byte
{
enum { __value = 0 };
typedef __false_type __type;
};

template<>
struct __is_byte<char>
{
enum { __value = 1 };
typedef __true_type __type;
};

template<>
struct __is_byte<signed char>
{
enum { __value = 1 };
typedef __true_type __type;
};

template<>
struct __is_byte<unsigned char>
{
enum { __value = 1 };
typedef __true_type __type;
};

enum class byte : unsigned char;

template<>
struct __is_byte<byte>
{
enum { __value = 1 };
typedef __true_type __type;
};

template<>
struct __is_byte<char8_t>
{
enum { __value = 1 };
typedef __true_type __type;
};

template<typename> struct iterator_traits;

template<typename _Tp>
struct __is_nonvolatile_trivially_copyable
{
enum { __value = __is_trivially_copyable(_Tp) };
};

template<typename _Tp>
struct __is_nonvolatile_trivially_copyable<volatile _Tp>
{
enum { __value = 0 };
};

template<typename _OutputIter, typename _InputIter>

struct __memcpyable
{
enum { __value = 0 };
};

template<typename _Tp>
struct __memcpyable<_Tp*, _Tp*>
: __is_nonvolatile_trivially_copyable<_Tp>
{ };

template<typename _Tp>
struct __memcpyable<_Tp*, const _Tp*>
: __is_nonvolatile_trivially_copyable<_Tp>
{ };

template<typename _Iter1, typename _Iter2>

struct __memcmpable
{
enum { __value = 0 };
};

template<typename _Tp>
struct __memcmpable<_Tp*, _Tp*>
: __is_nonvolatile_trivially_copyable<_Tp>
{ };

template<typename _Tp>
struct __memcmpable<const _Tp*, _Tp*>
: __is_nonvolatile_trivially_copyable<_Tp>
{ };

template<typename _Tp>
struct __memcmpable<_Tp*, const _Tp*>
: __is_nonvolatile_trivially_copyable<_Tp>
{ };

template<typename _Tp, bool _TreatAsBytes =

__is_byte<_Tp>::__value

>
struct __is_memcmp_ordered
{
static const bool __value = _Tp(-1) > _Tp(1);
};

template<typename _Tp>
struct __is_memcmp_ordered<_Tp, false>
{
static const bool __value = false;
};

template<typename _Tp, typename _Up, bool = sizeof(_Tp) == sizeof(_Up)>

struct __is_memcmp_ordered_with
{
static const bool __value = __is_memcmp_ordered<_Tp>::__value
&& __is_memcmp_ordered<_Up>::__value;
};

template<typename _Tp, typename _Up>

struct __is_memcmp_ordered_with<_Tp, _Up, false>
{
static const bool __value = false;
};
# 579 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/cpp_type_traits.h" 3
template<>
struct __is_memcmp_ordered_with<std::byte, std::byte, true>
{ static constexpr bool __value = true; };
template<typename _Tp, bool _SameSize>
struct __is_memcmp_ordered_with<_Tp, std::byte, _SameSize>
{ static constexpr bool __value = false; };

template<typename _Up, bool _SameSize>

struct __is_memcmp_ordered_with<std::byte, _Up, _SameSize>
{ static constexpr bool __value = false; };

template<typename _Tp>
struct __is_move_iterator
{
enum { __value = 0 };
typedef __false_type __type;
};

template<typename _Iterator>
constexpr
inline _Iterator
__miter_base(_Iterator __it)
{ return __it; }

}
}
# 62 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algobase.h" 2 3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/ext/type_traits.h" 1 3
# 32 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/ext/type_traits.h" 3

# 33 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/ext/type_traits.h" 3

extern "C++" {

namespace __gnu_cxx
{

template<bool, typename>
struct __enable_if
{ };

template<typename _Tp>
struct __enable_if<true, _Tp>
{ typedef _Tp __type; };

template<bool _Cond, typename _Iftrue, typename _Iffalse>

struct __conditional_type
{ typedef _Iftrue __type; };

template<typename _Iftrue, typename _Iffalse>

struct __conditional_type<false, _Iftrue, _Iffalse>
{ typedef _Iffalse __type; };

template<typename _Tp>
struct __add_unsigned
{
private:
typedef __enable_if<std::__is_integer<_Tp>::__value, _Tp> __if_type;

public:
typedef typename __if_type::__type __type;
};

template<>
struct __add_unsigned<char>
{ typedef unsigned char __type; };

template<>
struct __add_unsigned<signed char>
{ typedef unsigned char __type; };

template<>
struct __add_unsigned<short>
{ typedef unsigned short __type; };

template<>
struct __add_unsigned<int>
{ typedef unsigned int __type; };

template<>
struct __add_unsigned<long>
{ typedef unsigned long __type; };

template<>
struct __add_unsigned<long long>
{ typedef unsigned long long __type; };

template<>
struct __add_unsigned<bool>;

template<>
struct __add_unsigned<wchar_t>;

template<typename _Tp>
struct __remove_unsigned
{
private:
typedef __enable_if<std::__is_integer<_Tp>::__value, _Tp> __if_type;

public:
typedef typename __if_type::__type __type;
};

template<>
struct __remove_unsigned<char>
{ typedef signed char __type; };

template<>
struct __remove_unsigned<unsigned char>
{ typedef signed char __type; };

template<>
struct __remove_unsigned<unsigned short>
{ typedef short __type; };

template<>
struct __remove_unsigned<unsigned int>
{ typedef int __type; };

template<>
struct __remove_unsigned<unsigned long>
{ typedef long __type; };

template<>
struct __remove_unsigned<unsigned long long>
{ typedef long long __type; };

template<>
struct __remove_unsigned<bool>;

template<>
struct __remove_unsigned<wchar_t>;

template<typename _Type>
constexpr
inline bool
__is_null_pointer(_Type* __ptr)
{ return __ptr == 0; }

template<typename _Type>
constexpr
inline bool
__is_null_pointer(_Type)
{ return false; }

constexpr bool
__is_null_pointer(std::nullptr_t)
{ return true; }

template<typename _Tp, bool = std::__is_integer<_Tp>::__value>

struct __promote
{ typedef double __type; };
template<typename _Tp>
struct __promote<_Tp, false>
{ };

template<>
struct __promote<long double>
{ typedef long double __type; };

template<>
struct __promote<double>
{ typedef double __type; };

template<>
struct __promote<float>
{ typedef float __type; };

template<>
struct __promote<_Float16>
{ typedef _Float16 __type; };

template<>
struct __promote<_Float32>
{ typedef _Float32 __type; };

template<>
struct __promote<_Float64>
{ typedef _Float64 __type; };

template<>
struct __promote<_Float128>
{ typedef _Float128 __type; };

template<>
struct __promote<__gnu_cxx::__bfloat16_t>
{ typedef __gnu_cxx::__bfloat16_t __type; };

template<typename... _Tp>
using __promoted_t = decltype((typename __promote<_Tp>::__type(0) + ...));

template<typename _Tp, typename _Up>

using __promote_2 = __promote<__promoted_t<_Tp, _Up>>;
template<typename _Tp, typename _Up, typename _Vp>
using __promote_3 = __promote<__promoted_t<_Tp, _Up, _Vp>>;

template<typename _Tp, typename _Up, typename _Vp, typename _Wp>

using __promote_4 = __promote<__promoted_t<_Tp, _Up, _Vp, _Wp>>;
# 269 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/ext/type_traits.h" 3

}
}
# 63 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algobase.h" 2 3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/ext/numeric_traits.h" 1 3
# 32 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/ext/numeric_traits.h" 3

# 33 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/ext/numeric_traits.h" 3

namespace __gnu_cxx
{

# 50 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/ext/numeric_traits.h" 3
template<typename _Tp>
struct __is_integer_nonstrict
: public std::__is_integer<_Tp>
{
using std::__is_integer<_Tp>::__value;

enum { width = value ? sizeof(_Tp) * 8 : 0 };

};

template<typename _Value>
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<typename _Value>
const _Value __numeric_traits_integer<_Value>::__min;

template<typename _Value>
const _Value __numeric_traits_integer<_Value>::__max;
template<typename _Value>
const bool __numeric_traits_integer<_Value>::__is_signed;

template<typename _Value>
const int __numeric_traits_integer<_Value>::__digits;
# 137 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/ext/numeric_traits.h" 3
template<typename _Tp>
using __int_traits = __numeric_traits_integer<_Tp>;
# 157 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/ext/numeric_traits.h" 3
template<typename _Value>
struct __numeric_traits_floating
{

static const int __max_digits10 = (2 + (std::__are_same<_Value,

float>::__value ? 24 : std::__are_same<_Value, double>::__value ? 53 : 64) * 643L /
2136);

static const bool __is_signed = true;

static const int __digits10 = (std::__are_same<_Value, float>::__value ? 6 :
std::__are_same<_Value, double>::__value ? 15 : 18);
static const int __max_exponent10 = (std::__are_same<_Value,
float>::__value ? 38 : std::__are_same<_Value, double>::__value ? 308 : 4932);
};

template<typename _Value>
const int __numeric_traits_floating<_Value>::__max_digits10;

template<typename _Value>
const bool __numeric_traits_floating<_Value>::__is_signed;

template<typename _Value>
const int __numeric_traits_floating<_Value>::__digits10;

template<typename _Value>
const int __numeric_traits_floating<_Value>::__max_exponent10;

template<typename _Value>
struct __numeric_traits
: public __numeric_traits_integer<_Value>
{ };

template<>
struct __numeric_traits<float>
: public __numeric_traits_floating<float>
{ };

template<>
struct __numeric_traits<double>
: public __numeric_traits_floating<double>
{ };

template<>
struct __numeric_traits<long double>
: public __numeric_traits_floating<long double>
{ };
# 238 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/ext/numeric_traits.h" 3

}
# 64 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algobase.h" 2 3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_pair.h" 1 3
# 61 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_pair.h" 3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/move.h" 1 3
# 40 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/move.h" 3
namespace std
{

template<typename _Tp>
inline constexpr _Tp*
__addressof(_Tp& __r) noexcept
{ return __builtin_addressof(__r); }
# 67 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/move.h" 3
template<typename _Tp>
[[__nodiscard__]]
constexpr _Tp&&
forward(typename std::remove_reference<_Tp>::type& __t) noexcept
{ return static_cast<_Tp&&>(__t); }

template<typename _Tp>
[[__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<typename _Tp, typename _Up>

[[nodiscard]]
constexpr decltype(auto)
forward_like(_Up&& __x) noexcept
{
constexpr bool __as_rval = is_rvalue_reference_v<_Tp&&>;

if constexpr (is_const_v<remove_reference_t<_Tp>>)
{
using _Up2 = remove_reference_t<_Up>;
if constexpr (__as_rval)
return static_cast<const _Up2&&>(__x);
else
return static_cast<const _Up2&>(__x);
}
else
{
if constexpr (__as_rval)
return static_cast<remove_reference_t<_Up>&&>(__x);
else
return static_cast<_Up&>(__x);
}
}

template<typename _Tp, typename _Up>

using __like_t = decltype(std::forward_like<_Tp>(std::declval<_Up>()));

template<typename _Tp>
[[__nodiscard__]]
constexpr typename std::remove_reference<_Tp>::type&&
move(_Tp&& __t) noexcept
{ return static_cast<typename std::remove_reference<_Tp>::type&&>(__t); }

template<typename _Tp>
struct __move_if_noexcept_cond
: public __and_<__not_<is_nothrow_move_constructible<_Tp>>,
is_copy_constructible<_Tp>>::type { };
# 143 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/move.h" 3
template<typename _Tp>
[[__nodiscard__]]
constexpr
__conditional_t<__move_if_noexcept_cond<_Tp>::value, const _Tp&, _Tp&&>
move_if_noexcept(_Tp& __x) noexcept
{ return std::move(__x); }
# 159 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/move.h" 3
template<typename _Tp>
[[__nodiscard__]]
inline constexpr _Tp*
addressof(_Tp& __r) noexcept
{ return std::__addressof(__r); }

template<typename _Tp>
const _Tp* addressof(const _Tp&&) = delete;

template <typename _Tp, typename _Up = _Tp>

constexpr
inline _Tp
__exchange(_Tp& __obj, _Up&& __new_val)
{
_Tp __old_val = std::move(__obj);
__obj = std::forward<_Up>(__new_val);
return __old_val;
}
# 203 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/move.h" 3
template<typename _Tp>
constexpr
inline

typename enable_if<__and_<__not_<__is_tuple_like<_Tp>>,
is_move_constructible<_Tp>,
is_move_assignable<_Tp>>::value>::type

swap(_Tp& __a, _Tp& __b)

noexcept(__and_<is_nothrow_move_constructible<_Tp>,
is_nothrow_move_assignable<_Tp>>::value)

_Tp tmp = std::move(a);

__a = std::move(__b);
__b = std::move(__tmp);
}

template<typename _Tp, size_t _Nm>

constexpr
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 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_pair.h" 2 3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/utility.h" 1 3
# 36 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/utility.h" 3

# 37 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/utility.h" 3
namespace std
{

template<typename _Tp>
struct tuple_size;

template<typename _Tp,
typename _Up = typename remove_cv<_Tp>::type,
typename = typename enable_if<is_same<_Tp, _Up>::value>::type,
size_t = tuple_size<_Tp>::value>
using __enable_if_has_tuple_size = _Tp;

template<typename _Tp>
struct tuple_size<const __enable_if_has_tuple_size<_Tp>>
: public tuple_size<_Tp> { };

template<typename _Tp>
struct tuple_size<volatile __enable_if_has_tuple_size<_Tp>>
: public tuple_size<_Tp> { };

template<typename _Tp>
struct tuple_size<const volatile __enable_if_has_tuple_size<_Tp>>
: public tuple_size<_Tp> { };

template<typename _Tp>
inline constexpr size_t tuple_size_v = tuple_size<_Tp>::value;

template<size_t __i, typename _Tp>

struct tuple_element;

template<size_t __i, typename _Tp>

using __tuple_element_t = typename tuple_element<__i, _Tp>::type;

template<size_t __i, typename _Tp>

struct tuple_element<__i, const _Tp>
{
using type = const __tuple_element_t<__i, _Tp>;
};

template<size_t __i, typename _Tp>

struct tuple_element<__i, volatile _Tp>
{
using type = volatile __tuple_element_t<__i, _Tp>;
};

template<size_t __i, typename _Tp>

struct tuple_element<__i, const volatile _Tp>
{
using type = const volatile __tuple_element_t<__i, _Tp>;
};

template<typename _Tp, typename... _Types>

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 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/utility.h" 3
template<size_t __i, typename _Tp>
using tuple_element_t = typename tuple_element<__i, _Tp>::type;

template<size_t... _Indexes> struct _Index_tuple { };

template<size_t _Num>
struct _Build_index_tuple
{
# 154 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/utility.h" 3
using __type = _Index_tuple<__integer_pack(_Num)...>;

};

template<typename _Tp, _Tp... _Idx>

struct integer_sequence
{

static_assert(is_integral_v<_Tp>);

typedef _Tp value_type;

static constexpr size_t size() noexcept { return sizeof...(_Idx); }
};

template<typename _Tp, _Tp _Num>

using make_integer_sequence
= integer_sequence<_Tp, __integer_pack(_Num)...>;

template<size_t... _Idx>
using index_sequence = integer_sequence<size_t, _Idx...>;

template<size_t _Num>
using make_index_sequence = make_integer_sequence<size_t, _Num>;

template<typename... _Types>
using index_sequence_for = make_index_sequence<sizeof...(_Types)>;

struct in_place_t {
explicit in_place_t() = default;
};

inline constexpr in_place_t in_place{};

template<typename _Tp> struct in_place_type_t

{
explicit in_place_type_t() = default;
};

template<typename _Tp>
inline constexpr in_place_type_t<_Tp> in_place_type{};

template<size_t _Idx> struct in_place_index_t

{
explicit in_place_index_t() = default;
};

template<size_t _Idx>
inline constexpr in_place_index_t<_Idx> in_place_index{};

template<typename>
inline constexpr bool __is_in_place_type_v = false;

template<typename _Tp>
inline constexpr bool __is_in_place_type_v<in_place_type_t<_Tp>> = true;

template<typename _Tp>
using __is_in_place_type = bool_constant<__is_in_place_type_v<_Tp>>;

template<typename>
inline constexpr bool __is_in_place_index_v = false;

template<size_t _Nm>
inline constexpr bool __is_in_place_index_v<in_place_index_t<_Nm>> = true;
template<size_t _Np, typename... _Types>
struct _Nth_type
{ using type = __type_pack_element<_Np, _Types...>; };
# 276 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/utility.h" 3
namespace ranges::__detail
{
template<typename _Range>
inline constexpr bool __is_subrange = false;
}

}
# 63 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_pair.h" 2 3

namespace std
{

# 79 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_pair.h" 3
struct piecewise_construct_t { explicit piecewise_construct_t() = default; };

inline constexpr piecewise_construct_t piecewise_construct =

piecewise_construct_t();

template<typename _T1, typename _T2>

struct pair;

template<typename...>
class tuple;

template<typename _Tp, size_t _Nm>

struct array;

template<size_t...>
struct _Index_tuple;

template<size_t _Int, class _Tp1, class _Tp2>

constexpr typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&
get(pair<_Tp1, _Tp2>& __in) noexcept;

template<size_t _Int, class _Tp1, class _Tp2>

constexpr typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&&
get(pair<_Tp1, _Tp2>&& __in) noexcept;

template<size_t _Int, class _Tp1, class _Tp2>

constexpr const typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&
get(const pair<_Tp1, _Tp2>& __in) noexcept;

template<size_t _Int, class _Tp1, class _Tp2>

constexpr const typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&&
get(const pair<_Tp1, _Tp2>&& __in) noexcept;

template<size_t __i, typename... _Elements>

constexpr __tuple_element_t<__i, tuple<_Elements...>>&
get(tuple<_Elements...>& __t) noexcept;

template<size_t __i, typename... _Elements>

constexpr const __tuple_element_t<__i, tuple<_Elements...>>&
get(const tuple<_Elements...>& __t) noexcept;

template<size_t __i, typename... _Elements>

constexpr __tuple_element_t<__i, tuple<_Elements...>>&&
get(tuple<_Elements...>&& __t) noexcept;

template<size_t __i, typename... _Elements>

constexpr const __tuple_element_t<__i, tuple<_Elements...>>&&
get(const tuple<_Elements...>&& __t) noexcept;

template<size_t _Int, typename _Tp, size_t _Nm>

constexpr _Tp&
get(array<_Tp, _Nm>&) noexcept;

template<size_t _Int, typename _Tp, size_t _Nm>

constexpr _Tp&&
get(array<_Tp, _Nm>&&) noexcept;

template<size_t _Int, typename _Tp, size_t _Nm>

constexpr const _Tp&
get(const array<_Tp, _Nm>&) noexcept;

template<size_t _Int, typename _Tp, size_t _Nm>

constexpr const _Tp&&
get(const array<_Tp, _Nm>&&) noexcept;
# 221 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_pair.h" 3
template<typename _Tp>
inline constexpr bool __is_tuple_v = false;

template<typename... _Ts>
inline constexpr bool __is_tuple_v<tuple<_Ts...>> = true;

template<typename _Tp>
inline constexpr bool __is_tuple_like_v = false;

template<typename... _Elements>
inline constexpr bool __is_tuple_like_v<tuple<_Elements...>> = true;

template<typename _T1, typename _T2>

inline constexpr bool __is_tuple_like_v<pair<_T1, _T2>> = true;

template<typename _Tp, size_t _Nm>

inline constexpr bool __is_tuple_like_v<array<_Tp, _Nm>> = true;
template<typename _Tp>
concept __tuple_like = __is_tuple_like_v<remove_cvref_t<_Tp>>;

template<typename _Tp>
concept __pair_like = __tuple_like<_Tp> && tuple_size_v<remove_cvref_t<_Tp>> ==
2;

template<typename _Tp, typename _Tuple>

concept __eligible_tuple_like
= __detail::__different_from<_Tp, _Tuple> && __tuple_like<_Tp>
&& (tuple_size_v<remove_cvref_t<_Tp>> == tuple_size_v<_Tuple>)
&& !ranges::__detail::__is_subrange<remove_cvref_t<_Tp>>;

template<typename _Tp, typename _Pair>

concept __eligible_pair_like
= __detail::__different_from<_Tp, _Pair> && __pair_like<_Tp>
&& !ranges::__detail::__is_subrange<remove_cvref_t<_Tp>>;

template<typename _U1, typename _U2> class __pair_base

{

};
# 283 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_pair.h" 3
template<typename _T1, typename _T2>
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<typename... _Args1, typename... _Args2>

constexpr
pair(piecewise_construct_t, tuple<_Args1...>, tuple<_Args2...>);

constexpr 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);
}
# 319 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_pair.h" 3
constexpr void
swap(const pair& __p) const
noexcept(__and_v<__is_nothrow_swappable<const _T1>,
__is_nothrow_swappable<const _T2>>)
requires is_swappable_v<const _T1> && is_swappable_v<const _T2>
{
using std::swap;
swap(first, __p.first);
swap(second, __p.second);
}

private:
template<typename... _Args1, size_t... _Indexes1,
typename... _Args2, size_t... _Indexes2>
constexpr
pair(tuple<_Args1...>&, tuple<_Args2...>&,
_Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>);
public:

constexpr
explicit(__not_<__and_<__is_implicitly_default_constructible<_T1>,
__is_implicitly_default_constructible<_T2>>>())
pair()
requires is_default_constructible_v<_T1>
&& is_default_constructible_v<_T2>
: first(), second()
{ }

private:

template<typename _U1, typename _U2>

static constexpr bool
_S_constructible()
{
if constexpr (is_constructible_v<_T1, _U1>)
return is_constructible_v<_T2, _U2>;
return false;
}

template<typename _U1, typename _U2>

static constexpr bool
_S_nothrow_constructible()
{
if constexpr (is_nothrow_constructible_v<_T1, _U1>)
return is_nothrow_constructible_v<_T2, _U2>;
return false;
}

template<typename _U1, typename _U2>

static constexpr bool
_S_convertible()
{
if constexpr (is_convertible_v<_U1, _T1>)
return is_convertible_v<_U2, _T2>;
return false;
}

template<typename _U1, typename _U2>

static constexpr bool
_S_dangles()
{

if constexpr (__reference_constructs_from_temporary(_T1, _U1&&))

return true;
else
return __reference_constructs_from_temporary(_T2, _U2&&);

template<typename _UPair>
static constexpr bool
_S_constructible_from_pair_like()
{
return _S_constructible<decltype(std::get<0>(std::declval<_UPair>())),
decltype(std::get<1>(std::declval<_UPair>()))>();
}

template<typename _UPair>
static constexpr bool
_S_convertible_from_pair_like()
{
return _S_convertible<decltype(std::get<0>(std::declval<_UPair>())),
decltype(std::get<1>(std::declval<_UPair>()))>();
}

template<typename _UPair>
static constexpr bool
_S_dangles_from_pair_like()
{
return _S_dangles<decltype(std::get<0>(std::declval<_UPair>())),
decltype(std::get<1>(std::declval<_UPair>()))>();
}

public:

constexpr explicit(!_S_convertible<const _T1&, const _T2&>())

pair(const _T1& __x, const _T2& __y)
noexcept(_S_nothrow_constructible<const _T1&, const _T2&>())
requires (_S_constructible<const _T1&, const _T2&>())
: first(__x), second(__y)
{ }

template<typename _U1 = _T1, typename _U2 = _T2>

requires (_S_constructible<_U1, _U2>()) && (!_S_dangles<_U1, _U2>())
constexpr explicit(!_S_convertible<_U1, _U2>())
pair(_U1&& __x, _U2&& __y)
noexcept(_S_nothrow_constructible<_U1, _U2>())
: first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y))
{ }

template<typename _U1 = _T1, typename _U2 = _T2>

requires (_S_constructible<_U1, _U2>()) && (_S_dangles<_U1, _U2>())

constexpr explicit(!_S_convertible<_U1, _U2>())
pair(_U1&&, _U2&&) = delete;

template<typename _U1, typename _U2>

requires (_S_constructible<const _U1&, const _U2&>())
&& (!_S_dangles<_U1, _U2>())
constexpr explicit(!_S_convertible<const _U1&, const _U2&>())
pair(const pair<_U1, _U2>& __p)
noexcept(_S_nothrow_constructible<const _U1&, const _U2&>())
: first(__p.first), second(__p.second)
{ }

template<typename _U1, typename _U2>

requires (_S_constructible<const _U1&, const _U2&>())
&& (_S_dangles<const _U1&, const _U2&>())
constexpr explicit(!_S_convertible<const _U1&, const _U2&>())
pair(const pair<_U1, _U2>&) = delete;

template<typename _U1, typename _U2>

requires (_S_constructible<_U1, _U2>()) && (!_S_dangles<_U1, _U2>())
constexpr explicit(!_S_convertible<_U1, _U2>())
pair(pair<_U1, _U2>&& __p)
noexcept(_S_nothrow_constructible<_U1, _U2>())
: first(std::forward<_U1>(__p.first)),
second(std::forward<_U2>(__p.second))
{ }

template<typename _U1, typename _U2>

requires (_S_constructible<_U1, _U2>()) && (_S_dangles<_U1, _U2>())
constexpr explicit(!_S_convertible<_U1, _U2>())
pair(pair<_U1, _U2>&&) = delete;

template<typename _U1, typename _U2>

requires (_S_constructible<_U1&, _U2&>()) && (!_S_dangles<_U1&, _U2&>())
constexpr explicit(!_S_convertible<_U1&, _U2&>())
pair(pair<_U1, _U2>& __p)
noexcept(_S_nothrow_constructible<_U1&, _U2&>())
: first(__p.first), second(__p.second)
{ }
template<typename _U1, typename _U2>
requires (_S_constructible<_U1&, _U2&>()) && (_S_dangles<_U1&, _U2&>())
constexpr explicit(!_S_convertible<_U1&, _U2&>())
pair(pair<_U1, _U2>&) = delete;

template<typename _U1, typename _U2>

requires (_S_constructible<const _U1, const _U2>())
&& (!_S_dangles<const _U1, const _U2>())
constexpr explicit(!_S_convertible<const _U1, const _U2>())
pair(const pair<_U1, _U2>&& __p)
noexcept(_S_nothrow_constructible<const _U1, const _U2>())
: first(std::forward<const _U1>(__p.first)),
second(std::forward<const _U2>(__p.second))
{ }

template<typename _U1, typename _U2>

requires (_S_constructible<const _U1, const _U2>())
&& (_S_dangles<const _U1, const _U2>())
constexpr explicit(!_S_convertible<const _U1, const _U2>())
pair(const pair<_U1, _U2>&&) = delete;

template<__eligible_pair_like<pair> _UPair>
requires (_S_constructible_from_pair_like<_UPair>())
&& (!_S_dangles_from_pair_like<_UPair>())
constexpr explicit(!_S_convertible_from_pair_like<_UPair>())
pair(_UPair&& __p)
: first(std::get<0>(std::forward<_UPair>(__p))),
second(std::get<1>(std::forward<_UPair>(__p)))
{ }

template<__eligible_pair_like<pair> _UPair>
requires (_S_constructible_from_pair_like<_UPair>())
&& (_S_dangles_from_pair_like<_UPair>())
constexpr explicit(!_S_convertible_from_pair_like<_UPair>())
pair(_UPair&&) = delete;

private:

template<typename _U1, typename _U2>

static constexpr bool
_S_assignable()
{
if constexpr (is_assignable_v<_T1&, _U1>)
return is_assignable_v<_T2&, _U2>;
return false;
}

template<typename _U1, typename _U2>

static constexpr bool
_S_const_assignable()
{
if constexpr (is_assignable_v<const _T1&, _U1>)
return is_assignable_v<const _T2&, _U2>;
return false;
}

template<typename _U1, typename _U2>

static constexpr bool
_S_nothrow_assignable()
{
if constexpr (is_nothrow_assignable_v<_T1&, _U1>)
return is_nothrow_assignable_v<_T2&, _U2>;
return false;
}

template<typename _UPair>
static constexpr bool
_S_assignable_from_tuple_like()
{
return _S_assignable<decltype(std::get<0>(std::declval<_UPair>())),
decltype(std::get<1>(std::declval<_UPair>()))>();
}

template<typename _UPair>
static constexpr bool
_S_const_assignable_from_tuple_like()
{
return _S_const_assignable<decltype(std::get<0>(std::declval<_UPair>())),
decltype(std::get<1>(std::declval<_UPair>()))>();
}

public:

pair& operator=(const pair&) = delete;

constexpr pair&
operator=(const pair& __p)
noexcept(_S_nothrow_assignable<const _T1&, const _T2&>())
requires (_S_assignable<const _T1&, const _T2&>())
{
first = __p.first;
second = __p.second;
return *this;
}

constexpr pair&
operator=(pair&& __p)
noexcept(_S_nothrow_assignable<_T1, _T2>())
requires (_S_assignable<_T1, _T2>())
{
first = std::forward<first_type>(__p.first);
second = std::forward<second_type>(__p.second);
return *this;
}

template<typename _U1, typename _U2>

constexpr pair&
operator=(const pair<_U1, _U2>& __p)
noexcept(_S_nothrow_assignable<const _U1&, const _U2&>())
requires (_S_assignable<const _U1&, const _U2&>())
{
first = __p.first;
second = __p.second;
return *this;
}

template<typename _U1, typename _U2>

constexpr pair&
operator=(pair<_U1, _U2>&& __p)
noexcept(_S_nothrow_assignable<_U1, _U2>())
requires (_S_assignable<_U1, _U2>())
{
first = std::forward<_U1>(__p.first);
second = std::forward<_U2>(__p.second);
return *this;
}

constexpr const pair&

operator=(const pair& __p) const
requires (_S_const_assignable<const first_type&, const second_type&>())
{
first = __p.first;
second = __p.second;
return *this;
}

constexpr const pair&

operator=(pair&& __p) const
requires (_S_const_assignable<first_type, second_type>())
{
first = std::forward<first_type>(__p.first);
second = std::forward<second_type>(__p.second);
return *this;
}

template<typename _U1, typename _U2>

constexpr const pair&
operator=(const pair<_U1, _U2>& __p) const
requires (_S_const_assignable<const _U1&, const _U2&>())
{
first = __p.first;
second = __p.second;
return *this;
}

template<typename _U1, typename _U2>

constexpr const pair&
operator=(pair<_U1, _U2>&& __p) const
requires (_S_const_assignable<_U1, _U2>())
{
first = std::forward<_U1>(__p.first);
second = std::forward<_U2>(__p.second);
return *this;
}

template<__eligible_pair_like<pair> _UPair>
requires (_S_assignable_from_tuple_like<_UPair>())
constexpr pair&
operator=(_UPair&& __p)
{
first = std::get<0>(std::forward<_UPair>(__p));
second = std::get<1>(std::forward<_UPair>(__p));
return *this;
}

template<__eligible_pair_like<pair> _UPair>
requires (_S_const_assignable_from_tuple_like<_UPair>())
constexpr const pair&
operator=(_UPair&& __p) const
{
first = std::get<0>(std::forward<_UPair>(__p));
second = std::get<1>(std::forward<_UPair>(__p));
return *this;
}
# 995 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_pair.h" 3
};

template<typename _T1, typename _T2> pair(_T1, _T2) -> pair<_T1, _T2>;

template<typename _T1, typename _T2, typename _U1, typename _U2>

inline constexpr bool
operator==(const pair<_T1, _T2>& __x, const pair<_U1, _U2>& __y)
{ return __x.first == __y.first && __x.second == __y.second; }
# 1020 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_pair.h" 3
template<typename _T1, typename _T2, typename _U1, typename _U2>
constexpr common_comparison_category_t<__detail::__synth3way_t<_T1, _U1>,
__detail::__synth3way_t<_T2, _U2>>
operator<=>(const pair<_T1, _T2>& __x, const pair<_U1, _U2>& __y)
{
if (auto __c = __detail::__synth3way(__x.first, __y.first); __c != 0)
return __c;
return __detail::__synth3way(__x.second, __y.second);
}
# 1080 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_pair.h" 3
template<typename _T1, typename _T2>
constexpr inline
typename enable_if<__and_<__is_swappable<_T1>,
__is_swappable<_T2>>::value>::type

swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y)

noexcept(noexcept(__x.swap(__y)))
{ __x.swap(__y); }

template<typename _T1, typename _T2>

requires is_swappable_v<const _T1> && is_swappable_v<const _T2>
constexpr void
swap(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
noexcept(noexcept(__x.swap(__y)))
{ __x.swap(__y); }

template<typename _T1, typename _T2>

typename enable_if<!__and_<__is_swappable<_T1>,
__is_swappable<_T2>>::value>::type
swap(pair<_T1, _T2>&, pair<_T1, _T2>&) = delete;
# 1129 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_pair.h" 3
template<typename _T1, typename _T2>
constexpr pair<typename __decay_and_strip<_T1>::__type,
typename __decay_and_strip<_T2>::__type>
make_pair(_T1&& __x, _T2&& __y)
{
typedef typename __decay_and_strip<_T1>::__type __ds_type1;
typedef typename __decay_and_strip<_T2>::__type __ds_type2;
typedef pair<__ds_type1, __ds_type2> __pair_type;
return __pair_type(std::forward<_T1>(__x), std::forward<_T2>(__y));
}
# 1152 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_pair.h" 3
template<typename _T1, typename _T2>
struct __is_tuple_like_impl<pair<_T1, _T2>> : true_type
{ };

template<class _Tp1, class _Tp2>

struct tuple_size<pair<_Tp1, _Tp2>>
: public integral_constant<size_t, 2> { };

template<class _Tp1, class _Tp2>

struct tuple_element<0, pair<_Tp1, _Tp2>>
{ typedef _Tp1 type; };

template<class _Tp1, class _Tp2>

struct tuple_element<1, pair<_Tp1, _Tp2>>
{ typedef _Tp2 type; };

template<size_t __i, typename... _Types>

struct tuple_element<__i, tuple<_Types...>>;
template<typename _Tp1, typename _Tp2>
inline constexpr size_t tuple_size_v<pair<_Tp1, _Tp2>> = 2;

template<typename _Tp1, typename _Tp2>

inline constexpr size_t tuple_size_v<const pair<_Tp1, _Tp2>> = 2;

template<typename _Tp>
inline constexpr bool __is_pair = false;

template<typename _Tp, typename _Up>

inline constexpr bool __is_pair<pair<_Tp, _Up>> = true;

template<size_t _Int>
struct __pair_get;

template<>
struct __pair_get<0>
{
template<typename _Tp1, typename _Tp2>
static constexpr _Tp1&
__get(pair<_Tp1, _Tp2>& __pair) noexcept
{ return __pair.first; }

template<typename _Tp1, typename _Tp2>

static constexpr _Tp1&&
__move_get(pair<_Tp1, _Tp2>&& __pair) noexcept
{ return std::forward<_Tp1>(__pair.first); }

template<typename _Tp1, typename _Tp2>

static constexpr const _Tp1&
__const_get(const pair<_Tp1, _Tp2>& __pair) noexcept
{ return __pair.first; }

template<typename _Tp1, typename _Tp2>

static constexpr const _Tp1&&
__const_move_get(const pair<_Tp1, _Tp2>&& __pair) noexcept
{ return std::forward<const _Tp1>(__pair.first); }
};

template<>
struct __pair_get<1>
{
template<typename _Tp1, typename _Tp2>
static constexpr _Tp2&
__get(pair<_Tp1, _Tp2>& __pair) noexcept
{ return __pair.second; }

template<typename _Tp1, typename _Tp2>

static constexpr _Tp2&&
__move_get(pair<_Tp1, _Tp2>&& __pair) noexcept
{ return std::forward<_Tp2>(__pair.second); }

template<typename _Tp1, typename _Tp2>

static constexpr const _Tp2&
__const_get(const pair<_Tp1, _Tp2>& __pair) noexcept
{ return __pair.second; }

template<typename _Tp1, typename _Tp2>

static constexpr const _Tp2&&
__const_move_get(const pair<_Tp1, _Tp2>&& __pair) noexcept
{ return std::forward<const _Tp2>(__pair.second); }
};

template<size_t _Int, class _Tp1, class _Tp2>

constexpr typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&
get(pair<_Tp1, _Tp2>& __in) noexcept
{ return __pair_get<_Int>::__get(__in); }

template<size_t _Int, class _Tp1, class _Tp2>

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<size_t _Int, class _Tp1, class _Tp2>

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<size_t _Int, class _Tp1, class _Tp2>

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 <typename _Tp, typename _Up>

constexpr _Tp&
get(pair<_Tp, _Up>& __p) noexcept
{ return __p.first; }

template <typename _Tp, typename _Up>

constexpr const _Tp&
get(const pair<_Tp, _Up>& __p) noexcept
{ return __p.first; }

template <typename _Tp, typename _Up>

constexpr _Tp&&
get(pair<_Tp, _Up>&& __p) noexcept
{ return std::move(__p.first); }

template <typename _Tp, typename _Up>

constexpr const _Tp&&
get(const pair<_Tp, _Up>&& __p) noexcept
{ return std::move(__p.first); }

template <typename _Tp, typename _Up>

constexpr _Tp&
get(pair<_Up, _Tp>& __p) noexcept
{ return __p.second; }
template <typename _Tp, typename _Up>
constexpr const _Tp&
get(const pair<_Up, _Tp>& __p) noexcept
{ return __p.second; }

template <typename _Tp, typename _Up>

constexpr _Tp&&
get(pair<_Up, _Tp>&& __p) noexcept
{ return std::move(__p.second); }

template <typename _Tp, typename _Up>

constexpr const _Tp&&
get(const pair<_Up, _Tp>&& __p) noexcept
{ return std::move(__p.second); }

template<typename _T1, typename _T2, typename _U1, typename _U2,

template<typename> class _TQual, template<typename> class _UQual>
requires requires { typename pair<common_reference_t<_TQual<_T1>, _UQual<_U1>>,
common_reference_t<_TQual<_T2>, _UQual<_U2>>>; }
struct basic_common_reference<pair<_T1, _T2>, pair<_U1, _U2>, _TQual, _UQual>
{
using type = pair<common_reference_t<_TQual<_T1>, _UQual<_U1>>,
common_reference_t<_TQual<_T2>, _UQual<_U2>>>;
};

template<typename _T1, typename _T2, typename _U1, typename _U2>

requires requires { typename pair<common_type_t<_T1, _U1>, common_type_t<_T2,
_U2>>; }
struct common_type<pair<_T1, _T2>, pair<_U1, _U2>>
{ using type = pair<common_type_t<_T1, _U1>, common_type_t<_T2, _U2>>; };

}
# 65 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algobase.h" 2 3
# 1
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_iterator_base_types.h" 1
3
# 62
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_iterator_base_types.h" 3

# 63
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_iterator_base_types.h" 3
# 71
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_iterator_base_types.h" 3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/iterator_concepts.h" 1 3
# 33 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/iterator_concepts.h" 3

# 34 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/iterator_concepts.h" 3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/ptr_traits.h" 1 3
# 39 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/ptr_traits.h" 3
namespace __gnu_debug { struct _Safe_iterator_base; }

namespace std
{

class __undefined;

template<typename _Tp>
struct __get_first_arg
{ using type = __undefined; };

template<template<typename, typename...> class _SomeTemplate, typename _Tp,

typename... _Types>
struct __get_first_arg<_SomeTemplate<_Tp, _Types...>>
{ using type = _Tp; };

template<typename _Tp, typename _Up>

struct __replace_first_arg
{ };

template<template<typename, typename...> class _SomeTemplate, typename _Up,

typename _Tp, typename... _Types>
struct __replace_first_arg<_SomeTemplate<_Tp, _Types...>, _Up>
{ using type = _SomeTemplate<_Up, _Types...>; };

template<typename _Ptr, typename = void>

struct __ptr_traits_elem : __get_first_arg<_Ptr>
{ };

template<typename _Ptr> requires requires { typename _Ptr::element_type; }

struct __ptr_traits_elem<_Ptr, void>
{ using type = typename _Ptr::element_type; };

template<typename _Ptr>
using __ptr_traits_elem_t = typename __ptr_traits_elem<_Ptr>::type;

template<typename _Ptr, typename _Elt, bool = is_void<_Elt>::value>

struct __ptr_traits_ptr_to
{
using pointer = _Ptr;
using element_type = _Elt;

static pointer
pointer_to(element_type& __r)

requires requires {
{ pointer::pointer_to(__r) } -> convertible_to<pointer>;
}

{ return pointer::pointer_to(__r); }
};

template<typename _Ptr, typename _Elt>

struct __ptr_traits_ptr_to<_Ptr, _Elt, true>
{ };

template<typename _Tp>
struct __ptr_traits_ptr_to<_Tp*, _Tp, false>
{
using pointer = _Tp*;
using element_type = _Tp;

static constexpr pointer

pointer_to(element_type& __r) noexcept
{ return std::addressof(__r); }
};

template<typename _Ptr, typename _Elt>

struct __ptr_traits_impl : __ptr_traits_ptr_to<_Ptr, _Elt>
{
private:
template<typename _Tp>
using __diff_t = typename _Tp::difference_type;

template<typename _Tp, typename _Up>

using __rebind = __type_identity<typename _Tp::template rebind<_Up>>;

public:

using pointer = _Ptr;

using element_type = _Elt;

using difference_type = __detected_or_t<ptrdiff_t, __diff_t, _Ptr>;

template<typename _Up>
using rebind = typename __detected_or_t<__replace_first_arg<_Ptr, _Up>,
__rebind, _Ptr, _Up>::type;
};

template<typename _Ptr>
struct __ptr_traits_impl<_Ptr, __undefined>
{ };

template<typename _Ptr>
struct pointer_traits : __ptr_traits_impl<_Ptr, __ptr_traits_elem_t<_Ptr>>
{ };

template<typename _Tp>
struct pointer_traits<_Tp*> : __ptr_traits_ptr_to<_Tp*, _Tp>
{

typedef _Tp* pointer;

typedef _Tp element_type;

typedef ptrdiff_t difference_type;

template<typename _Up> using rebind = _Up*;

};

template<typename _Ptr, typename _Tp>

using __ptr_rebind = typename pointer_traits<_Ptr>::template rebind<_Tp>;

template<typename _Tp>
constexpr _Tp*
__to_address(_Tp* __ptr) noexcept
{
static_assert(!std::is_function<_Tp>::value, "not a function pointer");
return __ptr;
}
template<typename _Ptr>
constexpr auto
__to_address(const _Ptr& __ptr) noexcept
-> decltype(std::pointer_traits<_Ptr>::to_address(__ptr))
{ return std::pointer_traits<_Ptr>::to_address(__ptr); }

template<typename _Ptr, typename... _None>

constexpr auto
__to_address(const _Ptr& __ptr, _None...) noexcept
{
if constexpr (is_base_of_v<__gnu_debug::_Safe_iterator_base, _Ptr>)
return std::__to_address(__ptr.base().operator->());
else
return std::__to_address(__ptr.operator->());
}

template<typename _Tp>
constexpr _Tp*
to_address(_Tp* __ptr) noexcept
{ return std::__to_address(__ptr); }
# 251 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/ptr_traits.h" 3
template<typename _Ptr>
constexpr auto
to_address(const _Ptr& __ptr) noexcept
{ return std::__to_address(__ptr); }

}
# 38 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/iterator_concepts.h" 2
3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/ranges_cmp.h" 1 3
# 37 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/ranges_cmp.h" 3
namespace std
{

struct __is_transparent;

struct identity
{
template<typename _Tp>
[[nodiscard]]
constexpr _Tp&&
operator()(_Tp&& __t) const noexcept
{ return std::forward<_Tp>(__t); }
using is_transparent = __is_transparent;
};

namespace ranges
{
namespace __detail
{

template<typename _Tp, typename _Up>

concept __less_builtin_ptr_cmp
= requires (_Tp&& __t, _Up&& __u) { { __t < __u } -> same_as<bool>; }
&& convertible_to<_Tp, const volatile void*>
&& convertible_to<_Up, const volatile void*>
&& (! requires(_Tp&& __t, _Up&& __u)
{ operator<(std::forward<_Tp>(__t), std::forward<_Up>(__u)); }
&& ! requires(_Tp&& __t, _Up&& __u)
{ std::forward<_Tp>(__t).operator<(std::forward<_Up>(__u)); });
}

struct equal_to
{
template<typename _Tp, typename _Up>
requires equality_comparable_with<_Tp, _Up>
constexpr bool
operator()(_Tp&& __t, _Up&& __u) const
noexcept(noexcept(std::declval<_Tp>() == std::declval<_Up>()))
{ return std::forward<_Tp>(__t) == std::forward<_Up>(__u); }

using is_transparent = __is_transparent;

};

struct not_equal_to
{
template<typename _Tp, typename _Up>
requires equality_comparable_with<_Tp, _Up>
constexpr bool
operator()(_Tp&& __t, _Up&& __u) const
noexcept(noexcept(std::declval<_Up>() == std::declval<_Tp>()))
{ return !equal_to{}(std::forward<_Tp>(__t), std::forward<_Up>(__u)); }

using is_transparent = __is_transparent;

};

struct less
{
template<typename _Tp, typename _Up>
requires totally_ordered_with<_Tp, _Up>
constexpr bool
operator()(_Tp&& __t, _Up&& __u) const
noexcept(noexcept(std::declval<_Tp>() < std::declval<_Up>()))
{
if constexpr (__detail::__less_builtin_ptr_cmp<_Tp, _Up>)
{
if (std::__is_constant_evaluated())
return __t < __u;

auto __x = reinterpret_cast<long long unsigned int>(

static_cast<const volatile void*>(std::forward<_Tp>(__t)));
auto __y = reinterpret_cast<long long unsigned int>(
static_cast<const volatile void*>(std::forward<_Up>(__u)));
return __x < __y;
}
else
return std::forward<_Tp>(__t) < std::forward<_Up>(__u);
}

using is_transparent = __is_transparent;

};

struct greater
{
template<typename _Tp, typename _Up>
requires totally_ordered_with<_Tp, _Up>
constexpr bool
operator()(_Tp&& __t, _Up&& __u) const
noexcept(noexcept(std::declval<_Up>() < std::declval<_Tp>()))
{ return less{}(std::forward<_Up>(__u), std::forward<_Tp>(__t)); }

using is_transparent = __is_transparent;

};

struct greater_equal
{
template<typename _Tp, typename _Up>
requires totally_ordered_with<_Tp, _Up>
constexpr bool
operator()(_Tp&& __t, _Up&& __u) const
noexcept(noexcept(std::declval<_Tp>() < std::declval<_Up>()))
{ return !less{}(std::forward<_Tp>(__t), std::forward<_Up>(__u)); }

using is_transparent = __is_transparent;

};

struct less_equal
{
template<typename _Tp, typename _Up>
requires totally_ordered_with<_Tp, _Up>
constexpr bool
operator()(_Tp&& __t, _Up&& __u) const
noexcept(noexcept(std::declval<_Up>() < std::declval<_Tp>()))
{ return !less{}(std::forward<_Up>(__u), std::forward<_Tp>(__t)); }

using is_transparent = __is_transparent;

};

}
# 39 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/iterator_concepts.h" 2
3

namespace std
{

# 58 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/iterator_concepts.h" 3
struct default_sentinel_t { };

inline constexpr default_sentinel_t default_sentinel{};

struct input_iterator_tag;
struct output_iterator_tag;
struct forward_iterator_tag;
struct bidirectional_iterator_tag;
struct random_access_iterator_tag;
struct contiguous_iterator_tag;

template<typename _Iterator>
struct iterator_traits;

template<typename _Tp> requires is_object_v<_Tp>

struct iterator_traits<_Tp*>;

template<typename _Iterator, typename>

struct __iterator_traits;

namespace __detail
{
template<typename _Tp>
using __with_ref = _Tp&;

template<typename _Tp>
concept __can_reference = requires { typename __with_ref<_Tp>; };

template<typename _Tp>
concept __dereferenceable = requires(_Tp& __t)
{
{ *__t } -> __can_reference;
};
}

template<__detail::__dereferenceable _Tp>
using iter_reference_t = decltype(*std::declval<_Tp&>());

namespace ranges
{

namespace __imove
{
void iter_move() = delete;
template<typename _Tp>
concept __adl_imove
= (std::__detail::__class_or_enum<remove_reference_t<_Tp>>)
&& requires(_Tp&& __t) { iter_move(static_cast<_Tp&&>(__t)); };

struct _IterMove
{
private:
template<typename _Tp>
struct __result
{ using type = iter_reference_t<_Tp>; };

template<typename _Tp>
requires __adl_imove<_Tp>
struct __result<_Tp>
{ using type = decltype(iter_move(std::declval<_Tp>())); };

template<typename _Tp>
requires (!__adl_imove<_Tp>)
&& is_lvalue_reference_v<iter_reference_t<_Tp>>
struct __result<_Tp>
{ using type = remove_reference_t<iter_reference_t<_Tp>>&&; };

template<typename _Tp>
static constexpr bool
_S_noexcept()
{
if constexpr (__adl_imove<_Tp>)
return noexcept(iter_move(std::declval<_Tp>()));
else
return noexcept(*std::declval<_Tp>());
}

public:

template<std::__detail::__dereferenceable _Tp>
using __type = typename __result<_Tp>::type;

template<std::__detail::__dereferenceable _Tp>
[[nodiscard]]
constexpr __type<_Tp>
operator()(_Tp&& __e) const
noexcept(_S_noexcept<_Tp>())
{
if constexpr (__adl_imove<_Tp>)
return iter_move(static_cast<_Tp&&>(__e));
else if constexpr (is_lvalue_reference_v<iter_reference_t<_Tp>>)
return static_cast<__type<_Tp>>(*__e);
else
return *__e;
}
};
}

inline namespace _Cpo {

inline constexpr __imove::_IterMove iter_move{};
}
}

template<__detail::__dereferenceable _Tp>
requires __detail::__can_reference<ranges::__imove::_IterMove::__type<_Tp&>>
using iter_rvalue_reference_t = ranges::__imove::_IterMove::__type<_Tp&>;

template<typename> struct incrementable_traits { };

template<typename _Tp> requires is_object_v<_Tp>

struct incrementable_traits<_Tp*>
{ using difference_type = ptrdiff_t; };

template<typename _Iter>
struct incrementable_traits<const _Iter>
: incrementable_traits<_Iter> { };

template<typename _Tp> requires requires { typename _Tp::difference_type; }

struct incrementable_traits<_Tp>
{ using difference_type = typename _Tp::difference_type; };

template<typename _Tp>
requires (!requires { typename _Tp::difference_type; }
&& requires(const _Tp& __a, const _Tp& __b)
{ { __a - __b } -> integral; })
struct incrementable_traits<_Tp>
{
using difference_type
= make_signed_t<decltype(std::declval<_Tp>() - std::declval<_Tp>())>;
};
# 204 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/iterator_concepts.h" 3
namespace __detail
{

template<typename _Iter>
concept __primary_traits_iter
= __is_base_of(__iterator_traits<_Iter, void>, iterator_traits<_Iter>);

template<typename _Iter, typename _Tp>

struct __iter_traits_impl
{ using type = iterator_traits<_Iter>; };

template<typename _Iter, typename _Tp>

requires __primary_traits_iter<_Iter>
struct __iter_traits_impl<_Iter, _Tp>
{ using type = _Tp; };

template<typename _Iter, typename _Tp = _Iter>

using __iter_traits = typename __iter_traits_impl<_Iter, _Tp>::type;

template<typename _Tp>
using __iter_diff_t = typename
__iter_traits<_Tp, incrementable_traits<_Tp>>::difference_type;
}

template<typename _Tp>
using iter_difference_t = __detail::__iter_diff_t<remove_cvref_t<_Tp>>;
namespace __detail
{
template<typename> struct __cond_value_type { };

template<typename _Tp> requires is_object_v<_Tp>

struct __cond_value_type<_Tp>
{ using value_type = remove_cv_t<_Tp>; };

template<typename _Tp>
concept __has_member_value_type
= requires { typename _Tp::value_type; };

template<typename _Tp>
concept __has_member_element_type
= requires { typename _Tp::element_type; };

template<typename> struct indirectly_readable_traits { };

template<typename _Tp>
struct indirectly_readable_traits<_Tp*>
: __detail::__cond_value_type<_Tp>
{ };

template<typename _Iter> requires is_array_v<_Iter>

struct indirectly_readable_traits<_Iter>
{ using value_type = remove_cv_t<remove_extent_t<_Iter>>; };

template<typename _Iter>
struct indirectly_readable_traits<const _Iter>
: indirectly_readable_traits<_Iter>
{ };

template<__detail::__has_member_value_type _Tp>
struct indirectly_readable_traits<_Tp>
: __detail::__cond_value_type<typename _Tp::value_type>
{ };

template<__detail::__has_member_element_type _Tp>
struct indirectly_readable_traits<_Tp>
: __detail::__cond_value_type<typename _Tp::element_type>
{ };

template<__detail::__has_member_value_type _Tp>
requires __detail::__has_member_element_type<_Tp>
&& same_as<remove_cv_t<typename _Tp::element_type>,
remove_cv_t<typename _Tp::value_type>>
struct indirectly_readable_traits<_Tp>
: __detail::__cond_value_type<typename _Tp::value_type>
{ };

template<__detail::__has_member_value_type _Tp>
requires __detail::__has_member_element_type<_Tp>
struct indirectly_readable_traits<_Tp>
{ };

namespace __detail
{
template<typename _Tp>
using __iter_value_t = typename
__iter_traits<_Tp, indirectly_readable_traits<_Tp>>::value_type;
}

template<typename _Tp>
using iter_value_t = __detail::__iter_value_t<remove_cvref_t<_Tp>>;

namespace __detail
{

template<typename _Iter>
concept __cpp17_iterator = requires(_Iter __it)
{
{ *__it } -> __can_reference;
{ ++__it } -> same_as<_Iter&>;
{ *__it++ } -> __can_reference;
} && copyable<_Iter>;

template<typename _Iter>
concept __cpp17_input_iterator = __cpp17_iterator<_Iter>
&& equality_comparable<_Iter>
&& requires(_Iter __it)
{
typename incrementable_traits<_Iter>::difference_type;
typename indirectly_readable_traits<_Iter>::value_type;
typename common_reference_t<iter_reference_t<_Iter>&&,
typename indirectly_readable_traits<_Iter>::value_type&>;
typename common_reference_t<decltype(*__it++)&&,
typename indirectly_readable_traits<_Iter>::value_type&>;
requires signed_integral<
typename incrementable_traits<_Iter>::difference_type>;
};

template<typename _Iter>
concept __cpp17_fwd_iterator = __cpp17_input_iterator<_Iter>
&& constructible_from<_Iter>
&& is_lvalue_reference_v<iter_reference_t<_Iter>>
&& same_as<remove_cvref_t<iter_reference_t<_Iter>>,
typename indirectly_readable_traits<_Iter>::value_type>
&& requires(_Iter __it)
{
{ __it++ } -> convertible_to<const _Iter&>;
{ *__it++ } -> same_as<iter_reference_t<_Iter>>;
};

template<typename _Iter>
concept __cpp17_bidi_iterator = __cpp17_fwd_iterator<_Iter>
&& requires(_Iter __it)
{
{ --__it } -> same_as<_Iter&>;
{ __it-- } -> convertible_to<const _Iter&>;
{ *__it-- } -> same_as<iter_reference_t<_Iter>>;
};
template<typename _Iter>
concept __cpp17_randacc_iterator = __cpp17_bidi_iterator<_Iter>
&& totally_ordered<_Iter>
&& requires(_Iter __it,
typename incrementable_traits<_Iter>::difference_type __n)
{
{ __it += __n } -> same_as<_Iter&>;
{ __it -= __n } -> same_as<_Iter&>;
{ __it + __n } -> same_as<_Iter>;
{ __n + __it } -> same_as<_Iter>;
{ __it - __n } -> same_as<_Iter>;
{ __it - __it } -> same_as<decltype(__n)>;
{ __it[__n] } -> convertible_to<iter_reference_t<_Iter>>;
};

template<typename _Iter>
concept __iter_with_nested_types = requires {
typename _Iter::iterator_category;
typename _Iter::value_type;
typename _Iter::difference_type;
typename _Iter::reference;
};

template<typename _Iter>
concept __iter_without_nested_types = !__iter_with_nested_types<_Iter>;

template<typename _Iter>
concept __iter_without_category
= !requires { typename _Iter::iterator_category; };

template<typename _Iterator>
requires __detail::__iter_with_nested_types<_Iterator>
struct __iterator_traits<_Iterator, void>
{
private:
template<typename _Iter>
struct __ptr
{ using type = void; };

template<typename _Iter> requires requires { typename _Iter::pointer; }

struct __ptr<_Iter>
{ using type = typename _Iter::pointer; };

public:
using iterator_category = typename _Iterator::iterator_category;
using value_type = typename _Iterator::value_type;
using difference_type = typename _Iterator::difference_type;
using pointer = typename __ptr<_Iterator>::type;
using reference = typename _Iterator::reference;
};

template<typename _Iterator>
requires __detail::__iter_without_nested_types<_Iterator>
&& __detail::__cpp17_input_iterator<_Iterator>
struct __iterator_traits<_Iterator, void>
{
private:
template<typename _Iter>
struct __cat
{ using type = input_iterator_tag; };

template<typename _Iter>
requires requires { typename _Iter::iterator_category; }
struct __cat<_Iter>
{ using type = typename _Iter::iterator_category; };

template<typename _Iter>
requires __detail::__iter_without_category<_Iter>
&& __detail::__cpp17_randacc_iterator<_Iter>
struct __cat<_Iter>
{ using type = random_access_iterator_tag; };

template<typename _Iter>
requires __detail::__iter_without_category<_Iter>
&& __detail::__cpp17_bidi_iterator<_Iter>
struct __cat<_Iter>
{ using type = bidirectional_iterator_tag; };

template<typename _Iter>
requires __detail::__iter_without_category<_Iter>
&& __detail::__cpp17_fwd_iterator<_Iter>
struct __cat<_Iter>
{ using type = forward_iterator_tag; };

template<typename _Iter>
struct __ptr
{ using type = void; };

template<typename _Iter> requires requires { typename _Iter::pointer; }

struct __ptr<_Iter>
{ using type = typename _Iter::pointer; };

template<typename _Iter>
requires (!requires { typename _Iter::pointer; }
&& requires(_Iter& __it) { __it.operator->(); })
struct __ptr<_Iter>
{ using type = decltype(std::declval<_Iter&>().operator->()); };

template<typename _Iter>
struct __ref
{ using type = iter_reference_t<_Iter>; };

template<typename _Iter> requires requires { typename _Iter::reference; }

struct __ref<_Iter>
{ using type = typename _Iter::reference; };

public:
using iterator_category = typename __cat<_Iterator>::type;
using value_type
= typename indirectly_readable_traits<_Iterator>::value_type;
using difference_type
= typename incrementable_traits<_Iterator>::difference_type;
using pointer = typename __ptr<_Iterator>::type;
using reference = typename __ref<_Iterator>::type;
};
template<typename _Iterator>
requires __detail::__iter_without_nested_types<_Iterator>
&& __detail::__cpp17_iterator<_Iterator>
struct __iterator_traits<_Iterator, void>
{
private:
template<typename _Iter>
struct __diff
{ using type = void; };

template<typename _Iter>
requires requires
{ typename incrementable_traits<_Iter>::difference_type; }
struct __diff<_Iter>
{
using type = typename incrementable_traits<_Iter>::difference_type;
};

public:
using iterator_category = output_iterator_tag;
using value_type = void;
using difference_type = typename __diff<_Iterator>::type;
using pointer = void;
using reference = void;
};

namespace __detail
{
template<typename _Iter>
struct __iter_concept_impl;

template<typename _Iter>
requires requires { typename __iter_traits<_Iter>::iterator_concept; }
struct __iter_concept_impl<_Iter>
{ using type = typename __iter_traits<_Iter>::iterator_concept; };

template<typename _Iter>
requires (!requires { typename __iter_traits<_Iter>::iterator_concept; }
&& requires { typename __iter_traits<_Iter>::iterator_category; })
struct __iter_concept_impl<_Iter>
{ using type = typename __iter_traits<_Iter>::iterator_category; };

template<typename _Iter>
requires (!requires { typename __iter_traits<_Iter>::iterator_concept; }
&& !requires { typename __iter_traits<_Iter>::iterator_category; }
&& __primary_traits_iter<_Iter>)
struct __iter_concept_impl<_Iter>
{ using type = random_access_iterator_tag; };

template<typename _Iter>
struct __iter_concept_impl
{ };
template<typename _Iter>
using __iter_concept = typename __iter_concept_impl<_Iter>::type;

template<typename _In>
concept __indirectly_readable_impl = requires
{
typename iter_value_t<_In>;
typename iter_reference_t<_In>;
typename iter_rvalue_reference_t<_In>;
requires same_as<iter_reference_t<const _In>,
iter_reference_t<_In>>;
requires same_as<iter_rvalue_reference_t<const _In>,
iter_rvalue_reference_t<_In>>;
}
&& common_reference_with<iter_reference_t<_In>&&, iter_value_t<_In>&>
&& common_reference_with<iter_reference_t<_In>&&,
iter_rvalue_reference_t<_In>&&>
&& common_reference_with<iter_rvalue_reference_t<_In>&&,
const iter_value_t<_In>&>;

template<typename _In>
concept indirectly_readable
= __detail::__indirectly_readable_impl<remove_cvref_t<_In>>;

template<indirectly_readable _Tp>
using iter_common_reference_t
= common_reference_t<iter_reference_t<_Tp>, iter_value_t<_Tp>&>;

template<typename _Out, typename _Tp>

concept indirectly_writable = requires(_Out&& __o, _Tp&& __t)
{
*__o = std::forward<_Tp>(__t);
*std::forward<_Out>(__o) = std::forward<_Tp>(__t);
const_cast<const iter_reference_t<_Out>&&>(*__o)
= std::forward<_Tp>(__t);
const_cast<const iter_reference_t<_Out>&&>(*std::forward<_Out>(__o))
= std::forward<_Tp>(__t);
};

namespace ranges::__detail
{
class __max_diff_type;
class __max_size_type;

__extension__
template<typename _Tp>
concept __is_signed_int128

= same_as<_Tp, __int128>;

__extension__
template<typename _Tp>
concept __is_unsigned_int128

= same_as<_Tp, unsigned __int128>;

template<typename _Tp>
concept __cv_bool = same_as<const volatile _Tp, const volatile bool>;

template<typename _Tp>
concept __integral_nonbool = integral<_Tp> && !__cv_bool<_Tp>;

template<typename _Tp>
concept __is_int128 = __is_signed_int128<_Tp> || __is_unsigned_int128<_Tp>;

template<typename _Tp>
concept __is_integer_like = __integral_nonbool<_Tp>
|| __is_int128<_Tp>
|| same_as<_Tp, __max_diff_type> || same_as<_Tp, __max_size_type>;

template<typename _Tp>
concept __is_signed_integer_like = signed_integral<_Tp>
|| __is_signed_int128<_Tp>
|| same_as<_Tp, __max_diff_type>;

namespace detail { using ranges::detail::__is_signed_integer_like; }

template<typename _Iter>
concept weakly_incrementable = movable<_Iter>
&& requires(_Iter __i)
{
typename iter_difference_t<_Iter>;
requires __detail::__is_signed_integer_like<iter_difference_t<_Iter>>;
{ ++__i } -> same_as<_Iter&>;
__i++;
};

template<typename _Iter>
concept incrementable = regular<_Iter> && weakly_incrementable<_Iter>
&& requires(_Iter __i) { { __i++ } -> same_as<_Iter>; };

template<typename _Iter>
concept input_or_output_iterator
= requires(_Iter __i) { { *__i } -> __detail::__can_reference; }
&& weakly_incrementable<_Iter>;

template<typename _Sent, typename _Iter>

concept sentinel_for = semiregular<_Sent>
&& input_or_output_iterator<_Iter>
&& __detail::__weakly_eq_cmp_with<_Sent, _Iter>;

template<typename _Sent, typename _Iter>

inline constexpr bool disable_sized_sentinel_for = false;

template<typename _Sent, typename _Iter>

concept sized_sentinel_for = sentinel_for<_Sent, _Iter>
&& !disable_sized_sentinel_for<remove_cv_t<_Sent>, remove_cv_t<_Iter>>
&& requires(const _Iter& __i, const _Sent& __s)
{
{ __s - __i } -> same_as<iter_difference_t<_Iter>>;
{ __i - __s } -> same_as<iter_difference_t<_Iter>>;
};

template<typename _Iter>
concept input_iterator = input_or_output_iterator<_Iter>
&& indirectly_readable<_Iter>
&& requires { typename __detail::__iter_concept<_Iter>; }
&& derived_from<__detail::__iter_concept<_Iter>, input_iterator_tag>;

template<typename _Iter, typename _Tp>

concept output_iterator = input_or_output_iterator<_Iter>
&& indirectly_writable<_Iter, _Tp>
&& requires(_Iter __i, _Tp&& __t) { *__i++ = std::forward<_Tp>(__t); };

template<typename _Iter>
concept forward_iterator = input_iterator<_Iter>
&& derived_from<__detail::__iter_concept<_Iter>, forward_iterator_tag>
&& incrementable<_Iter> && sentinel_for<_Iter, _Iter>;

template<typename _Iter>
concept bidirectional_iterator = forward_iterator<_Iter>
&& derived_from<__detail::__iter_concept<_Iter>,
bidirectional_iterator_tag>
&& requires(_Iter __i)
{
{ --__i } -> same_as<_Iter&>;
{ __i-- } -> same_as<_Iter>;
};

template<typename _Iter>
concept random_access_iterator = bidirectional_iterator<_Iter>
&& derived_from<__detail::__iter_concept<_Iter>,
random_access_iterator_tag>
&& totally_ordered<_Iter> && sized_sentinel_for<_Iter, _Iter>
&& requires(_Iter __i, const _Iter __j,
const iter_difference_t<_Iter> __n)
{
{ __i += __n } -> same_as<_Iter&>;
{ __j + __n } -> same_as<_Iter>;
{ __n + __j } -> same_as<_Iter>;
{ __i -= __n } -> same_as<_Iter&>;
{ __j - __n } -> same_as<_Iter>;
{ __j[__n] } -> same_as<iter_reference_t<_Iter>>;
};

template<typename _Iter>
concept contiguous_iterator = random_access_iterator<_Iter>
&& derived_from<__detail::__iter_concept<_Iter>, contiguous_iterator_tag>
&& is_lvalue_reference_v<iter_reference_t<_Iter>>
&& same_as<iter_value_t<_Iter>, remove_cvref_t<iter_reference_t<_Iter>>>
&& requires(const _Iter& __i)
{
{ std::to_address(__i) }
-> same_as<add_pointer_t<iter_reference_t<_Iter>>>;
};

template<typename _Fn, typename _Iter>

concept indirectly_unary_invocable = indirectly_readable<_Iter>
&& copy_constructible<_Fn> && invocable<_Fn&, iter_value_t<_Iter>&>
&& invocable<_Fn&, iter_reference_t<_Iter>>
&& invocable<_Fn&, iter_common_reference_t<_Iter>>
&& common_reference_with<invoke_result_t<_Fn&, iter_value_t<_Iter>&>,
invoke_result_t<_Fn&, iter_reference_t<_Iter>>>;

template<typename _Fn, typename _Iter>

concept indirectly_regular_unary_invocable = indirectly_readable<_Iter>
&& copy_constructible<_Fn>
&& regular_invocable<_Fn&, iter_value_t<_Iter>&>
&& regular_invocable<_Fn&, iter_reference_t<_Iter>>
&& regular_invocable<_Fn&, iter_common_reference_t<_Iter>>
&& common_reference_with<invoke_result_t<_Fn&, iter_value_t<_Iter>&>,
invoke_result_t<_Fn&, iter_reference_t<_Iter>>>;

template<typename _Fn, typename _Iter>

concept indirect_unary_predicate = indirectly_readable<_Iter>
&& copy_constructible<_Fn> && predicate<_Fn&, iter_value_t<_Iter>&>
&& predicate<_Fn&, iter_reference_t<_Iter>>
&& predicate<_Fn&, iter_common_reference_t<_Iter>>;

template<typename _Fn, typename _I1, typename _I2>

concept indirect_binary_predicate
= indirectly_readable<_I1> && indirectly_readable<_I2>
&& copy_constructible<_Fn>
&& predicate<_Fn&, iter_value_t<_I1>&, iter_value_t<_I2>&>
&& predicate<_Fn&, iter_value_t<_I1>&, iter_reference_t<_I2>>
&& predicate<_Fn&, iter_reference_t<_I1>, iter_value_t<_I2>&>
&& predicate<_Fn&, iter_reference_t<_I1>, iter_reference_t<_I2>>
&& predicate<_Fn&, iter_common_reference_t<_I1>,
iter_common_reference_t<_I2>>;

template<typename _Fn, typename _I1, typename _I2 = _I1>

concept indirect_equivalence_relation
= indirectly_readable<_I1> && indirectly_readable<_I2>
&& copy_constructible<_Fn>
&& equivalence_relation<_Fn&, iter_value_t<_I1>&, iter_value_t<_I2>&>
&& equivalence_relation<_Fn&, iter_value_t<_I1>&, iter_reference_t<_I2>>
&& equivalence_relation<_Fn&, iter_reference_t<_I1>, iter_value_t<_I2>&>
&& equivalence_relation<_Fn&, iter_reference_t<_I1>,
iter_reference_t<_I2>>
&& equivalence_relation<_Fn&, iter_common_reference_t<_I1>,
iter_common_reference_t<_I2>>;

template<typename _Fn, typename _I1, typename _I2 = _I1>

concept indirect_strict_weak_order
= indirectly_readable<_I1> && indirectly_readable<_I2>
&& copy_constructible<_Fn>
&& strict_weak_order<_Fn&, iter_value_t<_I1>&, iter_value_t<_I2>&>
&& strict_weak_order<_Fn&, iter_value_t<_I1>&, iter_reference_t<_I2>>
&& strict_weak_order<_Fn&, iter_reference_t<_I1>, iter_value_t<_I2>&>
&& strict_weak_order<_Fn&, iter_reference_t<_I1>, iter_reference_t<_I2>>
&& strict_weak_order<_Fn&, iter_common_reference_t<_I1>,
iter_common_reference_t<_I2>>;

template<typename _Fn, typename... _Is>

requires (indirectly_readable<_Is> && ...)
&& invocable<_Fn, iter_reference_t<_Is>...>
using indirect_result_t = invoke_result_t<_Fn, iter_reference_t<_Is>...>;

namespace __detail
{
template<typename _Iter, typename _Proj>
struct __projected
{
struct __type
{
using value_type = remove_cvref_t<indirect_result_t<_Proj&, _Iter>>;
indirect_result_t<_Proj&, _Iter> operator*() const;
};
};

template<weakly_incrementable _Iter, typename _Proj>

struct __projected<_Iter, _Proj>
{
struct __type
{
using value_type = remove_cvref_t<indirect_result_t<_Proj&, _Iter>>;
using difference_type = iter_difference_t<_Iter>;
indirect_result_t<_Proj&, _Iter> operator*() const;
};
};
}

template<indirectly_readable _Iter,
indirectly_regular_unary_invocable<_Iter> _Proj>
using projected = typename __detail::__projected<_Iter, _Proj>::__type;

template<typename _In, typename _Out>

concept indirectly_movable = indirectly_readable<_In>
&& indirectly_writable<_Out, iter_rvalue_reference_t<_In>>;

template<typename _In, typename _Out>

concept indirectly_movable_storable = indirectly_movable<_In, _Out>
&& indirectly_writable<_Out, iter_value_t<_In>>
&& movable<iter_value_t<_In>>
&& constructible_from<iter_value_t<_In>, iter_rvalue_reference_t<_In>>
&& assignable_from<iter_value_t<_In>&, iter_rvalue_reference_t<_In>>;

template<typename _In, typename _Out>

concept indirectly_copyable = indirectly_readable<_In>
&& indirectly_writable<_Out, iter_reference_t<_In>>;

template<typename _In, typename _Out>

concept indirectly_copyable_storable = indirectly_copyable<_In, _Out>
&& indirectly_writable<_Out, iter_value_t<_In>&>
&& indirectly_writable<_Out, const iter_value_t<_In>&>
&& indirectly_writable<_Out, iter_value_t<_In>&&>
&& indirectly_writable<_Out, const iter_value_t<_In>&&>
&& copyable<iter_value_t<_In>>
&& constructible_from<iter_value_t<_In>, iter_reference_t<_In>>
&& assignable_from<iter_value_t<_In>&, iter_reference_t<_In>>;

namespace ranges
{

namespace __iswap
{
template<typename _It1, typename _It2>
void iter_swap(_It1, _It2) = delete;

template<typename _Tp, typename _Up>

concept __adl_iswap
= (std::__detail::__class_or_enum<remove_reference_t<_Tp>>
|| std::__detail::__class_or_enum<remove_reference_t<_Up>>)
&& requires(_Tp&& __t, _Up&& __u) {
iter_swap(static_cast<_Tp&&>(__t), static_cast<_Up&&>(__u));
};

template<typename _Xp, typename _Yp>

constexpr iter_value_t<_Xp>
__iter_exchange_move(_Xp&& __x, _Yp&& __y)
noexcept(noexcept(iter_value_t<_Xp>(iter_move(__x)))
&& noexcept(*__x = iter_move(__y)))
{
iter_value_t<_Xp> __old_value(iter_move(__x));
*__x = iter_move(__y);
return __old_value;
}

struct _IterSwap
{
private:
template<typename _Tp, typename _Up>
static constexpr bool
_S_noexcept()
{
if constexpr (__adl_iswap<_Tp, _Up>)
return noexcept(iter_swap(std::declval<_Tp>(),
std::declval<_Up>()));
else if constexpr (indirectly_readable<_Tp>
&& indirectly_readable<_Up>
&& swappable_with<iter_reference_t<_Tp>, iter_reference_t<_Up>>)
return noexcept(ranges::swap(*std::declval<_Tp>(),
*std::declval<_Up>()));
else
return noexcept(*std::declval<_Tp>()
= __iswap::__iter_exchange_move(std::declval<_Up>(),
std::declval<_Tp>()));
}

public:
template<typename _Tp, typename _Up>
requires __adl_iswap<_Tp, _Up>
|| (indirectly_readable<remove_reference_t<_Tp>>
&& indirectly_readable<remove_reference_t<_Up>>
&& swappable_with<iter_reference_t<_Tp>, iter_reference_t<_Up>>)
|| (indirectly_movable_storable<_Tp, _Up>
&& indirectly_movable_storable<_Up, _Tp>)
constexpr void
operator()(_Tp&& __e1, _Up&& __e2) const
noexcept(_S_noexcept<_Tp, _Up>())
{
if constexpr (__adl_iswap<_Tp, _Up>)
iter_swap(static_cast<_Tp&&>(__e1), static_cast<_Up&&>(__e2));
else if constexpr (indirectly_readable<_Tp>
&& indirectly_readable<_Up>
&& swappable_with<iter_reference_t<_Tp>, iter_reference_t<_Up>>)
ranges::swap(*__e1, *__e2);
else
*__e1 = __iswap::__iter_exchange_move(__e2, __e1);
}
};
}

inline namespace _Cpo {

inline constexpr __iswap::_IterSwap iter_swap{};
}

template<typename _I1, typename _I2 = _I1>

concept indirectly_swappable
= indirectly_readable<_I1> && indirectly_readable<_I2>
&& requires(const _I1 __i1, const _I2 __i2)
{
ranges::iter_swap(__i1, __i1);
ranges::iter_swap(__i2, __i2);
ranges::iter_swap(__i1, __i2);
ranges::iter_swap(__i2, __i1);
};

template<typename _I1, typename _I2, typename _Rel, typename _P1 = identity,

typename _P2 = identity>
concept indirectly_comparable
= indirect_binary_predicate<_Rel, projected<_I1, _P1>,
projected<_I2, _P2>>;

template<typename _Iter>
concept permutable = forward_iterator<_Iter>
&& indirectly_movable_storable<_Iter, _Iter>
&& indirectly_swappable<_Iter, _Iter>;

template<typename _I1, typename _I2, typename _Out,

typename _Rel = ranges::less, typename _P1 = identity,
typename _P2 = identity>
concept mergeable = input_iterator<_I1> && input_iterator<_I2>
&& weakly_incrementable<_Out> && indirectly_copyable<_I1, _Out>
&& indirectly_copyable<_I2, _Out>
&& indirect_strict_weak_order<_Rel, projected<_I1, _P1>,
projected<_I2, _P2>>;

template<typename _Iter, typename _Rel = ranges::less,

typename _Proj = identity>
concept sortable = permutable<_Iter>
&& indirect_strict_weak_order<_Rel, projected<_Iter, _Proj>>;

struct unreachable_sentinel_t
{
template<weakly_incrementable _It>
friend constexpr bool
operator==(unreachable_sentinel_t, const _It&) noexcept
{ return false; }
};

inline constexpr unreachable_sentinel_t unreachable_sentinel{};

namespace ranges::__access
{
using std::__detail::__class_or_enum;

struct _Decay_copy final

{
template<typename _Tp>
constexpr decay_t<_Tp>
operator()(_Tp&& __t) const
noexcept(is_nothrow_convertible_v<_Tp, decay_t<_Tp>>)
{ return std::forward<_Tp>(__t); }
} inline constexpr __decay_copy{};

template<typename _Tp>
concept __member_begin = requires(_Tp& __t)
{
{ __decay_copy(__t.begin()) } -> input_or_output_iterator;
};

void begin() = delete;

template<typename _Tp>
concept __adl_begin = __class_or_enum<remove_reference_t<_Tp>>
&& requires(_Tp& __t)
{
{ __decay_copy(begin(__t)) } -> input_or_output_iterator;
};

template<typename _Tp>
requires is_array_v<_Tp> || __member_begin<_Tp&> || __adl_begin<_Tp&>
auto
__begin(_Tp& __t)
{
if constexpr (is_array_v<_Tp>)
return __t + 0;
else if constexpr (__member_begin<_Tp&>)
return __t.begin();
else
return begin(__t);
}
}

namespace __detail
{

template<typename _Tp>
using __range_iter_t
= decltype(ranges::__access::__begin(std::declval<_Tp&>()));

}
# 72
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_iterator_base_types.h" 2
3

namespace std
{

# 93
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_iterator_base_types.h" 3
struct input_iterator_tag { };

struct output_iterator_tag { };

struct forward_iterator_tag : public input_iterator_tag { };

struct bidirectional_iterator_tag : public forward_iterator_tag { };

struct random_access_iterator_tag : public bidirectional_iterator_tag { };

struct contiguous_iterator_tag : public random_access_iterator_tag { };

# 125
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_iterator_base_types.h" 3
template<typename _Category, typename _Tp, typename _Distance = ptrdiff_t,
typename _Pointer = _Tp*, typename _Reference = _Tp&>
struct [[__deprecated__]] iterator
{

typedef _Category iterator_category;

typedef _Tp value_type;

typedef _Distance difference_type;

typedef _Pointer pointer;

typedef _Reference reference;

};
# 149
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_iterator_base_types.h" 3
template<typename _Iterator>
struct iterator_traits;

template<typename _Iterator, typename = __void_t<>>

struct __iterator_traits { };
# 176
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_iterator_base_types.h" 3
template<typename _Iterator>
struct iterator_traits
: public __iterator_traits<_Iterator> { };
# 194
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_iterator_base_types.h" 3
template<typename _Tp>

requires is_object_v<_Tp>

struct iterator_traits<_Tp*>
{
using iterator_concept = contiguous_iterator_tag;
using iterator_category = random_access_iterator_tag;
using value_type = remove_cv_t<_Tp>;
using difference_type = ptrdiff_t;
using pointer = _Tp*;
using reference = _Tp&;
};
# 235
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_iterator_base_types.h" 3
template<typename _Iter>
__attribute__((__always_inline__))
inline constexpr
typename iterator_traits<_Iter>::iterator_category
__iterator_category(const _Iter&)
{ return typename iterator_traits<_Iter>::iterator_category(); }

template<typename _Iter>
using __iter_category_t
= typename iterator_traits<_Iter>::iterator_category;

template<typename _InIter>
using _RequireInputIter =
__enable_if_t<is_convertible<__iter_category_t<_InIter>,
input_iterator_tag>::value>;

template<typename _It,
typename _Cat = __iter_category_t<_It>>
struct __is_random_access_iter
: is_base_of<random_access_iterator_tag, _Cat>
{
typedef is_base_of<random_access_iterator_tag, _Cat> _Base;
enum { __value = _Base::value };
};

}
# 66 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algobase.h" 2 3
# 1
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_iterator_base_funcs.h" 1
3
# 62
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_iterator_base_funcs.h" 3

# 63
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_iterator_base_funcs.h" 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/concept_check.h" 1 3
# 33 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/concept_check.h" 3

# 34 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/concept_check.h" 3
# 65
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_iterator_base_funcs.h" 2
3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/debug/assertions.h" 1 3
# 66
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_iterator_base_funcs.h" 2
3

namespace std
{

template <typename> struct _List_iterator;

template <typename> struct _List_const_iterator;

template<typename _InputIterator>
inline constexpr
typename iterator_traits<_InputIterator>::difference_type
__distance(_InputIterator __first, _InputIterator __last,
input_iterator_tag)
{

typename iterator_traits<_InputIterator>::difference_type __n = 0;

while (__first != __last)
{
++__first;
++__n;
}
return __n;
}

template<typename _RandomAccessIterator>
__attribute__((__always_inline__))
inline constexpr
typename iterator_traits<_RandomAccessIterator>::difference_type
__distance(_RandomAccessIterator __first, _RandomAccessIterator __last,
random_access_iterator_tag)
{

return last - first;

}

template<typename _Tp>
ptrdiff_t
__distance(std::_List_iterator<_Tp>,
std::_List_iterator<_Tp>,
input_iterator_tag);

template<typename _Tp>
ptrdiff_t
__distance(std::_List_const_iterator<_Tp>,
std::_List_const_iterator<_Tp>,
input_iterator_tag);

template<typename _OutputIterator>
void
__distance(_OutputIterator, _OutputIterator, output_iterator_tag) = delete;
# 144
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_iterator_base_funcs.h" 3
template<typename _InputIterator>
[[__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<typename _InputIterator, typename _Distance>

inline constexpr void
__advance(_InputIterator& __i, _Distance __n, input_iterator_tag)
{
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__n >=
0), false)) std::__glibcxx_assert_fail(); } while (false);
while (__n--)
++__i;
}

template<typename _BidirectionalIterator, typename _Distance>

inline constexpr void
__advance(_BidirectionalIterator& __i, _Distance __n,
bidirectional_iterator_tag)
{

if (__n > 0)
while (__n--)
++__i;
else
while (__n++)
--__i;
}

template<typename _RandomAccessIterator, typename _Distance>

inline constexpr void
__advance(_RandomAccessIterator& __i, _Distance __n,
random_access_iterator_tag)
{

if (__builtin_constant_p(n) && n == 1)

++__i;
else if (__builtin_constant_p(__n) && __n == -1)
--__i;
else
__i += __n;
}

template<typename _OutputIterator, typename _Distance>

void
__advance(_OutputIterator&, _Distance, output_iterator_tag) = delete;
# 217
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_iterator_base_funcs.h" 3
template<typename _InputIterator, typename _Distance>
__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<typename _InputIterator>
[[__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<typename _BidirectionalIterator>
[[__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 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algobase.h" 2 3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_iterator.h" 1 3
# 75 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_iterator.h" 3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/new" 1 3
# 38 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/new" 3

# 39 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/new" 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/exception.h" 1 3
# 34 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/exception.h" 3

# 35 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/exception.h" 3

extern "C++" {

namespace std
{
# 59 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/exception.h" 3
class exception
{
public:
exception() noexcept { }
virtual ~exception() noexcept;

exception(const exception&) = default;

exception& operator=(const exception&) = default;
exception(exception&&) = default;
exception& operator=(exception&&) = default;
virtual const char*
what() const noexcept;
};

}
# 42 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/new" 2 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 1 3
# 47 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 3

# 48 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 3
# 47 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/new" 2 3

#pragma GCC visibility push(default)

extern "C++" {

namespace std
{

class bad_alloc : public exception

{
public:
bad_alloc() throw() { }

bad_alloc(const bad_alloc&) = default;

bad_alloc& operator=(const bad_alloc&) = default;

virtual ~bad_alloc() throw();

new_handler set_new_handler(new_handler) throw();

new_handler get_new_handler() noexcept;

}
# 131 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/new" 3
[[__nodiscard__]] void* operator new(std::size_t)
__attribute__((__externally_visible__));
[[__nodiscard__]] void* operator new[](std::size_t)
__attribute__((__externally_visible__));
void operator delete(void*) noexcept
__attribute__((__externally_visible__));
void operator delete[](void*) noexcept
__attribute__((__externally_visible__));

void operator delete(void*, std::size_t) noexcept

__attribute__((__externally_visible__));
void operator delete[](void*, std::size_t) noexcept
__attribute__((__externally_visible__));

[[nodiscard]] void* operator new(std::size_t, const std::nothrow_t&) noexcept

__attribute__((__externally_visible__, __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<typename _Tp>
[[nodiscard]] constexpr _Tp*
launder(_Tp* __p) noexcept
{ return __builtin_launder(__p); }

template<typename _Ret, typename... _Args , bool _NE>

void launder(_Ret (*)(_Args...) noexcept (_NE)) = delete;
template<typename _Ret, typename... _Args , bool _NE>
void launder(_Ret (*)(_Args......) noexcept (_NE)) = delete;

void launder(void*) = delete;

void launder(const void*) = delete;
void launder(volatile void*) = delete;
void launder(const volatile void*) = delete;

inline constexpr size_t hardware_destructive_interference_size = 64;

inline constexpr size_t hardware_constructive_interference_size = 64;

namespace std
{

struct destroying_delete_t
{
explicit destroying_delete_t() = default;
};

inline constexpr destroying_delete_t destroying_delete{};

}

#pragma GCC visibility pop

# 76 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_iterator.h" 2 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_construct.h" 1 3
# 73 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_construct.h" 3
namespace std
{

template <typename _Tp>

constexpr inline void
destroy_at(_Tp* __location)
{
if constexpr (202400L > 201703L && is_array_v<_Tp>)
{
for (auto& __x : *__location)
std::destroy_at(std::__addressof(__x));
}
else
__location->~_Tp();
}

template<typename _Tp, typename... _Args>

constexpr auto
construct_at(_Tp* __location, _Args&&... __args)
noexcept(noexcept(::new((void*)0) _Tp(std::declval<_Args>()...)))
-> decltype(::new((void*)0) _Tp(std::declval<_Args>()...))
{ return ::new((void*)__location) _Tp(std::forward<_Args>(__args)...); }
# 106 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_construct.h" 3
template<typename _Tp, typename... _Args>
constexpr
inline void
_Construct(_Tp* __p, _Args&&... __args)
{

if (std::__is_constant_evaluated())
{

std::construct_at(__p, std::forward<_Args>(__args)...);
return;
}

::new((void*)__p) _Tp(std::forward<_Args>(__args)...);
}
# 132 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_construct.h" 3
template<typename _T1>
inline void
_Construct_novalue(_T1* __p)
{ ::new((void*)__p) _T1; }

template<typename _ForwardIterator>
constexpr void
_Destroy(_ForwardIterator __first, _ForwardIterator __last);

template<typename _Tp>
constexpr inline void
_Destroy(_Tp* __pointer)
{

std::destroy_at(__pointer);

template<bool>
struct _Destroy_aux
{
template<typename _ForwardIterator>
static constexpr void
__destroy(_ForwardIterator __first, _ForwardIterator __last)
{
for (; __first != __last; ++__first)
std::_Destroy(std::__addressof(*__first));
}
};

template<>
struct _Destroy_aux<true>
{
template<typename _ForwardIterator>
static void
__destroy(_ForwardIterator, _ForwardIterator) { }
};
template<typename _ForwardIterator>
constexpr 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");

if (std::__is_constant_evaluated())
return std::_Destroy_aux<false>::__destroy(__first, __last);

std::_Destroy_aux<__has_trivial_destructor(_Value_type)>::
__destroy(__first, __last);
}

template<bool>
struct _Destroy_n_aux
{
template<typename _ForwardIterator, typename _Size>
static constexpr _ForwardIterator
__destroy_n(_ForwardIterator __first, _Size __count)
{
for (; __count > 0; (void)++__first, --__count)
std::_Destroy(std::__addressof(*__first));
return __first;
}
};

template<>
struct _Destroy_n_aux<true>
{
template<typename _ForwardIterator, typename _Size>
static _ForwardIterator
__destroy_n(_ForwardIterator __first, _Size __count)
{
std::advance(__first, __count);
return __first;
}
};

template<typename _ForwardIterator, typename _Size>

constexpr 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");

if (std::__is_constant_evaluated())
return std::_Destroy_n_aux<false>::__destroy_n(__first, __count);

return std::_Destroy_n_aux<__has_trivial_destructor(_Value_type)>::
__destroy_n(__first, __count);
}

template <typename _ForwardIterator>

constexpr inline void
destroy(_ForwardIterator __first, _ForwardIterator __last)
{
std::_Destroy(__first, __last);
}

template <typename _ForwardIterator, typename _Size>

constexpr inline _ForwardIterator
destroy_n(_ForwardIterator __first, _Size __count)
{
return std::_Destroy_n(__first, __count);
}

}
# 79 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_iterator.h" 2 3

namespace std
{

namespace __detail
{

template<typename _Cat, typename _Limit, typename _Otherwise = _Cat>

using __clamp_iter_cat
= __conditional_t<derived_from<_Cat, _Limit>, _Limit, _Otherwise>;
}
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
# 128 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_iterator.h" 3
template<typename _Iterator>
class reverse_iterator
: public iterator<typename iterator_traits<_Iterator>::iterator_category,
typename iterator_traits<_Iterator>::value_type,
typename iterator_traits<_Iterator>::difference_type,
typename iterator_traits<_Iterator>::pointer,
typename iterator_traits<_Iterator>::reference>
{
template<typename _Iter>
friend class reverse_iterator;

template<typename _Iter>
static constexpr bool __convertible = !is_same_v<_Iter, _Iterator>
&& convertible_to<const _Iter&, _Iterator>;

protected:
_Iterator current;

typedef iterator_traits<_Iterator> __traits_type;

public:
typedef _Iterator iterator_type;
typedef typename __traits_type::pointer pointer;

using iterator_concept
= __conditional_t<random_access_iterator<_Iterator>,
random_access_iterator_tag,
bidirectional_iterator_tag>;
using iterator_category
= __detail::__clamp_iter_cat<typename __traits_type::iterator_category,
random_access_iterator_tag>;
using value_type = iter_value_t<_Iterator>;
using difference_type = iter_difference_t<_Iterator>;
using reference = iter_reference_t<_Iterator>;
# 178 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/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<typename _Iter>

requires __convertible<_Iter>

constexpr
reverse_iterator(const reverse_iterator<_Iter>& __x)
noexcept(noexcept(_Iterator(__x.current)))
: current(__x.current)
{ }

template<typename _Iter>

requires __convertible<_Iter>
&& assignable_from<_Iterator&, const _Iter&>

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; }
# 255 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_iterator.h" 3
[[__nodiscard__]]
constexpr reference
operator*() const
{
_Iterator __tmp = current;
return *--__tmp;
}

[[__nodiscard__]]
constexpr pointer
operator->() const

requires is_pointer_v<_Iterator>
|| requires(const _Iterator __i) { __i.operator->(); }

_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); }

[[nodiscard]]
friend constexpr iter_rvalue_reference_t<_Iterator>
iter_move(const reverse_iterator& __i)
noexcept(is_nothrow_copy_constructible_v<_Iterator>
&& noexcept(ranges::iter_move(--std::declval<_Iterator&>())))
{
auto __tmp = __i.base();
return ranges::iter_move(--__tmp);
}

template<indirectly_swappable<_Iterator> _Iter2>
friend constexpr void
iter_swap(const reverse_iterator& __x,
const reverse_iterator<_Iter2>& __y)
noexcept(is_nothrow_copy_constructible_v<_Iterator>
&& is_nothrow_copy_constructible_v<_Iter2>
&& noexcept(ranges::iter_swap(--std::declval<_Iterator&>(),
--std::declval<_Iter2&>())))
{
auto __xtmp = __x.base();
auto __ytmp = __y.base();
ranges::iter_swap(--__xtmp, --__ytmp);
}

private:
template<typename _Tp>
static constexpr _Tp*
_S_to_pointer(_Tp* __p)
{ return __p; }

template<typename _Tp>
static constexpr pointer
_S_to_pointer(_Tp __t)
{ return __t.operator->(); }
};
# 524 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_iterator.h" 3
template<typename _IteratorL, typename _IteratorR>
[[nodiscard]]
constexpr bool
operator==(const reverse_iterator<_IteratorL>& __x,
const reverse_iterator<_IteratorR>& __y)
requires requires { { __x.base() == __y.base() } -> convertible_to<bool>; }
{ return __x.base() == __y.base(); }

template<typename _IteratorL, typename _IteratorR>

[[nodiscard]]
constexpr bool
operator!=(const reverse_iterator<_IteratorL>& __x,
const reverse_iterator<_IteratorR>& __y)
requires requires { { __x.base() != __y.base() } -> convertible_to<bool>; }
{ return __x.base() != __y.base(); }

template<typename _IteratorL, typename _IteratorR>

[[nodiscard]]
constexpr bool
operator<(const reverse_iterator<_IteratorL>& __x,
const reverse_iterator<_IteratorR>& __y)
requires requires { { __x.base() > __y.base() } -> convertible_to<bool>; }
{ return __x.base() > __y.base(); }

template<typename _IteratorL, typename _IteratorR>

[[nodiscard]]
constexpr bool
operator>(const reverse_iterator<_IteratorL>& __x,
const reverse_iterator<_IteratorR>& __y)
requires requires { { __x.base() < __y.base() } -> convertible_to<bool>; }
{ return __x.base() < __y.base(); }

template<typename _IteratorL, typename _IteratorR>

[[nodiscard]]
constexpr bool
operator<=(const reverse_iterator<_IteratorL>& __x,
const reverse_iterator<_IteratorR>& __y)
requires requires { { __x.base() >= __y.base() } -> convertible_to<bool>; }
{ return __x.base() >= __y.base(); }

template<typename _IteratorL, typename _IteratorR>

[[nodiscard]]
constexpr bool
operator>=(const reverse_iterator<_IteratorL>& __x,
const reverse_iterator<_IteratorR>& __y)
requires requires { { __x.base() <= __y.base() } -> convertible_to<bool>; }
{ return __x.base() <= __y.base(); }

template<typename _IteratorL,
three_way_comparable_with<_IteratorL> _IteratorR>
[[nodiscard]]
constexpr compare_three_way_result_t<_IteratorL, _IteratorR>
operator<=>(const reverse_iterator<_IteratorL>& __x,
const reverse_iterator<_IteratorR>& __y)
{ return __y.base() <=> __x.base(); }

template<typename _Iterator>
[[nodiscard]]
constexpr bool
operator==(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y)
requires requires { { __x.base() == __y.base() } -> convertible_to<bool>; }
{ return __x.base() == __y.base(); }

template<three_way_comparable _Iterator>
[[nodiscard]]
constexpr compare_three_way_result_t<_Iterator, _Iterator>
operator<=>(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y)
{ return __y.base() <=> __x.base(); }
# 615 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_iterator.h" 3
template<typename _IteratorL, typename _IteratorR>
[[__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<typename _Iterator>
[[__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<typename _Iterator>
inline constexpr reverse_iterator<_Iterator>
__make_reverse_iterator(_Iterator __i)
{ return reverse_iterator<_Iterator>(__i); }

template<typename _Iterator>
[[__nodiscard__]]
inline constexpr reverse_iterator<_Iterator>
make_reverse_iterator(_Iterator __i)
{ return reverse_iterator<_Iterator>(__i); }

template<typename _Iterator1, typename _Iterator2>

requires (!sized_sentinel_for<_Iterator1, _Iterator2>)
inline constexpr bool
disable_sized_sentinel_for<reverse_iterator<_Iterator1>,
reverse_iterator<_Iterator2>> = true;

template<typename _Iterator>
constexpr
auto
__niter_base(reverse_iterator<_Iterator> __it)
-> decltype(__make_reverse_iterator(__niter_base(__it.base())))
{ return __make_reverse_iterator(__niter_base(__it.base())); }

template<typename _Iterator>
struct __is_move_iterator<reverse_iterator<_Iterator> >
: __is_move_iterator<_Iterator>
{ };

template<typename _Iterator>
constexpr
auto
__miter_base(reverse_iterator<_Iterator> __it)
-> decltype(__make_reverse_iterator(__miter_base(__it.base())))
{ return __make_reverse_iterator(__miter_base(__it.base())); }
# 688 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_iterator.h" 3
template<typename _Container>
class back_insert_iterator
: public iterator<output_iterator_tag, void, void, void, void>
{
protected:
_Container* container;

public:

typedef _Container container_type;

using difference_type = ptrdiff_t;

explicit constexpr
back_insert_iterator(_Container& __x)
: container(std::__addressof(__x)) { }
# 726 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_iterator.h" 3
constexpr
back_insert_iterator&
operator=(const typename _Container::value_type& __value)
{
container->push_back(__value);
return *this;
}

constexpr
back_insert_iterator&
operator=(typename _Container::value_type&& __value)
{
container->push_back(std::move(__value));
return *this;
}

[[__nodiscard__]] constexpr
back_insert_iterator&
operator*()
{ return *this; }

constexpr
back_insert_iterator&
operator++()
{ return *this; }

constexpr
back_insert_iterator
operator++(int)
{ return *this; }
};
# 773 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_iterator.h" 3
template<typename _Container>
[[__nodiscard__]] constexpr
inline back_insert_iterator<_Container>
back_inserter(_Container& __x)
{ return back_insert_iterator<_Container>(__x); }
# 789 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_iterator.h" 3
template<typename _Container>
class front_insert_iterator
: public iterator<output_iterator_tag, void, void, void, void>
{
protected:
_Container* container;

public:

typedef _Container container_type;

using difference_type = ptrdiff_t;

explicit constexpr
front_insert_iterator(_Container& __x)
: container(std::__addressof(__x)) { }
# 827 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_iterator.h" 3
constexpr
front_insert_iterator&
operator=(const typename _Container::value_type& __value)
{
container->push_front(__value);
return *this;
}

constexpr
front_insert_iterator&
operator=(typename _Container::value_type&& __value)
{
container->push_front(std::move(__value));
return *this;
}

[[__nodiscard__]] constexpr
front_insert_iterator&
operator*()
{ return *this; }

constexpr
front_insert_iterator&
operator++()
{ return *this; }

constexpr
front_insert_iterator
operator++(int)
{ return *this; }
};
# 874 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_iterator.h" 3
template<typename _Container>
[[__nodiscard__]] constexpr
inline front_insert_iterator<_Container>
front_inserter(_Container& __x)
{ return front_insert_iterator<_Container>(__x); }
# 894 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_iterator.h" 3
template<typename _Container>
class insert_iterator
: public iterator<output_iterator_tag, void, void, void, void>
{

using _Iter = std::detail::range_iter_t<_Container>;

protected:
_Container* container;
_Iter iter;

public:

typedef _Container container_type;

using difference_type = ptrdiff_t;

constexpr
insert_iterator(_Container& __x, _Iter __i)
: container(std::__addressof(__x)), iter(__i) {}
# 955 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_iterator.h" 3
constexpr
insert_iterator&
operator=(const typename _Container::value_type& __value)
{
iter = container->insert(iter, __value);
++iter;
return *this;
}

constexpr
insert_iterator&
operator=(typename _Container::value_type&& __value)
{
iter = container->insert(iter, std::move(__value));
++iter;
return *this;
}
[[__nodiscard__]] constexpr
insert_iterator&
operator*()
{ return *this; }

constexpr
insert_iterator&
operator++()
{ return *this; }

constexpr
insert_iterator&
operator++(int)
{ return *this; }
};

#pragma GCC diagnostic pop

# 1008 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_iterator.h" 3
template<typename _Container>
[[nodiscard]]
constexpr insert_iterator<_Container>
inserter(_Container& __x, std::__detail::__range_iter_t<_Container> __i)
{ return insert_iterator<_Container>(__x, __i); }
# 1023 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_iterator.h" 3

namespace __gnu_cxx
{

# 1037 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_iterator.h" 3
template<typename _Iterator, typename _Container>
class __normal_iterator
{
protected:
_Iterator _M_current;

typedef std::iterator_traits<_Iterator> __traits_type;

template<typename _Iter>
using __convertible_from
= std::__enable_if_t<std::is_convertible<_Iter, _Iterator>::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;

using iterator_concept = std::detail::iter_concept<_Iterator>;

constexpr __normal_iterator() noexcept
: _M_current(_Iterator()) { }

explicit constexpr
__normal_iterator(const _Iterator& __i) noexcept
: _M_current(__i) { }

template<typename _Iter, typename = __convertible_from<_Iter>>

constexpr
__normal_iterator(const __normal_iterator<_Iter, _Container>& __i)
noexcept
# 1085 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_iterator.h" 3
: _M_current(__i.base()) { }

constexpr
reference
operator*() const noexcept
{ return *_M_current; }

constexpr
pointer
operator->() const noexcept
{ return _M_current; }

constexpr
__normal_iterator&
operator++() noexcept
{
++_M_current;
return *this;
}

constexpr
__normal_iterator
operator++(int) noexcept
{ return __normal_iterator(_M_current++); }

constexpr
__normal_iterator&
operator--() noexcept
{
--_M_current;
return *this;
}

constexpr
__normal_iterator
operator--(int) noexcept
{ return __normal_iterator(_M_current--); }

constexpr
reference
operator[](difference_type __n) const noexcept
{ return _M_current[__n]; }
constexpr
__normal_iterator&
operator+=(difference_type __n) noexcept
{ _M_current += __n; return *this; }

constexpr
__normal_iterator
operator+(difference_type __n) const noexcept
{ return __normal_iterator(_M_current + __n); }

constexpr
__normal_iterator&
operator-=(difference_type __n) noexcept
{ _M_current -= __n; return *this; }

constexpr
__normal_iterator
operator-(difference_type __n) const noexcept
{ return __normal_iterator(_M_current - __n); }

constexpr
const _Iterator&
base() const noexcept
{ return _M_current; }
};
# 1166 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_iterator.h" 3
template<typename _IteratorL, typename _IteratorR, typename _Container>
[[nodiscard]]
constexpr bool
operator==(const __normal_iterator<_IteratorL, _Container>& __lhs,
const __normal_iterator<_IteratorR, _Container>& __rhs)
noexcept(noexcept(__lhs.base() == __rhs.base()))
requires requires {
{ __lhs.base() == __rhs.base() } -> std::convertible_to<bool>;
}
{ return __lhs.base() == __rhs.base(); }

template<typename _IteratorL, typename _IteratorR, typename _Container>

[[nodiscard]]
constexpr std::__detail::__synth3way_t<_IteratorR, _IteratorL>
operator<=>(const __normal_iterator<_IteratorL, _Container>& __lhs,
const __normal_iterator<_IteratorR, _Container>& __rhs)
noexcept(noexcept(std::__detail::__synth3way(__lhs.base(), __rhs.base())))
{ return std::__detail::__synth3way(__lhs.base(), __rhs.base()); }

template<typename _Iterator, typename _Container>

[[nodiscard]]
constexpr bool
operator==(const __normal_iterator<_Iterator, _Container>& __lhs,
const __normal_iterator<_Iterator, _Container>& __rhs)
noexcept(noexcept(__lhs.base() == __rhs.base()))
requires requires {
{ __lhs.base() == __rhs.base() } -> std::convertible_to<bool>;
}
{ return __lhs.base() == __rhs.base(); }

template<typename _Iterator, typename _Container>

[[nodiscard]]
constexpr std::__detail::__synth3way_t<_Iterator>
operator<=>(const __normal_iterator<_Iterator, _Container>& __lhs,
const __normal_iterator<_Iterator, _Container>& __rhs)
noexcept(noexcept(std::__detail::__synth3way(__lhs.base(), __rhs.base())))
{ return std::__detail::__synth3way(__lhs.base(), __rhs.base()); }
# 1307 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_iterator.h" 3
template<typename _IteratorL, typename _IteratorR, typename _Container>

[[__nodiscard__]] constexpr
inline auto
operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
const __normal_iterator<_IteratorR, _Container>& __rhs) noexcept
-> decltype(__lhs.base() - __rhs.base())

{ return lhs.base() - rhs.base(); }

template<typename _Iterator, typename _Container>

[[__nodiscard__]] constexpr
inline typename __normal_iterator<_Iterator, _Container>::difference_type
operator-(const __normal_iterator<_Iterator, _Container>& __lhs,
const __normal_iterator<_Iterator, _Container>& __rhs)
noexcept
{ return __lhs.base() - __rhs.base(); }

template<typename _Iterator, typename _Container>

[[__nodiscard__]] constexpr
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
{

template<typename _Iterator, typename _Container>

constexpr
_Iterator
__niter_base(__gnu_cxx::__normal_iterator<_Iterator, _Container> __it)
noexcept(std::is_nothrow_copy_constructible<_Iterator>::value)
{ return __it.base(); }
# 1371 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_iterator.h" 3
template<semiregular _Sent>
class move_sentinel
{
public:
constexpr
move_sentinel()
noexcept(is_nothrow_default_constructible_v<_Sent>)
: _M_last() { }
constexpr explicit
move_sentinel(_Sent __s)
noexcept(is_nothrow_move_constructible_v<_Sent>)
: _M_last(std::move(__s)) { }

template<typename _S2> requires convertible_to<const _S2&, _Sent>

constexpr
move_sentinel(const move_sentinel<_S2>& __s)
noexcept(is_nothrow_constructible_v<_Sent, const _S2&>)
: _M_last(__s.base())
{ }

template<typename _S2> requires assignable_from<_Sent&, const _S2&>

constexpr move_sentinel&
operator=(const move_sentinel<_S2>& __s)
noexcept(is_nothrow_assignable_v<_Sent, const _S2&>)
{
_M_last = __s.base();
return *this;
}

[[nodiscard]]
constexpr _Sent
base() const
noexcept(is_nothrow_copy_constructible_v<_Sent>)
{ return _M_last; }

private:
_Sent _M_last;
};

namespace __detail
{

template<typename _Iterator>
struct __move_iter_cat
{ };

template<typename _Iterator>
requires requires { typename __iter_category_t<_Iterator>; }
struct __move_iter_cat<_Iterator>
{
using iterator_category
= __clamp_iter_cat<__iter_category_t<_Iterator>,
random_access_iterator_tag>;
};

}
# 1439 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_iterator.h" 3
template<typename _Iterator>
class move_iterator

: public __detail::__move_iter_cat<_Iterator>

{
_Iterator _M_current;
using __traits_type = iterator_traits<_Iterator>;

template<typename _Iter2>
friend class move_iterator;

template<typename _Iter2>
static constexpr bool __convertible = !is_same_v<_Iter2, _Iterator>
&& convertible_to<const _Iter2&, _Iterator>;

static auto
_S_iter_concept()
{
if constexpr (random_access_iterator<_Iterator>)
return random_access_iterator_tag{};
else if constexpr (bidirectional_iterator<_Iterator>)
return bidirectional_iterator_tag{};
else if constexpr (forward_iterator<_Iterator>)
return forward_iterator_tag{};
else
return input_iterator_tag{};
}

public:
using iterator_type = _Iterator;

using iterator_concept = decltype(_S_iter_concept());

using value_type = iter_value_t<_Iterator>;

using difference_type = iter_difference_t<_Iterator>;
using pointer = _Iterator;
using reference = iter_rvalue_reference_t<_Iterator>;
# 1503 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_iterator.h" 3
constexpr
move_iterator()
: _M_current() { }

explicit constexpr
move_iterator(iterator_type __i)
: _M_current(std::move(__i)) { }

template<typename _Iter>

requires __convertible<_Iter>

constexpr
move_iterator(const move_iterator<_Iter>& __i)
: _M_current(__i._M_current) { }
template<typename _Iter>

requires __convertible<_Iter>
&& assignable_from<_Iterator&, const _Iter&>

constexpr
move_iterator& operator=(const move_iterator<_Iter>& __i)
{
_M_current = __i._M_current;
return *this;
}

[[nodiscard]]
constexpr const iterator_type&
base() const & noexcept
{ return _M_current; }

[[nodiscard]]
constexpr iterator_type
base() &&
{ return std::move(_M_current); }

[[__nodiscard__]]
constexpr reference
operator*() const

{ return ranges::iter_move(_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 void
operator++(int) requires (!forward_iterator<_Iterator>)
{ ++_M_current; }

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 ranges::iter_move(_M_current + __n); }

template<sentinel_for<_Iterator> _Sent>
[[nodiscard]]
friend constexpr bool
operator==(const move_iterator& __x, const move_sentinel<_Sent>& __y)
{ return __x.base() == __y.base(); }
template<sized_sentinel_for<_Iterator> _Sent>
[[nodiscard]]
friend constexpr iter_difference_t<_Iterator>
operator-(const move_sentinel<_Sent>& __x, const move_iterator& __y)
{ return __x.base() - __y.base(); }

template<sized_sentinel_for<_Iterator> _Sent>
[[nodiscard]]
friend constexpr iter_difference_t<_Iterator>
operator-(const move_iterator& __x, const move_sentinel<_Sent>& __y)
{ return __x.base() - __y.base(); }

[[nodiscard]]
friend constexpr iter_rvalue_reference_t<_Iterator>
iter_move(const move_iterator& __i)
noexcept(noexcept(ranges::iter_move(__i._M_current)))
{ return ranges::iter_move(__i._M_current); }

template<indirectly_swappable<_Iterator> _Iter2>
friend constexpr void
iter_swap(const move_iterator& __x, const move_iterator<_Iter2>& __y)
noexcept(noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
{ return ranges::iter_swap(__x._M_current, __y._M_current); }

};

template<typename _IteratorL, typename _IteratorR>

[[__nodiscard__]]
inline constexpr bool
operator==(const move_iterator<_IteratorL>& __x,
const move_iterator<_IteratorR>& __y)

requires requires { { x.base() == y.base() } -> convertible_to<bool>; }

{ return x.base() == y.base(); }

template<typename _IteratorL,
three_way_comparable_with<_IteratorL> _IteratorR>
[[__nodiscard__]]
constexpr compare_three_way_result_t<_IteratorL, _IteratorR>
operator<=>(const move_iterator<_IteratorL>& __x,
const move_iterator<_IteratorR>& __y)
{ return __x.base() <=> __y.base(); }
# 1691 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_iterator.h" 3
template<typename _IteratorL, typename _IteratorR>
[[__nodiscard__]]
inline constexpr bool
operator<(const move_iterator<_IteratorL>& __x,
const move_iterator<_IteratorR>& __y)

requires requires { { x.base() < y.base() } -> convertible_to<bool>; }

{ return x.base() < y.base(); }

template<typename _IteratorL, typename _IteratorR>

[[__nodiscard__]]
inline constexpr bool
operator<=(const move_iterator<_IteratorL>& __x,
const move_iterator<_IteratorR>& __y)

requires requires { { y.base() < x.base() } -> convertible_to<bool>; }

{ return !(y < x); }

template<typename _IteratorL, typename _IteratorR>

[[__nodiscard__]]
inline constexpr bool
operator>(const move_iterator<_IteratorL>& __x,
const move_iterator<_IteratorR>& __y)

requires requires { { y.base() < x.base() } -> convertible_to<bool>; }

{ return y < x; }

template<typename _IteratorL, typename _IteratorR>

[[__nodiscard__]]
inline constexpr bool
operator>=(const move_iterator<_IteratorL>& __x,
const move_iterator<_IteratorR>& __y)

requires requires { { x.base() < y.base() } -> convertible_to<bool>; }

{ return !(x < y); }

template<typename _Iterator>
[[__nodiscard__]]
inline constexpr bool
operator==(const move_iterator<_Iterator>& __x,
const move_iterator<_Iterator>& __y)
{ return __x.base() == __y.base(); }

template<three_way_comparable _Iterator>
[[__nodiscard__]]
constexpr compare_three_way_result_t<_Iterator>
operator<=>(const move_iterator<_Iterator>& __x,
const move_iterator<_Iterator>& __y)
{ return __x.base() <=> __y.base(); }
# 1786 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_iterator.h" 3
template<typename _IteratorL, typename _IteratorR>
[[__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<typename _Iterator>
[[__nodiscard__]]
inline constexpr move_iterator<_Iterator>
operator+(typename move_iterator<_Iterator>::difference_type __n,
const move_iterator<_Iterator>& __x)
{ return __x + __n; }
template<typename _Iterator>
[[__nodiscard__]]
inline constexpr move_iterator<_Iterator>
make_move_iterator(_Iterator __i)
{ return move_iterator<_Iterator>(std::move(__i)); }

template<typename _Iterator, typename _ReturnType

= __conditional_t<__move_if_noexcept_cond
<typename iterator_traits<_Iterator>::value_type>::value,
_Iterator, move_iterator<_Iterator>>>
inline constexpr _ReturnType
__make_move_if_noexcept_iterator(_Iterator __i)
{ return _ReturnType(__i); }

template<typename _Tp, typename _ReturnType

= __conditional_t<__move_if_noexcept_cond<_Tp>::value,
const _Tp*, move_iterator<_Tp*>>>
inline constexpr _ReturnType
__make_move_if_noexcept_iterator(_Tp* __i)
{ return _ReturnType(__i); }

namespace __detail
{
template<typename _It>
concept __common_iter_has_arrow = indirectly_readable<const _It>
&& (requires(const _It& __it) { __it.operator->(); }
|| is_reference_v<iter_reference_t<_It>>
|| constructible_from<iter_value_t<_It>, iter_reference_t<_It>>);

template<typename _It>
concept __common_iter_use_postfix_proxy
= (!requires (_It& __i) { { *__i++ } -> __can_reference; })
&& constructible_from<iter_value_t<_It>, iter_reference_t<_It>>
&& move_constructible<iter_value_t<_It>>;
}

template<input_or_output_iterator _It, sentinel_for<_It> _Sent>

requires (!same_as<_It, _Sent>) && copyable<_It>
class common_iterator
{
template<typename _Tp, typename _Up>
static constexpr bool
_S_noexcept1()
{
if constexpr (is_trivially_default_constructible_v<_Tp>)
return is_nothrow_assignable_v<_Tp&, _Up>;
else
return is_nothrow_constructible_v<_Tp, _Up>;
}

template<typename _It2, typename _Sent2>

static constexpr bool
_S_noexcept()
{ return _S_noexcept1<_It, _It2>() && _S_noexcept1<_Sent, _Sent2>(); }

class __arrow_proxy
{
iter_value_t<_It> _M_keep;

constexpr
__arrow_proxy(iter_reference_t<_It>&& __x)
: _M_keep(std::move(__x)) { }

friend class common_iterator;

public:
constexpr const iter_value_t<_It>*
operator->() const noexcept
{ return std::__addressof(_M_keep); }
};

class __postfix_proxy
{
iter_value_t<_It> _M_keep;

constexpr
__postfix_proxy(iter_reference_t<_It>&& __x)
: _M_keep(std::forward<iter_reference_t<_It>>(__x)) { }

friend class common_iterator;

public:
constexpr const iter_value_t<_It>&
operator*() const noexcept
{ return _M_keep; }
};

public:
constexpr
common_iterator()
noexcept(is_nothrow_default_constructible_v<_It>)
requires default_initializable<_It>
: _M_it(), _M_index(0)
{ }

constexpr
common_iterator(_It __i)
noexcept(is_nothrow_move_constructible_v<_It>)
: _M_it(std::move(__i)), _M_index(0)
{ }

constexpr
common_iterator(_Sent __s)
noexcept(is_nothrow_move_constructible_v<_Sent>)
: _M_sent(std::move(__s)), _M_index(1)
{ }

template<typename _It2, typename _Sent2>

requires convertible_to<const _It2&, _It>
&& convertible_to<const _Sent2&, _Sent>
constexpr
common_iterator(const common_iterator<_It2, _Sent2>& __x)
noexcept(_S_noexcept<const _It2&, const _Sent2&>())
: _M_valueless(), _M_index(__x._M_index)
{
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!
bool(__x._M_has_value()), false)) std::__glibcxx_assert_fail(); } while (false);
if (_M_index == 0)
{
if constexpr (is_trivially_default_constructible_v<_It>)
_M_it = std::move(__x._M_it);
else
std::construct_at(std::__addressof(_M_it), __x._M_it);
}
else if (_M_index == 1)
{
if constexpr (is_trivially_default_constructible_v<_Sent>)
_M_sent = std::move(__x._M_sent);
else
std::construct_at(std::__addressof(_M_sent), __x._M_sent);
}
}

common_iterator(const common_iterator&) = default;

constexpr
common_iterator(const common_iterator& __x)
noexcept(_S_noexcept<const _It&, const _Sent&>())
requires (!is_trivially_copyable_v<_It> || !is_trivially_copyable_v<_Sent>)
: _M_valueless(), _M_index(__x._M_index)
{
if (_M_index == 0)
{
if constexpr (is_trivially_default_constructible_v<_It>)
_M_it = __x._M_it;
else
std::construct_at(std::__addressof(_M_it), __x._M_it);
}
else if (_M_index == 1)
{
if constexpr (is_trivially_default_constructible_v<_Sent>)
_M_sent = __x._M_sent;
else
std::construct_at(std::__addressof(_M_sent), __x._M_sent);
}
}

common_iterator(common_iterator&&) = default;

constexpr
common_iterator(common_iterator&& __x)
noexcept(_S_noexcept<_It, _Sent>())
requires (!is_trivially_copyable_v<_It> || !is_trivially_copyable_v<_Sent>)
: _M_valueless(), _M_index(__x._M_index)
{
if (_M_index == 0)
{
if constexpr (is_trivially_default_constructible_v<_It>)
_M_it = std::move(__x._M_it);
else
std::construct_at(std::__addressof(_M_it), std::move(__x._M_it));
}
else if (_M_index == 1)
{
if constexpr (is_trivially_default_constructible_v<_Sent>)
_M_sent = std::move(__x._M_sent);
else
std::construct_at(std::__addressof(_M_sent),
std::move(__x._M_sent));
}
}

constexpr common_iterator&
operator=(const common_iterator&) = default;

constexpr common_iterator&
operator=(const common_iterator& __x)
noexcept(is_nothrow_copy_assignable_v<_It>
&& is_nothrow_copy_assignable_v<_Sent>
&& is_nothrow_copy_constructible_v<_It>
&& is_nothrow_copy_constructible_v<_Sent>)
requires (!is_trivially_copy_assignable_v<_It>
|| !is_trivially_copy_assignable_v<_Sent>)
{
_M_assign(__x);
return *this;
}

constexpr common_iterator&
operator=(common_iterator&&) = default;

constexpr common_iterator&
operator=(common_iterator&& __x)
noexcept(is_nothrow_move_assignable_v<_It>
&& is_nothrow_move_assignable_v<_Sent>
&& is_nothrow_move_constructible_v<_It>
&& is_nothrow_move_constructible_v<_Sent>)
requires (!is_trivially_move_assignable_v<_It>
|| !is_trivially_move_assignable_v<_Sent>)
{
_M_assign(std::move(__x));
return *this;
}

template<typename _It2, typename _Sent2>

requires convertible_to<const _It2&, _It>
&& convertible_to<const _Sent2&, _Sent>
&& assignable_from<_It&, const _It2&>
&& assignable_from<_Sent&, const _Sent2&>
constexpr common_iterator&
operator=(const common_iterator<_It2, _Sent2>& __x)
noexcept(is_nothrow_constructible_v<_It, const _It2&>
&& is_nothrow_constructible_v<_Sent, const _Sent2&>
&& is_nothrow_assignable_v<_It&, const _It2&>
&& is_nothrow_assignable_v<_Sent&, const _Sent2&>)
{
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!
bool(__x._M_has_value()), false)) std::__glibcxx_assert_fail(); } while (false);
_M_assign(__x);
return *this;
}

~common_iterator() = default;

constexpr
~common_iterator()
requires (!is_trivially_destructible_v<_It>
|| !is_trivially_destructible_v<_Sent>)

{
if (_M_index == 0)
_M_it.~_It();
else if (_M_index == 1)
_M_sent.~_Sent();
}

[[nodiscard]]
constexpr decltype(auto)
operator*()
{
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(_M_index
== 0), false)) std::__glibcxx_assert_fail(); } while (false);
return *_M_it;
}

[[nodiscard]]
constexpr decltype(auto)
operator*() const requires __detail::__dereferenceable<const _It>
{
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(_M_index
== 0), false)) std::__glibcxx_assert_fail(); } while (false);
return *_M_it;
}

[[nodiscard]]
constexpr auto
operator->() const requires __detail::__common_iter_has_arrow<_It>
{
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(_M_index
== 0), false)) std::__glibcxx_assert_fail(); } while (false);
if constexpr (is_pointer_v<_It> || requires { _M_it.operator->(); })
return _M_it;
else if constexpr (is_reference_v<iter_reference_t<_It>>)
{
auto&& __tmp = *_M_it;
return std::__addressof(__tmp);
}
else
return __arrow_proxy{*_M_it};
}

constexpr common_iterator&
operator++()
{
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(_M_index
== 0), false)) std::__glibcxx_assert_fail(); } while (false);
++_M_it;
return *this;
}

constexpr decltype(auto)
operator++(int)
{
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(_M_index
== 0), false)) std::__glibcxx_assert_fail(); } while (false);
if constexpr (forward_iterator<_It>)
{
common_iterator __tmp = *this;
++*this;
return __tmp;
}
else if constexpr (!__detail::__common_iter_use_postfix_proxy<_It>)
return _M_it++;
else
{
__postfix_proxy __p(**this);
++*this;
return __p;
}
}

template<typename _It2, sentinel_for<_It> _Sent2>

requires sentinel_for<_Sent, _It2>
friend constexpr bool
operator== [[nodiscard]] (const common_iterator& __x,
const common_iterator<_It2, _Sent2>& __y)
{
switch(__x._M_index << 2 | __y._M_index)
{
case 0b0000:
case 0b0101:
return true;
case 0b0001:
return __x._M_it == __y._M_sent;
case 0b0100:
return __x._M_sent == __y._M_it;
default:
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!
bool(__x._M_has_value()), false)) std::__glibcxx_assert_fail(); } while (false);
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!
bool(__y._M_has_value()), false)) std::__glibcxx_assert_fail(); } while (false);
__builtin_unreachable();
}
}

template<typename _It2, sentinel_for<_It> _Sent2>

requires sentinel_for<_Sent, _It2> && equality_comparable_with<_It, _It2>
friend constexpr bool
operator== [[nodiscard]] (const common_iterator& __x,
const common_iterator<_It2, _Sent2>& __y)
{
switch(__x._M_index << 2 | __y._M_index)
{
case 0b0101:
return true;
case 0b0000:
return __x._M_it == __y._M_it;
case 0b0001:
return __x._M_it == __y._M_sent;
case 0b0100:
return __x._M_sent == __y._M_it;
default:
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!
bool(__x._M_has_value()), false)) std::__glibcxx_assert_fail(); } while (false);
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!
bool(__y._M_has_value()), false)) std::__glibcxx_assert_fail(); } while (false);
__builtin_unreachable();
}
}

template<sized_sentinel_for<_It> _It2, sized_sentinel_for<_It> _Sent2>

requires sized_sentinel_for<_Sent, _It2>
friend constexpr iter_difference_t<_It2>
operator- [[nodiscard]] (const common_iterator& __x,
const common_iterator<_It2, _Sent2>& __y)
{
switch(__x._M_index << 2 | __y._M_index)
{
case 0b0101:
return 0;
case 0b0000:
return __x._M_it - __y._M_it;
case 0b0001:
return __x._M_it - __y._M_sent;
case 0b0100:
return __x._M_sent - __y._M_it;
default:
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!
bool(__x._M_has_value()), false)) std::__glibcxx_assert_fail(); } while (false);
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!
bool(__y._M_has_value()), false)) std::__glibcxx_assert_fail(); } while (false);
__builtin_unreachable();
}
}

[[nodiscard]]
friend constexpr iter_rvalue_reference_t<_It>
iter_move(const common_iterator& __i)
noexcept(noexcept(ranges::iter_move(std::declval<const _It&>())))
requires input_iterator<_It>
{
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!
bool(__i._M_index == 0), false)) std::__glibcxx_assert_fail(); } while (false);
return ranges::iter_move(__i._M_it);
}

template<indirectly_swappable<_It> _It2, typename _Sent2>

friend constexpr void
iter_swap(const common_iterator& __x,
const common_iterator<_It2, _Sent2>& __y)
noexcept(noexcept(ranges::iter_swap(std::declval<const _It&>(),
std::declval<const _It2&>())))
{
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__x._M_index
== 0), false)) std::__glibcxx_assert_fail(); } while (false);
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__y._M_index
== 0), false)) std::__glibcxx_assert_fail(); } while (false);
return ranges::iter_swap(__x._M_it, __y._M_it);
}

private:
template<input_or_output_iterator _It2, sentinel_for<_It2> _Sent2>
requires (!same_as<_It2, _Sent2>) && copyable<_It2>
friend class common_iterator;

constexpr bool
_M_has_value() const noexcept { return _M_index != _S_valueless; }

template<typename _CIt>
constexpr void
_M_assign(_CIt&& __x)
{
if (_M_index == __x._M_index)
{
if (_M_index == 0)
_M_it = std::forward<_CIt>(__x)._M_it;
else if (_M_index == 1)
_M_sent = std::forward<_CIt>(__x)._M_sent;
}
else
{
if (_M_index == 0)
_M_it.~_It();
else if (_M_index == 1)
_M_sent.~_Sent();
_M_index = _S_valueless;

if (__x._M_index == 0)
std::construct_at(std::__addressof(_M_it),
std::forward<_CIt>(__x)._M_it);
else if (__x._M_index == 1)
std::construct_at(std::__addressof(_M_sent),
std::forward<_CIt>(__x)._M_sent);
_M_index = __x._M_index;
}
}

union
{
_It _M_it;
_Sent _M_sent;
unsigned char _M_valueless;
};
unsigned char _M_index;

static constexpr unsigned char _S_valueless{2};

};

template<typename _It, typename _Sent>

struct incrementable_traits<common_iterator<_It, _Sent>>
{
using difference_type = iter_difference_t<_It>;
};

template<input_iterator _It, typename _Sent>

struct iterator_traits<common_iterator<_It, _Sent>>
{
private:
template<typename _Iter>
struct __ptr
{
using type = void;
};

template<typename _Iter>
requires __detail::__common_iter_has_arrow<_Iter>
struct __ptr<_Iter>
{
using _CIter = common_iterator<_Iter, _Sent>;
using type = decltype(std::declval<const _CIter&>().operator->());
};

static auto
_S_iter_cat()
{
if constexpr (requires { requires derived_from<__iter_category_t<_It>,
forward_iterator_tag>; })
return forward_iterator_tag{};
else
return input_iterator_tag{};
}

public:
using iterator_concept = __conditional_t<forward_iterator<_It>,
forward_iterator_tag,
input_iterator_tag>;
using iterator_category = decltype(_S_iter_cat());
using value_type = iter_value_t<_It>;
using difference_type = iter_difference_t<_It>;
using pointer = typename __ptr<_It>::type;
using reference = iter_reference_t<_It>;
};

namespace __detail
{
template<typename _It>
struct __counted_iter_value_type
{ };

template<indirectly_readable _It>
struct __counted_iter_value_type<_It>
{ using value_type = iter_value_t<_It>; };

template<typename _It>
struct __counted_iter_concept
{ };

template<typename _It>
requires requires { typename _It::iterator_concept; }
struct __counted_iter_concept<_It>
{ using iterator_concept = typename _It::iterator_concept; };

template<typename _It>
struct __counted_iter_cat
{ };

template<typename _It>
requires requires { typename _It::iterator_category; }
struct __counted_iter_cat<_It>
{ using iterator_category = typename _It::iterator_category; };
}

template<input_or_output_iterator _It>
class counted_iterator
: public __detail::__counted_iter_value_type<_It>,
public __detail::__counted_iter_concept<_It>,
public __detail::__counted_iter_cat<_It>
{
public:
using iterator_type = _It;

using difference_type = iter_difference_t<_It>;

constexpr counted_iterator() requires default_initializable<_It> = default;

constexpr
counted_iterator(_It __i, iter_difference_t<_It> __n)
: _M_current(std::move(__i)), _M_length(__n)
{ do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__n >=
0), false)) std::__glibcxx_assert_fail(); } while (false); }

template<typename _It2>
requires convertible_to<const _It2&, _It>
constexpr
counted_iterator(const counted_iterator<_It2>& __x)
: _M_current(__x._M_current), _M_length(__x._M_length)
{ }

template<typename _It2>
requires assignable_from<_It&, const _It2&>
constexpr counted_iterator&
operator=(const counted_iterator<_It2>& __x)
{
_M_current = __x._M_current;
_M_length = __x._M_length;
return *this;
}

[[nodiscard]]
constexpr const _It&
base() const & noexcept
{ return _M_current; }

[[nodiscard]]
constexpr _It
base() &&
noexcept(is_nothrow_move_constructible_v<_It>)
{ return std::move(_M_current); }

[[nodiscard]]
constexpr iter_difference_t<_It>
count() const noexcept { return _M_length; }

[[nodiscard]]
constexpr decltype(auto)
operator*()
noexcept(noexcept(*_M_current))
{
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(_M_length >
0), false)) std::__glibcxx_assert_fail(); } while (false);
return *_M_current;
}

[[nodiscard]]
constexpr decltype(auto)
operator*() const
noexcept(noexcept(*_M_current))
requires __detail::__dereferenceable<const _It>
{
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(_M_length >
0), false)) std::__glibcxx_assert_fail(); } while (false);
return *_M_current;
}

[[nodiscard]]
constexpr auto
operator->() const noexcept
requires contiguous_iterator<_It>
{ return std::to_address(_M_current); }

constexpr counted_iterator&
operator++()
{
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(_M_length >
0), false)) std::__glibcxx_assert_fail(); } while (false);
++_M_current;
--_M_length;
return *this;
}

constexpr decltype(auto)
operator++(int)
{
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(_M_length >
0), false)) std::__glibcxx_assert_fail(); } while (false);
--_M_length;
try
{
return _M_current++;
} catch(...) {
++_M_length;
throw;
}
}

constexpr counted_iterator
operator++(int) requires forward_iterator<_It>
{
auto __tmp = *this;
++*this;
return __tmp;
}

constexpr counted_iterator&
operator--() requires bidirectional_iterator<_It>
{
--_M_current;
++_M_length;
return *this;
}

constexpr counted_iterator
operator--(int) requires bidirectional_iterator<_It>
{
auto __tmp = *this;
--*this;
return __tmp;
}

[[nodiscard]]
constexpr counted_iterator
operator+(iter_difference_t<_It> __n) const
requires random_access_iterator<_It>
{ return counted_iterator(_M_current + __n, _M_length - __n); }

[[nodiscard]]
friend constexpr counted_iterator
operator+(iter_difference_t<_It> __n, const counted_iterator& __x)
requires random_access_iterator<_It>
{ return __x + __n; }

constexpr counted_iterator&
operator+=(iter_difference_t<_It> __n)
requires random_access_iterator<_It>
{
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__n <=
_M_length), false)) std::__glibcxx_assert_fail(); } while (false);
_M_current += __n;
_M_length -= __n;
return *this;
}

[[nodiscard]]
constexpr counted_iterator
operator-(iter_difference_t<_It> __n) const
requires random_access_iterator<_It>
{ return counted_iterator(_M_current - __n, _M_length + __n); }

template<common_with<_It> _It2>
[[nodiscard]]
friend constexpr iter_difference_t<_It2>
operator-(const counted_iterator& __x,
const counted_iterator<_It2>& __y)
{ return __y._M_length - __x._M_length; }

[[nodiscard]]
friend constexpr iter_difference_t<_It>
operator-(const counted_iterator& __x, default_sentinel_t)
{ return -__x._M_length; }

[[nodiscard]]
friend constexpr iter_difference_t<_It>
operator-(default_sentinel_t, const counted_iterator& __y)
{ return __y._M_length; }

constexpr counted_iterator&
operator-=(iter_difference_t<_It> __n)
requires random_access_iterator<_It>
{
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(-__n <=
_M_length), false)) std::__glibcxx_assert_fail(); } while (false);
_M_current -= __n;
_M_length += __n;
return *this;
}

[[nodiscard]]
constexpr decltype(auto)
operator[](iter_difference_t<_It> __n) const
noexcept(noexcept(_M_current[__n]))
requires random_access_iterator<_It>
{
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__n <
_M_length), false)) std::__glibcxx_assert_fail(); } while (false);
return _M_current[__n];
}

template<common_with<_It> _It2>
[[nodiscard]]
friend constexpr bool
operator==(const counted_iterator& __x,
const counted_iterator<_It2>& __y)
{ return __x._M_length == __y._M_length; }

[[nodiscard]]
friend constexpr bool
operator==(const counted_iterator& __x, default_sentinel_t)
{ return __x._M_length == 0; }

template<common_with<_It> _It2>
[[nodiscard]]
friend constexpr strong_ordering
operator<=>(const counted_iterator& __x,
const counted_iterator<_It2>& __y)
{ return __y._M_length <=> __x._M_length; }

[[nodiscard]]
friend constexpr iter_rvalue_reference_t<_It>
iter_move(const counted_iterator& __i)
noexcept(noexcept(ranges::iter_move(__i._M_current)))
requires input_iterator<_It>
{
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__i._M_length
> 0), false)) std::__glibcxx_assert_fail(); } while (false);
return ranges::iter_move(__i._M_current);
}

template<indirectly_swappable<_It> _It2>
friend constexpr void
iter_swap(const counted_iterator& __x,
const counted_iterator<_It2>& __y)
noexcept(noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
{
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!
bool(__x._M_length > 0 && __y._M_length > 0), false)) std::__glibcxx_assert_fail();
} while (false);
ranges::iter_swap(__x._M_current, __y._M_current);
}

private:
template<input_or_output_iterator _It2> friend class counted_iterator;

_It _M_current = _It();

iter_difference_t<_It> _M_length = 0;
};

template<input_iterator _It>
requires same_as<__detail::__iter_traits<_It>, iterator_traits<_It>>
struct iterator_traits<counted_iterator<_It>> : iterator_traits<_It>
{
using pointer = __conditional_t<contiguous_iterator<_It>,
add_pointer_t<iter_reference_t<_It>>,
void>;
};

template<indirectly_readable _It>
using iter_const_reference_t
= common_reference_t<const iter_value_t<_It>&&, iter_reference_t<_It>>;

template<input_iterator _It> class basic_const_iterator;

namespace __detail
{
template<typename _It>
concept __constant_iterator = input_iterator<_It>
&& same_as<iter_const_reference_t<_It>, iter_reference_t<_It>>;

template<typename _Tp>
inline constexpr bool __is_const_iterator = false;

template<typename _It>
inline constexpr bool __is_const_iterator<basic_const_iterator<_It>> = true;

template<typename _Tp>
concept __not_a_const_iterator = !__is_const_iterator<_Tp>;

template<indirectly_readable _It>
using __iter_const_rvalue_reference_t
= common_reference_t<const iter_value_t<_It>&&, iter_rvalue_reference_t<_It>>;
template<typename _It>
struct __basic_const_iterator_iter_cat
{ };

template<forward_iterator _It>
struct __basic_const_iterator_iter_cat<_It>
{ using iterator_category = __iter_category_t<_It>; };
}

template<input_iterator _It>
using const_iterator
= __conditional_t<__detail::__constant_iterator<_It>, _It,
basic_const_iterator<_It>>;

namespace __detail
{
template<typename _Sent>
struct __const_sentinel
{ using type = _Sent; };

template<input_iterator _Sent>
struct __const_sentinel<_Sent>
{ using type = const_iterator<_Sent>; };
}

template<semiregular _Sent>
using const_sentinel = typename __detail::__const_sentinel<_Sent>::type;

template<input_iterator _It>
class basic_const_iterator
: public __detail::__basic_const_iterator_iter_cat<_It>
{
_It _M_current = _It();
using __reference = iter_const_reference_t<_It>;
using __rvalue_reference = __detail::__iter_const_rvalue_reference_t<_It>;

static auto
_S_iter_concept()
{
if constexpr (contiguous_iterator<_It>)
return contiguous_iterator_tag{};
else if constexpr (random_access_iterator<_It>)
return random_access_iterator_tag{};
else if constexpr (bidirectional_iterator<_It>)
return bidirectional_iterator_tag{};
else if constexpr (forward_iterator<_It>)
return forward_iterator_tag{};
else
return input_iterator_tag{};
}

template<input_iterator _It2> friend class basic_const_iterator;

public:
using iterator_concept = decltype(_S_iter_concept());
using value_type = iter_value_t<_It>;
using difference_type = iter_difference_t<_It>;
basic_const_iterator() requires default_initializable<_It> = default;

constexpr
basic_const_iterator(_It __current)
noexcept(is_nothrow_move_constructible_v<_It>)
: _M_current(std::move(__current))
{ }

template<convertible_to<_It> _It2>
constexpr
basic_const_iterator(basic_const_iterator<_It2> __current)
noexcept(is_nothrow_constructible_v<_It, _It2>)
: _M_current(std::move(__current._M_current))
{ }

template<__detail::__different_from<basic_const_iterator> _Tp>
requires convertible_to<_Tp, _It>
constexpr
basic_const_iterator(_Tp&& __current)
noexcept(is_nothrow_constructible_v<_It, _Tp>)
: _M_current(std::forward<_Tp>(__current))
{ }

constexpr const _It&

base() const & noexcept
{ return _M_current; }

constexpr _It
base() &&
noexcept(is_nothrow_move_constructible_v<_It>)
{ return std::move(_M_current); }

constexpr __reference
operator*() const
noexcept(noexcept(static_cast<__reference>(*_M_current)))
{ return static_cast<__reference>(*_M_current); }

constexpr const auto*

operator->() const
noexcept(contiguous_iterator<_It> || noexcept(*_M_current))
requires is_lvalue_reference_v<iter_reference_t<_It>>
&& same_as<remove_cvref_t<iter_reference_t<_It>>, value_type>
{
if constexpr (contiguous_iterator<_It>)
return std::to_address(_M_current);
else
return std::__addressof(*_M_current);
}

constexpr basic_const_iterator&
operator++()
noexcept(noexcept(++_M_current))
{
++_M_current;
return *this;
}

constexpr void
operator++(int)
noexcept(noexcept(++_M_current))
{ ++_M_current; }

constexpr basic_const_iterator
operator++(int)
noexcept(noexcept(++*this) &&
is_nothrow_copy_constructible_v<basic_const_iterator>)
requires forward_iterator<_It>
{
auto __tmp = *this;
++*this;
return __tmp;
}

constexpr basic_const_iterator&
operator--()
noexcept(noexcept(--_M_current))
requires bidirectional_iterator<_It>
{
--_M_current;
return *this;
}

constexpr basic_const_iterator
operator--(int)
noexcept(noexcept(--*this) &&
is_nothrow_copy_constructible_v<basic_const_iterator>)
requires bidirectional_iterator<_It>
{
auto __tmp = *this;
--*this;
return __tmp;
}

constexpr basic_const_iterator&
operator+=(difference_type __n)
noexcept(noexcept(_M_current += __n))
requires random_access_iterator<_It>
{
_M_current += __n;
return *this;
}

constexpr basic_const_iterator&
operator-=(difference_type __n)
noexcept(noexcept(_M_current -= __n))
requires random_access_iterator<_It>
{
_M_current -= __n;
return *this;
}

constexpr __reference
operator[](difference_type __n) const
noexcept(noexcept(static_cast<__reference>(_M_current[__n])))
requires random_access_iterator<_It>
{ return static_cast<__reference>(_M_current[__n]); }

template<sentinel_for<_It> _Sent>
constexpr bool
operator==(const _Sent& __s) const
noexcept(noexcept(_M_current == __s))
{ return _M_current == __s; }

template<__detail::__not_a_const_iterator _CIt>
requires __detail::__constant_iterator<_CIt> && convertible_to<_It, _CIt>
constexpr
operator _CIt() const&
{ return _M_current; }

template<__detail::__not_a_const_iterator _CIt>
requires __detail::__constant_iterator<_CIt> && convertible_to<_It, _CIt>
constexpr
operator _CIt() &&
{ return std::move(_M_current); }

constexpr bool
operator<(const basic_const_iterator& __y) const
noexcept(noexcept(_M_current < __y._M_current))
requires random_access_iterator<_It>
{ return _M_current < __y._M_current; }

constexpr bool
operator>(const basic_const_iterator& __y) const
noexcept(noexcept(_M_current > __y._M_current))
requires random_access_iterator<_It>
{ return _M_current > __y._M_current; }

constexpr bool
operator<=(const basic_const_iterator& __y) const
noexcept(noexcept(_M_current <= __y._M_current))
requires random_access_iterator<_It>
{ return _M_current <= __y._M_current; }

constexpr bool
operator>=(const basic_const_iterator& __y) const
noexcept(noexcept(_M_current >= __y._M_current))
requires random_access_iterator<_It>
{ return _M_current >= __y._M_current; }

constexpr auto
operator<=>(const basic_const_iterator& __y) const
noexcept(noexcept(_M_current <=> __y._M_current))
requires random_access_iterator<_It> && three_way_comparable<_It>
{ return _M_current <=> __y._M_current; }

template<__detail::__different_from<basic_const_iterator> _It2>
constexpr bool
operator<(const _It2& __y) const
noexcept(noexcept(_M_current < __y))
requires random_access_iterator<_It> && totally_ordered_with<_It, _It2>
{ return _M_current < __y; }

template<__detail::__different_from<basic_const_iterator> _It2>
constexpr bool
operator>(const _It2& __y) const
noexcept(noexcept(_M_current > __y))
requires random_access_iterator<_It> && totally_ordered_with<_It, _It2>
{ return _M_current > __y; }

template<__detail::__different_from<basic_const_iterator> _It2>
constexpr bool
operator<=(const _It2& __y) const
noexcept(noexcept(_M_current <= __y))
requires random_access_iterator<_It> && totally_ordered_with<_It, _It2>
{ return _M_current <= __y; }

template<__detail::__different_from<basic_const_iterator> _It2>
constexpr bool
operator>=(const _It2& __y) const
noexcept(noexcept(_M_current >= __y))
requires random_access_iterator<_It> && totally_ordered_with<_It, _It2>
{ return _M_current >= __y; }

template<__detail::__different_from<basic_const_iterator> _It2>
constexpr auto
operator<=>(const _It2& __y) const
noexcept(noexcept(_M_current <=> __y))
requires random_access_iterator<_It> && totally_ordered_with<_It, _It2>
&& three_way_comparable_with<_It, _It2>
{ return _M_current <=> __y; }

template<__detail::__not_a_const_iterator _It2>
friend constexpr bool
operator<(const _It2& __x, const basic_const_iterator& __y)
noexcept(noexcept(__x < __y._M_current))
requires random_access_iterator<_It> && totally_ordered_with<_It, _It2>
{ return __x < __y._M_current; }

template<__detail::__not_a_const_iterator _It2>
friend constexpr bool
operator>(const _It2& __x, const basic_const_iterator& __y)
noexcept(noexcept(__x > __y._M_current))
requires random_access_iterator<_It> && totally_ordered_with<_It, _It2>
{ return __x > __y._M_current; }

template<__detail::__not_a_const_iterator _It2>
friend constexpr bool
operator<=(const _It2& __x, const basic_const_iterator& __y)
noexcept(noexcept(__x <= __y._M_current))
requires random_access_iterator<_It> && totally_ordered_with<_It, _It2>
{ return __x <= __y._M_current; }

template<__detail::__not_a_const_iterator _It2>
friend constexpr bool
operator>=(const _It2& __x, const basic_const_iterator& __y)
noexcept(noexcept(__x >= __y._M_current))
requires random_access_iterator<_It> && totally_ordered_with<_It, _It2>
{ return __x >= __y._M_current; }

friend constexpr basic_const_iterator

operator+(const basic_const_iterator& __i, difference_type __n)
noexcept(noexcept(basic_const_iterator(__i._M_current + __n)))
requires random_access_iterator<_It>
{ return basic_const_iterator(__i._M_current + __n); }

friend constexpr basic_const_iterator

operator+(difference_type __n, const basic_const_iterator& __i)
noexcept(noexcept(basic_const_iterator(__i._M_current + __n)))
requires random_access_iterator<_It>
{ return basic_const_iterator(__i._M_current + __n); }

friend constexpr basic_const_iterator

operator-(const basic_const_iterator& __i, difference_type __n)
noexcept(noexcept(basic_const_iterator(__i._M_current - __n)))
requires random_access_iterator<_It>
{ return basic_const_iterator(__i._M_current - __n); }

template<sized_sentinel_for<_It> _Sent>
constexpr difference_type
operator-(const _Sent& __y) const
noexcept(noexcept(_M_current - __y))
{ return _M_current - __y; }

template<__detail::__not_a_const_iterator _Sent>
requires sized_sentinel_for<_Sent, _It>
friend constexpr difference_type
operator-(const _Sent& __x, const basic_const_iterator& __y)
noexcept(noexcept(__x - __y._M_current))
{ return __x - __y._M_current; }

friend constexpr __rvalue_reference

iter_move(const basic_const_iterator& __i)

noexcept(noexcept(static_cast<__rvalue_reference>(ranges::iter_move(__i._M_current)
)))
{ return static_cast<__rvalue_reference>(ranges::iter_move(__i._M_current)); }
};

template<typename _Tp, common_with<_Tp> _Up>

requires input_iterator<common_type_t<_Tp, _Up>>
struct common_type<basic_const_iterator<_Tp>, _Up>
{ using type = basic_const_iterator<common_type_t<_Tp, _Up>>; };

template<typename _Tp, common_with<_Tp> _Up>

requires input_iterator<common_type_t<_Tp, _Up>>
struct common_type<_Up, basic_const_iterator<_Tp>>
{ using type = basic_const_iterator<common_type_t<_Tp, _Up>>; };

template<typename _Tp, common_with<_Tp> _Up>

requires input_iterator<common_type_t<_Tp, _Up>>
struct common_type<basic_const_iterator<_Tp>, basic_const_iterator<_Up>>
{ using type = basic_const_iterator<common_type_t<_Tp, _Up>>; };

template<input_iterator _It>
constexpr const_iterator<_It>
make_const_iterator(_It __it)
noexcept(is_nothrow_convertible_v<_It, const_iterator<_It>>)
{ return __it; }

template<semiregular _Sent>
constexpr const_sentinel<_Sent>
make_const_sentinel(_Sent __s)
noexcept(is_nothrow_convertible_v<_Sent, const_sentinel<_Sent>>)
{ return __s; }
template<typename _Iterator>
constexpr
auto
__niter_base(move_iterator<_Iterator> __it)
-> decltype(make_move_iterator(__niter_base(__it.base())))
{ return make_move_iterator(__niter_base(__it.base())); }

template<typename _Iterator>
struct __is_move_iterator<move_iterator<_Iterator> >
{
enum { __value = 1 };
typedef __true_type __type;
};

template<typename _Iterator>
constexpr
auto
__miter_base(move_iterator<_Iterator> __it)
-> decltype(__miter_base(__it.base()))
{ return __miter_base(__it.base()); }
# 2984 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_iterator.h" 3
template<typename _InputIterator>
using __iter_key_t = remove_const_t<

tuple_element_t<0, typename iterator_traits<_InputIterator>::value_type>>;

template<typename _InputIterator>
using __iter_val_t

= tuple_element_t<1, typename iterator_traits<_InputIterator>::value_type>;

template<typename _T1, typename _T2>

struct pair;

template<typename _InputIterator>
using __iter_to_alloc_t
= pair<const __iter_key_t<_InputIterator>, __iter_val_t<_InputIterator>>;

}
# 68 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algobase.h" 2 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/debug/debug.h" 1 3
# 48 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/debug/debug.h" 3
namespace std
{
namespace __debug { }
}
namespace __gnu_debug
{
using namespace std::__debug;

template<typename _Ite, typename _Seq, typename _Cat>

struct _Safe_iterator;
}
# 70 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algobase.h" 2 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/predefined_ops.h" 1 3
# 35 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/predefined_ops.h" 3
namespace __gnu_cxx
{
namespace __ops
{
struct _Iter_less_iter
{
template<typename _Iterator1, typename _Iterator2>
constexpr
bool
operator()(_Iterator1 __it1, _Iterator2 __it2) const
{ return *__it1 < *__it2; }
};

constexpr
inline _Iter_less_iter
__iter_less_iter()
{ return _Iter_less_iter(); }

struct _Iter_less_val
{

constexpr _Iter_less_val() = default;

constexpr
explicit
_Iter_less_val(_Iter_less_iter) { }

template<typename _Iterator, typename _Value>

constexpr
bool
operator()(_Iterator __it, _Value& __val) const
{ return *__it < __val; }
};

constexpr
inline _Iter_less_val
__iter_less_val()
{ return _Iter_less_val(); }

constexpr
inline _Iter_less_val
__iter_comp_val(_Iter_less_iter)
{ return _Iter_less_val(); }

struct _Val_less_iter
{

constexpr _Val_less_iter() = default;

constexpr
explicit
_Val_less_iter(_Iter_less_iter) { }

template<typename _Value, typename _Iterator>

constexpr
bool
operator()(_Value& __val, _Iterator __it) const
{ return __val < *__it; }
};

constexpr
inline _Val_less_iter
__val_less_iter()
{ return _Val_less_iter(); }

constexpr
inline _Val_less_iter
__val_comp_iter(_Iter_less_iter)
{ return _Val_less_iter(); }

struct _Iter_equal_to_iter
{
template<typename _Iterator1, typename _Iterator2>
constexpr
bool
operator()(_Iterator1 __it1, _Iterator2 __it2) const
{ return *__it1 == *__it2; }
};

constexpr
inline _Iter_equal_to_iter
__iter_equal_to_iter()
{ return _Iter_equal_to_iter(); }

struct _Iter_equal_to_val
{
template<typename _Iterator, typename _Value>
constexpr
bool
operator()(_Iterator __it, _Value& __val) const
{ return *__it == __val; }
};

constexpr
inline _Iter_equal_to_val
__iter_equal_to_val()
{ return _Iter_equal_to_val(); }
constexpr
inline _Iter_equal_to_val
__iter_comp_val(_Iter_equal_to_iter)
{ return _Iter_equal_to_val(); }

template<typename _Compare>
struct _Iter_comp_iter
{
_Compare _M_comp;

explicit constexpr
_Iter_comp_iter(_Compare __comp)
: _M_comp(std::move(__comp))
{ }

template<typename _Iterator1, typename _Iterator2>

constexpr
bool
operator()(_Iterator1 __it1, _Iterator2 __it2)
{ return bool(_M_comp(*__it1, *__it2)); }
};

template<typename _Compare>
constexpr
inline _Iter_comp_iter<_Compare>
__iter_comp_iter(_Compare __comp)
{ return _Iter_comp_iter<_Compare>(std::move(__comp)); }

template<typename _Compare>
struct _Iter_comp_val
{
_Compare _M_comp;

constexpr
explicit
_Iter_comp_val(_Compare __comp)
: _M_comp(std::move(__comp))
{ }

constexpr
explicit
_Iter_comp_val(const _Iter_comp_iter<_Compare>& __comp)
: _M_comp(__comp._M_comp)
{ }

constexpr
explicit
_Iter_comp_val(_Iter_comp_iter<_Compare>&& __comp)
: _M_comp(std::move(__comp._M_comp))
{ }

template<typename _Iterator, typename _Value>

constexpr
bool
operator()(_Iterator __it, _Value& __val)
{ return bool(_M_comp(*__it, __val)); }
};

template<typename _Compare>
constexpr
inline _Iter_comp_val<_Compare>
__iter_comp_val(_Compare __comp)
{ return _Iter_comp_val<_Compare>(std::move(__comp)); }

template<typename _Compare>
constexpr
inline _Iter_comp_val<_Compare>
__iter_comp_val(_Iter_comp_iter<_Compare> __comp)
{ return _Iter_comp_val<_Compare>(std::move(__comp)); }

template<typename _Compare>
struct _Val_comp_iter
{
_Compare _M_comp;

constexpr
explicit
_Val_comp_iter(_Compare __comp)
: _M_comp(std::move(__comp))
{ }

constexpr
explicit
_Val_comp_iter(const _Iter_comp_iter<_Compare>& __comp)
: _M_comp(__comp._M_comp)
{ }

constexpr
explicit
_Val_comp_iter(_Iter_comp_iter<_Compare>&& __comp)
: _M_comp(std::move(__comp._M_comp))
{ }

template<typename _Value, typename _Iterator>

constexpr
bool
operator()(_Value& __val, _Iterator __it)
{ return bool(_M_comp(__val, *__it)); }
};

template<typename _Compare>
constexpr
inline _Val_comp_iter<_Compare>
__val_comp_iter(_Compare __comp)
{ return _Val_comp_iter<_Compare>(std::move(__comp)); }

template<typename _Compare>
constexpr
inline _Val_comp_iter<_Compare>
__val_comp_iter(_Iter_comp_iter<_Compare> __comp)
{ return _Val_comp_iter<_Compare>(std::move(__comp)); }

template<typename _Value>
struct _Iter_equals_val
{
_Value& _M_value;

constexpr
explicit
_Iter_equals_val(_Value& __value)
: _M_value(__value)
{ }

template<typename _Iterator>
constexpr
bool
operator()(_Iterator __it)
{ return *__it == _M_value; }
};

template<typename _Value>
constexpr
inline _Iter_equals_val<_Value>
__iter_equals_val(_Value& __val)
{ return _Iter_equals_val<_Value>(__val); }

template<typename _Iterator1>
struct _Iter_equals_iter
{
_Iterator1 _M_it1;

constexpr
explicit
_Iter_equals_iter(_Iterator1 __it1)
: _M_it1(__it1)
{ }

template<typename _Iterator2>
constexpr
bool
operator()(_Iterator2 __it2)
{ return *__it2 == *_M_it1; }
};

template<typename _Iterator>
constexpr
inline _Iter_equals_iter<_Iterator>
__iter_comp_iter(_Iter_equal_to_iter, _Iterator __it)
{ return _Iter_equals_iter<_Iterator>(__it); }

template<typename _Predicate>
struct _Iter_pred
{
_Predicate _M_pred;

constexpr
explicit
_Iter_pred(_Predicate __pred)
: _M_pred(std::move(__pred))
{ }

template<typename _Iterator>
constexpr
bool
operator()(_Iterator __it)
{ return bool(_M_pred(*__it)); }
};

template<typename _Predicate>
constexpr
inline _Iter_pred<_Predicate>
__pred_iter(_Predicate __pred)
{ return _Iter_pred<_Predicate>(std::move(__pred)); }

template<typename _Compare, typename _Value>

struct _Iter_comp_to_val
{
_Compare _M_comp;
_Value& _M_value;

constexpr
_Iter_comp_to_val(_Compare __comp, _Value& __value)
: _M_comp(std::move(__comp)), _M_value(__value)
{ }

template<typename _Iterator>
constexpr
bool
operator()(_Iterator __it)
{ return bool(_M_comp(*__it, _M_value)); }
};

template<typename _Compare, typename _Value>

_Iter_comp_to_val<_Compare, _Value>
constexpr
__iter_comp_val(_Compare __comp, _Value &__val)
{
return _Iter_comp_to_val<_Compare, _Value>(std::move(__comp), __val);
}

template<typename _Compare, typename _Iterator1>

struct _Iter_comp_to_iter
{
_Compare _M_comp;
_Iterator1 _M_it1;

constexpr
_Iter_comp_to_iter(_Compare __comp, _Iterator1 __it1)
: _M_comp(std::move(__comp)), _M_it1(__it1)
{ }

template<typename _Iterator2>
constexpr
bool
operator()(_Iterator2 __it2)
{ return bool(_M_comp(*__it2, *_M_it1)); }
};

template<typename _Compare, typename _Iterator>

constexpr
inline _Iter_comp_to_iter<_Compare, _Iterator>
__iter_comp_iter(_Iter_comp_iter<_Compare> __comp, _Iterator __it)
{
return _Iter_comp_to_iter<_Compare, _Iterator>(
std::move(__comp._M_comp), __it);
}

template<typename _Predicate>
struct _Iter_negate
{
_Predicate _M_pred;

constexpr
explicit
_Iter_negate(_Predicate __pred)
: _M_pred(std::move(__pred))
{ }

template<typename _Iterator>
constexpr
bool
operator()(_Iterator __it)
{ return !bool(_M_pred(*__it)); }
};

template<typename _Predicate>
constexpr
inline _Iter_negate<_Predicate>
__negate(_Iter_pred<_Predicate> __pred)
{ return _Iter_negate<_Predicate>(std::move(__pred._M_pred)); }

}
}
# 72 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algobase.h" 2 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bit" 1 3
# 32 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bit" 3

# 33 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bit" 3
# 61 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bit" 3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 1 3
# 47 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 3

# 48 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 3
# 62 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bit" 2 3

namespace std
{

# 85 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bit" 3
template<typename _To, typename _From>
[[nodiscard]]
constexpr _To
bit_cast(const _From& __from) noexcept

requires (sizeof(_To) == sizeof(_From))

&& is_trivially_copyable_v<_To> && is_trivially_copyable_v<_From>
{
return __builtin_bit_cast(_To, __from);
}
# 107 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bit" 3
template<integral _Tp>
[[nodiscard]]
constexpr _Tp
byteswap(_Tp __value) noexcept
{
if constexpr (sizeof(_Tp) == 1)
return __value;

if !consteval
{
if constexpr (sizeof(_Tp) == 2)
return __builtin_bswap16(__value);
if constexpr (sizeof(_Tp) == 4)
return __builtin_bswap32(__value);
if constexpr (sizeof(_Tp) == 8)
return __builtin_bswap64(__value);
if constexpr (sizeof(_Tp) == 16)

return __builtin_bswap128(__value);

using _Up = typename __make_unsigned<__remove_cv_t<_Tp>>::__type;

size_t __diff = 8 * (sizeof(_Tp) - 1);
_Up __mask1 = static_cast<unsigned char>(~0);
_Up __mask2 = __mask1 << __diff;
_Up __val = __value;
for (size_t __i = 0; __i < sizeof(_Tp) / 2; ++__i)
{
_Up __byte1 = __val & __mask1;
_Up __byte2 = __val & __mask2;
__val = (__val ^ __byte1 ^ __byte2
^ (__byte1 << __diff) ^ (__byte2 >> __diff));
__mask1 <<= 8;
__mask2 >>= 8;
__diff -= 2 * 8;
}
return __val;
}

template<typename _Tp>
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<typename _Tp>
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<typename _Tp>
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<unsigned long long>::__digits;

constexpr auto _Nd_ul = __int_traits<unsigned long>::__digits;
constexpr auto _Nd_u = __int_traits<unsigned>::__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<unsigned long long>::__max;
unsigned long long __low = __x & __max_ull;
return (_Nd - _Nd_ull) + __builtin_clzll(__low);
}
}

template<typename _Tp>
constexpr int
__countl_one(_Tp __x) noexcept
{
return std::__countl_zero<_Tp>((_Tp)~__x);
}

template<typename _Tp>
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<unsigned long long>::__digits;

constexpr auto _Nd_ul = __int_traits<unsigned long>::__digits;
constexpr auto _Nd_u = __int_traits<unsigned>::__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<unsigned long long>::__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<typename _Tp>
constexpr int
__countr_one(_Tp __x) noexcept
{
return std::__countr_zero((_Tp)~__x);
}

template<typename _Tp>
constexpr int
__popcount(_Tp __x) noexcept
{
using __gnu_cxx::__int_traits;
constexpr auto _Nd = __int_traits<_Tp>::__digits;

constexpr auto _Nd_ull = __int_traits<unsigned long long>::__digits;

constexpr auto _Nd_ul = __int_traits<unsigned long>::__digits;
constexpr auto _Nd_u = __int_traits<unsigned>::__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<unsigned long long>::__max;

unsigned long long __low = __x & __max_ull;
unsigned long long __high = __x >> _Nd_ull;
return __builtin_popcountll(__low) + __builtin_popcountll(__high);
}
}

template<typename _Tp>
constexpr bool
__has_single_bit(_Tp __x) noexcept
{ return std::__popcount(__x) == 1; }

template<typename _Tp>
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()) if (__builtin_expect(!
bool(__shift_exponent != __int_traits<_Tp>::__digits), false))
std::__glibcxx_assert_fail(); } 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<typename _Tp>
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<typename _Tp>
constexpr int
__bit_width(_Tp __x) noexcept
{
constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits;
return _Nd - std::__countl_zero(__x);
}

template<typename _Tp>
concept __unsigned_integer = __is_unsigned_integer<_Tp>::value;

template<__unsigned_integer _Tp>
[[nodiscard]] constexpr _Tp
rotl(_Tp __x, int __s) noexcept
{ return std::__rotl(__x, __s); }
template<__unsigned_integer _Tp>
[[nodiscard]] constexpr _Tp
rotr(_Tp __x, int __s) noexcept
{ return std::__rotr(__x, __s); }

template<__unsigned_integer _Tp>
constexpr int
countl_zero(_Tp __x) noexcept
{ return std::__countl_zero(__x); }

template<__unsigned_integer _Tp>
constexpr int
countl_one(_Tp __x) noexcept
{ return std::__countl_one(__x); }

template<__unsigned_integer _Tp>
constexpr int
countr_zero(_Tp __x) noexcept
{ return std::__countr_zero(__x); }

template<__unsigned_integer _Tp>
constexpr int
countr_one(_Tp __x) noexcept
{ return std::__countr_one(__x); }

template<__unsigned_integer _Tp>
constexpr int
popcount(_Tp __x) noexcept
{ return std::__popcount(__x); }

template<__unsigned_integer _Tp>
constexpr bool
has_single_bit(_Tp __x) noexcept
{ return std::__has_single_bit(__x); }

template<__unsigned_integer _Tp>
constexpr _Tp
bit_ceil(_Tp __x) noexcept
{ return std::__bit_ceil(__x); }

template<__unsigned_integer _Tp>
constexpr _Tp
bit_floor(_Tp __x) noexcept
{ return std::__bit_floor(__x); }
template<__unsigned_integer _Tp>
constexpr int
bit_width(_Tp __x) noexcept
{ return std::__bit_width(__x); }
# 472 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bit" 3
enum class endian
{
little = 1234,
big = 4321,
native = 1234
};

}
# 77 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algobase.h" 2 3

namespace std
{

template<typename _Tp, typename _Up>

constexpr
inline int
__memcmp(const _Tp* __first1, const _Up* __first2, size_t __num)
{

static_assert(sizeof(_Tp) == sizeof(_Up), "can be compared with memcmp");

if (std::is_constant_evaluated())
{
for(; __num > 0; ++__first1, ++__first2, --__num)
if (*__first1 != *__first2)
return *__first1 < *__first2 ? -1 : 1;
return 0;
}
else

return __builtin_memcmp(first1, first2, sizeof(_Tp) * __num);

}
# 152 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algobase.h" 3
template<typename _ForwardIterator1, typename _ForwardIterator2>
constexpr
inline void
iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
{

# 185 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algobase.h" 3
swap(*__a, *__b);

}
# 201 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algobase.h" 3
template<typename _ForwardIterator1, typename _ForwardIterator2>
constexpr
_ForwardIterator2
swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2)
{

for (; first1 != last1; ++first1, (void)++first2)

std::iter_swap(__first1, __first2);
return __first2;
}
# 230 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algobase.h" 3
template<typename _Tp>
[[__nodiscard__]] constexpr
inline const _Tp&
min(const _Tp& __a, const _Tp& __b)
{

if (b < a)

return __b;
return __a;
}
# 254 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algobase.h" 3
template<typename _Tp>
[[__nodiscard__]] constexpr
inline const _Tp&
max(const _Tp& __a, const _Tp& __b)
{

if (a < b)

return __b;
return __a;
}
# 278 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algobase.h" 3
template<typename _Tp, typename _Compare>
[[__nodiscard__]] constexpr
inline const _Tp&
min(const _Tp& __a, const _Tp& __b, _Compare __comp)
{
if (__comp(__b, __a))
return __b;
return __a;
}
# 300 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algobase.h" 3
template<typename _Tp, typename _Compare>
[[__nodiscard__]] constexpr
inline const _Tp&
max(const _Tp& __a, const _Tp& __b, _Compare __comp)
{

if (__comp(__a, __b))
return __b;
return __a;
}

template<typename _Iterator>
constexpr
inline _Iterator
__niter_base(_Iterator __it)
noexcept(std::is_nothrow_copy_constructible<_Iterator>::value)
{ return __it; }
# 332 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algobase.h" 3
template<typename _Ite, typename _Seq>
constexpr
decltype(std::__niter_base(std::declval<_Ite>()))
__niter_base(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq,
std::random_access_iterator_tag>&)
noexcept(std::is_nothrow_copy_constructible<_Ite>::value);

template<typename _From, typename _To>

constexpr
inline _From
__niter_wrap(_From __from, _To __res)
{ return __from + (std::__niter_base(__res) - std::__niter_base(__from)); }

template<typename _Iterator>
constexpr
inline _Iterator
__niter_wrap(const _Iterator&, _Iterator __res)
{ return __res; }

template<bool _IsMove, bool _IsSimple, typename _Category>

struct __copy_move
{
template<typename _II, typename _OI>
constexpr
static _OI
__copy_m(_II __first, _II __last, _OI __result)
{
for (; __first != __last; ++__result, (void)++__first)
*__result = *__first;
return __result;
}
};

template<typename _Category>
struct __copy_move<true, false, _Category>
{
template<typename _II, typename _OI>
constexpr
static _OI
__copy_m(_II __first, _II __last, _OI __result)
{
for (; __first != __last; ++__result, (void)++__first)
*__result = std::move(*__first);
return __result;
}
};

template<>
struct __copy_move<false, false, random_access_iterator_tag>
{
template<typename _II, typename _OI>
constexpr
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<typename _Tp, typename _Up>

static void
__assign_one(_Tp* __to, _Up* __from)
{ *__to = *__from; }
};

template<>
struct __copy_move<true, false, random_access_iterator_tag>
{
template<typename _II, typename _OI>
constexpr
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<typename _Tp, typename _Up>

static void
__assign_one(_Tp* __to, _Up* __from)
{ *__to = std::move(*__from); }
};

template<bool _IsMove>
struct __copy_move<_IsMove, true, random_access_iterator_tag>
{
template<typename _Tp, typename _Up>
constexpr
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<typename _Tp, typename _Ref, typename _Ptr>

struct _Deque_iterator;

struct _Bit_iterator;

template<typename _CharT>
struct char_traits;

template<typename _CharT, typename _Traits>

class istreambuf_iterator;

template<typename _CharT, typename _Traits>

class ostreambuf_iterator;

template<bool _IsMove, typename _CharT>

typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type
__copy_move_a2(_CharT*, _CharT*,
ostreambuf_iterator<_CharT, char_traits<_CharT> >);

template<bool _IsMove, typename _CharT>

typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type
__copy_move_a2(const _CharT*, const _CharT*,
ostreambuf_iterator<_CharT, char_traits<_CharT> >);

template<bool _IsMove, typename _CharT>

typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
_CharT*>::__type
__copy_move_a2(istreambuf_iterator<_CharT, char_traits<_CharT> >,
istreambuf_iterator<_CharT, char_traits<_CharT> >, _CharT*);

template<bool _IsMove, typename _CharT>

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<bool _IsMove, typename _II, typename _OI>

constexpr
inline _OI
__copy_move_a2(_II __first, _II __last, _OI __result)
{
typedef typename iterator_traits<_II>::iterator_category _Category;

if (std::is_constant_evaluated())
return std::__copy_move<_IsMove, false, _Category>::
__copy_m(__first, __last, __result);

return std::__copy_move<_IsMove, __memcpyable<_OI, _II>::__value,

_Category>::__copy_m(__first, __last, __result);
}

template<bool _IsMove,
typename _Tp, typename _Ref, typename _Ptr, typename _OI>
_OI
__copy_move_a1(std::_Deque_iterator<_Tp, _Ref, _Ptr>,
std::_Deque_iterator<_Tp, _Ref, _Ptr>,
_OI);

template<bool _IsMove,
typename _ITp, typename _IRef, typename _IPtr, typename _OTp>
std::_Deque_iterator<_OTp, _OTp&, _OTp*>
__copy_move_a1(std::_Deque_iterator<_ITp, _IRef, _IPtr>,
std::_Deque_iterator<_ITp, _IRef, _IPtr>,
std::_Deque_iterator<_OTp, _OTp&, _OTp*>);

template<bool _IsMove, typename _II, typename _Tp>

typename __gnu_cxx::__enable_if<
__is_random_access_iter<_II>::__value,
std::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type
__copy_move_a1(_II, _II, std::_Deque_iterator<_Tp, _Tp&, _Tp*>);

template<bool _IsMove, typename _II, typename _OI>

constexpr
inline _OI
__copy_move_a1(_II __first, _II __last, _OI __result)
{ return std::__copy_move_a2<_IsMove>(__first, __last, __result); }

template<bool _IsMove, typename _II, typename _OI>

constexpr
inline _OI
__copy_move_a(_II __first, _II __last, _OI __result)
{
return std::__niter_wrap(__result,
std::__copy_move_a1<_IsMove>(std::__niter_base(__first),
std::__niter_base(__last),
std::__niter_base(__result)));
}

template<bool _IsMove,
typename _Ite, typename _Seq, typename _Cat, typename _OI>
constexpr
_OI
__copy_move_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&,
const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&,
_OI);

template<bool _IsMove,
typename _II, typename _Ite, typename _Seq, typename _Cat>
constexpr
__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>
__copy_move_a(_II, _II,
const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&);

template<typename _InputIterator, typename _Size, typename _OutputIterator>

constexpr
_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 _CharT, typename _Size>

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 _CharT, typename _Size>

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);
# 639 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algobase.h" 3
template<typename _II, typename _OI>
constexpr
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);
}
# 672 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algobase.h" 3
template<typename _II, typename _OI>
constexpr
inline _OI
move(_II __first, _II __last, _OI __result)
{

return std::__copy_move_a<true>(std::__miter_base(__first),
std::__miter_base(__last), __result);
}

template<bool _IsMove, bool _IsSimple, typename _Category>

struct __copy_move_backward
{
template<typename _BI1, typename _BI2>
constexpr
static _BI2
__copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
{
while (__first != __last)
*--__result = *--__last;
return __result;
}
};

template<typename _Category>
struct __copy_move_backward<true, false, _Category>
{
template<typename _BI1, typename _BI2>
constexpr
static _BI2
__copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
{
while (__first != __last)
*--__result = std::move(*--__last);
return __result;
}
};

template<>
struct __copy_move_backward<false, false, random_access_iterator_tag>
{
template<typename _BI1, typename _BI2>
constexpr
static _BI2
__copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
{
typename iterator_traits<_BI1>::difference_type
__n = __last - __first;
for (; __n > 0; --__n)
*--__result = *--__last;
return __result;
}
};

template<>
struct __copy_move_backward<true, false, random_access_iterator_tag>
{
template<typename _BI1, typename _BI2>
constexpr
static _BI2
__copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
{
typename iterator_traits<_BI1>::difference_type
__n = __last - __first;
for (; __n > 0; --__n)
*--__result = std::move(*--__last);
return __result;
}
};
template<bool _IsMove>
struct __copy_move_backward<_IsMove, true, random_access_iterator_tag>
{
template<typename _Tp, typename _Up>
constexpr
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<bool _IsMove, typename _BI1, typename _BI2>

constexpr
inline _BI2
__copy_move_backward_a2(_BI1 __first, _BI1 __last, _BI2 __result)
{
typedef typename iterator_traits<_BI1>::iterator_category _Category;

if (std::is_constant_evaluated())
return std::__copy_move_backward<_IsMove, false, _Category>::
__copy_move_b(__first, __last, __result);

return std::__copy_move_backward<_IsMove,
__memcpyable<_BI2, _BI1>::__value,
_Category>::__copy_move_b(__first,
__last,
__result);
}

template<bool _IsMove, typename _BI1, typename _BI2>

constexpr
inline _BI2
__copy_move_backward_a1(_BI1 __first, _BI1 __last, _BI2 __result)
{ return std::__copy_move_backward_a2<_IsMove>(__first, __last, __result); }

template<bool _IsMove,
typename _Tp, typename _Ref, typename _Ptr, typename _OI>
_OI
__copy_move_backward_a1(std::_Deque_iterator<_Tp, _Ref, _Ptr>,
std::_Deque_iterator<_Tp, _Ref, _Ptr>,
_OI);

template<bool _IsMove,
typename _ITp, typename _IRef, typename _IPtr, typename _OTp>
std::_Deque_iterator<_OTp, _OTp&, _OTp*>
__copy_move_backward_a1(
std::_Deque_iterator<_ITp, _IRef, _IPtr>,
std::_Deque_iterator<_ITp, _IRef, _IPtr>,
std::_Deque_iterator<_OTp, _OTp&, _OTp*>);

template<bool _IsMove, typename _II, typename _Tp>

typename __gnu_cxx::__enable_if<
__is_random_access_iter<_II>::__value,
std::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type
__copy_move_backward_a1(_II, _II,
std::_Deque_iterator<_Tp, _Tp&, _Tp*>);

template<bool _IsMove, typename _II, typename _OI>

constexpr
inline _OI
__copy_move_backward_a(_II __first, _II __last, _OI __result)
{
return std::__niter_wrap(__result,
std::__copy_move_backward_a1<_IsMove>
(std::__niter_base(__first), std::__niter_base(__last),
std::__niter_base(__result)));
}

template<bool _IsMove,
typename _Ite, typename _Seq, typename _Cat, typename _OI>
constexpr
_OI
__copy_move_backward_a(
const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&,
const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&,
_OI);

template<bool _IsMove,
typename _II, typename _Ite, typename _Seq, typename _Cat>
constexpr
__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>
__copy_move_backward_a(_II, _II,
const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&);

template<bool _IsMove,
typename _IIte, typename _ISeq, typename _ICat,
typename _OIte, typename _OSeq, typename _OCat>
constexpr
::__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>&);
# 875 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algobase.h" 3
template<typename _BI1, typename _BI2>
constexpr
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);
}
# 910 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algobase.h" 3
template<typename _BI1, typename _BI2>
constexpr
inline _BI2
move_backward(_BI1 __first, _BI1 __last, _BI2 __result)
{

return std::__copy_move_backward_a<true>(std::__miter_base(__first),
std::__miter_base(__last),
__result);
}

template<typename _ForwardIterator, typename _Tp>

constexpr
inline typename
__gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value, void>::__type
__fill_a1(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __value)
{
for (; __first != __last; ++__first)
*__first = __value;
}

template<typename _ForwardIterator, typename _Tp>

constexpr
inline typename
__gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, void>::__type
__fill_a1(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __value)
{
const _Tp __tmp = __value;
for (; __first != __last; ++__first)
*__first = __tmp;
}

template<typename _Tp>
constexpr
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;

if (std::is_constant_evaluated())
{
for (; __first != __last; ++__first)
*__first = __tmp;
return;
}

if (const size_t len = last - __first)

__builtin_memset(__first, static_cast<unsigned char>(__tmp), __len);
}

template<typename _Ite, typename _Cont, typename _Tp>

constexpr
inline void
__fill_a1(::__gnu_cxx::__normal_iterator<_Ite, _Cont> __first,
::__gnu_cxx::__normal_iterator<_Ite, _Cont> __last,
const _Tp& __value)
{ std::__fill_a1(__first.base(), __last.base(), __value); }

template<typename _Tp, typename _VTp>

void
__fill_a1(const std::_Deque_iterator<_Tp, _Tp&, _Tp*>&,
const std::_Deque_iterator<_Tp, _Tp&, _Tp*>&,
const _VTp&);

constexpr
void
__fill_a1(std::_Bit_iterator, std::_Bit_iterator,
const bool&);

template<typename _FIte, typename _Tp>

constexpr
inline void
__fill_a(_FIte __first, _FIte __last, const _Tp& __value)
{ std::__fill_a1(__first, __last, __value); }

template<typename _Ite, typename _Seq, typename _Cat, typename _Tp>

constexpr
void
__fill_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&,
const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&,
const _Tp&);
# 1019 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algobase.h" 3
template<typename _ForwardIterator, typename _Tp>
constexpr
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; }
# 1071 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/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; }

extension inline constexpr long long

__size_to_integer(__float128 __n) { return (long long)__n; }

template<typename _OutputIterator, typename _Size, typename _Tp>

constexpr
inline typename
__gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value, _OutputIterator>::__type
__fill_n_a1(_OutputIterator __first, _Size __n, const _Tp& __value)
{
for (; __n > 0; --__n, (void) ++__first)
*__first = __value;
return __first;
}

template<typename _OutputIterator, typename _Size, typename _Tp>

constexpr
inline typename
__gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, _OutputIterator>::__type
__fill_n_a1(_OutputIterator __first, _Size __n, const _Tp& __value)
{
const _Tp __tmp = __value;
for (; __n > 0; --__n, (void) ++__first)
*__first = __tmp;
return __first;
}

template<typename _Ite, typename _Seq, typename _Cat, typename _Size,

typename _Tp>
constexpr
::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>
__fill_n_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>& __first,
_Size __n, const _Tp& __value,
std::input_iterator_tag);

template<typename _OutputIterator, typename _Size, typename _Tp>

constexpr
inline _OutputIterator
__fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value,
std::output_iterator_tag)
{

static_assert(is_integral<_Size>{}, "fill_n must pass integral size");

return __fill_n_a1(first, n, __value);

}

template<typename _OutputIterator, typename _Size, typename _Tp>

constexpr
inline _OutputIterator
__fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value,
std::input_iterator_tag)
{

static_assert(is_integral<_Size>{}, "fill_n must pass integral size");

return __fill_n_a1(first, n, __value);

}

template<typename _OutputIterator, typename _Size, typename _Tp>

constexpr
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;
}
# 1172 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algobase.h" 3
template<typename _OI, typename _Size, typename _Tp>
constexpr
inline _OI
fill_n(_OI __first, _Size __n, const _Tp& __value)
{

return std::__fill_n_a(first, std::size_to_integer(n), value,

std::__iterator_category(__first));
}

template<bool _BoolType>
struct __equal
{
template<typename _II1, typename _II2>
constexpr
static bool
equal(_II1 __first1, _II1 __last1, _II2 __first2)
{
for (; __first1 != __last1; ++__first1, (void) ++__first2)
if (!(*__first1 == *__first2))
return false;
return true;
}
};

template<>
struct __equal<true>
{
template<typename _Tp>
constexpr
static bool
equal(const _Tp* __first1, const _Tp* __last1, const _Tp* __first2)
{
if (const size_t __len = (__last1 - __first1))
return !std::__memcmp(__first1, __first2, __len);
return true;
}
};

template<typename _Tp, typename _Ref, typename _Ptr, typename _II>

typename __gnu_cxx::__enable_if<
__is_random_access_iter<_II>::__value, bool>::__type
__equal_aux1(std::_Deque_iterator<_Tp, _Ref, _Ptr>,
std::_Deque_iterator<_Tp, _Ref, _Ptr>,
_II);

template<typename _Tp1, typename _Ref1, typename _Ptr1,

typename _Tp2, typename _Ref2, typename _Ptr2>
bool
__equal_aux1(std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>,
std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>,
std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>);

template<typename _II, typename _Tp, typename _Ref, typename _Ptr>

typename __gnu_cxx::__enable_if<
__is_random_access_iter<_II>::__value, bool>::__type
__equal_aux1(_II, _II,
std::_Deque_iterator<_Tp, _Ref, _Ptr>);

template<typename _II1, typename _II2>

constexpr
inline bool
__equal_aux1(_II1 __first1, _II1 __last1, _II2 __first2)
{
typedef typename iterator_traits<_II1>::value_type _ValueType1;
const bool __simple = ((__is_integer<_ValueType1>::__value
|| __is_pointer<_ValueType1>::__value)
&& __memcmpable<_II1, _II2>::__value);
return std::__equal<__simple>::equal(__first1, __last1, __first2);
}

template<typename _II1, typename _II2>

constexpr
inline bool
__equal_aux(_II1 __first1, _II1 __last1, _II2 __first2)
{
return std::__equal_aux1(std::__niter_base(__first1),
std::__niter_base(__last1),
std::__niter_base(__first2));
}

template<typename _II1, typename _Seq1, typename _Cat1, typename _II2>

constexpr
bool
__equal_aux(const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&,
const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&,
_II2);

template<typename _II1, typename _II2, typename _Seq2, typename _Cat2>

constexpr
bool
__equal_aux(_II1, _II1,
const ::__gnu_debug::_Safe_iterator<_II2, _Seq2, _Cat2>&);

template<typename _II1, typename _Seq1, typename _Cat1,

typename _II2, typename _Seq2, typename _Cat2>
constexpr
bool
__equal_aux(const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&,
const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&,
const ::__gnu_debug::_Safe_iterator<_II2, _Seq2, _Cat2>&);

template<typename, typename>
struct __lc_rai
{
template<typename _II1, typename _II2>
constexpr
static _II1
__newlast1(_II1, _II1 __last1, _II2, _II2)
{ return __last1; }

template<typename _II>
constexpr
static bool
__cnd2(_II __first, _II __last)
{ return __first != __last; }
};

template<>
struct __lc_rai<random_access_iterator_tag, random_access_iterator_tag>
{
template<typename _RAI1, typename _RAI2>
constexpr
static _RAI1
__newlast1(_RAI1 __first1, _RAI1 __last1,
_RAI2 __first2, _RAI2 __last2)
{
const typename iterator_traits<_RAI1>::difference_type
__diff1 = __last1 - __first1;
const typename iterator_traits<_RAI2>::difference_type
__diff2 = __last2 - __first2;
return __diff2 < __diff1 ? __first1 + __diff2 : __last1;
}

template<typename _RAI>
static constexpr bool
__cnd2(_RAI, _RAI)
{ return true; }
};

template<typename _II1, typename _II2, typename _Compare>

constexpr
bool
__lexicographical_compare_impl(_II1 __first1, _II1 __last1,
_II2 __first2, _II2 __last2,
_Compare __comp)
{
typedef typename iterator_traits<_II1>::iterator_category _Category1;
typedef typename iterator_traits<_II2>::iterator_category _Category2;
typedef std::__lc_rai<_Category1, _Category2> __rai_type;

last1 = rai_type::newlast1(first1, last1, first2, __last2);

for (; __first1 != __last1 && __rai_type::__cnd2(__first2, __last2);
++__first1, (void)++__first2)
{
if (__comp(__first1, __first2))
return true;
if (__comp(__first2, __first1))
return false;
}
return __first1 == __last1 && __first2 != __last2;
}

template<bool _BoolType>
struct __lexicographical_compare
{
template<typename _II1, typename _II2>
constexpr
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<typename _II1, typename _II2>

constexpr
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<true>
{
template<typename _Tp, typename _Up>
constexpr
static bool
__lc(const _Tp* __first1, const _Tp* __last1,
const _Up* __first2, const _Up* __last2)
{ return __3way(__first1, __last1, __first2, __last2) < 0; }

template<typename _Tp, typename _Up>

constexpr
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<typename _II1, typename _II2>

constexpr
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

&& !is_volatile_v<remove_reference_t<iter_reference_t<_II1>>>
&& !is_volatile_v<remove_reference_t<iter_reference_t<_II2>>>

);

return std::__lexicographical_compare<simple>::lc(first1, last1,

__first2, __last2);
}

template<typename _Tp1, typename _Ref1, typename _Ptr1,

typename _Tp2>
bool
__lexicographical_compare_aux1(
std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>,
std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>,
_Tp2*, _Tp2*);

template<typename _Tp1,
typename _Tp2, typename _Ref2, typename _Ptr2>
bool
__lexicographical_compare_aux1(_Tp1*, _Tp1*,
std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>,
std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>);

template<typename _Tp1, typename _Ref1, typename _Ptr1,

typename _Tp2, typename _Ref2, typename _Ptr2>
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<typename _II1, typename _II2>

constexpr
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<typename _Iter1, typename _Seq1, typename _Cat1,

typename _II2>
constexpr
bool
__lexicographical_compare_aux(
const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&,
const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&,
_II2, _II2);

template<typename _II1,
typename _Iter2, typename _Seq2, typename _Cat2>
constexpr
bool
__lexicographical_compare_aux(
_II1, _II1,
const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&,
const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&);

template<typename _Iter1, typename _Seq1, typename _Cat1,

typename _Iter2, typename _Seq2, typename _Cat2>
constexpr
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<typename _ForwardIterator, typename _Tp, typename _Compare>

constexpr
_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;
}
# 1524 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algobase.h" 3
template<typename _ForwardIterator, typename _Tp>
[[__nodiscard__]] constexpr
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<typename _Tp>
inline constexpr _Tp
__lg(_Tp __n)
{

return std::__bit_width(make_unsigned_t<_Tp>(__n)) - 1;
# 1557 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algobase.h" 3
}

# 1573 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algobase.h" 3
template<typename _II1, typename _II2>
[[__nodiscard__]] constexpr
inline bool
equal(_II1 __first1, _II1 __last1, _II2 __first2)
{
;

return std::__equal_aux(first1, last1, __first2);

}
# 1604 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algobase.h" 3
template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
[[__nodiscard__]] constexpr
inline bool
equal(_IIter1 __first1, _IIter1 __last1,
_IIter2 __first2, _BinaryPredicate __binary_pred)
{

for (; first1 != last1; ++first1, (void)++first2)

if (!bool(__binary_pred(*__first1, *__first2)))
return false;
return true;
}

template<typename _II1, typename _II2>

constexpr
inline bool
__equal4(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2)
{
using _RATag = random_access_iterator_tag;
using _Cat1 = typename iterator_traits<_II1>::iterator_category;
using _Cat2 = typename iterator_traits<_II2>::iterator_category;
using _RAIters = __and_<is_same<_Cat1, _RATag>, is_same<_Cat2, _RATag>>;
if (_RAIters())
{
auto __d1 = std::distance(__first1, __last1);
auto __d2 = std::distance(__first2, __last2);
if (__d1 != __d2)
return false;
return std::equal(__first1, __last1, __first2);
}

for (; first1 != last1 && first2 != last2;

++__first1, (void)++__first2)
if (!(*__first1 == *__first2))
return false;
return __first1 == __last1 && __first2 == __last2;
}

template<typename _II1, typename _II2, typename _BinaryPredicate>

constexpr
inline bool
__equal4(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2,
_BinaryPredicate __binary_pred)
{
using _RATag = random_access_iterator_tag;
using _Cat1 = typename iterator_traits<_II1>::iterator_category;
using _Cat2 = typename iterator_traits<_II2>::iterator_category;
using _RAIters = __and_<is_same<_Cat1, _RATag>, is_same<_Cat2, _RATag>>;
if (_RAIters())
{
auto __d1 = std::distance(__first1, __last1);
auto __d2 = std::distance(__first2, __last2);
if (__d1 != __d2)
return false;
return std::equal(__first1, __last1, __first2,
__binary_pred);
}

for (; first1 != last1 && first2 != last2;

++__first1, (void)++__first2)
if (!bool(__binary_pred(*__first1, *__first2)))
return false;
return __first1 == __last1 && __first2 == __last2;
}
# 1691 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algobase.h" 3
template<typename _II1, typename _II2>
[[__nodiscard__]] constexpr
inline bool
equal(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2)
{

;
;

return std::equal4(first1, last1, first2, __last2);

}
# 1724 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algobase.h" 3
template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
[[__nodiscard__]] constexpr
inline bool
equal(_IIter1 __first1, _IIter1 __last1,
_IIter2 __first2, _IIter2 __last2, _BinaryPredicate __binary_pred)
{

;
;

static_assert(same_as<common_comparison_category_t<_Cat>, _Cat>);

if (!std::__is_constant_evaluated())
if constexpr (same_as<_Comp, __detail::_Synth3way>
|| same_as<_Comp, compare_three_way>)
if constexpr (__memcmp_ordered_with<_InputIter1, _InputIter2>)
{
const auto [__len, __lencmp] = std::
__min_cmp(__last1 - __first1, __last2 - __first2);
if (__len)
{
const auto __blen = __len * sizeof(*__first1);
const auto __c
= __builtin_memcmp(&*__first1, &*__first2, __blen) <=> 0;
if (__c != 0)
return __c;
}
return __lencmp;
}

while (first1 != last1)

{
if (__first2 == __last2)
return strong_ordering::greater;
if (auto __cmp = __comp(*__first1, *__first2); __cmp != 0)
return __cmp;
++__first1;
++__first2;
}
return (__first2 == __last2) <=> true;
}

template<typename _InputIter1, typename _InputIter2>

constexpr auto
lexicographical_compare_three_way(_InputIter1 __first1,
_InputIter1 __last1,
_InputIter2 __first2,
_InputIter2 __last2)
{
return std::
lexicographical_compare_three_way(__first1, __last1, __first2, __last2,
compare_three_way{});
}

template<typename _InputIterator1, typename _InputIterator2,

typename _BinaryPredicate>
constexpr
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);
}
# 1934 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algobase.h" 3
template<typename _InputIterator1, typename _InputIterator2>
[[__nodiscard__]] constexpr
inline pair<_InputIterator1, _InputIterator2>
mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2)
{

return std::mismatch(first1, last1, first2,

__gnu_cxx::__ops::__iter_equal_to_iter());
}
# 1968 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algobase.h" 3
template<typename _InputIterator1, typename _InputIterator2,
typename _BinaryPredicate>
[[__nodiscard__]] constexpr
inline pair<_InputIterator1, _InputIterator2>
mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _BinaryPredicate __binary_pred)
{

return std::mismatch(first1, last1, first2,

__gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
}

template<typename _InputIterator1, typename _InputIterator2,

typename _BinaryPredicate>
constexpr
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);
}
# 2016 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algobase.h" 3
template<typename _InputIterator1, typename _InputIterator2>
[[__nodiscard__]] constexpr
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());
}
# 2052 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algobase.h" 3
template<typename _InputIterator1, typename _InputIterator2,
typename _BinaryPredicate>
[[__nodiscard__]] constexpr
inline pair<_InputIterator1, _InputIterator2>
mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_BinaryPredicate __binary_pred)
{

;
;

return std::mismatch(first1, last1, first2, __last2,

__gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
}

template<typename _InputIterator, typename _Predicate>

constexpr
inline _InputIterator
__find_if(_InputIterator __first, _InputIterator __last,
_Predicate __pred, input_iterator_tag)
{
while (__first != __last && !__pred(__first))
++__first;
return __first;
}

template<typename _RandomAccessIterator, typename _Predicate>

constexpr
_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;
}

switch (last - first)

{
case 3:
if (__pred(__first))
return __first;
++__first;

case 2:
if (__pred(__first))
return __first;
++__first;

case 1:
if (__pred(__first))
return __first;
++__first;

case 0:
default:
return __last;
}
}

template<typename _Iterator, typename _Predicate>

constexpr
inline _Iterator
__find_if(_Iterator __first, _Iterator __last, _Predicate __pred)
{
return __find_if(__first, __last, __pred,
std::__iterator_category(__first));
}

template<typename _InputIterator, typename _Predicate>

constexpr
typename iterator_traits<_InputIterator>::difference_type
__count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred)
{
typename iterator_traits<_InputIterator>::difference_type __n = 0;
for (; __first != __last; ++__first)
if (__pred(__first))
++__n;
return __n;
}

template<typename _ForwardIterator, typename _Predicate>

constexpr
_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<typename _ForwardIterator1, typename _ForwardIterator2,

typename _BinaryPredicate>
constexpr
_ForwardIterator1
__search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2,
_BinaryPredicate __predicate)
{

if (first1 == last1 || first2 == last2)

return __first1;

_ForwardIterator2 __p1(__first2);
if (++__p1 == __last2)
return std::__find_if(__first1, __last1,
__gnu_cxx::__ops::__iter_comp_iter(__predicate, __first2));
_ForwardIterator1 __current = __first1;

for (;;)
{
__first1 =
std::__find_if(__first1, __last1,
__gnu_cxx::__ops::__iter_comp_iter(__predicate, __first2));

if (__first1 == __last1)
return __last1;

_ForwardIterator2 p = p1;

__current = __first1;
if (++__current == __last1)
return __last1;

while (predicate(current, __p))

{
if (++__p == __last2)
return __first1;
if (++__current == __last1)
return __last1;
}
++__first1;
}
return __first1;
}

template<typename _ForwardIterator1, typename _ForwardIterator2,

typename _BinaryPredicate>
constexpr
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;
}
# 2276 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algobase.h" 3
template<typename _ForwardIterator1, typename _ForwardIterator2>
constexpr
inline bool
is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2)
{

return std::__is_permutation(first1, last1, __first2,

__gnu_cxx::__ops::__iter_equal_to_iter());
}

# 2318 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algobase.h" 3
template<typename _ForwardIterator1, typename _ForwardIterator2,
typename _BinaryPredicate>
constexpr
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));
}

}
# 44 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/array" 2 3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/range_access.h" 1 3
# 33 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/range_access.h" 3

# 34 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/range_access.h" 3
namespace std
{

template<typename _Container>
[[__nodiscard__, __gnu__::__always_inline__]]
inline constexpr auto
begin(_Container& __cont) -> decltype(__cont.begin())
{ return __cont.begin(); }

template<typename _Container>
[[__nodiscard__, __gnu__::__always_inline__]]
inline constexpr auto
begin(const _Container& __cont) -> decltype(__cont.begin())
{ return __cont.begin(); }

template<typename _Container>
[[__nodiscard__, __gnu__::__always_inline__]]
inline constexpr auto
end(_Container& __cont) -> decltype(__cont.end())
{ return __cont.end(); }

template<typename _Container>
[[__nodiscard__, __gnu__::__always_inline__]]
inline constexpr auto
end(const _Container& __cont) -> decltype(__cont.end())
{ return __cont.end(); }

template<typename _Tp, size_t _Nm>

[[__nodiscard__, __gnu__::__always_inline__]]
inline constexpr _Tp*
begin(_Tp (&__arr)[_Nm]) noexcept
{ return __arr; }

template<typename _Tp, size_t _Nm>

[[__nodiscard__, __gnu__::__always_inline__]]
inline constexpr _Tp*
end(_Tp (&__arr)[_Nm]) noexcept
{ return __arr + _Nm; }

template<typename _Tp> class valarray;

template<typename _Tp> _Tp* begin(valarray<_Tp>&) noexcept;

template<typename _Tp> const _Tp* begin(const valarray<_Tp>&) noexcept;
template<typename _Tp> _Tp* end(valarray<_Tp>&) noexcept;
template<typename _Tp> const _Tp* end(const valarray<_Tp>&) noexcept;

template<typename _Container>
[[__nodiscard__, __gnu__::__always_inline__]]
constexpr auto
cbegin(const _Container& __cont) noexcept(noexcept(std::begin(__cont)))
-> decltype(std::begin(__cont))
{ return std::begin(__cont); }

template<typename _Container>
[[__nodiscard__, __gnu__::__always_inline__]]
constexpr auto
cend(const _Container& __cont) noexcept(noexcept(std::end(__cont)))
-> decltype(std::end(__cont))
{ return std::end(__cont); }

template<typename _Container>
[[__nodiscard__, __gnu__::__always_inline__]]
inline constexpr auto
rbegin(_Container& __cont) -> decltype(__cont.rbegin())
{ return __cont.rbegin(); }
template<typename _Container>
[[__nodiscard__, __gnu__::__always_inline__]]
inline constexpr auto
rbegin(const _Container& __cont) -> decltype(__cont.rbegin())
{ return __cont.rbegin(); }

template<typename _Container>
[[__nodiscard__, __gnu__::__always_inline__]]
inline constexpr auto
rend(_Container& __cont) -> decltype(__cont.rend())
{ return __cont.rend(); }

template<typename _Container>
[[__nodiscard__, __gnu__::__always_inline__]]
inline constexpr auto
rend(const _Container& __cont) -> decltype(__cont.rend())
{ return __cont.rend(); }

template<typename _Tp, size_t _Nm>

[[__nodiscard__]]
inline constexpr reverse_iterator<_Tp*>
rbegin(_Tp (&__arr)[_Nm]) noexcept
{ return reverse_iterator<_Tp*>(__arr + _Nm); }

template<typename _Tp, size_t _Nm>

[[__nodiscard__]]
inline constexpr reverse_iterator<_Tp*>
rend(_Tp (&__arr)[_Nm]) noexcept
{ return reverse_iterator<_Tp*>(__arr); }
template<typename _Tp>
[[__nodiscard__]]
inline constexpr reverse_iterator<const _Tp*>
rbegin(initializer_list<_Tp> __il) noexcept
{ return reverse_iterator<const _Tp*>(__il.end()); }

template<typename _Tp>
[[__nodiscard__]]
inline constexpr reverse_iterator<const _Tp*>
rend(initializer_list<_Tp> __il) noexcept
{ return reverse_iterator<const _Tp*>(__il.begin()); }

template<typename _Container>
[[__nodiscard__, __gnu__::__always_inline__]]
inline constexpr auto
crbegin(const _Container& __cont) -> decltype(std::rbegin(__cont))
{ return std::rbegin(__cont); }

template<typename _Container>
[[__nodiscard__, __gnu__::__always_inline__]]
inline constexpr auto
crend(const _Container& __cont) -> decltype(std::rend(__cont))
{ return std::rend(__cont); }
# 259 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/range_access.h" 3
template <typename _Container>
[[nodiscard, __gnu__::__always_inline__]]
constexpr auto
size(const _Container& __cont) noexcept(noexcept(__cont.size()))
-> decltype(__cont.size())
{ return __cont.size(); }

template <typename _Tp, size_t _Nm>

[[nodiscard, __gnu__::__always_inline__]]
constexpr size_t
size(const _Tp (&)[_Nm]) noexcept
{ return _Nm; }
template <typename _Container>
[[nodiscard, __gnu__::__always_inline__]]
constexpr auto
empty(const _Container& __cont) noexcept(noexcept(__cont.empty()))
-> decltype(__cont.empty())
{ return __cont.empty(); }

template <typename _Tp, size_t _Nm>

[[nodiscard, __gnu__::__always_inline__]]
constexpr bool
empty(const _Tp (&)[_Nm]) noexcept
{ return false; }

template <typename _Tp>

[[nodiscard, __gnu__::__always_inline__]]
constexpr bool
empty(initializer_list<_Tp> __il) noexcept
{ return __il.size() == 0;}

template <typename _Container>

[[nodiscard, __gnu__::__always_inline__]]
constexpr auto
data(_Container& __cont) noexcept(noexcept(__cont.data()))
-> decltype(__cont.data())
{ return __cont.data(); }

template <typename _Container>

[[nodiscard, __gnu__::__always_inline__]]
constexpr auto
data(const _Container& __cont) noexcept(noexcept(__cont.data()))
-> decltype(__cont.data())
{ return __cont.data(); }

template <typename _Tp, size_t _Nm>

[[nodiscard, __gnu__::__always_inline__]]
constexpr _Tp*
data(_Tp (&__array)[_Nm]) noexcept
{ return __array; }
template <typename _Tp>
[[nodiscard, __gnu__::__always_inline__]]
constexpr const _Tp*
data(initializer_list<_Tp> __il) noexcept
{ return __il.begin(); }

template<typename _Container>
[[nodiscard, __gnu__::__always_inline__]]
constexpr auto
ssize(const _Container& __cont)
noexcept(noexcept(__cont.size()))
-> common_type_t<ptrdiff_t, make_signed_t<decltype(__cont.size())>>
{
using type = make_signed_t<decltype(__cont.size())>;
return static_cast<common_type_t<ptrdiff_t, type>>(__cont.size());
}

template<typename _Tp, ptrdiff_t _Num>

[[nodiscard, __gnu__::__always_inline__]]
constexpr ptrdiff_t
ssize(const _Tp (&)[_Num]) noexcept
{ return _Num; }

}
# 45 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/array" 2 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 1 3
# 47 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 3

# 48 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 3
# 53 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/array" 2 3

namespace std
{

template<typename _Tp, size_t _Nm>

struct __array_traits
{
using _Type = _Tp[_Nm];
using _Is_swappable = __is_swappable<_Tp>;
using _Is_nothrow_swappable = __is_nothrow_swappable<_Tp>;
};

template<typename _Tp>
struct __array_traits<_Tp, 0>
{

struct _Type
{

__attribute__((__always_inline__,__noreturn__))
_Tp& operator[](size_t) const noexcept { __builtin_trap(); }

__attribute__((__always_inline__))
constexpr explicit operator _Tp*() const noexcept { return nullptr; }
};

using _Is_swappable = true_type;

using _Is_nothrow_swappable = true_type;
};
# 99 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/array" 3
template<typename _Tp, std::size_t _Nm>
struct array
{
typedef _Tp value_type;
typedef value_type* pointer;
typedef const value_type* const_pointer;
typedef value_type& reference;
typedef const value_type& const_reference;
typedef value_type* iterator;
typedef const value_type* const_iterator;
typedef std::size_t size_type;
typedef std::ptrdiff_t difference_type;
typedef std::reverse_iterator<iterator> reverse_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

typename __array_traits<_Tp, _Nm>::_Type _M_elems;

constexpr void
fill(const value_type& __u)
{ std::fill_n(begin(), size(), __u); }

constexpr void
swap(array& __other)
noexcept(__array_traits<_Tp, _Nm>::_Is_nothrow_swappable::value)
{ std::swap_ranges(begin(), end(), __other.begin()); }

[[__gnu__::__const__, __nodiscard__]]
constexpr iterator
begin() noexcept
{ return iterator(data()); }

[[__nodiscard__]]
constexpr const_iterator
begin() const noexcept
{ return const_iterator(data()); }

[[__gnu__::__const__, __nodiscard__]]
constexpr iterator
end() noexcept
{ return iterator(data() + _Nm); }

[[__nodiscard__]]
constexpr const_iterator
end() const noexcept
{ return const_iterator(data() + _Nm); }

[[__gnu__::__const__, __nodiscard__]]
constexpr reverse_iterator
rbegin() noexcept
{ return reverse_iterator(end()); }

[[__nodiscard__]]
constexpr const_reverse_iterator
rbegin() const noexcept
{ return const_reverse_iterator(end()); }

[[__gnu__::__const__, __nodiscard__]]
constexpr reverse_iterator
rend() noexcept
{ return reverse_iterator(begin()); }

[[__nodiscard__]]
constexpr const_reverse_iterator
rend() const noexcept
{ return const_reverse_iterator(begin()); }

[[__nodiscard__]]
constexpr const_iterator
cbegin() const noexcept
{ return const_iterator(data()); }

[[__nodiscard__]]
constexpr const_iterator
cend() const noexcept
{ return const_iterator(data() + _Nm); }

[[__nodiscard__]]
constexpr const_reverse_iterator
crbegin() const noexcept
{ return const_reverse_iterator(end()); }

[[__nodiscard__]]
constexpr const_reverse_iterator
crend() const noexcept
{ return const_reverse_iterator(begin()); }

[[nodiscard, gnu::const, gnu::__always_inline__]]

constexpr size_type
size() const noexcept { return _Nm; }

[[nodiscard, gnu::const, gnu::__always_inline__]]

constexpr size_type
max_size() const noexcept { return _Nm; }

[[nodiscard, gnu::const, gnu::__always_inline__]]

constexpr bool
empty() const noexcept { return size() == 0; }

[[__nodiscard__]]
constexpr reference
operator[](size_type __n) noexcept
{
;
return _M_elems[__n];
}

[[__nodiscard__]]
constexpr const_reference
operator[](size_type __n) const noexcept
{

return _M_elems[__n];
}

constexpr reference
at(size_type __n)
{
if (__n >= _Nm)
std::__throw_out_of_range_fmt(("array::at: __n (which is %zu) " ">= _Nm (which
is %zu)")
,
__n, _Nm);
return _M_elems[__n];
}

constexpr const_reference
at(size_type __n) const
{

return __n < _Nm ? _M_elems[__n]

: (std::__throw_out_of_range_fmt(("array::at: __n (which is %zu) " ">= _Nm
(which is %zu)")
,
__n, _Nm),
_M_elems[__n]);
}

[[__nodiscard__]]
constexpr reference
front() noexcept
{
;
return _M_elems[(size_type)0];
}

[[__nodiscard__]]
constexpr const_reference
front() const noexcept
{
;

return _M_elems[(size_type)0];
}

[[__nodiscard__]]
constexpr reference
back() noexcept
{
;
return _M_elems[_Nm - 1];
}

[[__nodiscard__]]
constexpr const_reference
back() const noexcept
{

return _M_elems[_Nm - 1];

}

[[nodiscard, gnu::const, gnu::__always_inline__]]

constexpr pointer
data() noexcept
{ return static_cast<pointer>(_M_elems); }

[[__nodiscard__]]
constexpr const_pointer
data() const noexcept
{ return static_cast<const_pointer>(_M_elems); }
};

template<typename _Tp, typename... _Up>

array(_Tp, _Up...)
-> array<enable_if_t<(is_same_v<_Tp, _Up> && ...), _Tp>,
1 + sizeof...(_Up)>;

template<typename _Tp, std::size_t _Nm>

[[__nodiscard__]]
constexpr
inline bool
operator==(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
{ return std::equal(__one.begin(), __one.end(), __two.begin()); }

template<typename _Tp, size_t _Nm>

[[nodiscard]]
constexpr __detail::__synth3way_t<_Tp>
operator<=>(const array<_Tp, _Nm>& __a, const array<_Tp, _Nm>& __b)
{
if constexpr (_Nm && __is_memcmp_ordered<_Tp>::__value)
if (!std::__is_constant_evaluated())
{
constexpr size_t __n = _Nm * sizeof(_Tp);
return __builtin_memcmp(__a.data(), __b.data(), __n) <=> 0;
}

for (size_t i = 0; i < _Nm; ++__i)

{
auto __c = __detail::__synth3way(__a[__i], __b[__i]);
if (__c != 0)
return __c;
}
return strong_ordering::equal;
}
# 368 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/array" 3
template<typename _Tp, std::size_t _Nm>
constexpr
inline

__enable_if_t<__array_traits<_Tp, _Nm>::_Is_swappable::value>

swap(array<_Tp, _Nm>& __one, array<_Tp, _Nm>& __two)

noexcept(noexcept(__one.swap(__two)))
{ __one.swap(__two); }

template<typename _Tp, std::size_t _Nm>

__enable_if_t<!__array_traits<_Tp, _Nm>::_Is_swappable::value>
swap(array<_Tp, _Nm>&, array<_Tp, _Nm>&) = delete;

template<std::size_t _Int, typename _Tp, std::size_t _Nm>

[[__nodiscard__]]
constexpr _Tp&
get(array<_Tp, _Nm>& __arr) noexcept
{
static_assert(_Int < _Nm, "array index is within bounds");
return __arr._M_elems[_Int];
}

template<std::size_t _Int, typename _Tp, std::size_t _Nm>

[[__nodiscard__]]
constexpr _Tp&&
get(array<_Tp, _Nm>&& __arr) noexcept
{
static_assert(_Int < _Nm, "array index is within bounds");
return std::move(std::get<_Int>(__arr));
}

template<std::size_t _Int, typename _Tp, std::size_t _Nm>

[[__nodiscard__]]
constexpr const _Tp&
get(const array<_Tp, _Nm>& __arr) noexcept
{
static_assert(_Int < _Nm, "array index is within bounds");
return __arr._M_elems[_Int];
}

template<std::size_t _Int, typename _Tp, std::size_t _Nm>

[[__nodiscard__]]
constexpr const _Tp&&
get(const array<_Tp, _Nm>&& __arr) noexcept
{
static_assert(_Int < _Nm, "array index is within bounds");
return std::move(std::get<_Int>(__arr));
}

template<typename _Tp, size_t _Nm>

[[nodiscard]]
constexpr array<remove_cv_t<_Tp>, _Nm>
to_array(_Tp (&__a)[_Nm])
noexcept(is_nothrow_constructible_v<_Tp, _Tp&>)
{
static_assert(!is_array_v<_Tp>);
static_assert(is_constructible_v<_Tp, _Tp&>);
if constexpr (is_constructible_v<_Tp, _Tp&>)
{
if constexpr (is_trivial_v<_Tp>)
{
array<remove_cv_t<_Tp>, _Nm> __arr;
if (!__is_constant_evaluated() && _Nm != 0)
__builtin_memcpy((void*)__arr.data(), (void*)__a, sizeof(__a));
else
for (size_t __i = 0; __i < _Nm; ++__i)
__arr._M_elems[__i] = __a[__i];
return __arr;
}
else
return [&__a]<size_t... _Idx>(index_sequence<_Idx...>) {
return array<remove_cv_t<_Tp>, _Nm>{{ __a[_Idx]... }};
}(make_index_sequence<_Nm>{});
}
else
__builtin_unreachable();
}

template<typename _Tp, size_t _Nm>

[[nodiscard]]
constexpr array<remove_cv_t<_Tp>, _Nm>
to_array(_Tp (&&__a)[_Nm])
noexcept(is_nothrow_move_constructible_v<_Tp>)
{
static_assert(!is_array_v<_Tp>);
static_assert(is_move_constructible_v<_Tp>);
if constexpr (is_move_constructible_v<_Tp>)
{
if constexpr (is_trivial_v<_Tp>)
{
array<remove_cv_t<_Tp>, _Nm> __arr;
if (!__is_constant_evaluated() && _Nm != 0)
__builtin_memcpy((void*)__arr.data(), (void*)__a, sizeof(__a));
else
for (size_t __i = 0; __i < _Nm; ++__i)
__arr._M_elems[__i] = __a[__i];
return __arr;
}
else
return [&__a]<size_t... _Idx>(index_sequence<_Idx...>) {
return array<remove_cv_t<_Tp>, _Nm>{{ std::move(__a[_Idx])... }};
}(make_index_sequence<_Nm>{});
}
else
__builtin_unreachable();
}

template<typename _Tp, size_t _Nm>

struct tuple_size<array<_Tp, _Nm>>
: public integral_constant<size_t, _Nm> { };

template<size_t _Ind, typename _Tp, size_t _Nm>

struct tuple_element<_Ind, array<_Tp, _Nm>>
{
static_assert(_Ind < _Nm, "array index is in range");
using type = _Tp;
};

template<typename _Tp, size_t _Nm>

inline constexpr size_t tuple_size_v<array<_Tp, _Nm>> = _Nm;

template<typename _Tp, size_t _Nm>

inline constexpr size_t tuple_size_v<const array<_Tp, _Nm>> = _Nm;

template<typename _Tp, size_t _Nm>

struct __is_tuple_like_impl<array<_Tp, _Nm>> : true_type
{ };

}
# 44 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/format" 2 3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/charconv" 1 3
# 32 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/charconv" 3

# 33 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/charconv" 3
# 44 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/charconv" 3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/charconv.h" 1 3
# 33 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/charconv.h" 3

# 34 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/charconv.h" 3

namespace std
{

namespace __detail
{
template<typename _Tp>
constexpr bool __integer_to_chars_is_unsigned
= ! __gnu_cxx::__int_traits<_Tp>::__is_signed;

template<typename _Tp>
constexpr unsigned
__to_chars_len(_Tp __value, int __base = 10) noexcept
{

static_assert(__integer_to_chars_is_unsigned<_Tp>, "implementation bug");

unsigned __n = 1;
const unsigned __b2 = __base * __base;
const unsigned __b3 = __b2 * __base;
const unsigned long __b4 = __b3 * __base;
for (;;)
{
if (__value < (unsigned)__base) return __n;
if (__value < __b2) return __n + 1;
if (__value < __b3) return __n + 2;
if (__value < __b4) return __n + 3;
__value /= __b4;
__n += 4;
}
}

template<typename _Tp>
constexpr void
__to_chars_10_impl(char* __first, unsigned __len, _Tp __val) noexcept
{

static_assert(__integer_to_chars_is_unsigned<_Tp>, "implementation bug");

constexpr char __digits[201] =

"0001020304050607080910111213141516171819"
"2021222324252627282930313233343536373839"
"4041424344454647484950515253545556575859"
"6061626364656667686970717273747576777879"
"8081828384858687888990919293949596979899";
unsigned __pos = __len - 1;
while (__val >= 100)
{
auto const __num = (__val % 100) * 2;
__val /= 100;
__first[__pos] = __digits[__num + 1];
__first[__pos - 1] = __digits[__num];
__pos -= 2;
}
if (__val >= 10)
{
auto const __num = __val * 2;
__first[1] = __digits[__num + 1];
__first[0] = __digits[__num];
}
else
__first[0] = '0' + __val;
}

}
# 45 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/charconv" 2 3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/x86_64-w64-mingw32/bits/
error_constants.h" 1 3
# 34 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/x86_64-w64-mingw32/bits/
error_constants.h" 3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cerrno" 1 3
# 39 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cerrno" 3

# 40 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cerrno" 3

# 1 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/errno.h" 1 3
# 9 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/errno.h" 3
# 1 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/crtdefs.h" 1 3
# 10 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/crtdefs.h" 3
# 1 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/corecrt.h" 1 3
# 10 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/corecrt.h" 3
# 1 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/_mingw.h" 1 3
# 10 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/_mingw.h" 3
# 1 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/_mingw_mac.h" 1 3
# 98 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/_mingw_mac.h" 3

# 107 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/_mingw_mac.h" 3

# 316 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/_mingw_mac.h" 3

# 395 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/_mingw_mac.h" 3

# 11 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/_mingw.h" 2 3
# 1 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/_mingw_secapi.h" 1 3
# 44 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/_mingw_secapi.h" 3
extern "C++" {
template <bool __test, typename __dsttype>
struct __if_array;
template <typename __dsttype>
struct __if_array <true, __dsttype> {
typedef __dsttype __type;
};
}
# 12 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/_mingw.h" 2 3
# 282 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/_mingw.h" 3
# 1 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/vadefs.h" 1 3
# 9 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/vadefs.h" 3
# 1 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/_mingw.h" 1 3
# 661 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/_mingw.h" 3
# 1 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/sdks/_mingw_ddk.h" 1
3
# 662 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/_mingw.h" 2 3
# 10 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/vadefs.h" 2 3

#pragma pack(push,_CRT_PACKING)

extern "C" {

typedef __builtin_va_list __gnuc_va_list;

typedef __gnuc_va_list va_list;

# 99 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/vadefs.h" 3
}

#pragma pack(pop)
# 283 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/_mingw.h" 2 3
# 568 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/_mingw.h" 3
extern "C" {
# 580 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/_mingw.h" 3
void __attribute__((__cdecl__)) __debugbreak(void);
extern __inline__ __attribute__((__always_inline__,__gnu_inline__)) void
__attribute__((__cdecl__)) __debugbreak(void)
{

asm volatile("int {$}3":);

}
# 601 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/_mingw.h" 3
void __attribute__((__cdecl__)) __attribute__ ((__noreturn__)) __fastfail(unsigned
int code);
extern __inline__ __attribute__((__always_inline__,__gnu_inline__)) void
__attribute__((__cdecl__)) __attribute__ ((__noreturn__)) __fastfail(unsigned int
code)
{

asm volatile("int {$}0x29"::"c"(code));

# 615 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/_mingw.h" 3
__builtin_unreachable();
}
# 641 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/_mingw.h" 3
const char *__mingw_get_crt_info (void);

}
# 11 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/corecrt.h" 2 3

#pragma pack(push,_CRT_PACKING)
# 35 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/corecrt.h" 3
__extension__ typedef unsigned long long size_t;
# 45 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/corecrt.h" 3
__extension__ typedef long long ssize_t;

typedef size_t rsize_t;

# 62 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/corecrt.h" 3
__extension__ typedef long long intptr_t;
# 75 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/corecrt.h" 3
__extension__ typedef unsigned long long uintptr_t;
# 88 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/corecrt.h" 3
__extension__ typedef long long ptrdiff_t;
# 106 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/corecrt.h" 3
typedef unsigned short wint_t;
typedef unsigned short wctype_t;

typedef int errno_t;

typedef long __time32_t;

extension typedef long long __time64_t;

# 138 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/corecrt.h" 3
typedef __time64_t time_t;
# 430 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/corecrt.h" 3
struct threadlocaleinfostruct;
struct threadmbcinfostruct;
typedef struct threadlocaleinfostruct *pthreadlocinfo;
typedef struct threadmbcinfostruct *pthreadmbcinfo;
struct __lc_time_data;

typedef struct localeinfo_struct {

pthreadlocinfo locinfo;
pthreadmbcinfo mbcinfo;
} _locale_tstruct,*_locale_t;

typedef struct tagLC_ID {

unsigned short wLanguage;
unsigned short wCountry;
unsigned short wCodePage;
} LC_ID,*LPLC_ID;

typedef struct threadlocaleinfostruct {

int refcount;
unsigned int lc_codepage;
unsigned int lc_collate_cp;
unsigned long lc_handle[6];
LC_ID lc_id[6];
struct {
char *locale;
wchar_t *wlocale;
int *refcount;
int *wrefcount;
} lc_category[6];
int lc_clike;
int mb_cur_max;
int *lconv_intl_refcount;
int *lconv_num_refcount;
int *lconv_mon_refcount;
struct lconv *lconv;
int *ctype1_refcount;
unsigned short *ctype1;
const unsigned short *pctype;
const unsigned char *pclmap;
const unsigned char *pcumap;
struct __lc_time_data *lc_time_curr;

} threadlocinfo;
# 501 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/corecrt.h" 3
#pragma pack(pop)
# 11 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/crtdefs.h" 2 3
# 10 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/errno.h" 2 3

extern "C" {

attribute ((dllimport)) extern int *attribute((cdecl))

_errno(void);
errno_t __attribute__((__cdecl__)) _set_errno(int _Value);
errno_t __attribute__((__cdecl__)) _get_errno(int *_Value);
# 239 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/errno.h" 3
}
# 43 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cerrno" 2 3
# 35 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/x86_64-w64-mingw32/bits/
error_constants.h" 2 3

namespace std
{

enum class errc

{
address_family_not_supported = 102,
address_in_use = 100,
address_not_available = 101,
already_connected = 113,
argument_list_too_long = 7,
argument_out_of_domain = 33,
bad_address = 14,
bad_file_descriptor = 9,

bad_message = 104,

broken_pipe = 32,
connection_aborted = 106,
connection_already_in_progress = 103,
connection_refused = 107,
connection_reset = 108,
cross_device_link = 18,
destination_address_required = 109,
device_or_resource_busy = 16,
directory_not_empty = 41,
executable_format_error = 8,
file_exists = 17,
file_too_large = 27,
filename_too_long = 38,
function_not_supported = 40,
host_unreachable = 110,

identifier_removed = 111,

illegal_byte_sequence = 42,
inappropriate_io_control_operation = 25,
interrupted = 4,
invalid_argument = 22,
invalid_seek = 29,
io_error = 5,
is_a_directory = 21,
message_size = 115,
network_down = 116,
network_reset = 117,
network_unreachable = 118,
no_buffer_space = 119,

no_child_process = 10,
no_link = 121,

no_lock_available = 39,

no_message_available = 120,

no_message = 122,

no_protocol_option = 123,

no_space_on_device = 28,

no_stream_resources = 124,

no_such_device_or_address = 6,
no_such_device = 19,
no_such_file_or_directory = 2,
no_such_process = 3,
not_a_directory = 20,
not_a_socket = 128,

not_a_stream = 125,

not_connected = 126,
not_enough_memory = 12,

not_supported = 129,

operation_canceled = 105,
operation_in_progress = 112,

operation_not_permitted = 1,

operation_not_supported = 130,

operation_would_block = 140,

owner_dead = 133,

permission_denied = 13,
protocol_error = 134,
protocol_not_supported = 135,
read_only_file_system = 30,
resource_deadlock_would_occur = 36,
resource_unavailable_try_again = 11,
result_out_of_range = 34,

state_not_recoverable = 127,

stream_timeout = 137,

text_file_busy = 139,
timed_out = 138,

too_many_files_open_in_system = 23,
too_many_files_open = 24,
too_many_links = 31,
too_many_symbolic_link_levels = 114,

value_too_large = 132,

wrong_protocol_type = 136
};

}
# 46 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/charconv" 2 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 1 3
# 47 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 3

# 48 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 3
# 51 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/charconv" 2 3

namespace std
{

struct to_chars_result
{
char* ptr;
errc ec;

friend bool
operator==(const to_chars_result&, const to_chars_result&) = default;

constexpr explicit operator bool() const noexcept { return ec == errc{}; }

};

struct from_chars_result
{
const char* ptr;
errc ec;

friend bool
operator==(const from_chars_result&, const from_chars_result&) = default;

constexpr explicit operator bool() const noexcept { return ec == errc{}; }

};

namespace __detail
{

template<typename _Tp>
struct __to_chars_unsigned_type : __make_unsigned_selector_base
{
using _UInts = _List<unsigned int, unsigned long, unsigned long long

, unsigned __int128

>;
using type = typename __select<sizeof(_Tp), _UInts>::__type;
};

template<typename _Tp>
using __unsigned_least_t = typename __to_chars_unsigned_type<_Tp>::type;

template<typename _Tp>
constexpr unsigned
__to_chars_len(_Tp __value, int __base ) noexcept;

template<typename _Tp>
constexpr unsigned
__to_chars_len_2(_Tp __value) noexcept
{ return std::__bit_width(__value); }

template<typename _Tp>
constexpr to_chars_result
__to_chars(char* __first, char* __last, _Tp __val, int __base) noexcept
{
static_assert(__integer_to_chars_is_unsigned<_Tp>, "implementation bug");

to_chars_result __res;

const unsigned len = to_chars_len(val, base);

if (__builtin_expect((last - first) < __len, 0))

{
__res.ptr = __last;
__res.ec = errc::value_too_large;
return __res;
}

unsigned pos = len - 1;

constexpr char __digits[] = {

'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',
'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't',
'u', 'v', 'w', 'x', 'y', 'z'
};

while (val >= (unsigned)base)

{
auto const __quo = __val / __base;
auto const __rem = __val % __base;
__first[__pos--] = __digits[__rem];
__val = __quo;
}
*__first = __digits[__val];

res.ptr = first + __len;

__res.ec = {};
return __res;
}

template<typename _Tp>
constexpr to_chars_result
__to_chars_16(char* __first, char* __last, _Tp __val) noexcept
{
static_assert(__integer_to_chars_is_unsigned<_Tp>, "implementation bug");

to_chars_result __res;

const unsigned len = (to_chars_len_2(__val) + 3) / 4;

if (__builtin_expect((last - first) < __len, 0))

{
__res.ptr = __last;
__res.ec = errc::value_too_large;
return __res;
}

constexpr char __digits[] = {

'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'a', 'b', 'c', 'd', 'e', 'f'
};
unsigned __pos = __len - 1;
while (__val >= 0x100)
{
auto __num = __val & 0xF;
__val >>= 4;
__first[__pos] = __digits[__num];
__num = __val & 0xF;
__val >>= 4;
__first[__pos - 1] = __digits[__num];
__pos -= 2;
}
if (__val >= 0x10)
{
const auto __num = __val & 0xF;
__val >>= 4;
__first[1] = __digits[__num];
__first[0] = __digits[__val];
}
else
__first[0] = __digits[__val];
__res.ptr = __first + __len;
__res.ec = {};
return __res;
}

template<typename _Tp>
constexpr to_chars_result
__to_chars_10(char* __first, char* __last, _Tp __val) noexcept
{
static_assert(__integer_to_chars_is_unsigned<_Tp>, "implementation bug");

to_chars_result __res;

const unsigned len = to_chars_len(__val, 10);

if (__builtin_expect((last - first) < __len, 0))

{
__res.ptr = __last;
__res.ec = errc::value_too_large;
return __res;
}

detail::to_chars_10_impl(first, len, __val);

__res.ptr = __first + __len;
__res.ec = {};
return __res;
}

template<typename _Tp>
constexpr to_chars_result
__to_chars_8(char* __first, char* __last, _Tp __val) noexcept
{
static_assert(__integer_to_chars_is_unsigned<_Tp>, "implementation bug");

to_chars_result __res;
unsigned __len = 0;

if constexpr (__gnu_cxx::__int_traits<_Tp>::__digits <= 16)

{
__len = __val > 077777u ? 6u
: __val > 07777u ? 5u
: __val > 0777u ? 4u
: __val > 077u ? 3u
: __val > 07u ? 2u
: 1u;
}
else
__len = (__to_chars_len_2(__val) + 2) / 3;

if (__builtin_expect((last - first) < __len, 0))

{
__res.ptr = __last;
__res.ec = errc::value_too_large;
return __res;
}

unsigned pos = len - 1;

while (__val >= 0100)
{
auto __num = __val & 7;
__val >>= 3;
__first[__pos] = '0' + __num;
__num = __val & 7;
__val >>= 3;
__first[__pos - 1] = '0' + __num;
__pos -= 2;
}
if (__val >= 010)
{
auto const __num = __val & 7;
__val >>= 3;
__first[1] = '0' + __num;
__first[0] = '0' + __val;
}
else
__first[0] = '0' + __val;
__res.ptr = __first + __len;
__res.ec = {};
return __res;
}

template<typename _Tp>
constexpr to_chars_result
__to_chars_2(char* __first, char* __last, _Tp __val) noexcept
{
static_assert(__integer_to_chars_is_unsigned<_Tp>, "implementation bug");

to_chars_result __res;

const unsigned len = to_chars_len_2(__val);

if (__builtin_expect((last - first) < __len, 0))

{
__res.ptr = __last;
__res.ec = errc::value_too_large;
return __res;
}

unsigned pos = len - 1;

while (__pos)
{
__first[__pos--] = '0' + (__val & 1);
__val >>= 1;
}

__first[0] = '1';

res.ptr = first + __len;

__res.ec = {};
return __res;
}

template<typename _Tp>
constexpr to_chars_result
__to_chars_i(char* __first, char* __last, _Tp __value, int __base = 10)
{
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(2 <=
__base && __base <= 36), false)) std::__glibcxx_assert_fail(); } while (false);

using _Up = detail::unsigned_least_t<_Tp>;

_Up __unsigned_val = __value;

if (first == last) [[unlikely]]

return { __last, errc::value_too_large };

if (__value == 0)
{
*__first = '0';
return { __first + 1, errc{} };
}
else if constexpr (std::is_signed<_Tp>::value)
if (__value < 0)
{
*__first++ = '-';
__unsigned_val = _Up(~__value) + _Up(1);
}

switch (__base)
{
case 16:
return __detail::__to_chars_16(__first, __last, __unsigned_val);
case 10:
return __detail::__to_chars_10(__first, __last, __unsigned_val);
case 8:
return __detail::__to_chars_8(__first, __last, __unsigned_val);
case 2:
return __detail::__to_chars_2(__first, __last, __unsigned_val);
default:
return __detail::__to_chars(__first, __last, __unsigned_val, __base);
}
}

constexpr inline to_chars_result to_chars(char* first, char* last, char

__value, int __base = 10) { return std::__to_chars_i<char>(__first, __last,
__value, __base); }
constexpr inline to_chars_result to_chars(char* __first, char* __last, signed char
__value, int __base = 10) { return std::__to_chars_i<signed char>(__first, __last,
__value, __base); }
constexpr inline to_chars_result to_chars(char* __first, char* __last, unsigned
char __value, int __base = 10) { return std::__to_chars_i<unsigned char>(__first,
__last, __value, __base); }
constexpr inline to_chars_result to_chars(char* __first, char* __last, signed short
__value, int __base = 10) { return std::__to_chars_i<signed short>(__first, __last,
__value, __base); }
constexpr inline to_chars_result to_chars(char* __first, char* __last, unsigned
short __value, int __base = 10) { return std::__to_chars_i<unsigned short>(__first,
__last, __value, __base); }
constexpr inline to_chars_result to_chars(char* __first, char* __last, signed int
__value, int __base = 10) { return std::__to_chars_i<signed int>(__first, __last,
__value, __base); }
constexpr inline to_chars_result to_chars(char* __first, char* __last, unsigned int
__value, int __base = 10) { return std::__to_chars_i<unsigned int>(__first, __last,
__value, __base); }
constexpr inline to_chars_result to_chars(char* __first, char* __last, signed long
__value, int __base = 10) { return std::__to_chars_i<signed long>(__first, __last,
__value, __base); }
constexpr inline to_chars_result to_chars(char* __first, char* __last, unsigned
long __value, int __base = 10) { return std::__to_chars_i<unsigned long>(__first,
__last, __value, __base); }
constexpr inline to_chars_result to_chars(char* __first, char* __last, signed long
long __value, int __base = 10) { return std::__to_chars_i<signed long
long>(__first, __last, __value, __base); }
constexpr inline to_chars_result to_chars(char* __first, char* __last, unsigned
long long __value, int __base = 10) { return std::__to_chars_i<unsigned long
long>(__first, __last, __value, __base); }

constexpr inline to_chars_result to_chars(char* first, char* last, signed

__int128 __value, int __base = 10) { return std::__to_chars_i<signed
__int128>(__first, __last, __value, __base); }
constexpr inline to_chars_result to_chars(char* __first, char* __last, unsigned
__int128 __value, int __base = 10) { return std::__to_chars_i<unsigned
__int128>(__first, __last, __value, __base); }
# 391 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/charconv" 3
to_chars_result to_chars(char*, char*, bool, int = 10) = delete;

namespace __detail
{
template<typename _Tp>
constexpr bool
__raise_and_add(_Tp& __val, int __base, unsigned char __c)
{
if (__builtin_mul_overflow(__val, __base, &__val)
|| __builtin_add_overflow(__val, __c, &__val))
return false;
return true;
}

template<bool _DecOnly>
struct __from_chars_alnum_to_val_table
{
struct type { unsigned char __data[1u << 8] = {}; };

static constexpr type

_S_make_table()
{
constexpr unsigned char __lower_letters[27] = "abcdefghijklmnopqrstuvwxyz";
constexpr unsigned char __upper_letters[27] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
type __table;
for (auto& __entry : __table.__data)
__entry = 127;
for (int __i = 0; __i < 10; ++__i)
__table.__data['0' + __i] = __i;
for (int __i = 0; __i < 26; ++__i)
{
__table.__data[__lower_letters[__i]] = 10 + __i;
__table.__data[__upper_letters[__i]] = 10 + __i;
}
return __table;
}

static constexpr type value = (_DecOnly, _S_make_table());

};
# 446 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/charconv" 3
template<bool _DecOnly = false>
constexpr unsigned char
__from_chars_alnum_to_val(unsigned char __c)
{
if constexpr (_DecOnly)
return static_cast<unsigned char>(__c - '0');
else
return __from_chars_alnum_to_val_table<_DecOnly>::value.__data[__c];
}

template<bool _DecOnly, typename _Tp>

constexpr bool
__from_chars_pow2_base(const char*& __first, const char* __last, _Tp& __val,
int __base)
{
static_assert(is_integral<_Tp>::value, "implementation bug");
static_assert(is_unsigned<_Tp>::value, "implementation bug");

const int __log2_base = __countr_zero(unsigned(__base & 0x3f));

const ptrdiff_t len = last - __first;

ptrdiff_t __i = 0;
while (__i < __len && __first[__i] == '0')
++__i;
const ptrdiff_t __leading_zeroes = __i;
if (__i >= __len) [[__unlikely__]]
{
__first += __i;
return true;
}

unsigned char __leading_c = 0;

if (__base != 2)
{
__leading_c = __from_chars_alnum_to_val<_DecOnly>(__first[__i]);

if (__leading_c >= base) [[unlikely__]]

{
__first += __i;
return true;
}
__val = __leading_c;
++__i;
}
for (; __i < __len; ++__i)
{
const unsigned char __c = __from_chars_alnum_to_val<_DecOnly>(__first[__i]);
if (__c >= __base)
break;
__val = (__val << __log2_base) | __c;
}
__first += __i;
auto __significant_bits = (__i - __leading_zeroes) * __log2_base;
if (__base != 2)

__significant_bits -= __log2_base - __bit_width(__leading_c);

return __significant_bits <= __gnu_cxx::__int_traits<_Tp>::__digits;

}

template<bool _DecOnly, typename _Tp>

constexpr bool
__from_chars_alnum(const char*& __first, const char* __last, _Tp& __val,
int __base)
{

const int __bits_per_digit = __bit_width(unsigned(__base & 0x3f));

int __unused_bits_lower_bound = __gnu_cxx::__int_traits<_Tp>::__digits;
for (; __first != __last; ++__first)
{
const unsigned char __c = __from_chars_alnum_to_val<_DecOnly>(*__first);
if (__c >= __base)
return true;

__unused_bits_lower_bound -= __bits_per_digit;
if (__unused_bits_lower_bound >= 0) [[__likely__]]

val = val * base + c;

else if (!__raise_and_add(__val, __base, __c)) [[__unlikely__]]
{
while (++__first != __last
&& __from_chars_alnum_to_val<_DecOnly>(*__first) < __base)
;
return false;
}
}
return true;
}

template<typename _Tp,
enable_if_t<__or_<__is_standard_integer<_Tp>,
is_same<char, remove_cv_t<_Tp>>>::value, int> = 0>
constexpr from_chars_result
from_chars(const char* __first, const char* __last, _Tp& __value,
int __base = 10)
{
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(2 <=
__base && __base <= 36), false)) std::__glibcxx_assert_fail(); } while (false);

from_chars_result res{first, {}};

int __sign = 1;
if constexpr (std::is_signed<_Tp>::value)
if (__first != __last && *__first == '-')
{
__sign = -1;
++__first;
}

using _Up = detail::unsigned_least_t<_Tp>;

_Up __val = 0;

const auto start = first;

bool __valid;
if ((__base & (__base - 1)) == 0)
{
if (__base <= 8)
__valid = __detail::__from_chars_pow2_base<true>(__first, __last, __val,
__base);
else
__valid = __detail::__from_chars_pow2_base<false>(__first, __last, __val,
__base);
}
else if (__base <= 10)
__valid = __detail::__from_chars_alnum<true>(__first, __last, __val, __base);
else
__valid = __detail::__from_chars_alnum<false>(__first, __last, __val, __base);

if (__builtin_expect(first == start, 0))

__res.ec = errc::invalid_argument;
else
{
__res.ptr = __first;
if (!__valid)
__res.ec = errc::result_out_of_range;
else
{
if constexpr (std::is_signed<_Tp>::value)
{
_Tp __tmp;
if (__builtin_mul_overflow(__val, __sign, &__tmp))
__res.ec = errc::result_out_of_range;
else
__value = __tmp;
}
else
{
if constexpr (__gnu_cxx::__int_traits<_Up>::__max
> __gnu_cxx::__int_traits<_Tp>::__max)
{
if (__val > __gnu_cxx::__int_traits<_Tp>::__max)
__res.ec = errc::result_out_of_range;
else
__value = __val;
}
else
__value = __val;
}
}
}
return __res;
}

enum class chars_format

{
scientific = 1, fixed = 2, hex = 4, general = fixed | scientific
};

[[nodiscard]]
constexpr chars_format
operator|(chars_format __lhs, chars_format __rhs) noexcept
{ return (chars_format)((unsigned)__lhs | (unsigned)__rhs); }

[[nodiscard]]
constexpr chars_format
operator&(chars_format __lhs, chars_format __rhs) noexcept
{ return (chars_format)((unsigned)__lhs & (unsigned)__rhs); }

[[nodiscard]]
constexpr chars_format
operator^(chars_format __lhs, chars_format __rhs) noexcept
{ return (chars_format)((unsigned)__lhs ^ (unsigned)__rhs); }

[[nodiscard]]
constexpr chars_format
operator~(chars_format __fmt) noexcept
{ return (chars_format)~(unsigned)__fmt; }

constexpr chars_format&
operator|=(chars_format& __lhs, chars_format __rhs) noexcept
{ return __lhs = __lhs | __rhs; }

constexpr chars_format&
operator&=(chars_format& __lhs, chars_format __rhs) noexcept
{ return __lhs = __lhs & __rhs; }

constexpr chars_format&
operator^=(chars_format& __lhs, chars_format __rhs) noexcept
{ return __lhs = __lhs ^ __rhs; }

from_chars_result
from_chars(const char* __first, const char* __last, float& __value,
chars_format __fmt = chars_format::general) noexcept;

from_chars_result
from_chars(const char* __first, const char* __last, double& __value,
chars_format __fmt = chars_format::general) noexcept;

from_chars_result
from_chars(const char* __first, const char* __last, long double& __value,
chars_format __fmt = chars_format::general) noexcept;
from_chars_result
__from_chars_float16_t(const char* __first, const char* __last,
float& __value,
chars_format __fmt = chars_format::general) noexcept;
from_chars_result
__from_chars_bfloat16_t(const char* __first, const char* __last,
float& __value,
chars_format __fmt = chars_format::general) noexcept;

inline from_chars_result
from_chars(const char* __first, const char* __last, _Float16& __value,
chars_format __fmt = chars_format::general) noexcept
{
float __val;
from_chars_result __res
= __from_chars_float16_t(__first, __last, __val, __fmt);
if (__res.ec == errc{})
__value = _Float16(__val);
return __res;
}

inline from_chars_result
from_chars(const char* __first, const char* __last, _Float32& __value,
chars_format __fmt = chars_format::general) noexcept
{
float __val;
from_chars_result __res = from_chars(__first, __last, __val, __fmt);
if (__res.ec == errc{})
__value = _Float32(__val);
return __res;
}

inline from_chars_result
from_chars(const char* __first, const char* __last, _Float64& __value,
chars_format __fmt = chars_format::general) noexcept
{
double __val;
from_chars_result __res = from_chars(__first, __last, __val, __fmt);
if (__res.ec == errc{})
__value = _Float64(__val);
return __res;
}
# 758 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/charconv" 3
inline from_chars_result
from_chars(const char* __first, const char* __last,
__gnu_cxx::__bfloat16_t & __value,
chars_format __fmt = chars_format::general) noexcept
{
float __val;
from_chars_result __res
= __from_chars_bfloat16_t(__first, __last, __val, __fmt);
if (__res.ec == errc{})
__value = __gnu_cxx::__bfloat16_t(__val);
return __res;
}

to_chars_result to_chars(char* first, char* last, float __value) noexcept;

to_chars_result to_chars(char* __first, char* __last, float __value,
chars_format __fmt) noexcept;
to_chars_result to_chars(char* __first, char* __last, float __value,
chars_format __fmt, int __precision) noexcept;

to_chars_result to_chars(char* first, char* last, double __value) noexcept;

to_chars_result to_chars(char* __first, char* __last, double __value,
chars_format __fmt) noexcept;
to_chars_result to_chars(char* __first, char* __last, double __value,
chars_format __fmt, int __precision) noexcept;

to_chars_result to_chars(char* first, char* last, long double __value)

noexcept;
to_chars_result to_chars(char* __first, char* __last, long double __value,
chars_format __fmt) noexcept;
to_chars_result to_chars(char* __first, char* __last, long double __value,
chars_format __fmt, int __precision) noexcept;

to_chars_result __to_chars_float16_t(char* first, char* last,

float __value,
chars_format __fmt) noexcept;
to_chars_result __to_chars_bfloat16_t(char* __first, char* __last,
float __value,
chars_format __fmt) noexcept;

inline to_chars_result
to_chars(char* __first, char* __last, _Float16 __value) noexcept
{
return __to_chars_float16_t(__first, __last, float(__value),
chars_format{});
}
inline to_chars_result
to_chars(char* __first, char* __last, _Float16 __value,
chars_format __fmt) noexcept
{ return __to_chars_float16_t(__first, __last, float(__value), __fmt); }
inline to_chars_result
to_chars(char* __first, char* __last, _Float16 __value,
chars_format __fmt, int __precision) noexcept
{ return to_chars(__first, __last, float(__value), __fmt, __precision); }
inline to_chars_result
to_chars(char* __first, char* __last, _Float32 __value) noexcept
{ return to_chars(__first, __last, float(__value)); }
inline to_chars_result
to_chars(char* __first, char* __last, _Float32 __value,
chars_format __fmt) noexcept
{ return to_chars(__first, __last, float(__value), __fmt); }
inline to_chars_result
to_chars(char* __first, char* __last, _Float32 __value,
chars_format __fmt, int __precision) noexcept
{ return to_chars(__first, __last, float(__value), __fmt, __precision); }

inline to_chars_result
to_chars(char* __first, char* __last, _Float64 __value) noexcept
{ return to_chars(__first, __last, double(__value)); }
inline to_chars_result
to_chars(char* __first, char* __last, _Float64 __value,
chars_format __fmt) noexcept
{ return to_chars(__first, __last, double(__value), __fmt); }
inline to_chars_result
to_chars(char* __first, char* __last, _Float64 __value,
chars_format __fmt, int __precision) noexcept
{ return to_chars(__first, __last, double(__value), __fmt, __precision); }
# 914 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/charconv" 3
inline to_chars_result
to_chars(char* __first, char* __last,
__gnu_cxx::__bfloat16_t __value) noexcept
{
return __to_chars_bfloat16_t(__first, __last, float(__value),
chars_format{});
}
inline to_chars_result
to_chars(char* __first, char* __last, __gnu_cxx::__bfloat16_t __value,
chars_format __fmt) noexcept
{ return __to_chars_bfloat16_t(__first, __last, float(__value), __fmt); }
inline to_chars_result
to_chars(char* __first, char* __last, __gnu_cxx::__bfloat16_t __value,
chars_format __fmt, int __precision) noexcept
{ return to_chars(__first, __last, float(__value), __fmt, __precision); }

}
# 45 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/format" 2 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/limits" 1 3
# 40 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/limits" 3

# 41 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/limits" 3
# 158 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/limits" 3
namespace std
{
enum float_round_style
{
round_indeterminate = -1,
round_toward_zero = 0,
round_to_nearest = 1,
round_toward_infinity = 2,
round_toward_neg_infinity = 3
};

enum float_denorm_style
{

denorm_indeterminate = -1,

denorm_absent = 0,

denorm_present = 1
};
# 202 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/limits" 3
struct __numeric_limits_base
{

static constexpr bool is_specialized = false;

static constexpr int digits = 0;

static constexpr int digits10 = 0;

static constexpr int max_digits10 = 0;

static constexpr bool is_signed = false;

static constexpr bool is_integer = false;

static constexpr bool is_exact = false;

static constexpr int radix = 0;

static constexpr int min_exponent = 0;

static constexpr int min_exponent10 = 0;

static constexpr int max_exponent = 0;

static constexpr int max_exponent10 = 0;

static constexpr bool has_infinity = false;

static constexpr bool has_quiet_NaN = false;

static constexpr bool has_signaling_NaN = false;

static constexpr float_denorm_style has_denorm = denorm_absent;

static constexpr bool has_denorm_loss = false;

static constexpr bool is_iec559 = false;

static constexpr bool is_bounded = false;

# 288 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/limits" 3
static constexpr bool is_modulo = false;

static constexpr bool traps = false;

static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};

template<>
struct numeric_limits<char>
{
static constexpr bool is_specialized = true;

static constexpr char

static constexpr bool traps = true;

static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};

static constexpr char8_t

infinity() noexcept { return char8_t(); }
static constexpr char8_t
quiet_NaN() noexcept { return char8_t(); }

static constexpr char8_t

signaling_NaN() noexcept { return char8_t(); }

static constexpr char8_t

denorm_min() noexcept { return char8_t(); }

static constexpr bool is_iec559 = false;

static constexpr bool is_bounded = true;
static constexpr bool is_modulo = !is_signed;

static constexpr bool traps = true;

static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_toward_zero;
};

static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style = round_toward_zero;
};

static constexpr bool has_infinity = false;

template<>
struct numeric_limits<unsigned short>
{
static constexpr bool is_specialized = true;

static constexpr unsigned short

min() noexcept { return 0; }

static constexpr unsigned short

max() noexcept { return 0x7fff * 2U + 1; }
static constexpr unsigned short
lowest() noexcept { return min(); }

static constexpr int digits

= (sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0));
static constexpr int digits10
= ((sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0)) * 643L / 2136);

static constexpr int max_digits10 = 0;

static constexpr bool is_signed = false;

static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;

static constexpr unsigned short

epsilon() noexcept { return 0; }

static constexpr unsigned short

round_error() noexcept { return 0; }

static constexpr int min_exponent = 0;

static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;

min() noexcept { return -0x7fffffffL - 1; }

static constexpr long

max() noexcept { return 0x7fffffffL; }

static constexpr long

lowest() noexcept { return min(); }

static constexpr int digits = (sizeof(long) * 8 - ((long)(-1) < 0));

static constexpr int digits10 = ((sizeof(long) * 8 - ((long)(-1) < 0)) * 643L
/ 2136);

static constexpr int max_digits10 = 0;

static constexpr bool is_signed = true;

static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;

static constexpr long

epsilon() noexcept { return 0; }

static constexpr long

round_error() noexcept { return 0; }

static constexpr int min_exponent = 0;

static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;

static constexpr bool has_infinity = false;

template<>
struct numeric_limits<long long>
{
static constexpr bool is_specialized = true;

static constexpr long long

min() noexcept { return -0x7fffffffffffffffLL - 1; }

static constexpr long long

max() noexcept { return 0x7fffffffffffffffLL; }
static constexpr long long
lowest() noexcept { return min(); }

static constexpr int digits

= (sizeof(long long) * 8 - ((long long)(-1) < 0));
static constexpr int digits10
= ((sizeof(long long) * 8 - ((long long)(-1) < 0)) * 643L / 2136);

static constexpr int max_digits10 = 0;

static constexpr bool is_signed = true;

static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;

static constexpr long long

epsilon() noexcept { return 0; }

static constexpr long long

round_error() noexcept { return 0; }

static constexpr int min_exponent = 0;

static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;

static constexpr bool has_infinity = false;

template<>
struct numeric_limits<unsigned long long>
{
static constexpr bool is_specialized = true;

static constexpr unsigned long long

min() noexcept { return 0; }

static constexpr unsigned long long

max() noexcept { return 0x7fffffffffffffffLL * 2ULL + 1; }

static constexpr unsigned long long

lowest() noexcept { return min(); }

static constexpr int digits

= (sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0));
static constexpr int digits10
= ((sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0)) *
643L / 2136);

static constexpr int max_digits10 = 0;

static constexpr bool is_signed = false;

static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int radix = 2;

static constexpr unsigned long long

epsilon() noexcept { return 0; }

static constexpr unsigned long long

round_error() noexcept { return 0; }

static constexpr int min_exponent = 0;

static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;

static constexpr bool tinyness_before
= false;
static constexpr float_round_style round_style
= round_to_nearest;
};

static constexpr __gnu_cxx::__bfloat16_t

signaling_NaN() noexcept
{ return __builtin_nansf16b(""); }

static constexpr __gnu_cxx::__bfloat16_t

denorm_min() noexcept
{ return 9.18354961579912115600575419704879436e-41BF16; }

static constexpr bool is_iec559

= has_infinity && has_quiet_NaN && has_denorm == denorm_present;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = false;

static constexpr bool traps = false;

static constexpr bool tinyness_before = false;
static constexpr float_round_style round_style
= round_to_nearest;
};

__extension__
template<>
struct numeric_limits<__float128>
{
static constexpr bool is_specialized = true;

static constexpr __float128

min() noexcept
{

return extension 0x1.0p-16382Q;

static constexpr __float128

max() noexcept
{

return extension 0x1.ffffffffffffffffffffffffffffp+16383Q;

static constexpr __float128

lowest() noexcept
{ return -max(); }

static constexpr int digits = 113;

static constexpr int digits10 = 33;

static constexpr int max_digits10 = 35;

static constexpr bool is_signed = true;

static constexpr bool is_integer = false;
static constexpr bool is_exact = false;
static constexpr int radix = 2;

static constexpr __float128

epsilon() noexcept
{ return double(1.9259299443872359e-34); }

static constexpr __float128

round_error() noexcept { return 0.5; }

static constexpr int min_exponent = -16381;

static constexpr int min_exponent10 = -4931;
static constexpr int max_exponent = 16384;
static constexpr int max_exponent10 = 4932;

static constexpr bool has_infinity = 1;

static constexpr bool has_quiet_NaN = 1;

static constexpr bool has_signaling_NaN = true;

static constexpr float_denorm_style has_denorm

= denorm_present;
static constexpr bool has_denorm_loss = false;

# 37 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/locale" 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/localefwd.h" 1 3
# 37 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/localefwd.h" 3

# 38 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/localefwd.h" 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/x86_64-w64-mingw32/bits/c+
+locale.h" 1 3
# 39 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/x86_64-w64-mingw32/bits/c+
+locale.h" 3

# 40 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/x86_64-w64-mingw32/bits/c+
+locale.h" 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/clocale" 1 3
# 39 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/clocale" 3

# 40 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/clocale" 3

# 1 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/locale.h" 1 3
# 12 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/locale.h" 3
# 1 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/stdio.h" 1 3
# 9 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/stdio.h" 3
# 1
"D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/corecrt_stdio_config.h" 1
3
# 10 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/stdio.h" 2 3

#pragma pack(push,_CRT_PACKING)

extern "C" {
# 33 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/stdio.h" 3
struct _iobuf {
char *_ptr;
int _cnt;
char *_base;
int _flag;
int _file;
int _charbuf;
int _bufsiz;
char *_tmpfname;

};
typedef struct _iobuf FILE;
# 99 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/stdio.h" 3
# 1 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/_mingw_off_t.h" 1 3

typedef long _off_t;

typedef long off32_t;

extension typedef long long _off64_t;

extension typedef long long off64_t;

# 26 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/_mingw_off_t.h" 3
typedef off32_t off_t;
# 100 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/stdio.h" 2 3

attribute ((dllimport)) FILE *attribute((cdecl))

__acrt_iob_func(unsigned index);

attribute ((dllimport)) FILE *attribute((cdecl))

__iob_func(void);
# 123 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/stdio.h" 3
__extension__ typedef long long fpos_t;
# 167 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/stdio.h" 3
extern
__attribute__((__format__(__gnu_scanf__, 2,3))) __attribute__ ((__nonnull__ (2)))
int __attribute__((__cdecl__)) __mingw_sscanf(const char * __restrict__
_Src,const char * __restrict__ _Format,...);
extern
__attribute__((__format__(__gnu_scanf__, 2,0))) __attribute__ ((__nonnull__ (2)))
int __attribute__((__cdecl__)) __mingw_vsscanf (const char * __restrict__
_Str,const char * __restrict__ Format,va_list argp);
extern
__attribute__((__format__(__gnu_scanf__, 1,2))) __attribute__ ((__nonnull__ (1)))
int __attribute__((__cdecl__)) __mingw_scanf(const char * __restrict__
_Format,...);
extern
__attribute__((__format__(__gnu_scanf__, 1,0))) __attribute__ ((__nonnull__ (1)))
int __attribute__((__cdecl__)) __mingw_vscanf(const char * __restrict__ Format,
va_list argp);
extern
__attribute__((__format__(__gnu_scanf__, 2,3))) __attribute__ ((__nonnull__ (2)))
int __attribute__((__cdecl__)) __mingw_fscanf(FILE * __restrict__ _File,const
char * __restrict__ _Format,...);
extern
__attribute__((__format__(__gnu_scanf__, 2,0))) __attribute__ ((__nonnull__ (2)))
int __attribute__((__cdecl__)) __mingw_vfscanf (FILE * __restrict__ fp, const
char * __restrict__ Format,va_list argp);

extern
__attribute__((__format__(__gnu_printf__,3,0))) __attribute__ ((__nonnull__ (3)))
int __attribute__((__cdecl__)) __mingw_vsnprintf(char * __restrict__
_DstBuf,size_t _MaxCount,const char * __restrict__ _Format,
va_list _ArgList);
extern
__attribute__((__format__(__gnu_printf__,3,4))) __attribute__ ((__nonnull__ (3)))
int __attribute__((__cdecl__)) __mingw_snprintf(char * __restrict__ s, size_t n,
const char * __restrict__ format, ...);
extern
__attribute__((__format__(__gnu_printf__,1,2))) __attribute__ ((__nonnull__ (1)))
int __attribute__((__cdecl__)) __mingw_printf(const char * __restrict__ , ... )
__attribute__ ((__nothrow__));
extern
__attribute__((__format__(__gnu_printf__,1,0))) __attribute__ ((__nonnull__ (1)))
int __attribute__((__cdecl__)) __mingw_vprintf (const char * __restrict__ ,
va_list) __attribute__ ((__nothrow__));
extern
__attribute__((__format__(__gnu_printf__,2,3))) __attribute__ ((__nonnull__ (2)))
int __attribute__((__cdecl__)) __mingw_fprintf (FILE * __restrict__ , const char
* __restrict__ , ...) __attribute__ ((__nothrow__));
extern
__attribute__((__format__(__gnu_printf__,2,0))) __attribute__ ((__nonnull__ (2)))
int __attribute__((__cdecl__)) __mingw_vfprintf (FILE * __restrict__ , const char
* __restrict__ , va_list) __attribute__ ((__nothrow__));
extern
__attribute__((__format__(__gnu_printf__,2,3))) __attribute__ ((__nonnull__ (2)))
int __attribute__((__cdecl__)) __mingw_sprintf (char * __restrict__ , const char
* __restrict__ , ...) __attribute__ ((__nothrow__));
extern
__attribute__((__format__(__gnu_printf__,2,0))) __attribute__ ((__nonnull__ (2)))
int __attribute__((__cdecl__)) __mingw_vsprintf (char * __restrict__ , const char
* __restrict__ , va_list) __attribute__ ((__nothrow__));
extern
__attribute__((__format__(__gnu_printf__,2,3))) __attribute__((nonnull (1,2)))
int __attribute__((__cdecl__)) __mingw_asprintf(char ** __restrict__ , const char
* __restrict__ , ...) __attribute__ ((__nothrow__));
extern
__attribute__((__format__(__gnu_printf__,2,0))) __attribute__((nonnull (1,2)))
int __attribute__((__cdecl__)) __mingw_vasprintf(char ** __restrict__ , const
char * __restrict__ , va_list) __attribute__ ((__nothrow__));

extern
__attribute__((__format__(__ms_scanf__, 2,3))) __attribute__ ((__nonnull__ (2)))
int __attribute__((__cdecl__)) __ms_sscanf(const char * __restrict__ _Src,const
char * __restrict__ _Format,...);
extern
__attribute__((__format__(__ms_scanf__, 1,2))) __attribute__ ((__nonnull__ (1)))
int __attribute__((__cdecl__)) __ms_scanf(const char * __restrict__ _Format,...);
extern
__attribute__((__format__(__ms_scanf__, 2,3))) __attribute__ ((__nonnull__ (2)))
int __attribute__((__cdecl__)) __ms_fscanf(FILE * __restrict__ _File,const char *
__restrict__ _Format,...);

extern
__attribute__((__format__(__ms_printf__, 1,2))) __attribute__ ((__nonnull__ (1)))
int __attribute__((__cdecl__)) __ms_printf(const char * __restrict__ , ... )
__attribute__ ((__nothrow__));
extern
__attribute__((__format__(__ms_printf__, 1,0))) __attribute__ ((__nonnull__ (1)))
int __attribute__((__cdecl__)) __ms_vprintf (const char * __restrict__ , va_list)
__attribute__ ((__nothrow__));
extern
__attribute__((__format__(__ms_printf__, 2,3))) __attribute__ ((__nonnull__ (2)))
int __attribute__((__cdecl__)) __ms_fprintf (FILE * __restrict__ , const char *
__restrict__ , ...) __attribute__ ((__nothrow__));
extern
__attribute__((__format__(__ms_printf__, 2,0))) __attribute__ ((__nonnull__ (2)))
int __attribute__((__cdecl__)) __ms_vfprintf (FILE * __restrict__ , const char *
__restrict__ , va_list) __attribute__ ((__nothrow__));
extern
__attribute__((__format__(__ms_printf__, 2,3))) __attribute__ ((__nonnull__ (2)))
int __attribute__((__cdecl__)) __ms_sprintf (char * __restrict__ , const char *
__restrict__ , ...) __attribute__ ((__nothrow__));
extern
__attribute__((__format__(__ms_printf__, 2,0))) __attribute__ ((__nonnull__ (2)))
int __attribute__((__cdecl__)) __ms_vsprintf (char * __restrict__ , const char *
__restrict__ , va_list) __attribute__ ((__nothrow__));
# 296 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/stdio.h" 3
extern "C++" {

inline __attribute__((__cdecl__))
__attribute__((__format__(__gnu_scanf__, 2,3))) __attribute__ ((__nonnull__ (2)))
int sscanf(const char *__source, const char *__format, ...)
{
int __retval;
__builtin_va_list __local_argv; __builtin_va_start( __local_argv, __format );
__retval = __mingw_vsscanf( __source, __format, __local_argv );
__builtin_va_end( __local_argv );
return __retval;
}

inline __attribute__((__cdecl__))
__attribute__((__format__(__gnu_scanf__, 1,2))) __attribute__ ((__nonnull__ (1)))
int scanf(const char *__format, ...)
{
int __retval;
__builtin_va_list __local_argv; __builtin_va_start( __local_argv, __format );
__retval = __mingw_vfscanf( (__acrt_iob_func(0)), __format, __local_argv );
__builtin_va_end( __local_argv );
return __retval;
}

inline __attribute__((__cdecl__))
__attribute__((__format__(__gnu_scanf__, 2,3))) __attribute__ ((__nonnull__ (2)))
int fscanf(FILE *__stream, const char *__format, ...)
{
int __retval;
__builtin_va_list __local_argv; __builtin_va_start( __local_argv, __format );
__retval = __mingw_vfscanf( __stream, __format, __local_argv );
__builtin_va_end( __local_argv );
return __retval;
}

#pragma GCC diagnostic push

#pragma GCC diagnostic ignored "-Wshadow"

inline __attribute__((__cdecl__))
__attribute__((__format__(__gnu_scanf__, 2,0))) __attribute__ ((__nonnull__ (2)))
int vsscanf (const char *__source, const char *__format, __builtin_va_list
__local_argv)
{
return __mingw_vsscanf( __source, __format, __local_argv );
}

inline __attribute__((__cdecl__))
__attribute__((__format__(__gnu_scanf__, 1,0))) __attribute__ ((__nonnull__ (1)))
int vscanf(const char *__format, __builtin_va_list __local_argv)
{
return __mingw_vfscanf( (__acrt_iob_func(0)), __format, __local_argv );
}

inline __attribute__((__cdecl__))
__attribute__((__format__(__gnu_scanf__, 2,0))) __attribute__ ((__nonnull__ (2)))
int vfscanf (FILE *__stream, const char *__format, __builtin_va_list __local_argv)
{
return __mingw_vfscanf( __stream, __format, __local_argv );
}

#pragma GCC diagnostic pop

inline __attribute__((__cdecl__))
__attribute__((__format__(__gnu_printf__,2,3))) __attribute__ ((__nonnull__ (2)))
int fprintf (FILE *__stream, const char *__format, ...)
{
int __retval;
__builtin_va_list __local_argv; __builtin_va_start( __local_argv, __format );
__retval = __mingw_vfprintf( __stream, __format, __local_argv );
__builtin_va_end( __local_argv );
return __retval;
}

inline __attribute__((__cdecl__))
__attribute__((__format__(__gnu_printf__,1,2))) __attribute__ ((__nonnull__ (1)))
int printf (const char *__format, ...)
{
int __retval;
__builtin_va_list __local_argv; __builtin_va_start( __local_argv, __format );
__retval = __mingw_vfprintf( (__acrt_iob_func(1)), __format, __local_argv );
__builtin_va_end( __local_argv );
return __retval;
}
# 407 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/stdio.h" 3
inline __attribute__((__cdecl__))
__attribute__((__format__(__gnu_printf__,2,3))) __attribute__ ((__nonnull__ (2)))
int sprintf (char *__stream, const char *__format, ...)
{
int __retval;
__builtin_va_list __local_argv; __builtin_va_start( __local_argv, __format );
__retval = __mingw_vsprintf( __stream, __format, __local_argv );
__builtin_va_end( __local_argv );
return __retval;
}

inline __attribute__((__cdecl__))
__attribute__((__format__(__gnu_printf__,2,0))) __attribute__ ((__nonnull__ (2)))
int vfprintf (FILE *__stream, const char *__format, __builtin_va_list __local_argv)
{
return __mingw_vfprintf( __stream, __format, __local_argv );
}

inline __attribute__((__cdecl__))
__attribute__((__format__(__gnu_printf__,1,0))) __attribute__ ((__nonnull__ (1)))
int vprintf (const char *__format, __builtin_va_list __local_argv)
{
return __mingw_vfprintf( (__acrt_iob_func(1)), __format, __local_argv );
}

inline __attribute__((__cdecl__))
__attribute__((__format__(__gnu_printf__,2,0))) __attribute__ ((__nonnull__ (2)))
int vsprintf (char *__stream, const char *__format, __builtin_va_list __local_argv)
{
# 446 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/stdio.h" 3
return __mingw_vsprintf( __stream, __format, __local_argv );
}
# 464 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/stdio.h" 3
inline __attribute__((__cdecl__))
__attribute__((__format__(__gnu_printf__,3,4))) __attribute__ ((__nonnull__ (3)))
int snprintf (char *__stream, size_t __n, const char *__format, ...)
{
int __retval;
__builtin_va_list __local_argv; __builtin_va_start( __local_argv, __format );
__retval = __mingw_vsnprintf( __stream, __n, __format, __local_argv );
__builtin_va_end( __local_argv );
return __retval;
}

inline __attribute__((__cdecl__))
__attribute__((__format__(__gnu_printf__,3,0))) __attribute__ ((__nonnull__ (3)))
int vsnprintf (char *__stream, size_t __n, const char *__format, __builtin_va_list
__local_argv)
{
return __mingw_vsnprintf( __stream, __n, __format, __local_argv );
}
# 494 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/stdio.h" 3
}
# 618 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/stdio.h" 3
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _filbuf(FILE
*_File);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _flsbuf(int
_Ch,FILE *_File);

attribute ((dllimport)) FILE *attribute((cdecl)) _fsopen(const

char *_Filename,const char *_Mode,int _ShFlag);

void attribute((cdecl)) clearerr(FILE *_File);

int __attribute__((__cdecl__)) fclose(FILE *_File);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _fcloseall(void);

attribute ((dllimport)) FILE *attribute((cdecl)) _fdopen(int

_FileHandle,const char *_Mode);

int attribute((cdecl)) feof(FILE *_File);

int __attribute__((__cdecl__)) ferror(FILE *_File);
int __attribute__((__cdecl__)) fflush(FILE *_File);
int __attribute__((__cdecl__)) fgetc(FILE *_File);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _fgetchar(void);
int __attribute__((__cdecl__)) fgetpos(FILE * __restrict__ _File ,fpos_t *
__restrict__ _Pos);
int __attribute__((__cdecl__)) fgetpos64(FILE * __restrict__ _File ,fpos_t *
__restrict__ _Pos);
char *__attribute__((__cdecl__)) fgets(char * __restrict__ _Buf,int
_MaxCount,FILE * __restrict__ _File);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _fileno(FILE
*_File);

attribute ((dllimport)) char *attribute((cdecl)) _tempnam(const

char *_DirName,const char *_FilePrefix);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _flushall(void);
FILE *__attribute__((__cdecl__)) fopen(const char * __restrict__ _Filename,const
char * __restrict__ _Mode) ;
FILE *fopen64(const char * __restrict__ filename,const char * __restrict__ mode);
int __attribute__((__cdecl__)) fputc(int _Ch,FILE *_File);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _fputchar(int
_Ch);
int __attribute__((__cdecl__)) fputs(const char * __restrict__ _Str,FILE *
__restrict__ _File);
size_t __attribute__((__cdecl__)) fread(void * __restrict__ _DstBuf,size_t
_ElementSize,size_t _Count,FILE * __restrict__ _File);
FILE *__attribute__((__cdecl__)) freopen(const char * __restrict__
_Filename,const char * __restrict__ _Mode,FILE * __restrict__ _File) ;
int __attribute__((__cdecl__)) fsetpos(FILE *_File,const fpos_t *_Pos);
int __attribute__((__cdecl__)) fsetpos64(FILE *_File,const fpos_t *_Pos);
int __attribute__((__cdecl__)) fseek(FILE *_File,long _Offset,int _Origin);
long __attribute__((__cdecl__)) ftell(FILE *_File);

attribute ((dllimport)) int attribute((cdecl)) _fseeki64(FILE

*_File,long long _Offset,int _Origin);
__attribute__ ((__dllimport__)) long long __attribute__((__cdecl__))
_ftelli64(FILE *_File);
# 677 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/stdio.h" 3
int fseeko64(FILE* stream, _off64_t offset, int whence);
int fseeko(FILE* stream, _off_t offset, int whence);

_off_t ftello(FILE * stream);

_off64_t ftello64(FILE * stream);
# 698 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/stdio.h" 3
size_t __attribute__((__cdecl__)) fwrite(const void * __restrict__ _Str,size_t
_Size,size_t _Count,FILE * __restrict__ _File);
int __attribute__((__cdecl__)) getc(FILE *_File);
int __attribute__((__cdecl__)) getchar(void);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__))
_getmaxstdio(void);
char *__attribute__((__cdecl__)) gets(char *_Buffer)
__attribute__((__warning__("Using gets() is always unsafe - use fgets()
instead")));
int __attribute__((__cdecl__)) _getw(FILE *_File);

void attribute((cdecl)) perror(const char *_ErrMsg);

attribute ((dllimport)) int attribute((cdecl)) _pclose(FILE

*_File);
__attribute__ ((__dllimport__)) FILE *__attribute__((__cdecl__)) _popen(const
char *_Command,const char *_Mode);

int attribute((cdecl)) putc(int _Ch,FILE *_File);

int __attribute__((__cdecl__)) putchar(int _Ch);
int __attribute__((__cdecl__)) puts(const char *_Str);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _putw(int
_Word,FILE *_File);

int attribute((cdecl)) remove(const char *_Filename);

int __attribute__((__cdecl__)) rename(const char *_OldFilename,const char
*_NewFilename);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _unlink(const char
*_Filename);

int attribute((cdecl)) unlink(const char *_Filename) ;

void attribute((cdecl)) rewind(FILE *_File);

__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _rmtmp(void);
void __attribute__((__cdecl__)) setbuf(FILE * __restrict__ _File,char *
__restrict__ _Buffer) ;
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _setmaxstdio(int
_Max);
__attribute__ ((__dllimport__)) unsigned int __attribute__((__cdecl__))
_set_output_format(unsigned int _Format);
__attribute__ ((__dllimport__)) unsigned int __attribute__((__cdecl__))
_get_output_format(void);
int __attribute__((__cdecl__)) setvbuf(FILE * __restrict__ _File,char *
__restrict__ _Buf,int _Mode,size_t _Size);

__attribute__ ((__pure__))
__attribute__((__format__(__ms_printf__, 1,2))) __attribute__ ((__nonnull__ (1)))
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _scprintf(const
char * __restrict__ _Format,...);
__attribute__((__format__(__ms_scanf__, 3,4))) __attribute__ ((__nonnull__ (3)))
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _snscanf(const
char * __restrict__ _Src,size_t _MaxCount,const char * __restrict__ _Format,...) ;

__attribute__ ((__pure__))
__attribute__((__format__(__ms_printf__, 1,0))) __attribute__ ((__nonnull__ (1)))
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _vscprintf(const
char * __restrict__ _Format,va_list _ArgList);
FILE *__attribute__((__cdecl__)) tmpfile(void) ;
char *__attribute__((__cdecl__)) tmpnam(char *_Buffer);
int __attribute__((__cdecl__)) ungetc(int _Ch,FILE *_File);

attribute((format(__ms_printf, 3,4))) attribute ((nonnull__ (3)))

__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _snprintf(char *
__restrict__ _Dest,size_t _Count,const char * __restrict__ _Format,...) ;
__attribute__((__format__(__ms_printf__, 3,0))) __attribute__ ((__nonnull__ (3)))
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _vsnprintf(char *
__restrict__ _Dest,size_t _Count,const char * __restrict__ _Format,va_list _Args) ;
# 988 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/stdio.h" 3
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__))
_set_printf_count_output(int _Value);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__))
_get_printf_count_output(void);

__attribute__ ((__nonnull__
(2)))
int __attribute__((__cdecl__)) __mingw_swscanf(const wchar_t * __restrict__
_Src,const wchar_t * __restrict__ _Format,...);
__attribute__ ((__nonnull__
(2)))
int __attribute__((__cdecl__)) __mingw_vswscanf (const wchar_t * __restrict__
_Str,const wchar_t * __restrict__ Format,va_list argp);
__attribute__ ((__nonnull__
(1)))
int __attribute__((__cdecl__)) __mingw_wscanf(const wchar_t * __restrict__
_Format,...);
__attribute__ ((__nonnull__
(1)))
int __attribute__((__cdecl__)) __mingw_vwscanf(const wchar_t * __restrict__
Format, va_list argp);
__attribute__ ((__nonnull__
(2)))
int __attribute__((__cdecl__)) __mingw_fwscanf(FILE * __restrict__ _File,const
wchar_t * __restrict__ _Format,...);
__attribute__ ((__nonnull__
(2)))
int __attribute__((__cdecl__)) __mingw_vfwscanf (FILE * __restrict__ fp, const
wchar_t * __restrict__ Format,va_list argp);

__attribute__ ((__nonnull__
(2)))
int __attribute__((__cdecl__)) __mingw_fwprintf(FILE * __restrict__ _File,const
wchar_t * __restrict__ _Format,...);
__attribute__ ((__nonnull__
(1)))
int __attribute__((__cdecl__)) __mingw_wprintf(const wchar_t * __restrict__
_Format,...);
__attribute__ ((__nonnull__
(2)))
int __attribute__((__cdecl__)) __mingw_vfwprintf(FILE * __restrict__ _File,const
wchar_t * __restrict__ _Format,va_list _ArgList);
__attribute__ ((__nonnull__
(1)))
int __attribute__((__cdecl__)) __mingw_vwprintf(const wchar_t * __restrict__
_Format,va_list _ArgList);
__attribute__ ((__nonnull__
(3)))
int __attribute__((__cdecl__)) __mingw_snwprintf (wchar_t * __restrict__ s,
size_t n, const wchar_t * __restrict__ format, ...);
__attribute__ ((__nonnull__
(3)))
int __attribute__((__cdecl__)) __mingw_vsnwprintf (wchar_t * __restrict__ ,
size_t, const wchar_t * __restrict__ , va_list);
__attribute__ ((__nonnull__
(2)))
int __attribute__((__cdecl__)) __mingw_swprintf(wchar_t * __restrict__ , const
wchar_t * __restrict__ , ...);
__attribute__ ((__nonnull__
(2)))
int __attribute__((__cdecl__)) __mingw_vswprintf(wchar_t * __restrict__ , const
wchar_t * __restrict__ ,va_list);

__attribute__ ((__nonnull__
(2)))
int __attribute__((__cdecl__)) __ms_swscanf(const wchar_t * __restrict__
_Src,const wchar_t * __restrict__ _Format,...);
__attribute__ ((__nonnull__
(1)))
int __attribute__((__cdecl__)) __ms_wscanf(const wchar_t * __restrict__
_Format,...);
__attribute__ ((__nonnull__
(2)))
int __attribute__((__cdecl__)) __ms_fwscanf(FILE * __restrict__ _File,const
wchar_t * __restrict__ _Format,...);

__attribute__ ((__nonnull__
(2)))
int __attribute__((__cdecl__)) __ms_fwprintf(FILE * __restrict__ _File,const
wchar_t * __restrict__ _Format,...);
__attribute__ ((__nonnull__
(1)))
int __attribute__((__cdecl__)) __ms_wprintf(const wchar_t * __restrict__
_Format,...);
__attribute__ ((__nonnull__
(2)))
int __attribute__((__cdecl__)) __ms_vfwprintf(FILE * __restrict__ _File,const
wchar_t * __restrict__ _Format,va_list _ArgList);
__attribute__ ((__nonnull__
(1)))
int __attribute__((__cdecl__)) __ms_vwprintf(const wchar_t * __restrict__
_Format,va_list _ArgList);
__attribute__ ((__nonnull__
(2)))
int __attribute__((__cdecl__)) __ms_swprintf(wchar_t * __restrict__ , const
wchar_t * __restrict__ , ...);
__attribute__ ((__nonnull__
(2)))
int __attribute__((__cdecl__)) __ms_vswprintf(wchar_t * __restrict__ , const
wchar_t * __restrict__ ,va_list);
# 1056 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/stdio.h" 3
inline __attribute__((__cdecl__))
__attribute__ ((__nonnull__
(2)))
int swscanf(const wchar_t *__source, const wchar_t *__format, ...)
{
int __retval;
__builtin_va_list __local_argv; __builtin_va_start( __local_argv, __format );
__retval = __mingw_vswscanf( __source, __format, __local_argv );
__builtin_va_end( __local_argv );
return __retval;
}

inline __attribute__((__cdecl__))
__attribute__ ((__nonnull__
(1)))
int wscanf(const wchar_t *__format, ...)
{
int __retval;
__builtin_va_list __local_argv; __builtin_va_start( __local_argv, __format );
__retval = __mingw_vfwscanf( (__acrt_iob_func(0)), __format, __local_argv );
__builtin_va_end( __local_argv );
return __retval;
}

inline __attribute__((__cdecl__))
__attribute__ ((__nonnull__
(2)))
int fwscanf(FILE *__stream, const wchar_t *__format, ...)
{
int __retval;
__builtin_va_list __local_argv; __builtin_va_start( __local_argv, __format );
__retval = __mingw_vfwscanf( __stream, __format, __local_argv );
__builtin_va_end( __local_argv );
return __retval;
}

inline __attribute__((__cdecl__))
__attribute__ ((__nonnull__
(2)))
int vswscanf (const wchar_t * __restrict__ __source, const wchar_t * __restrict__
__format, __builtin_va_list __local_argv)
{
return __mingw_vswscanf( __source, __format, __local_argv );
}

inline __attribute__((__cdecl__))
__attribute__ ((__nonnull__
(1)))
int vwscanf(const wchar_t *__format, __builtin_va_list __local_argv)
{
return __mingw_vfwscanf( (__acrt_iob_func(0)), __format, __local_argv );
}

inline __attribute__((__cdecl__))
__attribute__ ((__nonnull__
(2)))
int vfwscanf (FILE *__stream, const wchar_t *__format, __builtin_va_list
__local_argv)
{
return __mingw_vfwscanf( __stream, __format, __local_argv );
}

inline __attribute__((__cdecl__))
__attribute__ ((__nonnull__
(2)))
int fwprintf (FILE *__stream, const wchar_t *__format, ...)
{
int __retval;
__builtin_va_list __local_argv; __builtin_va_start( __local_argv, __format );
__retval = __mingw_vfwprintf( __stream, __format, __local_argv );
__builtin_va_end( __local_argv );
return __retval;
}

inline __attribute__((__cdecl__))
__attribute__ ((__nonnull__
(1)))
int wprintf (const wchar_t *__format, ...)
{
int __retval;
__builtin_va_list __local_argv; __builtin_va_start( __local_argv, __format );
__retval = __mingw_vfwprintf( (__acrt_iob_func(1)), __format, __local_argv );
__builtin_va_end( __local_argv );
return __retval;
}

inline __attribute__((__cdecl__))
__attribute__ ((__nonnull__
(2)))
int vfwprintf (FILE *__stream, const wchar_t *__format, __builtin_va_list
__local_argv)
{
return __mingw_vfwprintf( __stream, __format, __local_argv );
}

inline __attribute__((__cdecl__))
__attribute__ ((__nonnull__
(1)))
int vwprintf (const wchar_t *__format, __builtin_va_list __local_argv)
{
return __mingw_vfwprintf( (__acrt_iob_func(1)), __format, __local_argv );
}
# 1166 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/stdio.h" 3
inline __attribute__((__cdecl__))
__attribute__ ((__nonnull__
(3)))
int snwprintf (wchar_t *__stream, size_t __n, const wchar_t *__format, ...)
{
int __retval;
__builtin_va_list __local_argv; __builtin_va_start( __local_argv, __format );
__retval = __mingw_vsnwprintf( __stream, __n, __format, __local_argv );
__builtin_va_end( __local_argv );
return __retval;
}

inline __attribute__((__cdecl__))
__attribute__ ((__nonnull__
(3)))
int vsnwprintf (wchar_t *__stream, size_t __n, const wchar_t *__format,
__builtin_va_list __local_argv)
{

return __mingw_vsnwprintf( stream, n, format, local_argv );

}
# 1310 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/stdio.h" 3
__attribute__ ((__dllimport__)) FILE *__attribute__((__cdecl__)) _wfsopen(const
wchar_t *_Filename,const wchar_t *_Mode,int _ShFlag);

wint_t attribute((cdecl)) fgetwc(FILE *_File);

__attribute__ ((__dllimport__)) wint_t __attribute__((__cdecl__))
_fgetwchar(void);
wint_t __attribute__((__cdecl__)) fputwc(wchar_t _Ch,FILE *_File);
__attribute__ ((__dllimport__)) wint_t __attribute__((__cdecl__))
_fputwchar(wchar_t _Ch);
wint_t __attribute__((__cdecl__)) getwc(FILE *_File);
wint_t __attribute__((__cdecl__)) getwchar(void);
wint_t __attribute__((__cdecl__)) putwc(wchar_t _Ch,FILE *_File);
wint_t __attribute__((__cdecl__)) putwchar(wchar_t _Ch);
wint_t __attribute__((__cdecl__)) ungetwc(wint_t _Ch,FILE *_File);
wchar_t *__attribute__((__cdecl__)) fgetws(wchar_t * __restrict__ _Dst,int
_SizeInWords,FILE * __restrict__ _File);
int __attribute__((__cdecl__)) fputws(const wchar_t * __restrict__ _Str,FILE *
__restrict__ _File);
__attribute__ ((__dllimport__)) wchar_t *__attribute__((__cdecl__))
_getws(wchar_t *_String) ;
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _putws(const
wchar_t *_Str);
# 1383 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/stdio.h" 3
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _scwprintf(const
wchar_t * __restrict__ _Format,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__))
_swprintf_c(wchar_t * __restrict__ _DstBuf,size_t _SizeInWords,const wchar_t *
__restrict__ _Format,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__))
_vswprintf_c(wchar_t * __restrict__ _DstBuf,size_t _SizeInWords,const wchar_t *
__restrict__ _Format,va_list _ArgList);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _snwprintf(wchar_t
* __restrict__ _Dest,size_t _Count,const wchar_t * __restrict__ _Format,...) ;
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__))
_vsnwprintf(wchar_t * __restrict__ _Dest,size_t _Count,const wchar_t * __restrict__
_Format,va_list _Args) ;
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _vscwprintf(const
wchar_t * __restrict__ _Format,va_list _ArgList);
# 1413 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/stdio.h" 3
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _swprintf(wchar_t
* __restrict__ _Dest,const wchar_t * __restrict__ _Format,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _vswprintf(wchar_t
* __restrict__ _Dest,const wchar_t * __restrict__ _Format,va_list _Args);

# 1 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/swprintf.inl" 1 3
# 12 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/swprintf.inl" 3
inline __attribute__((__cdecl__))
__attribute__ ((__nonnull__
(3)))
int vswprintf (wchar_t *__stream, size_t __count, const wchar_t *__format,
__builtin_va_list __local_argv)
{
return vsnwprintf( __stream, __count, __format, __local_argv );
}

inline __attribute__((__cdecl__))
__attribute__ ((__nonnull__
(3)))
int swprintf (wchar_t *__stream, size_t __count, const wchar_t *__format, ...)
{
int __retval;
__builtin_va_list __local_argv;

__builtin_va_start( __local_argv, __format );

__retval = vswprintf( __stream, __count, __format, __local_argv );
__builtin_va_end( __local_argv );
return __retval;
}
extern "C++" {

inline __attribute__((__cdecl__))
__attribute__ ((__nonnull__
(2)))
int vswprintf (wchar_t *__stream, const wchar_t *__format, __builtin_va_list
__local_argv)
{

return __mingw_vswprintf( stream, format, __local_argv );

inline __attribute__((__cdecl__))
__attribute__ ((__nonnull__
(2)))
int swprintf (wchar_t *__stream, const wchar_t *__format, ...)
{
int __retval;
__builtin_va_list __local_argv;

__builtin_va_start( __local_argv, __format );

__retval = vswprintf( __stream, __format, __local_argv );
__builtin_va_end( __local_argv );
return __retval;
}

}
# 1419 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/stdio.h" 2 3
# 1428 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/stdio.h" 3
__attribute__ ((__dllimport__)) wchar_t *__attribute__((__cdecl__))
_wtempnam(const wchar_t *_Directory,const wchar_t *_FilePrefix);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _snwscanf(const
wchar_t * __restrict__ _Src,size_t _MaxCount,const wchar_t * __restrict__
_Format,...);
__attribute__ ((__dllimport__)) FILE *__attribute__((__cdecl__)) _wfdopen(int
_FileHandle ,const wchar_t *_Mode);
__attribute__ ((__dllimport__)) FILE *__attribute__((__cdecl__)) _wfopen(const
wchar_t * __restrict__ _Filename,const wchar_t *__restrict__ _Mode) ;
__attribute__ ((__dllimport__)) FILE *__attribute__((__cdecl__)) _wfreopen(const
wchar_t * __restrict__ _Filename,const wchar_t * __restrict__ _Mode,FILE *
__restrict__ _OldFile) ;

attribute ((dllimport)) void attribute((cdecl)) _wperror(const

wchar_t *_ErrMsg);

attribute ((dllimport)) FILE *attribute((cdecl)) _wpopen(const

wchar_t *_Command,const wchar_t *_Mode);

attribute ((dllimport)) int attribute((cdecl)) _wremove(const

wchar_t *_Filename);
__attribute__ ((__dllimport__)) wchar_t *__attribute__((__cdecl__))
_wtmpnam(wchar_t *_Buffer);
# 1457 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/stdio.h" 3
inline wint_t __attribute__((__cdecl__)) getwchar() {return
(fgetwc((__acrt_iob_func(0)))); }
inline wint_t __attribute__((__cdecl__)) putwchar(wchar_t _C) {return (fputwc(_C,
(__acrt_iob_func(1)))); }
# 1488 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/stdio.h" 3
__attribute__ ((__dllimport__)) void __attribute__((__cdecl__)) _lock_file(FILE
*_File);
__attribute__ ((__dllimport__)) void __attribute__((__cdecl__)) _unlock_file(FILE
*_File);
# 1506 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/stdio.h" 3
char *__attribute__((__cdecl__)) tempnam(const char *_Directory,const char
*_FilePrefix) ;
int __attribute__((__cdecl__)) fcloseall(void) ;
FILE *__attribute__((__cdecl__)) fdopen(int _FileHandle,const char *_Format) ;
int __attribute__((__cdecl__)) fgetchar(void) ;
int __attribute__((__cdecl__)) fileno(FILE *_File) ;
int __attribute__((__cdecl__)) flushall(void) ;
int __attribute__((__cdecl__)) fputchar(int _Ch) ;
int __attribute__((__cdecl__)) getw(FILE *_File) ;
int __attribute__((__cdecl__)) putw(int _Ch,FILE *_File) ;
int __attribute__((__cdecl__)) rmtmp(void) ;
# 1532 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/stdio.h" 3
int __attribute__((__cdecl__)) __mingw_str_wide_utf8 (const wchar_t * const wptr,
char **mbptr, size_t * buflen);
# 1546 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/stdio.h" 3
int __attribute__((__cdecl__)) __mingw_str_utf8_wide (const char *const mbptr,
wchar_t ** wptr, size_t * buflen);
# 1555 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/stdio.h" 3
void __attribute__((__cdecl__)) __mingw_str_free(void *ptr);

attribute ((dllimport)) intptr_t attribute((cdecl)) _wspawnl(int

_Mode,const wchar_t *_Filename,const wchar_t *_ArgList,...);
__attribute__ ((__dllimport__)) intptr_t __attribute__((__cdecl__)) _wspawnle(int
_Mode,const wchar_t *_Filename,const wchar_t *_ArgList,...);
__attribute__ ((__dllimport__)) intptr_t __attribute__((__cdecl__)) _wspawnlp(int
_Mode,const wchar_t *_Filename,const wchar_t *_ArgList,...);
__attribute__ ((__dllimport__)) intptr_t __attribute__((__cdecl__))
_wspawnlpe(int _Mode,const wchar_t *_Filename,const wchar_t *_ArgList,...);
__attribute__ ((__dllimport__)) intptr_t __attribute__((__cdecl__)) _wspawnv(int
_Mode,const wchar_t *_Filename,const wchar_t *const *_ArgList);
__attribute__ ((__dllimport__)) intptr_t __attribute__((__cdecl__)) _wspawnve(int
_Mode,const wchar_t *_Filename,const wchar_t *const *_ArgList,const wchar_t *const
*_Env);
__attribute__ ((__dllimport__)) intptr_t __attribute__((__cdecl__)) _wspawnvp(int
_Mode,const wchar_t *_Filename,const wchar_t *const *_ArgList);
__attribute__ ((__dllimport__)) intptr_t __attribute__((__cdecl__))
_wspawnvpe(int _Mode,const wchar_t *_Filename,const wchar_t *const *_ArgList,const
wchar_t *const *_Env);
# 1586 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/stdio.h" 3
__attribute__ ((__dllimport__)) intptr_t __attribute__((__cdecl__)) _spawnv(int
_Mode,const char *_Filename,const char *const *_ArgList);
__attribute__ ((__dllimport__)) intptr_t __attribute__((__cdecl__)) _spawnve(int
_Mode,const char *_Filename,const char *const *_ArgList,const char *const *_Env);
__attribute__ ((__dllimport__)) intptr_t __attribute__((__cdecl__)) _spawnvp(int
_Mode,const char *_Filename,const char *const *_ArgList);
__attribute__ ((__dllimport__)) intptr_t __attribute__((__cdecl__)) _spawnvpe(int
_Mode,const char *_Filename,const char *const *_ArgList,const char *const *_Env);

#pragma pack(pop)

# 1 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/sec_api/stdio_s.h" 1
3
# 9 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/sec_api/stdio_s.h" 3
# 1 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/stdio.h" 1 3
# 10 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/sec_api/stdio_s.h" 2
3
# 21 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/sec_api/stdio_s.h" 3
extern "C" {

attribute ((dllimport)) errno_t attribute((cdecl))

clearerr_s(FILE *_File);

size_t attribute((cdecl)) fread_s(void *_DstBuf,size_t _DstSize,size_t

_ElementSize,size_t _Count,FILE *_File);
# 515 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/sec_api/stdio_s.h"
3
int __attribute__((__cdecl__)) fprintf_s(FILE *_File,const char *_Format,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _fscanf_s_l(FILE
*_File,const char *_Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) fscanf_s(FILE
*_File, const char *_Format, ...);
int __attribute__((__cdecl__)) printf_s(const char *_Format,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _scanf_l(const
char *_Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _scanf_s_l(const
char *_Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) scanf_s(const char
*_Format, ...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _snprintf_c(char
*_DstBuf,size_t _MaxCount,const char *_Format,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _vsnprintf_c(char
*_DstBuf,size_t _MaxCount,const char *_Format,va_list _ArgList);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _fscanf_l(FILE
*_File,const char *_Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _sscanf_l(const
char *_Src,const char *_Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _sscanf_s_l(const
char *_Src,const char *_Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) sscanf_s(const
char *_Src,const char *_Format,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _snscanf_s(const
char *_Src,size_t _MaxCount,const char *_Format,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _snscanf_l(const
char *_Src,size_t _MaxCount,const char *_Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _snscanf_s_l(const
char *_Src,size_t _MaxCount,const char *_Format,_locale_t _Locale,...);
int __attribute__((__cdecl__)) vfprintf_s(FILE *_File,const char *_Format,va_list
_ArgList);
int __attribute__((__cdecl__)) vprintf_s(const char *_Format,va_list _ArgList);

int attribute((cdecl)) vsnprintf_s(char *_DstBuf,size_t _DstSize,size_t

_MaxCount,const char *_Format,va_list _ArgList);

attribute ((dllimport)) int attribute((cdecl)) _vsnprintf_s(char

*_DstBuf,size_t _DstSize,size_t _MaxCount,const char *_Format,va_list _ArgList);

attribute((dllimport)) int attribute((cdecl)) vsprintf_s(char

*_DstBuf,size_t _Size,const char *_Format,va_list _ArgList);

attribute((dllimport)) int attribute((cdecl)) sprintf_s(char

*_DstBuf,size_t _DstSize,const char *_Format,...);

attribute ((dllimport)) int attribute((cdecl)) _snprintf_s(char

*_DstBuf,size_t _DstSize,size_t _MaxCount,const char *_Format,...);

attribute ((dllimport)) int attribute((cdecl)) _fprintf_p(FILE

*_File,const char *_Format,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _printf_p(const
char *_Format,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _sprintf_p(char
*_Dst,size_t _MaxCount,const char *_Format,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _vfprintf_p(FILE
*_File,const char *_Format,va_list _ArgList);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _vprintf_p(const
char *_Format,va_list _ArgList);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _vsprintf_p(char
*_Dst,size_t _MaxCount,const char *_Format,va_list _ArgList);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _scprintf_p(const
char *_Format,...);
__attribute__((dllimport)) int __attribute__((__cdecl__)) _vscprintf_p(const char
*_Format,va_list _ArgList);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _printf_l(const
char *_Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _printf_p_l(const
char *_Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _vprintf_l(const
char *_Format,_locale_t _Locale,va_list _ArgList);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _vprintf_p_l(const
char *_Format,_locale_t _Locale,va_list _ArgList);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _fprintf_l(FILE
*_File,const char *_Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _fprintf_p_l(FILE
*_File,const char *_Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _vfprintf_l(FILE
*_File,const char *_Format,_locale_t _Locale,va_list _ArgList);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _vfprintf_p_l(FILE
*_File,const char *_Format,_locale_t _Locale,va_list _ArgList);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _sprintf_l(char
*_DstBuf,const char *_Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _sprintf_p_l(char
*_DstBuf,size_t _MaxCount,const char *_Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _vsprintf_l(char
*_DstBuf,const char *_Format,_locale_t,va_list _ArgList);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _vsprintf_p_l(char
*_DstBuf,size_t _MaxCount,const char *_Format,_locale_t _Locale,va_list _ArgList);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _scprintf_l(const
char *_Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__))
_scprintf_p_l(const char *_Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _vscprintf_l(const
char *_Format,_locale_t _Locale,va_list _ArgList);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__))
_vscprintf_p_l(const char *_Format,_locale_t _Locale,va_list _ArgList);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _printf_s_l(const
char *_Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _vprintf_s_l(const
char *_Format,_locale_t _Locale,va_list _ArgList);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _fprintf_s_l(FILE
*_File,const char *_Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _vfprintf_s_l(FILE
*_File,const char *_Format,_locale_t _Locale,va_list _ArgList);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _sprintf_s_l(char
*_DstBuf,size_t _DstSize,const char *_Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _vsprintf_s_l(char
*_DstBuf,size_t _DstSize,const char *_Format,_locale_t _Locale,va_list _ArgList);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _snprintf_s_l(char
*_DstBuf,size_t _DstSize,size_t _MaxCount,const char *_Format,_locale_t
_Locale,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__))
_vsnprintf_s_l(char *_DstBuf,size_t _DstSize,size_t _MaxCount,const char
*_Format,_locale_t _Locale,va_list _ArgList);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _snprintf_l(char
*_DstBuf,size_t _MaxCount,const char *_Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _snprintf_c_l(char
*_DstBuf,size_t _MaxCount,const char *_Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _vsnprintf_l(char
*_DstBuf,size_t _MaxCount,const char *_Format,_locale_t _Locale,va_list _ArgList);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__))
_vsnprintf_c_l(char *_DstBuf,size_t _MaxCount,const char *,_locale_t
_Locale,va_list _ArgList);

extern "C++" { template <size_t size> inline int attribute((cdecl__))

vsnprintf_s(char (&_DstBuf)[__size], size_t _MaxCount, const char* _Format, va_list
_ArgList) { return vsnprintf_s(_DstBuf,__size,_MaxCount,_Format,_ArgList); } }
extern "C++" { template <size_t __size> inline int __attribute__((__cdecl__))
_vsnprintf_s(char (&_DstBuf)[__size], size_t _MaxCount, const char* _Format,
va_list _ArgList) { return _vsnprintf_s(_DstBuf,__size,_MaxCount,_Format,_ArgList);
} }
extern "C++" { template <size_t __size> inline int __attribute__((__cdecl__))
vsprintf_s(char (&_DstBuf)[__size], const char* _Format, va_list _ArgList) { return
vsprintf_s(_DstBuf,__size,_Format,_ArgList); } }
extern "C++" { template <size_t __size> inline int __attribute__((__cdecl__))
sprintf_s(char (&_DstBuf)[__size], const char* _Format, ...) { va_list __vaargs;
__builtin_va_start(__vaargs,_Format); int __retval =
vsprintf_s(_DstBuf,__size,_Format,__vaargs); __builtin_va_end(__vaargs); return
__retval; } }
extern "C++" { template <size_t __size> inline int __attribute__((__cdecl__))
_snprintf_s(char (&_DstBuf)[__size], size_t _MaxCount, const char* _Format, ...)
{ va_list __vaargs; __builtin_va_start(__vaargs,_Format); int __retval =
_vsnprintf_s(_DstBuf,__size,_MaxCount,_Format,__vaargs);
__builtin_va_end(__vaargs); return __retval; } }

attribute ((dllimport)) errno_t attribute((cdecl)) fopen_s(FILE

**_File,const char *_Filename,const char *_Mode);
__attribute__ ((__dllimport__)) errno_t __attribute__((__cdecl__))
freopen_s(FILE** _File, const char *_Filename, const char *_Mode, FILE *_Stream);

attribute ((dllimport)) char* attribute((cdecl))

gets_s(char*,rsize_t);
extern "C++" { template <size_t __size> inline char* __attribute__((__cdecl__))
get_s(char (&_DstBuf)[__size]) { return get_s(_DstBuf,__size); } }

attribute ((dllimport)) errno_t attribute((cdecl)) tmpfile_s(FILE

**_File);

attribute ((dllimport)) errno_t attribute((cdecl))

tmpnam_s(char*,rsize_t);
extern "C++" { template <size_t __size> inline errno_t __attribute__((__cdecl__))
tmpnam_s(char (&_DstBuf)[__size]) { return tmpnam_s(_DstBuf,__size); } }

attribute ((dllimport)) wchar_t *attribute((cdecl))

_getws_s(wchar_t *_Str,size_t _SizeInWords);
extern "C++" { template <size_t __size> inline wchar_t*
__attribute__((__cdecl__)) _getws_s(wchar_t (&_DstBuf)[__size]) { return
_getws_s(_DstBuf,__size); } }
# 830 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/sec_api/stdio_s.h"
3
int __attribute__((__cdecl__)) fwprintf_s(FILE *_File,const wchar_t
*_Format,...);
int __attribute__((__cdecl__)) wprintf_s(const wchar_t *_Format,...);
int __attribute__((__cdecl__)) vfwprintf_s(FILE *_File,const wchar_t
*_Format,va_list _ArgList);
int __attribute__((__cdecl__)) vwprintf_s(const wchar_t *_Format,va_list
_ArgList);

int attribute((cdecl)) vswprintf_s(wchar_t *_Dst,size_t

_SizeInWords,const wchar_t *_Format,va_list _ArgList);

int attribute((cdecl)) swprintf_s(wchar_t *_Dst,size_t _SizeInWords,const

wchar_t *_Format,...);

attribute ((dllimport)) int attribute((cdecl))

_vsnwprintf_s(wchar_t *_DstBuf,size_t _DstSizeInWords,size_t _MaxCount,const
wchar_t *_Format,va_list _ArgList);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__))
_snwprintf_s(wchar_t *_DstBuf,size_t _DstSizeInWords,size_t _MaxCount,const wchar_t
*_Format,...);

attribute ((dllimport)) int attribute((cdecl)) _wprintf_s_l(const

wchar_t *_Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__))
_vwprintf_s_l(const wchar_t *_Format,_locale_t _Locale,va_list _ArgList);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _fwprintf_s_l(FILE
*_File,const wchar_t *_Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__))
_vfwprintf_s_l(FILE *_File,const wchar_t *_Format,_locale_t _Locale,va_list
_ArgList);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__))
_swprintf_s_l(wchar_t *_DstBuf,size_t _DstSize,const wchar_t *_Format,_locale_t
_Locale,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__))
_vswprintf_s_l(wchar_t *_DstBuf,size_t _DstSize,const wchar_t *_Format,_locale_t
_Locale,va_list _ArgList);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__))
_snwprintf_s_l(wchar_t *_DstBuf,size_t _DstSize,size_t _MaxCount,const wchar_t
*_Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__))
_vsnwprintf_s_l(wchar_t *_DstBuf,size_t _DstSize,size_t _MaxCount,const wchar_t
*_Format,_locale_t _Locale,va_list _ArgList);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _fwscanf_s_l(FILE
*_File,const wchar_t *_Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) fwscanf_s(FILE
*_File, const wchar_t *_Format, ...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _swscanf_s_l(const
wchar_t *_Src,const wchar_t *_Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) swscanf_s(const
wchar_t *_Src,const wchar_t *_Format,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _snwscanf_s(const
wchar_t *_Src,size_t _MaxCount,const wchar_t *_Format,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__))
_snwscanf_s_l(const wchar_t *_Src,size_t _MaxCount,const wchar_t *_Format,_locale_t
_Locale,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _wscanf_s_l(const
wchar_t *_Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) wscanf_s(const
wchar_t *_Format, ...);

extern "C++" { template <size_t size> inline int attribute((cdecl__))

vswprintf_s(wchar_t (&_Dst)[__size], const wchar_t* _Format, va_list _ArgList)
{ return vswprintf_s(_Dst,__size,_Format,_ArgList); } }
extern "C++" { template <size_t __size> inline int __attribute__((__cdecl__))
swprintf_s(wchar_t (&_Dst)[__size], const wchar_t* _Format, ...) { va_list
__vaargs; __builtin_va_start(__vaargs,_Format); int __retval =
vswprintf_s(_Dst,__size,_Format,__vaargs); __builtin_va_end(__vaargs); return
__retval; } }
extern "C++" { template <size_t __size> inline int __attribute__((__cdecl__))
_vsnwprintf_s(wchar_t (&_DstBuf)[__size], size_t _MaxCount, const wchar_t* _Format,
va_list _ArgList) { return
_vsnwprintf_s(_DstBuf,__size,_MaxCount,_Format,_ArgList); } }
extern "C++" { template <size_t __size> inline int __attribute__((__cdecl__))
_snwprintf_s(wchar_t (&_DstBuf)[__size], size_t _MaxCount, const wchar_t*
_Format, ...) { va_list __vaargs; __builtin_va_start(__vaargs,_Format); int
__retval = _vsnwprintf_s(_DstBuf,__size,_MaxCount,_Format,__vaargs);
__builtin_va_end(__vaargs); return __retval; } }

attribute ((dllimport)) errno_t attribute((cdecl)) _wfopen_s(FILE

**_File,const wchar_t *_Filename,const wchar_t *_Mode);
__attribute__ ((__dllimport__)) errno_t __attribute__((__cdecl__))
_wfreopen_s(FILE **_File,const wchar_t *_Filename,const wchar_t *_Mode,FILE
*_OldFile);

attribute ((dllimport)) errno_t attribute((cdecl))

_wtmpnam_s(wchar_t *_DstBuf,size_t _SizeInWords);
extern "C++" { template <size_t __size> inline errno_t __attribute__((__cdecl__))
_wtmpnam_s(wchar_t (&_DstBuf)[__size]) { return _wtmpnam_s(_DstBuf,__size); } }

attribute ((dllimport)) int attribute((cdecl)) _fwprintf_p(FILE

*_File,const wchar_t *_Format,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _wprintf_p(const
wchar_t *_Format,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _vfwprintf_p(FILE
*_File,const wchar_t *_Format,va_list _ArgList);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _vwprintf_p(const
wchar_t *_Format,va_list _ArgList);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__))
_swprintf_p(wchar_t *_DstBuf,size_t _MaxCount,const wchar_t *_Format,...);
__attribute__((dllimport)) int __attribute__((__cdecl__)) _vswprintf_p(wchar_t
*_DstBuf,size_t _MaxCount,const wchar_t *_Format,va_list _ArgList);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _scwprintf_p(const
wchar_t *_Format,...);
__attribute__((dllimport)) int __attribute__((__cdecl__)) _vscwprintf_p(const
wchar_t *_Format,va_list _ArgList);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _wprintf_l(const
wchar_t *_Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _wprintf_p_l(const
wchar_t *_Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _vwprintf_l(const
wchar_t *_Format,_locale_t _Locale,va_list _ArgList);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__))
_vwprintf_p_l(const wchar_t *_Format,_locale_t _Locale,va_list _ArgList);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _fwprintf_l(FILE
*_File,const wchar_t *_Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _fwprintf_p_l(FILE
*_File,const wchar_t *_Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _vfwprintf_l(FILE
*_File,const wchar_t *_Format,_locale_t _Locale,va_list _ArgList);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__))
_vfwprintf_p_l(FILE *_File,const wchar_t *_Format,_locale_t _Locale,va_list
_ArgList);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__))
_swprintf_c_l(wchar_t *_DstBuf,size_t _MaxCount,const wchar_t *_Format,_locale_t
_Locale,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__))
_swprintf_p_l(wchar_t *_DstBuf,size_t _MaxCount,const wchar_t *_Format,_locale_t
_Locale,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__))
_vswprintf_c_l(wchar_t *_DstBuf,size_t _MaxCount,const wchar_t *_Format,_locale_t
_Locale,va_list _ArgList);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__))
_vswprintf_p_l(wchar_t *_DstBuf,size_t _MaxCount,const wchar_t *_Format,_locale_t
_Locale,va_list _ArgList);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _scwprintf_l(const
wchar_t *_Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__))
_scwprintf_p_l(const wchar_t *_Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__))
_vscwprintf_p_l(const wchar_t *_Format,_locale_t _Locale,va_list _ArgList);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__))
_snwprintf_l(wchar_t *_DstBuf,size_t _MaxCount,const wchar_t *_Format,_locale_t
_Locale,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__))
_vsnwprintf_l(wchar_t *_DstBuf,size_t _MaxCount,const wchar_t *_Format,_locale_t
_Locale,va_list _ArgList);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__))
__swprintf_l(wchar_t *_Dest,const wchar_t *_Format,_locale_t _Plocinfo,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__))
__vswprintf_l(wchar_t *_Dest,const wchar_t *_Format,_locale_t _Plocinfo,va_list
_Args);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__))
_vscwprintf_l(const wchar_t *_Format,_locale_t _Locale,va_list _ArgList);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _fwscanf_l(FILE
*_File,const wchar_t *_Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _swscanf_l(const
wchar_t *_Src,const wchar_t *_Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _snwscanf_l(const
wchar_t *_Src,size_t _MaxCount,const wchar_t *_Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _wscanf_l(const
wchar_t *_Format,_locale_t _Locale,...);
# 916 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/sec_api/stdio_s.h"
3
}
# 1605 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/stdio.h" 2 3
# 13 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/locale.h" 2 3

#pragma pack(push,_CRT_PACKING)

extern "C" {
# 45 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/locale.h" 3
struct lconv {
char *decimal_point;
char *thousands_sep;
char *grouping;
char *int_curr_symbol;
char *currency_symbol;
char *mon_decimal_point;
char *mon_thousands_sep;
char *mon_grouping;
char *positive_sign;
char *negative_sign;
char int_frac_digits;
char frac_digits;
char p_cs_precedes;
char p_sep_by_space;
char n_cs_precedes;
char n_sep_by_space;
char p_sign_posn;
char n_sign_posn;

wchar_t* _W_decimal_point;
wchar_t* _W_thousands_sep;
wchar_t* _W_int_curr_symbol;
wchar_t* _W_currency_symbol;
wchar_t* _W_mon_decimal_point;
wchar_t* _W_mon_thousands_sep;
wchar_t* _W_positive_sign;
wchar_t* _W_negative_sign;

};
# 89 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/locale.h" 3
int __attribute__((__cdecl__)) _configthreadlocale(int _Flag);
char *__attribute__((__cdecl__)) setlocale(int _Category,const char *_Locale);
__attribute__ ((__dllimport__)) struct lconv *__attribute__((__cdecl__))
localeconv(void);
__attribute__ ((__dllimport__)) _locale_t __attribute__((__cdecl__))
_get_current_locale(void);
__attribute__ ((__dllimport__)) _locale_t __attribute__((__cdecl__))
_create_locale(int _Category,const char *_Locale);
__attribute__ ((__dllimport__)) void __attribute__((__cdecl__))
_free_locale(_locale_t _Locale);
_locale_t __attribute__((__cdecl__)) __get_current_locale(void);
_locale_t __attribute__((__cdecl__)) __create_locale(int _Category,const char
*_Locale);
void __attribute__((__cdecl__)) __free_locale(_locale_t _Locale);

attribute ((dllimport)) unsigned int attribute((cdecl))

___lc_codepage_func(void);

attribute ((dllimport)) wchar_t *attribute((cdecl))

_wsetlocale(int _Category,const wchar_t *_Locale);
# 113 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/locale.h" 3
}

#pragma pack(pop)
# 43 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/clocale" 2 3
# 51 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/clocale" 3
namespace std
{
using ::lconv;
using ::setlocale;
using ::localeconv;
}
# 42 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/x86_64-w64-mingw32/bits/c+
+locale.h" 2 3

namespace std
{

typedef int* __c_locale;

inline int
__convert_from_v(const __c_locale&, char* __out,
const int __size __attribute__((__unused__)),
const char* __fmt, ...)
{
char* __old = std::setlocale(4, 0);
char* __sav = 0;
if (__builtin_strcmp(__old, "C"))
{
const size_t __len = __builtin_strlen(__old) + 1;
__sav = new char[__len];
__builtin_memcpy(__sav, __old, __len);
std::setlocale(4, "C");
}

__builtin_va_list __args;
__builtin_va_start(__args, __fmt);

const int ret = mingw_vsnprintf(out, size, fmt, args);

__builtin_va_end(__args);

if (__sav)
{
std::setlocale(4, __sav);
delete [] __sav;
}
return __ret;
}

}
# 41 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/localefwd.h" 2 3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/iosfwd" 1 3
# 36 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/iosfwd" 3

# 37 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/iosfwd" 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stringfwd.h" 1 3
# 37 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stringfwd.h" 3

# 38 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stringfwd.h" 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/memoryfwd.h" 1 3
# 46 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/memoryfwd.h" 3

# 47 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/memoryfwd.h" 3
namespace std
{

# 64 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/memoryfwd.h" 3
template<typename>
class allocator;

template<>
class allocator<void>;

template<typename, typename>
struct uses_allocator;

template<typename>
struct allocator_traits;

}
# 41 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stringfwd.h" 2 3

namespace std
{

template<class _CharT>
struct char_traits;

template<> struct char_traits<char>;

template<> struct char_traits<wchar_t>;

template<> struct char_traits<char8_t>;

template<> struct char_traits<char16_t>;

template<> struct char_traits<char32_t>;

namespace __cxx11 {

template<typename _CharT, typename _Traits = char_traits<_CharT>,

typename _Alloc = allocator<_CharT> >
class basic_string;
}

typedef basic_string<char> string;

typedef basic_string<wchar_t> wstring;

typedef basic_string<char8_t> u8string;

typedef basic_string<char16_t> u16string;

typedef basic_string<char32_t> u32string;

}
# 42 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/iosfwd" 2 3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/postypes.h" 1 3
# 38 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/postypes.h" 3

# 39 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/postypes.h" 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cwchar" 1 3
# 39 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cwchar" 3

# 40 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cwchar" 3

# 1 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/wchar.h" 1 3
# 11 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/wchar.h" 3
# 1 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/corecrt_wstdlib.h" 1
3
# 12 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/corecrt_wstdlib.h" 3
extern "C" {

attribute ((dllimport)) errno_t attribute((cdecl)) _itow_s (int

_Val,wchar_t *_DstBuf,size_t _SizeInWords,int _Radix);
extern "C++" { template <size_t __size> inline errno_t __attribute__((__cdecl__))
_itow_s(int _Val, wchar_t (&_DstBuf)[__size], int _Radix) { return _itow_s(_Val,
_DstBuf, __size, _Radix); } }

attribute ((dllimport)) errno_t attribute((cdecl)) _ltow_s (long

_Val,wchar_t *_DstBuf,size_t _SizeInWords,int _Radix);
extern "C++" { template <size_t __size> inline errno_t __attribute__((__cdecl__))
_ltow_s(long _Val, wchar_t (&_DstBuf)[__size], int _Radix) { return _ltow_s(_Val,
_DstBuf, __size, _Radix); } }
__attribute__ ((__dllimport__)) errno_t __attribute__((__cdecl__)) _ultow_s
(unsigned long _Val,wchar_t *_DstBuf,size_t _SizeInWords,int _Radix);
extern "C++" { template <size_t __size> inline errno_t __attribute__((__cdecl__))
_ultow_s(unsigned long _Val, wchar_t (&_DstBuf)[__size], int _Radix) { return
_ultow_s(_Val, _DstBuf, __size, _Radix); } }

attribute ((dllimport)) errno_t attribute((cdecl))

_wgetenv_s(size_t *_ReturnSize,wchar_t *_DstBuf,size_t _DstSizeInWords,const
wchar_t *_VarName);
extern "C++" { template <size_t __size> inline errno_t __attribute__((__cdecl__))
_wgetenv_s(size_t* _ReturnSize, wchar_t (&_DstBuf)[__size], const wchar_t*
_VarName) { return _wgetenv_s(_ReturnSize, _DstBuf, __size, _VarName); } }

attribute ((dllimport)) errno_t attribute((cdecl))

_wdupenv_s(wchar_t **_Buffer,size_t *_BufferSizeInWords,const wchar_t *_VarName);
__attribute__ ((__dllimport__)) errno_t __attribute__((__cdecl__)) _i64tow_s(long
long _Val,wchar_t *_DstBuf,size_t _SizeInWords,int _Radix);
__attribute__ ((__dllimport__)) errno_t __attribute__((__cdecl__))
_ui64tow_s(unsigned long long _Val,wchar_t *_DstBuf,size_t _SizeInWords,int
_Radix);

attribute ((dllimport)) errno_t attribute((cdecl))

_wmakepath_s(wchar_t *_PathResult,size_t _SizeInWords,const wchar_t *_Drive,const
wchar_t *_Dir,const wchar_t *_Filename,const wchar_t *_Ext);
extern "C++" { template <size_t __size> inline errno_t __attribute__((__cdecl__))
_wmakepath_s(wchar_t (&_PathResult)[__size], const wchar_t* _Drive, const wchar_t*
_Dir, const wchar_t* _Filename, const wchar_t* _Ext) { return
_wmakepath_s(_PathResult,__size,_Drive,_Dir,_Filename,_Ext); } }

attribute ((dllimport)) errno_t attribute((cdecl))

_wputenv_s(const wchar_t *_Name,const wchar_t *_Value);

attribute ((dllimport)) errno_t attribute((cdecl))

_wsearchenv_s(const wchar_t *_Filename,const wchar_t *_EnvVar,wchar_t
*_ResultPath,size_t _SizeInWords);
extern "C++" { template <size_t __size> inline errno_t __attribute__((__cdecl__))
_wsearchenv_s(const wchar_t* _Filename, const wchar_t* _EnvVar, wchar_t
(&_ResultPath)[__size]) { return _wsearchenv_s(_Filename, _EnvVar, _ResultPath,
__size); } }

attribute ((dllimport)) errno_t attribute((cdecl))

_wsplitpath_s(const wchar_t *_FullPath,wchar_t *_Drive,size_t
_DriveSizeInWords,wchar_t *_Dir,size_t _DirSizeInWords,wchar_t *_Filename,size_t
_FilenameSizeInWords,wchar_t *_Ext,size_t _ExtSizeInWords);
extern "C++" { template <size_t __drive_size, size_t __dir_size, size_t
__name_size, size_t __ext_size> inline errno_t __attribute__((__cdecl__))
_wsplitpath_s(const wchar_t *_Dest, wchar_t (&__drive)[__drive_size], wchar_t
(&__dir)[__dir_size], wchar_t (&__name)[__name_size], wchar_t (&__ext)[__ext_size])
{ return _wsplitpath_s(_Dest, __drive, __drive_size, __dir, __dir_size, __name,
__name_size, __ext, __ext_size); } }

}
# 12 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/wchar.h" 2 3
# 26 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/wchar.h" 3
#pragma pack(push,_CRT_PACKING)
extern "C" {
# 56 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/wchar.h" 3
__attribute__ ((__dllimport__)) FILE *__attribute__((__cdecl__))
__acrt_iob_func(unsigned index);
# 82 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/wchar.h" 3
typedef unsigned long _fsize_t;

struct _wfinddata32_t {
unsigned attrib;
__time32_t time_create;
__time32_t time_access;
__time32_t time_write;
_fsize_t size;
wchar_t name[260];
};

struct _wfinddata32i64_t {
unsigned attrib;
__time32_t time_create;
__time32_t time_access;
__time32_t time_write;
__extension__ long long size;
wchar_t name[260];
};

struct _wfinddata64i32_t {
unsigned attrib;
__time64_t time_create;
__time64_t time_access;
__time64_t time_write;
_fsize_t size;
wchar_t name[260];
};

struct _wfinddata64_t {
unsigned attrib;
__time64_t time_create;
__time64_t time_access;
__time64_t time_write;
__extension__ long long size;
wchar_t name[260];
};
# 187 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/wchar.h" 3
extern unsigned short ** __imp__pctype;
# 202 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/wchar.h" 3
extern unsigned short ** __imp__wctype;
# 217 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/wchar.h" 3
extern unsigned short ** __imp__pwctype;
# 241 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/wchar.h" 3
int __attribute__((__cdecl__)) iswalpha(wint_t _C);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _iswalpha_l(wint_t
_C,_locale_t _Locale);
int __attribute__((__cdecl__)) iswupper(wint_t _C);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _iswupper_l(wint_t
_C,_locale_t _Locale);
int __attribute__((__cdecl__)) iswlower(wint_t _C);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _iswlower_l(wint_t
_C,_locale_t _Locale);
int __attribute__((__cdecl__)) iswdigit(wint_t _C);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _iswdigit_l(wint_t
_C,_locale_t _Locale);
int __attribute__((__cdecl__)) iswxdigit(wint_t _C);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__))
_iswxdigit_l(wint_t _C,_locale_t _Locale);
int __attribute__((__cdecl__)) iswspace(wint_t _C);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _iswspace_l(wint_t
_C,_locale_t _Locale);
int __attribute__((__cdecl__)) iswpunct(wint_t _C);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _iswpunct_l(wint_t
_C,_locale_t _Locale);
int __attribute__((__cdecl__)) iswalnum(wint_t _C);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _iswalnum_l(wint_t
_C,_locale_t _Locale);
int __attribute__((__cdecl__)) iswprint(wint_t _C);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _iswprint_l(wint_t
_C,_locale_t _Locale);
int __attribute__((__cdecl__)) iswgraph(wint_t _C);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _iswgraph_l(wint_t
_C,_locale_t _Locale);
int __attribute__((__cdecl__)) iswcntrl(wint_t _C);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _iswcntrl_l(wint_t
_C,_locale_t _Locale);
int __attribute__((__cdecl__)) iswascii(wint_t _C);

int attribute((cdecl)) isleadbyte(int _C);

__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _isleadbyte_l(int
_C,_locale_t _Locale);

wint_t attribute((cdecl)) towupper(wint_t _C);

__attribute__ ((__dllimport__)) wint_t __attribute__((__cdecl__))
_towupper_l(wint_t _C,_locale_t _Locale);
wint_t __attribute__((__cdecl__)) towlower(wint_t _C);
__attribute__ ((__dllimport__)) wint_t __attribute__((__cdecl__))
_towlower_l(wint_t _C,_locale_t _Locale);
int __attribute__((__cdecl__)) iswctype(wint_t _C,wctype_t _Type);
# 281 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/wchar.h" 3
int __attribute__((__cdecl__)) is_wctype(wint_t _C,wctype_t _Type);

int attribute((cdecl)) iswblank(wint_t _C);

attribute ((dllimport)) wchar_t *attribute((cdecl))

_wgetcwd(wchar_t *_DstBuf,int _SizeInWords);
__attribute__ ((__dllimport__)) wchar_t *__attribute__((__cdecl__)) _wgetdcwd(int
_Drive,wchar_t *_DstBuf,int _SizeInWords);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _wchdir(const
wchar_t *_Path);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _wmkdir(const
wchar_t *_Path);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _wrmdir(const
wchar_t *_Path);

attribute ((dllimport)) int attribute((cdecl)) _waccess(const

wchar_t *_Filename,int _AccessMode);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _wchmod(const
wchar_t *_Filename,int _Mode);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _wcreat(const
wchar_t *_Filename,int _PermissionMode) ;
__attribute__ ((__dllimport__)) intptr_t __attribute__((__cdecl__))
_wfindfirst32(const wchar_t *_Filename,struct _wfinddata32_t *_FindData);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__))
_wfindnext32(intptr_t _FindHandle,struct _wfinddata32_t *_FindData);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _wunlink(const
wchar_t *_Filename);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _wrename(const
wchar_t *_OldFilename,const wchar_t *_NewFilename);
__attribute__ ((__dllimport__)) wchar_t *__attribute__((__cdecl__))
_wmktemp(wchar_t *_TemplateName) ;
__attribute__ ((__dllimport__)) intptr_t __attribute__((__cdecl__))
_wfindfirst32i64(const wchar_t *_Filename,struct _wfinddata32i64_t *_FindData);
intptr_t __attribute__((__cdecl__)) _wfindfirst64i32(const wchar_t
*_Filename,struct _wfinddata64i32_t *_FindData);
__attribute__ ((__dllimport__)) intptr_t __attribute__((__cdecl__))
_wfindfirst64(const wchar_t *_Filename,struct _wfinddata64_t *_FindData);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__))
_wfindnext32i64(intptr_t _FindHandle,struct _wfinddata32i64_t *_FindData);
int __attribute__((__cdecl__)) _wfindnext64i32(intptr_t _FindHandle,struct
_wfinddata64i32_t *_FindData);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__))
_wfindnext64(intptr_t _FindHandle,struct _wfinddata64_t *_FindData);
__attribute__ ((__dllimport__)) errno_t __attribute__((__cdecl__)) _wsopen_s(int
*_FileHandle,const wchar_t *_Filename,int _OpenFlag,int _ShareFlag,int
_PermissionFlag);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _wopen(const
wchar_t *_Filename,int _OpenFlag,...) ;
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _wsopen(const
wchar_t *_Filename,int _OpenFlag,int _ShareFlag,...) ;
# 333 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/wchar.h" 3
__attribute__ ((__dllimport__)) intptr_t __attribute__((__cdecl__)) _wexecl(const
wchar_t *_Filename,const wchar_t *_ArgList,...);
__attribute__ ((__dllimport__)) intptr_t __attribute__((__cdecl__))
_wexecle(const wchar_t *_Filename,const wchar_t *_ArgList,...);
__attribute__ ((__dllimport__)) intptr_t __attribute__((__cdecl__))
_wexeclp(const wchar_t *_Filename,const wchar_t *_ArgList,...);
__attribute__ ((__dllimport__)) intptr_t __attribute__((__cdecl__))
_wexeclpe(const wchar_t *_Filename,const wchar_t *_ArgList,...);
__attribute__ ((__dllimport__)) intptr_t __attribute__((__cdecl__)) _wexecv(const
wchar_t *_Filename,const wchar_t *const *_ArgList);
__attribute__ ((__dllimport__)) intptr_t __attribute__((__cdecl__))
_wexecve(const wchar_t *_Filename,const wchar_t *const *_ArgList,const wchar_t
*const *_Env);
__attribute__ ((__dllimport__)) intptr_t __attribute__((__cdecl__))
_wexecvp(const wchar_t *_Filename,const wchar_t *const *_ArgList);
__attribute__ ((__dllimport__)) intptr_t __attribute__((__cdecl__))
_wexecvpe(const wchar_t *_Filename,const wchar_t *const *_ArgList,const wchar_t
*const *_Env);
# 357 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/wchar.h" 3
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _wsystem(const
wchar_t *_Command);
# 398 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/wchar.h" 3
typedef unsigned short _ino_t;

typedef unsigned short ino_t;

typedef unsigned int _dev_t;

typedef unsigned int dev_t;

# 1 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/_mingw_stat64.h" 1 3
# 25 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/_mingw_stat64.h" 3
struct _stat32 {
_dev_t st_dev;
_ino_t st_ino;
unsigned short st_mode;
short st_nlink;
short st_uid;
short st_gid;
_dev_t st_rdev;
_off_t st_size;
__time32_t st_atime;
__time32_t st_mtime;
__time32_t st_ctime;
};

struct stat {
_dev_t st_dev;
_ino_t st_ino;
unsigned short st_mode;
short st_nlink;
short st_uid;
short st_gid;
_dev_t st_rdev;
_off_t st_size;
time_t st_atime;
time_t st_mtime;
time_t st_ctime;
};

struct _stat32i64 {
_dev_t st_dev;
_ino_t st_ino;
unsigned short st_mode;
short st_nlink;
short st_uid;
short st_gid;
_dev_t st_rdev;
__extension__ long long st_size;
__time32_t st_atime;
__time32_t st_mtime;
__time32_t st_ctime;
};

struct _stat64i32 {
_dev_t st_dev;
_ino_t st_ino;
unsigned short st_mode;
short st_nlink;
short st_uid;
short st_gid;
_dev_t st_rdev;
_off_t st_size;
__time64_t st_atime;
__time64_t st_mtime;
__time64_t st_ctime;
};

struct _stat64 {
_dev_t st_dev;
_ino_t st_ino;
unsigned short st_mode;
short st_nlink;
short st_uid;
short st_gid;
_dev_t st_rdev;
__extension__ long long st_size;
__time64_t st_atime;
__time64_t st_mtime;
__time64_t st_ctime;
};
# 414 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/wchar.h" 2 3

attribute ((dllimport)) int attribute((cdecl)) _wstat32(const

wchar_t *_Name,struct _stat32 *_Stat);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _wstat32i64(const
wchar_t *_Name,struct _stat32i64 *_Stat);
int __attribute__((__cdecl__)) _wstat64i32(const wchar_t *_Name,struct _stat64i32
*_Stat);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _wstat64(const
wchar_t *_Name,struct _stat64 *_Stat);
# 432 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/wchar.h" 3
__attribute__ ((__dllimport__)) wchar_t *_cgetws(wchar_t *_Buffer) ;
__attribute__ ((__dllimport__)) wint_t __attribute__((__cdecl__)) _getwch(void);
__attribute__ ((__dllimport__)) wint_t __attribute__((__cdecl__)) _getwche(void);
__attribute__ ((__dllimport__)) wint_t __attribute__((__cdecl__)) _putwch(wchar_t
_WCh);
__attribute__ ((__dllimport__)) wint_t __attribute__((__cdecl__))
_ungetwch(wint_t _WCh);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _cputws(const
wchar_t *_String);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _cwprintf(const
wchar_t * __restrict__ _Format,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _cwscanf(const
wchar_t * __restrict__ _Format,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _cwscanf_l(const
wchar_t * __restrict__ _Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _vcwprintf(const
wchar_t * __restrict__ _Format,va_list _ArgList);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _cwprintf_p(const
wchar_t * __restrict__ _Format,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _vcwprintf_p(const
wchar_t * __restrict__ _Format,va_list _ArgList);

attribute ((dllimport)) int attribute((cdecl)) _cwprintf_l(const

wchar_t * __restrict__ _Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _vcwprintf_l(const
wchar_t * __restrict__ _Format,_locale_t _Locale,va_list _ArgList);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__))
_cwprintf_p_l(const wchar_t * __restrict__ _Format,_locale_t _Locale,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__))
_vcwprintf_p_l(const wchar_t * __restrict__ _Format,_locale_t _Locale,va_list
_ArgList);
# 1228 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/wchar.h" 3
__attribute__ ((__dllimport__)) wchar_t *__attribute__((__cdecl__)) _itow(int
_Value,wchar_t *_Dest,int _Radix) ;
__attribute__ ((__dllimport__)) wchar_t *__attribute__((__cdecl__)) _ltow(long
_Value,wchar_t *_Dest,int _Radix) ;
__attribute__ ((__dllimport__)) wchar_t *__attribute__((__cdecl__))
_ultow(unsigned long _Value,wchar_t *_Dest,int _Radix) ;
__attribute__ ((__dllimport__)) double __attribute__((__cdecl__)) _wcstod_l(const
wchar_t * __restrict__ _Str,wchar_t ** __restrict__ _EndPtr,_locale_t _Locale);

double attribute((cdecl)) __mingw_wcstod(const wchar_t * restrict

_Str,wchar_t ** __restrict__ _EndPtr);
float __attribute__((__cdecl__)) __mingw_wcstof(const wchar_t * __restrict__
nptr, wchar_t ** __restrict__ endptr);
long double __attribute__((__cdecl__)) __mingw_wcstold(const wchar_t *
__restrict__, wchar_t ** __restrict__);

inline __attribute__((__cdecl__))
double __attribute__((__cdecl__)) wcstod(const wchar_t * __restrict__
_Str,wchar_t ** __restrict__ _EndPtr){
return __mingw_wcstod(_Str,_EndPtr);
}
inline __attribute__((__cdecl__))
float __attribute__((__cdecl__)) wcstof(const wchar_t * __restrict__ _Str,wchar_t
** __restrict__ _EndPtr){
return __mingw_wcstof(_Str,_EndPtr);
}
long double __attribute__((__cdecl__)) wcstold (const wchar_t * __restrict__,
wchar_t ** __restrict__);

long attribute((cdecl)) wcstol(const wchar_t * restrict _Str,wchar_t

** __restrict__ _EndPtr,int _Radix);
__attribute__ ((__dllimport__)) long __attribute__((__cdecl__)) _wcstol_l(const
wchar_t * __restrict__ _Str,wchar_t ** __restrict__ _EndPtr,int _Radix,_locale_t
_Locale);
unsigned long __attribute__((__cdecl__)) wcstoul(const wchar_t * __restrict__
_Str,wchar_t ** __restrict__ _EndPtr,int _Radix);
__attribute__ ((__dllimport__)) unsigned long __attribute__((__cdecl__))
_wcstoul_l(const wchar_t * __restrict__ _Str,wchar_t ** __restrict__ _EndPtr,int
_Radix,_locale_t _Locale);
__attribute__ ((__dllimport__)) wchar_t *__attribute__((__cdecl__))
_wgetenv(const wchar_t *_VarName) ;

attribute ((dllimport)) double attribute((cdecl)) _wtof(const

wchar_t *_Str);
__attribute__ ((__dllimport__)) double __attribute__((__cdecl__)) _wtof_l(const
wchar_t *_Str,_locale_t _Locale);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _wtoi(const
wchar_t *_Str);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _wtoi_l(const
wchar_t *_Str,_locale_t _Locale);
__attribute__ ((__dllimport__)) long __attribute__((__cdecl__)) _wtol(const
wchar_t *_Str);
__attribute__ ((__dllimport__)) long __attribute__((__cdecl__)) _wtol_l(const
wchar_t *_Str,_locale_t _Locale);

extension attribute ((dllimport)) wchar_t *attribute((cdecl))

_i64tow(long long _Val,wchar_t *_DstBuf,int _Radix) ;
__extension__ __attribute__ ((__dllimport__)) wchar_t *__attribute__((__cdecl__))
_ui64tow(unsigned long long _Val,wchar_t *_DstBuf,int _Radix);
__extension__ __attribute__ ((__dllimport__)) long long
__attribute__((__cdecl__)) _wtoi64(const wchar_t *_Str);
__extension__ __attribute__ ((__dllimport__)) long long
__attribute__((__cdecl__)) _wtoi64_l(const wchar_t *_Str,_locale_t _Locale);
__extension__ __attribute__ ((__dllimport__)) long long
__attribute__((__cdecl__)) _wcstoi64(const wchar_t *_Str,wchar_t **_EndPtr,int
_Radix);
__extension__ __attribute__ ((__dllimport__)) long long
__attribute__((__cdecl__)) _wcstoi64_l(const wchar_t *_Str,wchar_t **_EndPtr,int
_Radix,_locale_t _Locale);
__extension__ __attribute__ ((__dllimport__)) unsigned long long
__attribute__((__cdecl__)) _wcstoui64(const wchar_t *_Str,wchar_t **_EndPtr,int
_Radix);
__extension__ __attribute__ ((__dllimport__)) unsigned long long
__attribute__((__cdecl__)) _wcstoui64_l(const wchar_t *_Str,wchar_t **_EndPtr,int
_Radix,_locale_t _Locale);

attribute ((dllimport)) wchar_t *attribute((cdecl))

_wfullpath(wchar_t *_FullPath,const wchar_t *_Path,size_t _SizeInWords);
__attribute__ ((__dllimport__)) void __attribute__((__cdecl__))
_wmakepath(wchar_t *_ResultPath,const wchar_t *_Drive,const wchar_t *_Dir,const
wchar_t *_Filename,const wchar_t *_Ext);

attribute ((dllimport)) int attribute((cdecl)) _wputenv(const

wchar_t *_EnvString);
__attribute__ ((__dllimport__)) void __attribute__((__cdecl__)) _wsearchenv(const
wchar_t *_Filename,const wchar_t *_EnvVar,wchar_t *_ResultPath) ;
__attribute__ ((__dllimport__)) void __attribute__((__cdecl__)) _wsplitpath(const
wchar_t *_FullPath,wchar_t *_Drive,wchar_t *_Dir,wchar_t *_Filename,wchar_t
*_Ext) ;

attribute ((dllimport)) wchar_t *attribute((cdecl)) _wcsdup(const

wchar_t *_Str);
wchar_t *__attribute__((__cdecl__)) wcscat(wchar_t * __restrict__ _Dest,const
wchar_t * __restrict__ _Source) ;
wchar_t *__attribute__((__cdecl__)) wcschr(const wchar_t *_Str,wchar_t _Ch);
int __attribute__((__cdecl__)) wcscmp(const wchar_t *_Str1,const wchar_t *_Str2);
wchar_t *__attribute__((__cdecl__)) wcscpy(wchar_t * __restrict__ _Dest,const
wchar_t * __restrict__ _Source) ;
size_t __attribute__((__cdecl__)) wcscspn(const wchar_t *_Str,const wchar_t
*_Control);
size_t __attribute__((__cdecl__)) wcslen(const wchar_t *_Str);
size_t __attribute__((__cdecl__)) wcsnlen(const wchar_t *_Src,size_t _MaxCount);
wchar_t *__attribute__((__cdecl__)) wcsncat(wchar_t * __restrict__ _Dest,const
wchar_t * __restrict__ _Source,size_t _Count) ;
int __attribute__((__cdecl__)) wcsncmp(const wchar_t *_Str1,const wchar_t
*_Str2,size_t _MaxCount);
wchar_t *__attribute__((__cdecl__)) wcsncpy(wchar_t * __restrict__ _Dest,const
wchar_t * __restrict__ _Source,size_t _Count) ;
wchar_t *__attribute__((__cdecl__)) _wcsncpy_l(wchar_t * __restrict__ _Dest,const
wchar_t * __restrict__ _Source,size_t _Count,_locale_t _Locale) ;
wchar_t *__attribute__((__cdecl__)) wcspbrk(const wchar_t *_Str,const wchar_t
*_Control);
wchar_t *__attribute__((__cdecl__)) wcsrchr(const wchar_t *_Str,wchar_t _Ch);
size_t __attribute__((__cdecl__)) wcsspn(const wchar_t *_Str,const wchar_t
*_Control);
wchar_t *__attribute__((__cdecl__)) wcsstr(const wchar_t *_Str,const wchar_t
*_SubStr);

wchar_t attribute((cdecl)) wcstok(wchar_t restrict _Str,const

wchar_t * __restrict__ _Delim) ;

attribute ((dllimport)) wchar_t *attribute((cdecl)) _wcserror(int

_ErrNum) ;
__attribute__ ((__dllimport__)) wchar_t *__attribute__((__cdecl__))
__wcserror(const wchar_t *_Str) ;
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _wcsicmp(const
wchar_t *_Str1,const wchar_t *_Str2);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _wcsicmp_l(const
wchar_t *_Str1,const wchar_t *_Str2,_locale_t _Locale);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _wcsnicmp(const
wchar_t *_Str1,const wchar_t *_Str2,size_t _MaxCount);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _wcsnicmp_l(const
wchar_t *_Str1,const wchar_t *_Str2,size_t _MaxCount,_locale_t _Locale);
__attribute__ ((__dllimport__)) wchar_t *__attribute__((__cdecl__))
_wcsnset(wchar_t *_Str,wchar_t _Val,size_t _MaxCount) ;
__attribute__ ((__dllimport__)) wchar_t *__attribute__((__cdecl__))
_wcsrev(wchar_t *_Str);
__attribute__ ((__dllimport__)) wchar_t *__attribute__((__cdecl__))
_wcsset(wchar_t *_Str,wchar_t _Val) ;
__attribute__ ((__dllimport__)) wchar_t *__attribute__((__cdecl__))
_wcslwr(wchar_t *_String) ;
__attribute__ ((__dllimport__)) wchar_t *_wcslwr_l(wchar_t *_String,_locale_t
_Locale) ;
__attribute__ ((__dllimport__)) wchar_t *__attribute__((__cdecl__))
_wcsupr(wchar_t *_String) ;
__attribute__ ((__dllimport__)) wchar_t *_wcsupr_l(wchar_t *_String,_locale_t
_Locale) ;
size_t __attribute__((__cdecl__)) wcsxfrm(wchar_t * __restrict__ _Dst,const
wchar_t * __restrict__ _Src,size_t _MaxCount);
__attribute__ ((__dllimport__)) size_t __attribute__((__cdecl__))
_wcsxfrm_l(wchar_t * __restrict__ _Dst,const wchar_t * __restrict__ _Src,size_t
_MaxCount,_locale_t _Locale);
int __attribute__((__cdecl__)) wcscoll(const wchar_t *_Str1,const wchar_t
*_Str2);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _wcscoll_l(const
wchar_t *_Str1,const wchar_t *_Str2,_locale_t _Locale);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _wcsicoll(const
wchar_t *_Str1,const wchar_t *_Str2);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _wcsicoll_l(const
wchar_t *_Str1,const wchar_t *_Str2,_locale_t _Locale);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _wcsncoll(const
wchar_t *_Str1,const wchar_t *_Str2,size_t _MaxCount);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _wcsncoll_l(const
wchar_t *_Str1,const wchar_t *_Str2,size_t _MaxCount,_locale_t _Locale);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _wcsnicoll(const
wchar_t *_Str1,const wchar_t *_Str2,size_t _MaxCount);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _wcsnicoll_l(const
wchar_t *_Str1,const wchar_t *_Str2,size_t _MaxCount,_locale_t _Locale);

wchar_t attribute((cdecl)) wcsdup(const wchar_t _Str) ;

int attribute((cdecl)) wcsicmp(const wchar_t _Str1,const wchar_t _Str2)

;
int __attribute__((__cdecl__)) wcsnicmp(const wchar_t *_Str1,const wchar_t
*_Str2,size_t _MaxCount) ;
wchar_t *__attribute__((__cdecl__)) wcsnset(wchar_t *_Str,wchar_t _Val,size_t
_MaxCount) ;
wchar_t *__attribute__((__cdecl__)) wcsrev(wchar_t *_Str) ;
wchar_t *__attribute__((__cdecl__)) wcsset(wchar_t *_Str,wchar_t _Val) ;
wchar_t *__attribute__((__cdecl__)) wcslwr(wchar_t *_Str) ;
wchar_t *__attribute__((__cdecl__)) wcsupr(wchar_t *_Str) ;
int __attribute__((__cdecl__)) wcsicoll(const wchar_t *_Str1,const wchar_t
*_Str2) ;
struct tm {
int tm_sec;
int tm_min;
int tm_hour;
int tm_mday;
int tm_mon;
int tm_year;
int tm_wday;
int tm_yday;
int tm_isdst;
};

attribute ((dllimport)) wchar_t *attribute((cdecl))

_wasctime(const struct tm *_Tm);
__attribute__((dllimport)) errno_t __attribute__((__cdecl__)) _wasctime_s
(wchar_t *_Buf,size_t _SizeInWords,const struct tm *_Tm);
wchar_t *__attribute__((__cdecl__)) _wctime32(const __time32_t *_Time) ;
__attribute__((dllimport)) errno_t __attribute__((__cdecl__)) _wctime32_s
(wchar_t *_Buf,size_t _SizeInWords,const __time32_t *_Time);
size_t __attribute__((__cdecl__)) wcsftime(wchar_t * __restrict__ _Buf,size_t
_SizeInWords,const wchar_t * __restrict__ _Format,const struct tm * __restrict__
_Tm);
__attribute__ ((__dllimport__)) size_t __attribute__((__cdecl__))
_wcsftime_l(wchar_t * __restrict__ _Buf,size_t _SizeInWords,const wchar_t *
__restrict__ _Format,const struct tm * __restrict__ _Tm,_locale_t _Locale);
__attribute__ ((__dllimport__)) wchar_t *__attribute__((__cdecl__))
_wstrdate(wchar_t *_Buffer) ;
__attribute__((dllimport)) errno_t __attribute__((__cdecl__)) _wstrdate_s
(wchar_t *_Buf,size_t _SizeInWords);
__attribute__ ((__dllimport__)) wchar_t *__attribute__((__cdecl__))
_wstrtime(wchar_t *_Buffer) ;
__attribute__((dllimport)) errno_t __attribute__((__cdecl__)) _wstrtime_s
(wchar_t *_Buf,size_t _SizeInWords);
__attribute__ ((__dllimport__)) wchar_t *__attribute__((__cdecl__))
_wctime64(const __time64_t *_Time) ;
__attribute__((dllimport)) errno_t __attribute__((__cdecl__)) _wctime64_s
(wchar_t *_Buf,size_t _SizeInWords,const __time64_t *_Time);

wchar_t attribute((cdecl)) _wctime(const time_t _Time) ;

inline wchar_t attribute((cdecl)) _wctime(const time_t _Time) { return

_wctime64(_Time); }
# 1401 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/wchar.h" 3
errno_t __attribute__((__cdecl__)) _wctime_s(wchar_t *, size_t, const time_t *);

inline errno_t attribute((cdecl)) _wctime_s (wchar_t *_Buffer,size_t

_SizeInWords,const time_t *_Time) { return _wctime64_s
(_Buffer,_SizeInWords,_Time); }
# 1420 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/wchar.h" 3
typedef int mbstate_t;

typedef wchar_t _Wint_t;

wint_t attribute((cdecl)) btowc(int);

size_t __attribute__((__cdecl__)) mbrlen(const char * __restrict__ _Ch,size_t
_SizeInBytes,mbstate_t * __restrict__ _State);
size_t __attribute__((__cdecl__)) mbrtowc(wchar_t * __restrict__ _DstCh,const
char * __restrict__ _SrcCh,size_t _SizeInBytes,mbstate_t * __restrict__ _State);
size_t __attribute__((__cdecl__)) mbsrtowcs(wchar_t * __restrict__ _Dest,const
char ** __restrict__ _PSrc,size_t _Count,mbstate_t * __restrict__ _State) ;
size_t __attribute__((__cdecl__)) wcrtomb(char * __restrict__ _Dest,wchar_t
_Source,mbstate_t * __restrict__ _State) ;
size_t __attribute__((__cdecl__)) wcsrtombs(char * __restrict__ _Dest,const
wchar_t ** __restrict__ _PSource,size_t _Count,mbstate_t * __restrict__ _State) ;
int __attribute__((__cdecl__)) wctob(wint_t _WCh);

wchar_t attribute((cdecl)) wmemset(wchar_t s, wchar_t c, size_t n);

wchar_t *__attribute__((__cdecl__)) wmemchr(const wchar_t *s, wchar_t c, size_t
n);
int __attribute__((__cdecl__)) wmemcmp(const wchar_t *s1, const wchar_t
*s2,size_t n);
wchar_t *__attribute__((__cdecl__)) wmemcpy(wchar_t * __restrict__ s1,const
wchar_t * __restrict__ s2,size_t n) ;
wchar_t * __attribute__((__cdecl__)) wmempcpy (wchar_t *_Dst, const wchar_t
*_Src, size_t _Size);
wchar_t *__attribute__((__cdecl__)) wmemmove(wchar_t *s1, const wchar_t *s2,
size_t n) ;
int __attribute__((__cdecl__)) fwide(FILE *stream,int mode);

int attribute((cdecl)) mbsinit(const mbstate_t *ps);

extension long long attribute((cdecl)) wcstoll(const wchar_t *

__restrict__ nptr,wchar_t ** __restrict__ endptr, int base);
__extension__ unsigned long long __attribute__((__cdecl__)) wcstoull(const
wchar_t * __restrict__ nptr,wchar_t ** __restrict__ endptr, int base);

void attribute((cdecl)) memmove(void _Dst,const void *_Src,size_t

_MaxCount);
void *__attribute__((__cdecl__)) memcpy(void * __restrict__ _Dst,const void *
__restrict__ _Src,size_t _MaxCount) ;

inline int attribute((cdecl)) fwide(FILE *_F,int _M) { (void)_F; return

(_M); }

inline int attribute((cdecl)) mbsinit(const mbstate_t *_P) { return (!_P

|| *_P==0); }

inline wchar_t attribute((cdecl)) wmemchr(const wchar_t _S,wchar_t

_C,size_t _N) {
if (_S) {
for ( ; 0 < _N; ++_S, --_N)
if (*_S == _C)
return ( wchar_t *)(_S);
}
return ( wchar_t *) 0LL;
}
inline int __attribute__((__cdecl__)) wmemcmp(const wchar_t *_S1,const wchar_t
*_S2,size_t _N) {
if (_N == 0 || _S1 == _S2)
return 0;
if ((_S1 && !(_S2)) || (_S2 && !(_S1)))
return !(_S2) ? 1 : -1;
for ( ; 0 < _N; ++_S1, ++_S2, --_N)
if (*_S1 != *_S2)
return (*_S1 < *_S2 ? -1 : +1);
return 0;
}
inline wchar_t *__attribute__((__cdecl__)) wmemcpy(wchar_t * __restrict__
_S1,const wchar_t * __restrict__ _S2,size_t _N)
{
return (wchar_t *) memcpy (_S1,_S2,_N*sizeof(wchar_t));
}
inline wchar_t *__attribute__((__cdecl__)) wmemmove(wchar_t *_S1,const wchar_t
*_S2,size_t _N) { return (wchar_t *)memmove(_S1,_S2,_N*sizeof(wchar_t)); }
inline wchar_t *__attribute__((__cdecl__)) wmemset(wchar_t *_S,wchar_t _C,size_t
_N) {
wchar_t *_Su = _S;
for (;0<_N;++_Su,--_N) {
*_Su = _C;
}
return (_S);
}
# 1531 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/wchar.h" 3
}

#pragma pack(pop)

# 1 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/sec_api/wchar_s.h" 1
3
# 9 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/sec_api/wchar_s.h" 3
# 1 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/wchar.h" 1 3
# 10 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/sec_api/wchar_s.h" 2
3
# 21 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/sec_api/wchar_s.h" 3
extern "C" {

attribute((dllimport)) errno_t attribute((cdecl)) _waccess_s (const

wchar_t *_Filename,int _AccessMode);
__attribute__((dllimport)) errno_t __attribute__((__cdecl__)) _wmktemp_s (wchar_t
*_TemplateName,size_t _SizeInWords);

attribute((dllimport)) errno_t attribute((cdecl)) _cgetws_s (wchar_t

*_Buffer,size_t _SizeInWords,size_t *_SizeRead);
__attribute__((dllimport)) int __attribute__((__cdecl__)) _cwprintf_s (const
wchar_t *_Format,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _cwscanf_s(const
wchar_t *_Format,...);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _cwscanf_s_l(const
wchar_t *_Format,_locale_t _Locale,...);
__attribute__((dllimport)) int __attribute__((__cdecl__)) _vcwprintf_s (const
wchar_t *_Format,va_list _ArgList);
__attribute__((dllimport)) int __attribute__((__cdecl__)) _cwprintf_s_l (const
wchar_t *_Format,_locale_t _Locale,...);
__attribute__((dllimport)) int __attribute__((__cdecl__)) _vcwprintf_s_l (const
wchar_t *_Format,_locale_t _Locale,va_list _ArgList);
# 316 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/sec_api/wchar_s.h"
3
__attribute__ ((__dllimport__)) wchar_t *__attribute__((__cdecl__))
wcstok_s(wchar_t *_Str,const wchar_t *_Delim,wchar_t **_Context);
__attribute__ ((__dllimport__)) errno_t __attribute__((__cdecl__))
_wcserror_s(wchar_t *_Buf,size_t _SizeInWords,int _ErrNum);
extern "C++" { template <size_t __size> inline errno_t __attribute__((__cdecl__))
_wcserror_s(wchar_t (&_Buf)[__size], int _ErrNum) { return
_wcserror_s(_Buf,__size,_ErrNum); } }
__attribute__ ((__dllimport__)) errno_t __attribute__((__cdecl__))
__wcserror_s(wchar_t *_Buffer,size_t _SizeInWords,const wchar_t *_ErrMsg);
extern "C++" { template <size_t __size> inline errno_t __attribute__((__cdecl__))
__wcserror_s(wchar_t (&_Buffer)[__size], const wchar_t * _ErrMsg) { return
__wcserror_s(_Buffer,__size,_ErrMsg); } }
__attribute__ ((__dllimport__)) errno_t __attribute__((__cdecl__))
_wcsnset_s(wchar_t *_Dst,size_t _DstSizeInWords,wchar_t _Val,size_t _MaxCount);
extern "C++" { template <size_t __size> inline errno_t __attribute__((__cdecl__))
_wcsnset_s(wchar_t (&_Dst)[__size], wchar_t _Val, size_t _MaxCount) { return
_wcsnset_s(_Dst,__size,_Val,_MaxCount); } }
__attribute__ ((__dllimport__)) errno_t __attribute__((__cdecl__))
_wcsset_s(wchar_t *_Str,size_t _SizeInWords,wchar_t _Val);
extern "C++" { template <size_t __size> inline errno_t __attribute__((__cdecl__))
_wcsset_s(wchar_t (&_Str)[__size], wchar_t _Val) { return
_wcsset_s(_Str,__size,_Val); } }
__attribute__ ((__dllimport__)) errno_t __attribute__((__cdecl__))
_wcslwr_s(wchar_t *_Str,size_t _SizeInWords);
extern "C++" { template <size_t __size> inline errno_t __attribute__((__cdecl__))
_wcslwr_s(wchar_t (&_Str)[__size]) { return _wcslwr_s(_Str,__size); } }
__attribute__ ((__dllimport__)) errno_t __attribute__((__cdecl__))
_wcslwr_s_l(wchar_t *_Str,size_t _SizeInWords,_locale_t _Locale);
extern "C++" { template <size_t __size> inline errno_t __attribute__((__cdecl__))
_wcslwr_s_l(wchar_t (&_Str)[__size], _locale_t _Locale) { return
_wcslwr_s_l(_Str,__size,_Locale); } }
__attribute__ ((__dllimport__)) errno_t __attribute__((__cdecl__))
_wcsupr_s(wchar_t *_Str,size_t _Size);
extern "C++" { template <size_t __size> inline errno_t __attribute__((__cdecl__))
_wcsupr_s(wchar_t (&_Str)[__size]) { return _wcsupr_s(_Str,__size); } }
__attribute__ ((__dllimport__)) errno_t __attribute__((__cdecl__))
_wcsupr_s_l(wchar_t *_Str,size_t _Size,_locale_t _Locale);
extern "C++" { template <size_t __size> inline errno_t __attribute__((__cdecl__))
_wcsupr_s_l(wchar_t (&_Str)[__size], _locale_t _Locale) { return
_wcsupr_s_l(_Str,__size,_Locale); } }

attribute ((dllimport)) errno_t attribute((cdecl))

wcscat_s(wchar_t *_Dst, rsize_t _DstSize, const wchar_t *_Src);
extern "C++" { template <size_t __size> inline errno_t __attribute__((__cdecl__))
wcscat_s(wchar_t (&_Dest)[__size], const wchar_t * _Source) { return
wcscat_s(_Dest,__size,_Source); } }
__attribute__ ((__dllimport__)) errno_t __attribute__((__cdecl__))
wcscpy_s(wchar_t *_Dst, rsize_t _DstSize, const wchar_t *_Src);
extern "C++" { template <size_t __size> inline errno_t __attribute__((__cdecl__))
wcscpy_s(wchar_t (&_Dest)[__size], const wchar_t * _Source) { return
wcscpy_s(_Dest,__size,_Source); } }

attribute ((dllimport)) errno_t attribute((cdecl))

wcsncat_s(wchar_t *_Dst,size_t _DstSizeInChars,const wchar_t *_Src,size_t
_MaxCount);
extern "C++" { template <size_t __size> inline errno_t __attribute__((__cdecl__))
wcsncat_s(wchar_t (&_Dst)[__size], const wchar_t * _Src, size_t _MaxCount) { return
wcsncat_s(_Dst,__size,_Src,_MaxCount); } }
__attribute__ ((__dllimport__)) errno_t __attribute__((__cdecl__))
_wcsncat_s_l(wchar_t *_Dst,size_t _DstSizeInChars,const wchar_t *_Src,size_t
_MaxCount,_locale_t _Locale);
extern "C++" { template <size_t __size> inline errno_t __attribute__((__cdecl__))
_wcsncat_s_l(wchar_t (&_Dst)[__size], const wchar_t * _Src, size_t _MaxCount,
_locale_t _Locale) { return _wcsncat_s_l(_Dst,__size,_Src,_MaxCount,_Locale); } }
__attribute__ ((__dllimport__)) errno_t __attribute__((__cdecl__))
wcsncpy_s(wchar_t *_Dst,size_t _DstSizeInChars,const wchar_t *_Src,size_t
_MaxCount);
extern "C++" { template <size_t __size> inline errno_t __attribute__((__cdecl__))
wcsncpy_s(wchar_t (&_Dst)[__size], const wchar_t * _Src, size_t _MaxCount) { return
wcsncpy_s(_Dst,__size,_Src,_MaxCount); } }
__attribute__ ((__dllimport__)) errno_t __attribute__((__cdecl__))
_wcsncpy_s_l(wchar_t *_Dst,size_t _DstSizeInChars,const wchar_t *_Src,size_t
_MaxCount,_locale_t _Locale);
extern "C++" { template <size_t __size> inline errno_t __attribute__((__cdecl__))
_wcsncpy_s_l(wchar_t (&_Dst)[__size], const wchar_t * _Src, size_t _MaxCount,
_locale_t _Locale) { return _wcsncpy_s_l(_Dst,__size,_Src,_MaxCount,_Locale); } }
__attribute__ ((__dllimport__)) wchar_t *__attribute__((__cdecl__))
_wcstok_s_l(wchar_t *_Str,const wchar_t *_Delim,wchar_t **_Context,_locale_t
_Locale);
__attribute__ ((__dllimport__)) errno_t __attribute__((__cdecl__))
_wcsset_s_l(wchar_t *_Str,size_t _SizeInChars,wchar_t _Val,_locale_t _Locale);
extern "C++" { template <size_t __size> inline errno_t __attribute__((__cdecl__))
_wcsset_s_l(wchar_t (&_Str)[__size], wchar_t _Val, _locale_t _Locale) { return
_wcsset_s_l(_Str,__size,_Val,_Locale); } }
__attribute__ ((__dllimport__)) errno_t __attribute__((__cdecl__))
_wcsnset_s_l(wchar_t *_Str,size_t _SizeInChars,wchar_t _Val, size_t
_Count,_locale_t _Locale);
extern "C++" { template <size_t __size> inline errno_t __attribute__((__cdecl__))
_wcsnset_s_l(wchar_t (&_Str)[__size], wchar_t _Val, size_t _Count, _locale_t
_Locale) { return _wcsnset_s_l(_Str,__size,_Val,_Count,_Locale); } }

inline attribute((__always_inline__)) size_t attribute((cdecl))

wcsnlen_s(const wchar_t * _src, size_t _count) {
return _src ? wcsnlen(_src, _count) : 0;
}

attribute((dllimport)) errno_t attribute((cdecl)) _wasctime_s

(wchar_t *_Buf,size_t _SizeInWords,const struct tm *_Tm);
__attribute__((dllimport)) errno_t __attribute__((__cdecl__)) _wctime32_s
(wchar_t *_Buf,size_t _SizeInWords,const __time32_t *_Time);
__attribute__((dllimport)) errno_t __attribute__((__cdecl__)) _wstrdate_s
(wchar_t *_Buf,size_t _SizeInWords);
__attribute__((dllimport)) errno_t __attribute__((__cdecl__)) _wstrtime_s
(wchar_t *_Buf,size_t _SizeInWords);
__attribute__((dllimport)) errno_t __attribute__((__cdecl__)) _wctime64_s
(wchar_t *_Buf,size_t _SizeInWords,const __time64_t *_Time);
# 375 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/sec_api/wchar_s.h"
3
__attribute__ ((__dllimport__)) errno_t __attribute__((__cdecl__))
mbsrtowcs_s(size_t *_Retval,wchar_t *_Dst,size_t _SizeInWords,const char
**_PSrc,size_t _N,mbstate_t *_State);
extern "C++" { template <size_t __size> inline errno_t __attribute__((__cdecl__))
mbsrtowcs_s(size_t* _Retval, wchar_t (&_Dst)[__size], const char** _PSrc, size_t
_N, mbstate_t _State) { return mbsrtowcs_s(_Retval, _Dst, __size, _PSrc, _N,
_State); } }

attribute ((dllimport)) errno_t attribute((cdecl))

wcrtomb_s(size_t *_Retval,char *_Dst,size_t _SizeInBytes,wchar_t _Ch,mbstate_t
*_State);
extern "C++" { template <size_t __size> inline errno_t __attribute__((__cdecl__))
wcrtomb_s(size_t* _Retval, char (&_Dst)[__size], wchar_t _Ch, mbstate_t _State)
{ return wcrtomb_s(_Retval, _Dst, __size, _Ch, _State); } }

attribute ((dllimport)) errno_t attribute((cdecl))

wcsrtombs_s(size_t *_Retval,char *_Dst,size_t _SizeInBytes,const wchar_t
**_Src,size_t _Size,mbstate_t *_State);
extern "C++" { template <size_t __size> inline errno_t __attribute__((__cdecl__))
wcsrtombs_s(size_t _Retval, char (&_Dst)[__size], const wchar_t** _Src, size_t
_Size, mbstate_t _State) { return wcsrtombs_s(_Retval, _Dst, __size, _Src, _Size,
_State); } }

attribute((dllimport)) errno_t attribute((cdecl)) wmemcpy_s (wchar_t

*_dest,size_t _numberOfElements,const wchar_t *_src,size_t _count);
__attribute__((dllimport)) errno_t __attribute__((__cdecl__)) wmemmove_s(wchar_t
*_dest,size_t _numberOfElements,const wchar_t *_src,size_t _count);

}
# 1537 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/wchar.h" 2 3
# 45 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cwchar" 2 3
# 62 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cwchar" 3
namespace std
{
using ::mbstate_t;
}
# 135 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cwchar" 3
extern "C++"
{
namespace std
{

using ::wint_t;

using ::btowc;
using ::fgetwc;
using ::fgetws;
using ::fputwc;
using ::fputws;
using ::fwide;
using ::fwprintf;
using ::fwscanf;
using ::getwc;
using ::getwchar;
using ::mbrlen;
using ::mbrtowc;
using ::mbsinit;
using ::mbsrtowcs;
using ::putwc;
using ::putwchar;

using ::swprintf;

using ::swscanf;
using ::ungetwc;
using ::vfwprintf;

using ::vfwscanf;

using ::vswprintf;

using ::vswscanf;

using ::vwprintf;

using ::vwscanf;

using ::wcrtomb;
using ::wcscat;
using ::wcscmp;
using ::wcscoll;
using ::wcscpy;
using ::wcscspn;
using ::wcsftime;
using ::wcslen;
using ::wcsncat;
using ::wcsncmp;
using ::wcsncpy;
using ::wcsrtombs;
using ::wcsspn;
using ::wcstod;

using ::wcstof;

using ::wcstok;
using ::wcstol;
using ::wcstoul;
using ::wcsxfrm;
using ::wctob;
using ::wmemcmp;
using ::wmemcpy;
using ::wmemmove;
using ::wmemset;
using ::wprintf;
using ::wscanf;
using ::wcschr;
using ::wcspbrk;
using ::wcsrchr;
using ::wcsstr;
using ::wmemchr;

inline wchar_t*
wcschr(wchar_t* __p, wchar_t __c)
{ return wcschr(const_cast<const wchar_t*>(__p), __c); }

inline wchar_t*
wcspbrk(wchar_t* __s1, const wchar_t* __s2)
{ return wcspbrk(const_cast<const wchar_t*>(__s1), __s2); }

inline wchar_t*
wcsrchr(wchar_t* __p, wchar_t __c)
{ return wcsrchr(const_cast<const wchar_t*>(__p), __c); }

inline wchar_t*
wcsstr(wchar_t* __s1, const wchar_t* __s2)
{ return wcsstr(const_cast<const wchar_t*>(__s1), __s2); }

inline wchar_t*
wmemchr(wchar_t* __p, wchar_t __c, size_t __n)
{ return wmemchr(const_cast<const wchar_t*>(__p), __c, __n); }

}
}

namespace __gnu_cxx
{

using ::wcstold;
# 260 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cwchar" 3
using ::wcstoll;
using ::wcstoull;

namespace std
{
using ::__gnu_cxx::wcstold;
using ::__gnu_cxx::wcstoll;
using ::__gnu_cxx::wcstoull;
}
# 280 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cwchar" 3
namespace std
{
using std::wcstof;

using std::vfwscanf;

using std::vswscanf;

using std::vwscanf;

using std::wcstold;
using std::wcstoll;
using std::wcstoull;

}
# 41 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/postypes.h" 2 3

namespace std
{

# 62 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/postypes.h" 3
typedef long long int streamoff;

typedef ptrdiff_t streamsize;

# 81 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/postypes.h" 3
template<typename _StateT>
class fpos
{
private:
streamoff _M_off;
_StateT _M_state;

public:

fpos()
: _M_off(0), _M_state() { }
# 103 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/postypes.h" 3
fpos(streamoff __off)
: _M_off(__off), _M_state() { }

fpos(const fpos&) = default;

fpos& operator=(const fpos&) = default;
~fpos() = default;

operator streamoff() const { return _M_off; }

void
state(_StateT __st)
{ _M_state = __st; }

_StateT
state() const
{ return _M_state; }

fpos&
operator+=(streamoff __off)
{
_M_off += __off;
return *this;
}

fpos&
operator-=(streamoff __off)
{
_M_off -= __off;
return *this;
}

fpos
operator+(streamoff __off) const
{
fpos __pos(*this);
__pos += __off;
return __pos;
}

fpos
operator-(streamoff __off) const
{
fpos __pos(*this);
__pos -= __off;
return __pos;
}
streamoff
operator-(const fpos& __other) const
{ return _M_off - __other._M_off; }
};

template<typename _StateT>
inline bool
operator==(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs)
{ return streamoff(__lhs) == streamoff(__rhs); }

template<typename _StateT>
inline bool
operator!=(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs)
{ return streamoff(__lhs) != streamoff(__rhs); }

typedef fpos<mbstate_t> streampos;

typedef fpos<mbstate_t> wstreampos;

typedef fpos<mbstate_t> u8streampos;

typedef fpos<mbstate_t> u16streampos;

typedef fpos<mbstate_t> u32streampos;

}
# 43 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/iosfwd" 2 3

namespace std
{

# 76 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/iosfwd" 3
class ios_base;

template<typename _CharT, typename _Traits = char_traits<_CharT> >

class basic_ios;
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class basic_streambuf;

template<typename _CharT, typename _Traits = char_traits<_CharT> >

class basic_istream;

template<typename _CharT, typename _Traits = char_traits<_CharT> >

class basic_ostream;

template<typename _CharT, typename _Traits = char_traits<_CharT> >

class basic_iostream;

namespace __cxx11 {

template<typename _CharT, typename _Traits = char_traits<_CharT>,

typename _Alloc = allocator<_CharT> >
class basic_stringbuf;

template<typename _CharT, typename _Traits = char_traits<_CharT>,

typename _Alloc = allocator<_CharT> >
class basic_istringstream;

template<typename _CharT, typename _Traits = char_traits<_CharT>,

typename _Alloc = allocator<_CharT> >
class basic_ostringstream;

template<typename _CharT, typename _Traits = char_traits<_CharT>,

typename _Alloc = allocator<_CharT> >
class basic_stringstream;

template<typename _CharT, typename _Traits = char_traits<_CharT> >

class basic_filebuf;

template<typename _CharT, typename _Traits = char_traits<_CharT> >

class basic_ifstream;

template<typename _CharT, typename _Traits = char_traits<_CharT> >

class basic_ofstream;

template<typename _CharT, typename _Traits = char_traits<_CharT> >

class basic_fstream;

template<typename _CharT, typename _Traits = char_traits<_CharT> >

class istreambuf_iterator;

template<typename _CharT, typename _Traits = char_traits<_CharT> >

class ostreambuf_iterator;

typedef basic_ios<char> ios;

typedef basic_streambuf<char> streambuf;

typedef basic_istream<char> istream;

typedef basic_ostream<char> ostream;

typedef basic_iostream<char> iostream;

typedef basic_stringbuf<char> stringbuf;

typedef basic_istringstream<char> istringstream;

typedef basic_ostringstream<char> ostringstream;

typedef basic_stringstream<char> stringstream;

typedef basic_filebuf<char> filebuf;

typedef basic_ifstream<char> ifstream;

typedef basic_ofstream<char> ofstream;

typedef basic_fstream<char> fstream;

typedef basic_ios<wchar_t> wios;

typedef basic_streambuf<wchar_t> wstreambuf;

typedef basic_istream<wchar_t> wistream;

typedef basic_ostream<wchar_t> wostream;

typedef basic_iostream<wchar_t> wiostream;

typedef basic_stringbuf<wchar_t> wstringbuf;

typedef basic_istringstream<wchar_t> wistringstream;

typedef basic_ostringstream<wchar_t> wostringstream;

typedef basic_stringstream<wchar_t> wstringstream;

typedef basic_filebuf<wchar_t> wfilebuf;

typedef basic_ifstream<wchar_t> wifstream;

typedef basic_ofstream<wchar_t> wofstream;

typedef basic_fstream<wchar_t> wfstream;

template<typename _CharT, typename _Traits = char_traits<_CharT>,

typename _Allocator = allocator<_CharT>>
class basic_syncbuf;
template<typename _CharT, typename _Traits = char_traits<_CharT>,
typename _Allocator = allocator<_CharT>>
class basic_osyncstream;

using syncbuf = basic_syncbuf<char>;

using osyncstream = basic_osyncstream<char>;

using wsyncbuf = basic_syncbuf<wchar_t>;

using wosyncstream = basic_osyncstream<wchar_t>;

template<typename _CharT, typename _Traits = char_traits<_CharT>>

class basic_spanbuf;
template<typename _CharT, typename _Traits = char_traits<_CharT>>
class basic_ispanstream;
template<typename _CharT, typename _Traits = char_traits<_CharT>>
class basic_ospanstream;
template<typename _CharT, typename _Traits = char_traits<_CharT>>
class basic_spanstream;

using spanbuf = basic_spanbuf<char>;

using ispanstream = basic_ispanstream<char>;
using ospanstream = basic_ospanstream<char>;
using spanstream = basic_spanstream<char>;

using wspanbuf = basic_spanbuf<wchar_t>;

using wispanstream = basic_ispanstream<wchar_t>;
using wospanstream = basic_ospanstream<wchar_t>;
using wspanstream = basic_spanstream<wchar_t>;

}
# 42 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/localefwd.h" 2 3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cctype" 1 3
# 39 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cctype" 3

# 40 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cctype" 3

# 1 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/ctype.h" 1 3
# 12 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/ctype.h" 3
extern "C" {
# 80 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/ctype.h" 3
extern const unsigned char __newclmap[];
extern const unsigned char __newcumap[];
extern pthreadlocinfo __ptlocinfo;
extern pthreadmbcinfo __ptmbcinfo;
extern int __globallocalestatus;
extern int __locale_changed;
extern struct threadlocaleinfostruct __initiallocinfo;
extern _locale_tstruct __initiallocalestructinfo;
pthreadlocinfo __attribute__((__cdecl__)) __updatetlocinfo(void);
pthreadmbcinfo __attribute__((__cdecl__)) __updatetmbcinfo(void);
# 108 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/ctype.h" 3
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _isctype(int
_C,int _Type);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _isctype_l(int
_C,int _Type,_locale_t _Locale);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) isalpha(int _C);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _isalpha_l(int
_C,_locale_t _Locale);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) isupper(int _C);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _isupper_l(int
_C,_locale_t _Locale);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) islower(int _C);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _islower_l(int
_C,_locale_t _Locale);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) isdigit(int _C);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _isdigit_l(int
_C,_locale_t _Locale);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) isxdigit(int _C);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _isxdigit_l(int
_C,_locale_t _Locale);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) isspace(int _C);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _isspace_l(int
_C,_locale_t _Locale);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) ispunct(int _C);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _ispunct_l(int
_C,_locale_t _Locale);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) isalnum(int _C);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _isalnum_l(int
_C,_locale_t _Locale);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) isprint(int _C);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _isprint_l(int
_C,_locale_t _Locale);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) isgraph(int _C);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _isgraph_l(int
_C,_locale_t _Locale);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) iscntrl(int _C);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _iscntrl_l(int
_C,_locale_t _Locale);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) toupper(int _C);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) tolower(int _C);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _tolower(int _C);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _tolower_l(int
_C,_locale_t _Locale);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _toupper(int _C);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _toupper_l(int
_C,_locale_t _Locale);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) __isascii(int _C);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) __toascii(int _C);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) __iscsymf(int _C);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) __iscsym(int _C);

int attribute((cdecl)) isblank(int _C);

# 209 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/ctype.h" 3
extern int * __imp___mb_cur_max;

attribute ((dllimport)) int attribute((cdecl))

___mb_cur_max_func(void);
# 297 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/ctype.h" 3
}
# 43 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cctype" 2 3
# 62 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cctype" 3
namespace std
{
using ::isalnum;
using ::isalpha;
using ::iscntrl;
using ::isdigit;
using ::isgraph;
using ::islower;
using ::isprint;
using ::ispunct;
using ::isspace;
using ::isupper;
using ::isxdigit;
using ::tolower;
using ::toupper;
}

namespace std
{
using ::isblank;
}
# 43 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/localefwd.h" 2 3

namespace std
{

# 55 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/localefwd.h" 3
class locale;

template<typename _Facet>
bool
has_facet(const locale&) throw();

template<typename _Facet>
const _Facet&
use_facet(const locale&);

template<typename _CharT>
bool
isspace(_CharT, const locale&);

template<typename _CharT>
bool
isprint(_CharT, const locale&);

template<typename _CharT>
bool
iscntrl(_CharT, const locale&);

template<typename _CharT>
bool
isupper(_CharT, const locale&);

template<typename _CharT>
bool
islower(_CharT, const locale&);

template<typename _CharT>
bool
isalpha(_CharT, const locale&);

template<typename _CharT>
bool
isdigit(_CharT, const locale&);

template<typename _CharT>
bool
ispunct(_CharT, const locale&);

template<typename _CharT>
bool
isxdigit(_CharT, const locale&);

template<typename _CharT>
bool
isalnum(_CharT, const locale&);

template<typename _CharT>
bool
isgraph(_CharT, const locale&);

template<typename _CharT>
bool
isblank(_CharT, const locale&);
template<typename _CharT>
_CharT
toupper(_CharT, const locale&);

template<typename _CharT>
_CharT
tolower(_CharT, const locale&);

struct ctype_base;
template<typename _CharT>
class ctype;
template<> class ctype<char>;

template<> class ctype<wchar_t>;

template<typename _CharT>
class ctype_byname;

class codecvt_base;
template<typename _InternT, typename _ExternT, typename _StateT>
class codecvt;
template<> class codecvt<char, char, mbstate_t>;

template<> class codecvt<wchar_t, char, mbstate_t>;

template<> class codecvt<char16_t, char, mbstate_t>;

template<> class codecvt<char32_t, char, mbstate_t>;

template<> class codecvt<char16_t, char8_t, mbstate_t>;

template<> class codecvt<char32_t, char8_t, mbstate_t>;

template<typename _InternT, typename _ExternT, typename _StateT>

class codecvt_byname;

template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >

class num_get;
template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
class num_put;

namespace __cxx11 {
template<typename _CharT> class numpunct;
template<typename _CharT> class numpunct_byname;
}

namespace __cxx11 {

template<typename _CharT>
class collate;
template<typename _CharT>
class collate_byname;
}
class time_base;
namespace __cxx11 {
template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
class time_get;
template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
class time_get_byname;
}
template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
class time_put;
template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
class time_put_byname;

class money_base;
namespace __cxx11 {
template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
class money_get;
template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
class money_put;
}
namespace __cxx11 {
template<typename _CharT, bool _Intl = false>
class moneypunct;
template<typename _CharT, bool _Intl = false>
class moneypunct_byname;
}

struct messages_base;
namespace __cxx11 {
template<typename _CharT>
class messages;
template<typename _CharT>
class messages_byname;
}

}
# 41 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/locale" 2 3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_classes.h" 1 3
# 37 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_classes.h" 3

# 38 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_classes.h" 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/string" 1 3
# 36 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/string" 3

# 37 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/string" 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/char_traits.h" 1 3
# 37 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/char_traits.h" 3
# 38 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/char_traits.h" 3
# 46 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/char_traits.h" 3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cwchar" 1 3
# 39 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cwchar" 3

# 40 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cwchar" 3
# 47 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/char_traits.h" 2 3
# 64 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/char_traits.h" 3
namespace __gnu_cxx
{

# 68 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/char_traits.h" 3
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wstringop-overflow"
#pragma GCC diagnostic ignored "-Wstringop-overread"
#pragma GCC diagnostic ignored "-Warray-bounds"
# 83 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/char_traits.h" 3
template<typename _CharT>
struct _Char_types
{
typedef unsigned long int_type;

typedef std::streampos pos_type;

typedef std::streamoff off_type;
typedef std::mbstate_t state_type;

};
# 110 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/char_traits.h" 3
template<typename _CharT>
struct char_traits
{
typedef _CharT char_type;
typedef typename _Char_types<_CharT>::int_type int_type;

typedef typename _Char_types<_CharT>::pos_type pos_type;

typedef typename _Char_types<_CharT>::off_type off_type;
typedef typename _Char_types<_CharT>::state_type state_type;

using comparison_category = std::strong_ordering;

static constexpr int_type

eof()
{ return static_cast<int_type>(-1); }

static constexpr int_type

not_eof(const int_type& __c)
{ return !eq_int_type(__c, eof()) ? __c : to_int_type(char_type()); }

};

template<typename _CharT>
constexpr int
char_traits<_CharT>::
compare(const char_type* __s1, const char_type* __s2, std::size_t __n)
{
for (std::size_t __i = 0; __i < __n; ++__i)
if (lt(__s1[__i], __s2[__i]))
return -1;
else if (lt(__s2[__i], __s1[__i]))
return 1;
return 0;
}

template<typename _CharT>
constexpr std::size_t
char_traits<_CharT>::
length(const char_type* __p)
{
std::size_t __i = 0;
while (!eq(__p[__i], char_type()))
++__i;
return __i;
}

template<typename _CharT>
constexpr const typename char_traits<_CharT>::char_type*
char_traits<_CharT>::
find(const char_type* __s, std::size_t __n, const char_type& __a)
{
for (std::size_t __i = 0; __i < __n; ++__i)
if (eq(__s[__i], __a))
return __s + __i;
return 0;
}

template<typename _CharT>
constexpr
typename char_traits<_CharT>::char_type*
char_traits<_CharT>::
move(char_type* __s1, const char_type* __s2, std::size_t __n)
{
if (__n == 0)
return __s1;

if (std::__is_constant_evaluated())
{

if (__builtin_constant_p(s2 < s1)

&& __s1 > __s2 && __s1 < (__s2 + __n))
{
do
{
--__n;
assign(__s1[__n], __s2[__n]);
}
while (__n > 0);
}
else
copy(__s1, __s2, __n);
return __s1;
}

__builtin_memmove(s1, s2, __n * sizeof(char_type));

return __s1;
}

template<typename _CharT>
constexpr
typename char_traits<_CharT>::char_type*
char_traits<_CharT>::
copy(char_type* __s1, const char_type* __s2, std::size_t __n)
{
if (__n == 0)
return __s1;

if (std::__is_constant_evaluated())
{
for (std::size_t __i = 0; __i < __n; ++__i)
std::construct_at(__s1 + __i, __s2[__i]);
return __s1;
}

__builtin_memcpy(s1, s2, __n * sizeof(char_type));

return __s1;
}

template<typename _CharT>
constexpr
typename char_traits<_CharT>::char_type*
char_traits<_CharT>::
assign(char_type* __s, std::size_t __n, char_type __a)
{

if (std::__is_constant_evaluated())
{
for (std::size_t __i = 0; __i < __n; ++__i)
std::construct_at(__s + __i, __a);
return __s;
}

if constexpr (sizeof(_CharT) == 1 && __is_trivial(_CharT))

{
if (__n)
{
unsigned char __c;
__builtin_memcpy(&__c, __builtin_addressof(__a), 1);
__builtin_memset(__s, __c, __n);
}
}
else
{
for (std::size_t __i = 0; __i < __n; ++__i)
__s[__i] = __a;
}
return __s;
}

namespace std
{

# 322 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/char_traits.h" 3
template<typename _CharT>
struct char_traits : public __gnu_cxx::char_traits<_CharT>
{ };

template<>
struct char_traits<char>
{
typedef char char_type;
typedef int int_type;

typedef streampos pos_type;

typedef streamoff off_type;
typedef mbstate_t state_type;

using comparison_category = strong_ordering;

static constexpr void

assign(char_type& __c1, const char_type& __c2) noexcept
{

if (std::__is_constant_evaluated())
std::construct_at(__builtin_addressof(__c1), __c2);
else

__c1 = __c2;
}

static constexpr bool

eq(const char_type& __c1, const char_type& __c2) noexcept
{ return __c1 == __c2; }

static constexpr bool

lt(const char_type& __c1, const char_type& __c2) noexcept
{

return (static_cast<unsigned char>(__c1)

< static_cast<unsigned char>(__c2));
}

static constexpr int

compare(const char_type* __s1, const char_type* __s2, size_t __n)
{
if (__n == 0)
return 0;

if (std::__is_constant_evaluated())
{
for (size_t __i = 0; __i < __n; ++__i)
if (lt(__s1[__i], __s2[__i]))
return -1;
else if (lt(__s2[__i], __s1[__i]))
return 1;
return 0;
}

return __builtin_memcmp(s1, s2, __n);

}

static constexpr size_t

length(const char_type* __s)
{
if (std::__is_constant_evaluated())
return __gnu_cxx::char_traits<char_type>::length(__s);

return __builtin_strlen(__s);
}

static constexpr const char_type*

find(const char_type* __s, size_t __n, const char_type& __a)
{
if (__n == 0)
return 0;

if (std::__is_constant_evaluated())
return __gnu_cxx::char_traits<char_type>::find(__s, __n, __a);

return static_cast<const char_type*>(__builtin_memchr(s, a, __n));

}

static constexpr char_type*

move(char_type* __s1, const char_type* __s2, size_t __n)
{
if (__n == 0)
return __s1;

if (std::__is_constant_evaluated())
return __gnu_cxx::char_traits<char_type>::move(__s1, __s2, __n);

return static_cast<char_type*>(__builtin_memmove(s1, s2, __n));

}

static constexpr char_type*

copy(char_type* __s1, const char_type* __s2, size_t __n)
{
if (__n == 0)
return __s1;

if (std::__is_constant_evaluated())
return __gnu_cxx::char_traits<char_type>::copy(__s1, __s2, __n);

return static_cast<char_type*>(__builtin_memcpy(s1, s2, __n));

}

static constexpr char_type*

assign(char_type* __s, size_t __n, char_type __a)
{
if (__n == 0)
return __s;

if (std::__is_constant_evaluated())
return __gnu_cxx::char_traits<char_type>::assign(__s, __n, __a);

return static_cast<char_type*>(__builtin_memset(s, a, __n));

}

static constexpr char_type

to_char_type(const int_type& __c) noexcept
{ return static_cast<char_type>(__c); }
static constexpr int_type
to_int_type(const char_type& __c) noexcept
{ return static_cast<int_type>(static_cast<unsigned char>(__c)); }

static constexpr bool

eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
{ return __c1 == __c2; }

static constexpr int_type

eof() noexcept
{ return static_cast<int_type>(-1); }

static constexpr int_type

not_eof(const int_type& __c) noexcept
{ return (__c == eof()) ? 0 : __c; }

};

template<>
struct char_traits<wchar_t>
{
typedef wchar_t char_type;
typedef wint_t int_type;

typedef streamoff off_type;

typedef wstreampos pos_type;
typedef mbstate_t state_type;

using comparison_category = strong_ordering;

static constexpr void

assign(char_type& __c1, const char_type& __c2) noexcept
{

if (std::__is_constant_evaluated())
std::construct_at(__builtin_addressof(__c1), __c2);
else

__c1 = __c2;
}

static constexpr bool

eq(const char_type& __c1, const char_type& __c2) noexcept
{ return __c1 == __c2; }

static constexpr bool

lt(const char_type& __c1, const char_type& __c2) noexcept
{ return __c1 < __c2; }

static constexpr int

compare(const char_type* __s1, const char_type* __s2, size_t __n)
{
if (__n == 0)
return 0;

if (std::__is_constant_evaluated())
return __gnu_cxx::char_traits<char_type>::compare(__s1, __s2, __n);

return wmemcmp(s1, s2, __n);

}

static constexpr size_t

length(const char_type* __s)
{

if (std::__is_constant_evaluated())
return __gnu_cxx::char_traits<char_type>::length(__s);

return wcslen(__s);
}

static constexpr const char_type*

find(const char_type* __s, size_t __n, const char_type& __a)
{
if (__n == 0)
return 0;

if (std::__is_constant_evaluated())
return __gnu_cxx::char_traits<char_type>::find(__s, __n, __a);

return wmemchr(s, a, __n);

}

static constexpr char_type*

move(char_type* __s1, const char_type* __s2, size_t __n)
{
if (__n == 0)
return __s1;

if (std::__is_constant_evaluated())
return __gnu_cxx::char_traits<char_type>::move(__s1, __s2, __n);

return wmemmove(s1, s2, __n);

}

static constexpr char_type*

copy(char_type* __s1, const char_type* __s2, size_t __n)
{
if (__n == 0)
return __s1;

if (std::__is_constant_evaluated())
return __gnu_cxx::char_traits<char_type>::copy(__s1, __s2, __n);

return wmemcpy(s1, s2, __n);

}

static constexpr char_type*

assign(char_type* __s, size_t __n, char_type __a)
{
if (__n == 0)
return __s;

static constexpr void

assign(char_type& __c1, const char_type& __c2) noexcept
{

if (std::__is_constant_evaluated())
std::construct_at(__builtin_addressof(__c1), __c2);
else
__c1 = __c2;
}

static constexpr bool

eq(const char_type& __c1, const char_type& __c2) noexcept
{ return __c1 == __c2; }

static constexpr bool

lt(const char_type& __c1, const char_type& __c2) noexcept
{ return __c1 < __c2; }

static constexpr int

compare(const char_type* __s1, const char_type* __s2, size_t __n)
{
if (__n == 0)
return 0;

if (std::__is_constant_evaluated())
return __gnu_cxx::char_traits<char_type>::compare(__s1, __s2, __n);

return __builtin_memcmp(s1, s2, __n);

}

static constexpr size_t

length(const char_type* __s)
{

if (std::__is_constant_evaluated())
return __gnu_cxx::char_traits<char_type>::length(__s);

size_t __i = 0;
while (!eq(__s[__i], char_type()))
++__i;
return __i;
}

static constexpr const char_type*

find(const char_type* __s, size_t __n, const char_type& __a)
{
if (__n == 0)
return 0;

if (std::__is_constant_evaluated())
return __gnu_cxx::char_traits<char_type>::find(__s, __n, __a);

return static_cast<const char_type*>(__builtin_memchr(s, a, __n));

}

static constexpr char_type*

move(char_type* __s1, const char_type* __s2, size_t __n)
{
if (__n == 0)
return __s1;

if (std::__is_constant_evaluated())
return __gnu_cxx::char_traits<char_type>::move(__s1, __s2, __n);

return static_cast<char_type*>(__builtin_memmove(s1, s2, __n));

}
static constexpr char_type*
copy(char_type* __s1, const char_type* __s2, size_t __n)
{
if (__n == 0)
return __s1;

if (std::__is_constant_evaluated())
return __gnu_cxx::char_traits<char_type>::copy(__s1, __s2, __n);

return static_cast<char_type*>(__builtin_memcpy(s1, s2, __n));

}

static constexpr char_type*

assign(char_type* __s, size_t __n, char_type __a)
{
if (__n == 0)
return __s;

not_eof(const int_type& __c) noexcept
{ return eq_int_type(__c, eof()) ? 0 : __c; }

};

namespace std
{

template<>
struct char_traits<char16_t>
{
typedef char16_t char_type;

typedef short unsigned int int_type;

typedef streamoff off_type;

typedef u16streampos pos_type;
typedef mbstate_t state_type;

using comparison_category = strong_ordering;

static constexpr void

assign(char_type& __c1, const char_type& __c2) noexcept
{

if (std::__is_constant_evaluated())
std::construct_at(__builtin_addressof(__c1), __c2);
else

__c1 = __c2;
}

static constexpr bool

eq(const char_type& __c1, const char_type& __c2) noexcept
{ return __c1 == __c2; }

static constexpr bool

lt(const char_type& __c1, const char_type& __c2) noexcept
{ return __c1 < __c2; }

static constexpr int

compare(const char_type* __s1, const char_type* __s2, size_t __n)
{
for (size_t __i = 0; __i < __n; ++__i)
if (lt(__s1[__i], __s2[__i]))
return -1;
else if (lt(__s2[__i], __s1[__i]))
return 1;
return 0;
}

static constexpr size_t

length(const char_type* __s)
{
size_t __i = 0;
while (!eq(__s[__i], char_type()))
++__i;
return __i;
}

static constexpr const char_type*

find(const char_type* __s, size_t __n, const char_type& __a)
{
for (size_t __i = 0; __i < __n; ++__i)
if (eq(__s[__i], __a))
return __s + __i;
return 0;
}

static constexpr char_type*

move(char_type* __s1, const char_type* __s2, size_t __n)
{
if (__n == 0)
return __s1;

if (std::__is_constant_evaluated())
return __gnu_cxx::char_traits<char_type>::move(__s1, __s2, __n);

return (static_cast<char_type*>
(__builtin_memmove(__s1, __s2, __n * sizeof(char_type))));
}

static constexpr char_type*

copy(char_type* __s1, const char_type* __s2, size_t __n)
{
if (__n == 0)
return __s1;

if (std::__is_constant_evaluated())
return __gnu_cxx::char_traits<char_type>::copy(__s1, __s2, __n);

return (static_cast<char_type*>
(__builtin_memcpy(__s1, __s2, __n * sizeof(char_type))));
}

static constexpr char_type*

assign(char_type* __s, size_t __n, char_type __a)
{
for (size_t __i = 0; __i < __n; ++__i)
assign(__s[__i], __a);
return __s;
}

static constexpr char_type

to_char_type(const int_type& __c) noexcept
{ return char_type(__c); }

static constexpr bool

eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
{ return __c1 == __c2; }

static constexpr int_type

to_int_type(const char_type& __c) noexcept
{ return __c == eof() ? int_type(0xfffd) : int_type(__c); }

static constexpr int_type

eof() noexcept
{ return static_cast<int_type>(-1); }

static constexpr int_type

not_eof(const int_type& __c) noexcept
{ return eq_int_type(__c, eof()) ? 0 : __c; }

};

template<>
struct char_traits<char32_t>
{
typedef char32_t char_type;

typedef unsigned int int_type;

typedef streamoff off_type;

typedef u32streampos pos_type;
typedef mbstate_t state_type;

using comparison_category = strong_ordering;

static constexpr void

assign(char_type& __c1, const char_type& __c2) noexcept
{

if (std::__is_constant_evaluated())
std::construct_at(__builtin_addressof(__c1), __c2);
else

__c1 = __c2;
}

static constexpr bool

eq(const char_type& __c1, const char_type& __c2) noexcept
{ return __c1 == __c2; }

static constexpr bool

lt(const char_type& __c1, const char_type& __c2) noexcept
{ return __c1 < __c2; }

static constexpr int

static constexpr size_t

length(const char_type* __s)
{
size_t __i = 0;
while (!eq(__s[__i], char_type()))
++__i;
return __i;
}

static constexpr const char_type*

find(const char_type* __s, size_t __n, const char_type& __a)
{
for (size_t __i = 0; __i < __n; ++__i)
if (eq(__s[__i], __a))
return __s + __i;
return 0;
}

static constexpr char_type*

move(char_type* __s1, const char_type* __s2, size_t __n)
{
if (__n == 0)
return __s1;

if (std::__is_constant_evaluated())
return __gnu_cxx::char_traits<char_type>::move(__s1, __s2, __n);

return (static_cast<char_type*>
(__builtin_memmove(__s1, __s2, __n * sizeof(char_type))));
}

static constexpr char_type*

copy(char_type* __s1, const char_type* __s2, size_t __n)
{
if (__n == 0)
return __s1;

if (std::__is_constant_evaluated())
return __gnu_cxx::char_traits<char_type>::copy(__s1, __s2, __n);

return (static_cast<char_type*>
(__builtin_memcpy(__s1, __s2, __n * sizeof(char_type))));
}

static constexpr char_type*

assign(char_type* __s, size_t __n, char_type __a)
{
for (size_t __i = 0; __i < __n; ++__i)
assign(__s[__i], __a);
return __s;
}

static constexpr char_type

to_char_type(const int_type& __c) noexcept
{ return char_type(__c); }

static constexpr int_type

to_int_type(const char_type& __c) noexcept
{ return int_type(__c); }

static constexpr bool

eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
{ return __c1 == __c2; }

static constexpr int_type

eof() noexcept
{ return static_cast<int_type>(-1); }

static constexpr int_type

not_eof(const int_type& __c) noexcept
{ return eq_int_type(__c, eof()) ? 0 : __c; }

};

namespace __detail
{
template<typename _ChTraits>
constexpr auto
__char_traits_cmp_cat(int __cmp) noexcept
{
if constexpr (requires { typename _ChTraits::comparison_category; })
{
using _Cat = typename _ChTraits::comparison_category;
static_assert( !is_void_v<common_comparison_category_t<_Cat>> );
return static_cast<_Cat>(__cmp <=> 0);
}
else
return static_cast<weak_ordering>(__cmp <=> 0);
}
}

#pragma GCC diagnostic pop

}
# 43 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/string" 2 3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/allocator.h" 1 3
# 46 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/allocator.h" 3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/x86_64-w64-mingw32/bits/c+
+allocator.h" 1 3
# 33 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/x86_64-w64-mingw32/bits/c+
+allocator.h" 3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/new_allocator.h" 1 3
# 41 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/new_allocator.h" 3
namespace std
{

# 62 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/new_allocator.h" 3
template<typename _Tp>
class __new_allocator
{
public:
typedef _Tp value_type;
typedef std::size_t size_type;
typedef std::ptrdiff_t difference_type;
# 83 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/new_allocator.h" 3
typedef std::true_type propagate_on_container_move_assignment;
__attribute__((__always_inline__))
constexpr
__new_allocator() noexcept { }

__attribute__((__always_inline__))
constexpr
__new_allocator(const __new_allocator&) noexcept { }

template<typename _Tp1>
__attribute__((__always_inline__))
constexpr
__new_allocator(const __new_allocator<_Tp1>&) noexcept { }

__new_allocator& operator=(const __new_allocator&) = default;

# 125 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/new_allocator.h" 3
[[__nodiscard__]] _Tp*
allocate(size_type __n, const void* = static_cast<const void*>(0))
{

static_assert(sizeof(_Tp) != 0, "cannot allocate incomplete types");

if (__builtin_expect(__n > this->_M_max_size(), false))

{

if (__n > (std::size_t(-1) / sizeof(_Tp)))

std::__throw_bad_array_new_length();
std::__throw_bad_alloc();
}

if (alignof(_Tp) > 16)

{
std::align_val_t __al = std::align_val_t(alignof(_Tp));
return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp),
__al));
}

return static_cast<_Tp>(::operator new(__n sizeof(_Tp)));

}

void
deallocate(_Tp* __p, size_type __n __attribute__ ((__unused__)))
{

if (alignof(_Tp) > 16)

{
::operator delete((__p), (__n) * sizeof(_Tp),
std::align_val_t(alignof(_Tp)));
return;
}

::operator delete((p), (n) * sizeof(_Tp));

}
# 213 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/new_allocator.h" 3
template<typename _Up>
friend __attribute__((__always_inline__)) constexpr bool
operator==(const __new_allocator&, const __new_allocator<_Up>&)
noexcept
{ return true; }
# 227 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/new_allocator.h" 3
private:
__attribute__((__always_inline__))
constexpr size_type
_M_max_size() const noexcept
{

return std::size_t(0x7fffffffffffffffLL) / sizeof(_Tp);

}
};

}
# 34 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/x86_64-w64-mingw32/bits/c+
+allocator.h" 2 3

namespace std
{
# 46 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/x86_64-w64-mingw32/bits/c+
+allocator.h" 3
template<typename _Tp>
using __allocator_base = __new_allocator<_Tp>;
}
# 47 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/allocator.h" 2 3

namespace std
{

# 72 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/allocator.h" 3
template<>
class allocator<void>
{
public:
typedef void value_type;
typedef size_t size_type;
typedef ptrdiff_t difference_type;
# 93 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/allocator.h" 3
using propagate_on_container_move_assignment = true_type;
using is_always_equal
__attribute__ ((__deprecated__ ("use '" "std::allocator_traits::is_always_equal"
"' instead")))
= true_type;

allocator() = default;
~allocator() = default;

template<typename _Up>
__attribute__((__always_inline__))
constexpr
allocator(const allocator<_Up>&) noexcept { }

};
# 127 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/allocator.h" 3
template<typename _Tp>
class allocator : public __allocator_base<_Tp>
{
public:
typedef _Tp value_type;
typedef size_t size_type;
typedef ptrdiff_t difference_type;
# 150 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/allocator.h" 3
using propagate_on_container_move_assignment = true_type;

using is_always_equal
__attribute__ ((__deprecated__ ("use '" "std::allocator_traits::is_always_equal"
"' instead")))
= true_type;

__attribute__((__always_inline__))
constexpr
allocator() noexcept { }

__attribute__((__always_inline__))
constexpr
allocator(const allocator& __a) noexcept
: __allocator_base<_Tp>(__a) { }

allocator& operator=(const allocator&) = default;

template<typename _Tp1>
__attribute__((__always_inline__))
constexpr
allocator(const allocator<_Tp1>&) noexcept { }

__attribute__((__always_inline__))

constexpr

~allocator() noexcept { }

[[nodiscard,__gnu__::__always_inline__]]
constexpr _Tp*
allocate(size_t __n)
{
if (std::__is_constant_evaluated())
{
if (__builtin_mul_overflow(__n, sizeof(_Tp), &__n))
std::__throw_bad_array_new_length();
return static_cast<_Tp*>(::operator new(__n));
}

return __allocator_base<_Tp>::allocate(__n, 0);

}

[[__gnu__::__always_inline__]]
constexpr void
deallocate(_Tp* __p, size_t __n)
{
if (std::__is_constant_evaluated())
{
::operator delete(__p);
return;
}
__allocator_base<_Tp>::deallocate(__p, __n);
}

friend attribute((__always_inline__)) constexpr

bool
operator==(const allocator&, const allocator&) noexcept
{ return true; }
# 225 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/allocator.h" 3
};

template<typename _T1, typename _T2>

__attribute__((__always_inline__))
inline constexpr bool
operator==(const allocator<_T1>&, const allocator<_T2>&)
noexcept
{ return true; }
# 252 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/allocator.h" 3
template<typename _Tp>
class allocator<const _Tp>
{
public:
typedef _Tp value_type;
allocator() { }
template<typename _Up> allocator(const allocator<_Up>&) { }
};

template<typename _Tp>
class allocator<volatile _Tp>
{
public:
typedef _Tp value_type;
allocator() { }
template<typename _Up> allocator(const allocator<_Up>&) { }
};

template<typename _Tp>
class allocator<const volatile _Tp>
{
public:
typedef _Tp value_type;
allocator() { }
template<typename _Up> allocator(const allocator<_Up>&) { }
};

extern template class allocator<char>;

extern template class allocator<wchar_t>;

}
# 44 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/string" 2 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/ostream_insert.h" 1 3
# 33 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/ostream_insert.h" 3

# 34 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/ostream_insert.h" 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/cxxabi_forced.h" 1 3
# 34 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/cxxabi_forced.h" 3

# 35 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/cxxabi_forced.h" 3

#pragma GCC visibility push(default)

namespace __cxxabiv1
{
class __forced_unwind
{
virtual ~__forced_unwind() throw();

virtual void __pure_dummy() = 0;

};
}

#pragma GCC visibility pop

# 37 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/ostream_insert.h" 2 3

namespace std
{

template<typename _CharT, typename _Traits>

inline void
__ostream_write(basic_ostream<_CharT, _Traits>& __out,
const _CharT* __s, streamsize __n)
{
typedef basic_ostream<_CharT, _Traits> __ostream_type;
typedef typename __ostream_type::ios_base __ios_base;

const streamsize put = out.rdbuf()->sputn(s, n);

if (__put != __n)
__out.setstate(__ios_base::badbit);
}

template<typename _CharT, typename _Traits>

inline void
__ostream_fill(basic_ostream<_CharT, _Traits>& __out, streamsize __n)
{
typedef basic_ostream<_CharT, _Traits> __ostream_type;
typedef typename __ostream_type::ios_base __ios_base;

const _CharT c = out.fill();

for (; __n > 0; --__n)
{
const typename _Traits::int_type __put = __out.rdbuf()->sputc(__c);
if (_Traits::eq_int_type(__put, _Traits::eof()))
{
__out.setstate(__ios_base::badbit);
break;
}
}
}

template<typename _CharT, typename _Traits>

basic_ostream<_CharT, _Traits>&
__ostream_insert(basic_ostream<_CharT, _Traits>& __out,
const _CharT* __s, streamsize __n)
{
typedef basic_ostream<_CharT, _Traits> __ostream_type;
typedef typename __ostream_type::ios_base __ios_base;

typename __ostream_type::sentry cerb(out);

if (__cerb)
{
try
{
const streamsize __w = __out.width();
if (__w > __n)
{
const bool __left = ((__out.flags()
& __ios_base::adjustfield)
== __ios_base::left);
if (!__left)
__ostream_fill(__out, __w - __n);
if (__out.good())
__ostream_write(__out, __s, __n);
if (__left && __out.good())
__ostream_fill(__out, __w - __n);
}
else
__ostream_write(__out, __s, __n);
__out.width(0);
}
catch(__cxxabiv1::__forced_unwind&)
{
__out._M_setstate(__ios_base::badbit);
throw;
}
catch(...)
{ __out._M_setstate(__ios_base::badbit); }
}
return __out;
}

extern template ostream& __ostream_insert(ostream&, const char*, streamsize);

extern template wostream& __ostream_insert(wostream&, const wchar_t*,

streamsize);

}
# 47 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/string" 2 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_function.h" 1 3
# 63 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_function.h" 3
namespace std
{

# 116 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_function.h" 3
template<typename _Arg, typename _Result>
struct unary_function
{

typedef _Arg argument_type;

template<typename _Tp>
struct minus : public binary_function<_Tp, _Tp, _Tp>
{
constexpr
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x - __y; }
};

template<typename _Tp>
struct multiplies : public binary_function<_Tp, _Tp, _Tp>
{
constexpr
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x * __y; }
};

template<typename _Tp>
struct divides : public binary_function<_Tp, _Tp, _Tp>
{
constexpr
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x / __y; }
};

template<typename _Tp>
struct modulus : public binary_function<_Tp, _Tp, _Tp>
{
constexpr
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x % __y; }
};

template<typename _Tp>
struct negate : public unary_function<_Tp, _Tp>
{
constexpr
_Tp
operator()(const _Tp& __x) const
{ return -__x; }
};
#pragma GCC diagnostic pop
template<>
struct plus<void>
{
template <typename _Tp, typename _Up>
constexpr
auto
operator()(_Tp&& __t, _Up&& __u) const
noexcept(noexcept(std::forward<_Tp>(__t) + std::forward<_Up>(__u)))
-> decltype(std::forward<_Tp>(__t) + std::forward<_Up>(__u))
{ return std::forward<_Tp>(__t) + std::forward<_Up>(__u); }

typedef __is_transparent is_transparent;

};

template<>
struct minus<void>
{
template <typename _Tp, typename _Up>
constexpr
auto
operator()(_Tp&& __t, _Up&& __u) const
noexcept(noexcept(std::forward<_Tp>(__t) - std::forward<_Up>(__u)))
-> decltype(std::forward<_Tp>(__t) - std::forward<_Up>(__u))
{ return std::forward<_Tp>(__t) - std::forward<_Up>(__u); }

typedef __is_transparent is_transparent;

};

template<>
struct multiplies<void>
{
template <typename _Tp, typename _Up>
constexpr
auto
operator()(_Tp&& __t, _Up&& __u) const
noexcept(noexcept(std::forward<_Tp>(__t) * std::forward<_Up>(__u)))
-> decltype(std::forward<_Tp>(__t) * std::forward<_Up>(__u))
{ return std::forward<_Tp>(__t) * std::forward<_Up>(__u); }

typedef __is_transparent is_transparent;

};

template<>
struct divides<void>
{
template <typename _Tp, typename _Up>
constexpr
auto
operator()(_Tp&& __t, _Up&& __u) const
noexcept(noexcept(std::forward<_Tp>(__t) / std::forward<_Up>(__u)))
-> decltype(std::forward<_Tp>(__t) / std::forward<_Up>(__u))
{ return std::forward<_Tp>(__t) / std::forward<_Up>(__u); }

typedef __is_transparent is_transparent;

};
template<>
struct modulus<void>
{
template <typename _Tp, typename _Up>
constexpr
auto
operator()(_Tp&& __t, _Up&& __u) const
noexcept(noexcept(std::forward<_Tp>(__t) % std::forward<_Up>(__u)))
-> decltype(std::forward<_Tp>(__t) % std::forward<_Up>(__u))
{ return std::forward<_Tp>(__t) % std::forward<_Up>(__u); }

typedef __is_transparent is_transparent;

};

template<typename _Tp>
struct not_equal_to : public binary_function<_Tp, _Tp, bool>
{
constexpr
bool
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x != __y; }
};

template<typename _Tp>
struct greater : public binary_function<_Tp, _Tp, bool>
{
constexpr
bool
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x > __y; }
};

template<typename _Tp>
struct less : public binary_function<_Tp, _Tp, bool>
{
constexpr
bool
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x < __y; }
};

template<typename _Tp>
struct greater_equal : public binary_function<_Tp, _Tp, bool>
{
constexpr
bool
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x >= __y; }
};

template<typename _Tp>
struct less_equal : public binary_function<_Tp, _Tp, bool>
{
constexpr
bool
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x <= __y; }
};

template<typename _Tp>
struct greater<_Tp*> : public binary_function<_Tp*, _Tp*, bool>
{
constexpr bool
operator()(_Tp* __x, _Tp* __y) const noexcept
{

if (std::__is_constant_evaluated())
return __x > __y;

return (long long unsigned int)__x > (long long unsigned int)__y;
}
};

template<typename _Tp>
struct less<_Tp*> : public binary_function<_Tp*, _Tp*, bool>
{
constexpr bool
operator()(_Tp* __x, _Tp* __y) const noexcept
{

if (std::__is_constant_evaluated())
return __x < __y;

return (long long unsigned int)__x < (long long unsigned int)__y;
}
};

template<typename _Tp>
struct greater_equal<_Tp*> : public binary_function<_Tp*, _Tp*, bool>
{
constexpr bool
operator()(_Tp* __x, _Tp* __y) const noexcept
{

if (std::__is_constant_evaluated())
return __x >= __y;

return (long long unsigned int)__x >= (long long unsigned int)__y;
}
};

template<typename _Tp>
struct less_equal<_Tp*> : public binary_function<_Tp*, _Tp*, bool>
{
constexpr bool
operator()(_Tp* __x, _Tp* __y) const noexcept
{

if (std::__is_constant_evaluated())
return __x <= __y;

return (long long unsigned int)__x <= (long long unsigned int)__y;
}
};
#pragma GCC diagnostic pop

template<>
struct equal_to<void>
{
template <typename _Tp, typename _Up>
constexpr auto
operator()(_Tp&& __t, _Up&& __u) const
noexcept(noexcept(std::forward<_Tp>(__t) == std::forward<_Up>(__u)))
-> decltype(std::forward<_Tp>(__t) == std::forward<_Up>(__u))
{ return std::forward<_Tp>(__t) == std::forward<_Up>(__u); }

typedef __is_transparent is_transparent;

};

template<>
struct not_equal_to<void>
{
template <typename _Tp, typename _Up>
constexpr auto
operator()(_Tp&& __t, _Up&& __u) const
noexcept(noexcept(std::forward<_Tp>(__t) != std::forward<_Up>(__u)))
-> decltype(std::forward<_Tp>(__t) != std::forward<_Up>(__u))
{ return std::forward<_Tp>(__t) != std::forward<_Up>(__u); }

typedef __is_transparent is_transparent;

};

template<>
struct greater<void>
{
template <typename _Tp, typename _Up>
constexpr auto
operator()(_Tp&& __t, _Up&& __u) const
noexcept(noexcept(std::forward<_Tp>(__t) > std::forward<_Up>(__u)))
-> decltype(std::forward<_Tp>(__t) > std::forward<_Up>(__u))
{
return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u),
__ptr_cmp<_Tp, _Up>{});
}

template<typename _Tp, typename _Up>

constexpr bool
operator()(_Tp* __t, _Up* __u) const noexcept
{ return greater<common_type_t<_Tp*, _Up*>>{}(__t, __u); }

typedef __is_transparent is_transparent;

private:
template <typename _Tp, typename _Up>
static constexpr decltype(auto)
_S_cmp(_Tp&& __t, _Up&& __u, false_type)
{ return std::forward<_Tp>(__t) > std::forward<_Up>(__u); }

template <typename _Tp, typename _Up>

static constexpr bool
_S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept
{
return greater<const volatile void*>{}(
static_cast<const volatile void*>(std::forward<_Tp>(__t)),
static_cast<const volatile void*>(std::forward<_Up>(__u)));
}

template<typename _Tp, typename _Up, typename = void>

struct __not_overloaded2 : true_type { };

template<typename _Tp, typename _Up>

struct __not_overloaded2<_Tp, _Up, __void_t<
decltype(std::declval<_Tp>().operator>(std::declval<_Up>()))>>
: false_type { };

template<typename _Tp, typename _Up, typename = void>

struct __not_overloaded : __not_overloaded2<_Tp, _Up> { };

template<typename _Tp, typename _Up>

struct __not_overloaded<_Tp, _Up, __void_t<
decltype(operator>(std::declval<_Tp>(), std::declval<_Up>()))>>
: false_type { };

template<typename _Tp, typename _Up>

using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>,
is_convertible<_Tp, const volatile void*>,
is_convertible<_Up, const volatile void*>>;
};

template<>
struct less<void>
{
template <typename _Tp, typename _Up>
constexpr auto
operator()(_Tp&& __t, _Up&& __u) const
noexcept(noexcept(std::forward<_Tp>(__t) < std::forward<_Up>(__u)))
-> decltype(std::forward<_Tp>(__t) < std::forward<_Up>(__u))
{
return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u),
__ptr_cmp<_Tp, _Up>{});
}

template<typename _Tp, typename _Up>

constexpr bool
operator()(_Tp* __t, _Up* __u) const noexcept
{ return less<common_type_t<_Tp*, _Up*>>{}(__t, __u); }

typedef __is_transparent is_transparent;

private:
template <typename _Tp, typename _Up>
static constexpr decltype(auto)
_S_cmp(_Tp&& __t, _Up&& __u, false_type)
{ return std::forward<_Tp>(__t) < std::forward<_Up>(__u); }

template <typename _Tp, typename _Up>

static constexpr bool
_S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept
{
return less<const volatile void*>{}(
static_cast<const volatile void*>(std::forward<_Tp>(__t)),
static_cast<const volatile void*>(std::forward<_Up>(__u)));
}

template<typename _Tp, typename _Up, typename = void>

struct __not_overloaded2 : true_type { };

template<typename _Tp, typename _Up>

struct __not_overloaded2<_Tp, _Up, __void_t<
decltype(std::declval<_Tp>().operator<(std::declval<_Up>()))>>
: false_type { };

template<typename _Tp, typename _Up, typename = void>

struct __not_overloaded : __not_overloaded2<_Tp, _Up> { };

template<typename _Tp, typename _Up>

struct __not_overloaded<_Tp, _Up, __void_t<
decltype(operator<(std::declval<_Tp>(), std::declval<_Up>()))>>
: false_type { };

template<typename _Tp, typename _Up>

using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>,
is_convertible<_Tp, const volatile void*>,
is_convertible<_Up, const volatile void*>>;
};

template<>
struct greater_equal<void>
{
template <typename _Tp, typename _Up>
constexpr auto
operator()(_Tp&& __t, _Up&& __u) const
noexcept(noexcept(std::forward<_Tp>(__t) >= std::forward<_Up>(__u)))
-> decltype(std::forward<_Tp>(__t) >= std::forward<_Up>(__u))
{
return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u),
__ptr_cmp<_Tp, _Up>{});
}

template<typename _Tp, typename _Up>

constexpr bool
operator()(_Tp* __t, _Up* __u) const noexcept
{ return greater_equal<common_type_t<_Tp*, _Up*>>{}(__t, __u); }

typedef __is_transparent is_transparent;

private:
template <typename _Tp, typename _Up>
static constexpr decltype(auto)
_S_cmp(_Tp&& __t, _Up&& __u, false_type)
{ return std::forward<_Tp>(__t) >= std::forward<_Up>(__u); }
template <typename _Tp, typename _Up>
static constexpr bool
_S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept
{
return greater_equal<const volatile void*>{}(
static_cast<const volatile void*>(std::forward<_Tp>(__t)),
static_cast<const volatile void*>(std::forward<_Up>(__u)));
}

template<typename _Tp, typename _Up, typename = void>

struct __not_overloaded2 : true_type { };

template<typename _Tp, typename _Up>

struct __not_overloaded2<_Tp, _Up, __void_t<
decltype(std::declval<_Tp>().operator>=(std::declval<_Up>()))>>
: false_type { };

template<typename _Tp, typename _Up, typename = void>

struct __not_overloaded : __not_overloaded2<_Tp, _Up> { };

template<typename _Tp, typename _Up>

struct __not_overloaded<_Tp, _Up, __void_t<
decltype(operator>=(std::declval<_Tp>(), std::declval<_Up>()))>>
: false_type { };

template<typename _Tp, typename _Up>

using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>,
is_convertible<_Tp, const volatile void*>,
is_convertible<_Up, const volatile void*>>;
};

template<>
struct less_equal<void>
{
template <typename _Tp, typename _Up>
constexpr auto
operator()(_Tp&& __t, _Up&& __u) const
noexcept(noexcept(std::forward<_Tp>(__t) <= std::forward<_Up>(__u)))
-> decltype(std::forward<_Tp>(__t) <= std::forward<_Up>(__u))
{
return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u),
__ptr_cmp<_Tp, _Up>{});
}

template<typename _Tp, typename _Up>

constexpr bool
operator()(_Tp* __t, _Up* __u) const noexcept
{ return less_equal<common_type_t<_Tp*, _Up*>>{}(__t, __u); }

typedef __is_transparent is_transparent;

private:
template <typename _Tp, typename _Up>
static constexpr decltype(auto)
_S_cmp(_Tp&& __t, _Up&& __u, false_type)
{ return std::forward<_Tp>(__t) <= std::forward<_Up>(__u); }

template <typename _Tp, typename _Up>

static constexpr bool
_S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept
{
return less_equal<const volatile void*>{}(
static_cast<const volatile void*>(std::forward<_Tp>(__t)),
static_cast<const volatile void*>(std::forward<_Up>(__u)));
}

template<typename _Tp, typename _Up, typename = void>

struct __not_overloaded2 : true_type { };

template<typename _Tp, typename _Up>

struct __not_overloaded2<_Tp, _Up, __void_t<
decltype(std::declval<_Tp>().operator<=(std::declval<_Up>()))>>
: false_type { };

template<typename _Tp, typename _Up, typename = void>

struct __not_overloaded : __not_overloaded2<_Tp, _Up> { };

template<typename _Tp, typename _Up>

struct __not_overloaded<_Tp, _Up, __void_t<
decltype(operator<=(std::declval<_Tp>(), std::declval<_Up>()))>>
: false_type { };

template<typename _Tp, typename _Up>

using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>,
is_convertible<_Tp, const volatile void*>,
is_convertible<_Up, const volatile void*>>;
};
# 778 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_function.h" 3
template<typename _Tp = void>
struct logical_and;

template<typename _Tp = void>

struct logical_or;

template<typename _Tp = void>

struct logical_not;

#pragma GCC diagnostic push

#pragma GCC diagnostic ignored "-Wdeprecated-declarations"

template<typename _Tp>
struct logical_and : public binary_function<_Tp, _Tp, bool>
{
constexpr
bool
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x && __y; }
};

template<typename _Tp>
struct logical_or : public binary_function<_Tp, _Tp, bool>
{
constexpr
bool
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x || __y; }
};

template<typename _Tp>
struct logical_not : public unary_function<_Tp, bool>
{
constexpr
bool
operator()(const _Tp& __x) const
{ return !__x; }
};
#pragma GCC diagnostic pop

template<>
struct logical_and<void>
{
template <typename _Tp, typename _Up>
constexpr
auto
operator()(_Tp&& __t, _Up&& __u) const
noexcept(noexcept(std::forward<_Tp>(__t) && std::forward<_Up>(__u)))
-> decltype(std::forward<_Tp>(__t) && std::forward<_Up>(__u))
{ return std::forward<_Tp>(__t) && std::forward<_Up>(__u); }

typedef __is_transparent is_transparent;

};

template<>
struct logical_or<void>
{
template <typename _Tp, typename _Up>
constexpr
auto
operator()(_Tp&& __t, _Up&& __u) const
noexcept(noexcept(std::forward<_Tp>(__t) || std::forward<_Up>(__u)))
-> decltype(std::forward<_Tp>(__t) || std::forward<_Up>(__u))
{ return std::forward<_Tp>(__t) || std::forward<_Up>(__u); }

typedef __is_transparent is_transparent;

};

#pragma GCC diagnostic ignored "-Wdeprecated-declarations"

template<typename _Tp>
struct bit_and : public binary_function<_Tp, _Tp, _Tp>
{
constexpr
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x & __y; }
};

template<typename _Tp>
struct bit_or : public binary_function<_Tp, _Tp, _Tp>
{
constexpr
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x | __y; }
};

template<typename _Tp>
struct bit_xor : public binary_function<_Tp, _Tp, _Tp>
{
constexpr
_Tp
operator()(const _Tp& __x, const _Tp& __y) const
{ return __x ^ __y; }
};

template<typename _Tp>
struct bit_not : public unary_function<_Tp, _Tp>
{
constexpr
_Tp
operator()(const _Tp& __x) const
{ return ~__x; }
};
#pragma GCC diagnostic pop

template <>
struct bit_and<void>
{
template <typename _Tp, typename _Up>
constexpr
auto
operator()(_Tp&& __t, _Up&& __u) const
noexcept(noexcept(std::forward<_Tp>(__t) & std::forward<_Up>(__u)))
-> decltype(std::forward<_Tp>(__t) & std::forward<_Up>(__u))
{ return std::forward<_Tp>(__t) & std::forward<_Up>(__u); }

typedef __is_transparent is_transparent;

};

template <>
struct bit_or<void>
{
template <typename _Tp, typename _Up>
constexpr
auto
operator()(_Tp&& __t, _Up&& __u) const
noexcept(noexcept(std::forward<_Tp>(__t) | std::forward<_Up>(__u)))
-> decltype(std::forward<_Tp>(__t) | std::forward<_Up>(__u))
{ return std::forward<_Tp>(__t) | std::forward<_Up>(__u); }

typedef __is_transparent is_transparent;

};

template <>
struct bit_xor<void>
{
template <typename _Tp, typename _Up>
constexpr
auto
operator()(_Tp&& __t, _Up&& __u) const
noexcept(noexcept(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u)))
-> decltype(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u))
{ return std::forward<_Tp>(__t) ^ std::forward<_Up>(__u); }

typedef __is_transparent is_transparent;

};

template <>
struct bit_not<void>
{
template <typename _Tp>
constexpr
auto
operator()(_Tp&& __t) const
noexcept(noexcept(~std::forward<_Tp>(__t)))
-> decltype(~std::forward<_Tp>(__t))
{ return ~std::forward<_Tp>(__t); }

typedef __is_transparent is_transparent;

};

#pragma GCC diagnostic push

#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
# 1020 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_function.h" 3
template<typename _Predicate>
class [[__deprecated__]] unary_negate
: public unary_function<typename _Predicate::argument_type, bool>
{
protected:
_Predicate _M_pred;

public:
constexpr
explicit
unary_negate(const _Predicate& __x) : _M_pred(__x) { }

constexpr
bool
operator()(const typename _Predicate::argument_type& __x) const
{ return !_M_pred(__x); }
};

template<typename _Predicate>
__attribute__ ((__deprecated__ ("use '" "std::not_fn" "' instead")))
constexpr
inline unary_negate<_Predicate>
not1(const _Predicate& __pred)
{ return unary_negate<_Predicate>(__pred); }

template<typename _Predicate>
class [[__deprecated__]] binary_negate
: public binary_function<typename _Predicate::first_argument_type,
typename _Predicate::second_argument_type, bool>
{
protected:
_Predicate _M_pred;

public:
constexpr
explicit
binary_negate(const _Predicate& __x) : _M_pred(__x) { }

constexpr
bool
operator()(const typename _Predicate::first_argument_type& __x,
const typename _Predicate::second_argument_type& __y) const
{ return !_M_pred(__x, __y); }
};
template<typename _Predicate>
__attribute__ ((__deprecated__ ("use '" "std::not_fn" "' instead")))
constexpr
inline binary_negate<_Predicate>
not2(const _Predicate& __pred)
{ return binary_negate<_Predicate>(__pred); }
# 1101 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_function.h" 3
template<typename _Arg, typename _Result>
class pointer_to_unary_function : public unary_function<_Arg, _Result>
{
protected:
_Result (*_M_ptr)(_Arg);

public:
pointer_to_unary_function() { }

explicit
pointer_to_unary_function(_Result (*__x)(_Arg))
: _M_ptr(__x) { }

_Result
operator()(_Arg __x) const
{ return _M_ptr(__x); }
} __attribute__ ((__deprecated__));

template<typename _Arg, typename _Result>

__attribute__ ((__deprecated__ ("use '" "std::function" "' instead")))
inline pointer_to_unary_function<_Arg, _Result>
ptr_fun(_Result (*__x)(_Arg))
{ return pointer_to_unary_function<_Arg, _Result>(__x); }

template<typename _Arg1, typename _Arg2, typename _Result>

class pointer_to_binary_function
: public binary_function<_Arg1, _Arg2, _Result>
{
protected:
_Result (*_M_ptr)(_Arg1, _Arg2);

public:
pointer_to_binary_function() { }

explicit
pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2))
: _M_ptr(__x) { }

_Result
operator()(_Arg1 __x, _Arg2 __y) const
{ return _M_ptr(__x, __y); }
} __attribute__ ((__deprecated__));

template<typename _Arg1, typename _Arg2, typename _Result>

__attribute__ ((__deprecated__ ("use '" "std::function" "' instead")))
inline pointer_to_binary_function<_Arg1, _Arg2, _Result>
ptr_fun(_Result (*__x)(_Arg1, _Arg2))
{ return pointer_to_binary_function<_Arg1, _Arg2, _Result>(__x); }
template<typename _Tp>
struct _Identity
: public unary_function<_Tp, _Tp>
{
_Tp&
operator()(_Tp& __x) const
{ return __x; }

const _Tp&
operator()(const _Tp& __x) const
{ return __x; }
};

template<typename _Tp> struct _Identity<const _Tp> : _Identity<_Tp> { };

template<typename _Pair>
struct _Select1st
: public unary_function<_Pair, typename _Pair::first_type>
{
typename _Pair::first_type&
operator()(_Pair& __x) const
{ return __x.first; }

const typename _Pair::first_type&

operator()(const _Pair& __x) const
{ return __x.first; }

template<typename _Pair2>
typename _Pair2::first_type&
operator()(_Pair2& __x) const
{ return __x.first; }

template<typename _Pair2>
const typename _Pair2::first_type&
operator()(const _Pair2& __x) const
{ return __x.first; }

};

template<typename _Pair>
struct _Select2nd
: public unary_function<_Pair, typename _Pair::second_type>
{
typename _Pair::second_type&
operator()(_Pair& __x) const
{ return __x.second; }

const typename _Pair::second_type&

operator()(const _Pair& __x) const
{ return __x.second; }
};
# 1228 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_function.h" 3
template<typename _Ret, typename _Tp>
class mem_fun_t : public unary_function<_Tp*, _Ret>
{
public:
explicit
mem_fun_t(_Ret (_Tp::*__pf)())
: _M_f(__pf) { }

_Ret
operator()(_Tp* __p) const
{ return (__p->*_M_f)(); }

private:
_Ret (_Tp::*_M_f)();
} __attribute__ ((__deprecated__));

template<typename _Ret, typename _Tp>

class const_mem_fun_t : public unary_function<const _Tp*, _Ret>
{
public:
explicit
const_mem_fun_t(_Ret (_Tp::*__pf)() const)
: _M_f(__pf) { }

_Ret
operator()(const _Tp* __p) const
{ return (__p->*_M_f)(); }

private:
_Ret (_Tp::*_M_f)() const;
} __attribute__ ((__deprecated__));

template<typename _Ret, typename _Tp>

class mem_fun_ref_t : public unary_function<_Tp, _Ret>
{
public:
explicit
mem_fun_ref_t(_Ret (_Tp::*__pf)())
: _M_f(__pf) { }

_Ret
operator()(_Tp& __r) const
{ return (__r.*_M_f)(); }

private:
_Ret (_Tp::*_M_f)();
} __attribute__ ((__deprecated__));

template<typename _Ret, typename _Tp>

class const_mem_fun_ref_t : public unary_function<_Tp, _Ret>
{
public:
explicit
const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const)
: _M_f(__pf) { }

_Ret
operator()(const _Tp& __r) const
{ return (__r.*_M_f)(); }
private:
_Ret (_Tp::*_M_f)() const;
} __attribute__ ((__deprecated__));

template<typename _Ret, typename _Tp, typename _Arg>

class mem_fun1_t : public binary_function<_Tp*, _Arg, _Ret>
{
public:
explicit
mem_fun1_t(_Ret (_Tp::*__pf)(_Arg))
: _M_f(__pf) { }

_Ret
operator()(_Tp* __p, _Arg __x) const
{ return (__p->*_M_f)(__x); }

private:
_Ret (_Tp::*_M_f)(_Arg);
} __attribute__ ((__deprecated__));

template<typename _Ret, typename _Tp, typename _Arg>

class const_mem_fun1_t : public binary_function<const _Tp*, _Arg, _Ret>
{
public:
explicit
const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const)
: _M_f(__pf) { }

_Ret
operator()(const _Tp* __p, _Arg __x) const
{ return (__p->*_M_f)(__x); }

private:
_Ret (_Tp::*_M_f)(_Arg) const;
} __attribute__ ((__deprecated__));

template<typename _Ret, typename _Tp, typename _Arg>

class mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
{
public:
explicit
mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg))
: _M_f(__pf) { }

_Ret
operator()(_Tp& __r, _Arg __x) const
{ return (__r.*_M_f)(__x); }

private:
_Ret (_Tp::*_M_f)(_Arg);
} __attribute__ ((__deprecated__));

template<typename _Ret, typename _Tp, typename _Arg>

class const_mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
{
public:
explicit
const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const)
: _M_f(__pf) { }

_Ret
operator()(const _Tp& __r, _Arg __x) const
{ return (__r.*_M_f)(__x); }

private:
_Ret (_Tp::*_M_f)(_Arg) const;
} __attribute__ ((__deprecated__));

template<typename _Ret, typename _Tp>

__attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead")))
inline mem_fun_t<_Ret, _Tp>
mem_fun(_Ret (_Tp::*__f)())
{ return mem_fun_t<_Ret, _Tp>(__f); }

template<typename _Ret, typename _Tp>

__attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead")))
inline const_mem_fun_t<_Ret, _Tp>
mem_fun(_Ret (_Tp::*__f)() const)
{ return const_mem_fun_t<_Ret, _Tp>(__f); }

template<typename _Ret, typename _Tp>

__attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead")))
inline mem_fun_ref_t<_Ret, _Tp>
mem_fun_ref(_Ret (_Tp::*__f)())
{ return mem_fun_ref_t<_Ret, _Tp>(__f); }

template<typename _Ret, typename _Tp>

__attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead")))
inline const_mem_fun_ref_t<_Ret, _Tp>
mem_fun_ref(_Ret (_Tp::*__f)() const)
{ return const_mem_fun_ref_t<_Ret, _Tp>(__f); }

template<typename _Ret, typename _Tp, typename _Arg>

__attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead")))
inline mem_fun1_t<_Ret, _Tp, _Arg>
mem_fun(_Ret (_Tp::*__f)(_Arg))
{ return mem_fun1_t<_Ret, _Tp, _Arg>(__f); }

template<typename _Ret, typename _Tp, typename _Arg>

__attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead")))
inline const_mem_fun1_t<_Ret, _Tp, _Arg>
mem_fun(_Ret (_Tp::*__f)(_Arg) const)
{ return const_mem_fun1_t<_Ret, _Tp, _Arg>(__f); }

template<typename _Ret, typename _Tp, typename _Arg>

__attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead")))
inline mem_fun1_ref_t<_Ret, _Tp, _Arg>
mem_fun_ref(_Ret (_Tp::*__f)(_Arg))
{ return mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }

template<typename _Ret, typename _Tp, typename _Arg>

__attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead")))
inline const_mem_fun1_ref_t<_Ret, _Tp, _Arg>
mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const)
{ return const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
#pragma GCC diagnostic pop

template<typename _Func, typename _SfinaeType, typename = __void_t<>>

struct __has_is_transparent
{ };

template<typename _Func, typename _SfinaeType>

struct __has_is_transparent<_Func, _SfinaeType,
__void_t<typename _Func::is_transparent>>
{ typedef void type; };

template<typename _Func, typename _SfinaeType>

using __has_is_transparent_t
= typename __has_is_transparent<_Func, _SfinaeType>::type;

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/backward/binders.h" 1 3
# 60 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/backward/binders.h" 3
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"

namespace std
{

# 107 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/backward/binders.h" 3
template<typename _Operation>
class binder1st
: public unary_function<typename _Operation::second_argument_type,
typename _Operation::result_type>
{
protected:
_Operation op;
typename _Operation::first_argument_type value;

public:
binder1st(const _Operation& __x,
const typename _Operation::first_argument_type& __y)
: op(__x), value(__y) { }

typename _Operation::result_type
operator()(const typename _Operation::second_argument_type& __x) const
{ return op(value, __x); }

typename _Operation::result_type
operator()(typename _Operation::second_argument_type& __x) const
{ return op(value, __x); }
} __attribute__ ((__deprecated__ ("use '" "std::bind" "' instead")));
template<typename _Operation, typename _Tp>
__attribute__ ((__deprecated__ ("use '" "std::bind" "' instead")))
inline binder1st<_Operation>
bind1st(const _Operation& __fn, const _Tp& __x)
{
typedef typename _Operation::first_argument_type _Arg1_type;
return binder1st<_Operation>(__fn, _Arg1_type(__x));
}

template<typename _Operation>
class binder2nd
: public unary_function<typename _Operation::first_argument_type,
typename _Operation::result_type>
{
protected:
_Operation op;
typename _Operation::second_argument_type value;

public:
binder2nd(const _Operation& __x,
const typename _Operation::second_argument_type& __y)
: op(__x), value(__y) { }

typename _Operation::result_type
operator()(const typename _Operation::first_argument_type& __x) const
{ return op(__x, value); }

typename _Operation::result_type
operator()(typename _Operation::first_argument_type& __x) const
{ return op(__x, value); }
} __attribute__ ((__deprecated__ ("use '" "std::bind" "' instead")));

template<typename _Operation, typename _Tp>

__attribute__ ((__deprecated__ ("use '" "std::bind" "' instead")))
inline binder2nd<_Operation>
bind2nd(const _Operation& __fn, const _Tp& __x)
{
typedef typename _Operation::second_argument_type _Arg2_type;
return binder2nd<_Operation>(__fn, _Arg2_type(__x));
}

#pragma GCC diagnostic pop

# 1436 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_function.h" 2 3
# 50 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/string" 2 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/refwrap.h" 1 3
# 33 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/refwrap.h" 3
# 34 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/refwrap.h" 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/invoke.h" 1 3
# 33 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/invoke.h" 3

# 34 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/invoke.h" 3
# 42 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/invoke.h" 3
namespace std
{

# 53 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/invoke.h" 3
template<typename _Tp, typename _Up = typename __inv_unwrap<_Tp>::type>
constexpr _Up&&
__invfwd(typename remove_reference<_Tp>::type& __t) noexcept
{ return static_cast<_Up&&>(__t); }

template<typename _Res, typename _Fn, typename... _Args>

constexpr _Res
__invoke_impl(__invoke_other, _Fn&& __f, _Args&&... __args)
{ return std::forward<_Fn>(__f)(std::forward<_Args>(__args)...); }

template<typename _Res, typename _MemFun, typename _Tp, typename... _Args>

constexpr _Res
__invoke_impl(__invoke_memfun_ref, _MemFun&& __f, _Tp&& __t,
_Args&&... __args)
{ return (__invfwd<_Tp>(__t).*__f)(std::forward<_Args>(__args)...); }

template<typename _Res, typename _MemFun, typename _Tp, typename... _Args>

constexpr _Res
__invoke_impl(__invoke_memfun_deref, _MemFun&& __f, _Tp&& __t,
_Args&&... __args)
{
return ((*std::forward<_Tp>(__t)).*__f)(std::forward<_Args>(__args)...);
}

template<typename _Res, typename _MemPtr, typename _Tp>

constexpr _Res
__invoke_impl(__invoke_memobj_ref, _MemPtr&& __f, _Tp&& __t)
{ return __invfwd<_Tp>(__t).*__f; }

template<typename _Res, typename _MemPtr, typename _Tp>

constexpr _Res
__invoke_impl(__invoke_memobj_deref, _MemPtr&& __f, _Tp&& __t)
{ return (*std::forward<_Tp>(__t)).*__f; }

template<typename _Callable, typename... _Args>

constexpr typename __invoke_result<_Callable, _Args...>::type
__invoke(_Callable&& __fn, _Args&&... __args)
noexcept(__is_nothrow_invocable<_Callable, _Args...>::value)
{
using __result = __invoke_result<_Callable, _Args...>;
using __type = typename __result::type;
using __tag = typename __result::__invoke_type;
return std::__invoke_impl<__type>(__tag{}, std::forward<_Callable>(__fn),
std::forward<_Args>(__args)...);
}

template<typename _Res, typename _Callable, typename... _Args>

constexpr enable_if_t<is_invocable_r_v<_Res, _Callable, _Args...>, _Res>
__invoke_r(_Callable&& __fn, _Args&&... __args)
noexcept(is_nothrow_invocable_r_v<_Res, _Callable, _Args...>)
{
using __result = __invoke_result<_Callable, _Args...>;
using __type = typename __result::type;
using __tag = typename __result::__invoke_type;
if constexpr (is_void_v<_Res>)
std::__invoke_impl<__type>(__tag{}, std::forward<_Callable>(__fn),
std::forward<_Args>(__args)...);
else
return std::__invoke_impl<__type>(__tag{},
std::forward<_Callable>(__fn),
std::forward<_Args>(__args)...);
}
# 155 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/invoke.h" 3

}
# 39 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/refwrap.h" 2 3

namespace std
{

# 56 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/refwrap.h" 3
template<typename _Res, typename... _ArgTypes>
struct _Maybe_unary_or_binary_function { };

#pragma GCC diagnostic push

#pragma GCC diagnostic ignored "-Wdeprecated-declarations"

template<typename _Res, typename _T1>

struct _Maybe_unary_or_binary_function<_Res, _T1>
: std::unary_function<_T1, _Res> { };

template<typename _Res, typename _T1, typename _T2>

struct _Maybe_unary_or_binary_function<_Res, _T1, _T2>
: std::binary_function<_T1, _T2, _Res> { };

#pragma GCC diagnostic pop

template<typename _Signature>
struct _Mem_fn_traits;

template<typename _Res, typename _Class, typename... _ArgTypes>

struct _Mem_fn_traits_base
{
using __result_type = _Res;
using __maybe_type
= _Maybe_unary_or_binary_function<_Res, _Class*, _ArgTypes...>;
using __arity = integral_constant<size_t, sizeof...(_ArgTypes)>;
};
# 107 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/refwrap.h" 3
template<typename _Res, typename _Class, typename... _ArgTypes> struct
_Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) > : _Mem_fn_traits_base<_Res, _Class,
_ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename
_Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)
(_ArgTypes... ...) > : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using
__vararg = true_type; }; template<typename _Res, typename _Class, typename...
_ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const > :
_Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg =
false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const > :
_Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type;
}; template<typename _Res, typename _Class, typename... _ArgTypes> struct
_Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile > :
_Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg =
false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile > :
_Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg =
true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile > :
_Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg =
false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile > :
_Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg =
true_type; };
template<typename _Res, typename _Class, typename... _ArgTypes> struct
_Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) &> : _Mem_fn_traits_base<_Res,
_Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res,
typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)
(_ArgTypes... ...) &> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using
__vararg = true_type; }; template<typename _Res, typename _Class, typename...
_ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const &> :
_Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg =
false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const &> :
_Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type;
}; template<typename _Res, typename _Class, typename... _ArgTypes> struct
_Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile &> :
_Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg =
false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile &> :
_Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg =
true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile &> :
_Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg =
false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile &> :
_Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg =
true_type; };
template<typename _Res, typename _Class, typename... _ArgTypes> struct
_Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) &&> : _Mem_fn_traits_base<_Res,
_Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res,
typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)
(_ArgTypes... ...) &&> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using
__vararg = true_type; }; template<typename _Res, typename _Class, typename...
_ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const &&> :
_Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg =
false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const &&> :
_Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type;
}; template<typename _Res, typename _Class, typename... _ArgTypes> struct
_Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile &&> :
_Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg =
false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile &&> :
_Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg =
true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile &&> :
_Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg =
false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile &&> :
_Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg =
true_type; };

template<typename _Res, typename _Class, typename... _ArgTypes> struct

_Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) noexcept> : _Mem_fn_traits_base<_Res,
_Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res,
typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)
(_ArgTypes... ...) noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...>
{ using __vararg = true_type; }; template<typename _Res, typename _Class,
typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const
noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg
= false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const noexcept> :
_Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type;
}; template<typename _Res, typename _Class, typename... _ArgTypes> struct
_Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile noexcept> :
_Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg =
false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile noexcept> :
_Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg =
true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile noexcept> :
_Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg =
false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile noexcept> :
_Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg =
true_type; };
template<typename _Res, typename _Class, typename... _ArgTypes> struct
_Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) & noexcept> :
_Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; };
template<typename _Res, typename _Class, typename... _ArgTypes> struct
_Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) & noexcept> :
_Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; };
template<typename _Res, typename _Class, typename... _ArgTypes> struct
_Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const & noexcept> :
_Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg =
false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const & noexcept> :
_Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type;
}; template<typename _Res, typename _Class, typename... _ArgTypes> struct
_Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile & noexcept> :
_Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg =
false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile & noexcept> :
_Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg =
true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile & noexcept> :
_Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg =
false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile & noexcept>
: _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg =
true_type; };
template<typename _Res, typename _Class, typename... _ArgTypes> struct
_Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) && noexcept> :
_Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; };
template<typename _Res, typename _Class, typename... _ArgTypes> struct
_Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) && noexcept> :
_Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; };
template<typename _Res, typename _Class, typename... _ArgTypes> struct
_Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const && noexcept> :
_Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg =
false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const && noexcept> :
_Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type;
}; template<typename _Res, typename _Class, typename... _ArgTypes> struct
_Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile && noexcept> :
_Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg =
false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile && noexcept> :
_Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg =
true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile && noexcept> :
_Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg =
false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes>
struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile &&
noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using
__vararg = true_type; };

template<typename _Functor, typename = __void_t<>>

struct _Maybe_get_result_type
{ };

template<typename _Functor>
struct _Maybe_get_result_type<_Functor,
__void_t<typename _Functor::result_type>>
{ typedef typename _Functor::result_type result_type; };

template<typename _Functor>
struct _Weak_result_type_impl
: _Maybe_get_result_type<_Functor>
{ };
template<typename _Res, typename... _ArgTypes , bool _NE>
struct _Weak_result_type_impl<_Res(_ArgTypes...) noexcept (_NE)>
{ typedef _Res result_type; };

template<typename _Res, typename... _ArgTypes , bool _NE>

struct _Weak_result_type_impl<_Res(_ArgTypes......) noexcept (_NE)>
{ typedef _Res result_type; };

template<typename _Res, typename... _ArgTypes , bool _NE>

struct _Weak_result_type_impl<_Res(*)(_ArgTypes...) noexcept (_NE)>
{ typedef _Res result_type; };

template<typename _Res, typename... _ArgTypes , bool _NE>

struct
_Weak_result_type_impl<_Res(*)(_ArgTypes......) noexcept (_NE)>
{ typedef _Res result_type; };

template<typename _Functor,
bool = is_member_function_pointer<_Functor>::value>
struct _Weak_result_type_memfun
: _Weak_result_type_impl<_Functor>
{ };

template<typename _MemFunPtr>
struct _Weak_result_type_memfun<_MemFunPtr, true>
{
using result_type = typename _Mem_fn_traits<_MemFunPtr>::__result_type;
};

template<typename _Func, typename _Class>

struct _Weak_result_type_memfun<_Func _Class::*, false>
{ };

template<typename _Functor>
struct _Weak_result_type
: _Weak_result_type_memfun<typename remove_cv<_Functor>::type>
{ };
# 306 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/refwrap.h" 3
template<typename _Tp>
class reference_wrapper

{
_Tp* _M_data;
constexpr
static _Tp* _S_fun(_Tp& __r) noexcept { return std::__addressof(__r); }

static void _S_fun(_Tp&&) = delete;

template<typename _Up, typename _Up2 = __remove_cvref_t<_Up>>

using __not_same
= typename enable_if<!is_same<reference_wrapper, _Up2>::value>::type;

public:
typedef _Tp type;

template<typename _Up, typename = __not_same<_Up>, typename

= decltype(reference_wrapper::_S_fun(std::declval<_Up>()))>
constexpr
reference_wrapper(_Up&& __uref)
noexcept(noexcept(reference_wrapper::_S_fun(std::declval<_Up>())))
: _M_data(reference_wrapper::_S_fun(std::forward<_Up>(__uref)))
{ }

reference_wrapper(const reference_wrapper&) = default;

reference_wrapper&
operator=(const reference_wrapper&) = default;

constexpr
operator _Tp&() const noexcept
{ return this->get(); }

constexpr
_Tp&
get() const noexcept
{ return *_M_data; }

template<typename... _Args>
constexpr
typename __invoke_result<_Tp&, _Args...>::type
operator()(_Args&&... __args) const
noexcept(__is_nothrow_invocable<_Tp&, _Args...>::value)
{

if constexpr (is_object_v<type>)
static_assert(sizeof(type), "type must be complete");

return std::__invoke(get(), std::forward<_Args>(__args)...);

}

[[nodiscard]]
friend constexpr bool
operator==(reference_wrapper __x, reference_wrapper __y)
requires requires { { __x.get() == __y.get() } -> convertible_to<bool>; }
{ return __x.get() == __y.get(); }
[[nodiscard]]
friend constexpr bool
operator==(reference_wrapper __x, const _Tp& __y)
requires requires { { __x.get() == __y } -> convertible_to<bool>; }
{ return __x.get() == __y; }

[[nodiscard]]
friend constexpr bool
operator==(reference_wrapper __x, reference_wrapper<const _Tp> __y)
requires (!is_const_v<_Tp>)
&& requires { { __x.get() == __y.get() } -> convertible_to<bool>; }
{ return __x.get() == __y.get(); }

[[nodiscard]]
friend constexpr auto
operator<=>(reference_wrapper __x, reference_wrapper __y)
requires requires (const _Tp __t) {
{ __t < __t } -> __detail::__boolean_testable;
}
{ return __detail::__synth3way(__x.get(), __y.get()); }

[[nodiscard]]
friend constexpr auto
operator<=>(reference_wrapper __x, const _Tp& __y)
requires requires { { __y < __y } -> __detail::__boolean_testable; }
{ return __detail::__synth3way(__x.get(), __y); }

[[nodiscard]]
friend constexpr auto
operator<=>(reference_wrapper __x, reference_wrapper<const _Tp> __y)
requires (!is_const_v<_Tp>) && requires (const _Tp __t) {
{ __t < __t } -> __detail::__boolean_testable;
}
{ return __detail::__synth3way(__x.get(), __y.get()); }

};

template<typename _Tp>
reference_wrapper(_Tp&) -> reference_wrapper<_Tp>;

template<typename _Tp>
constexpr
inline reference_wrapper<_Tp>
ref(_Tp& __t) noexcept
{ return reference_wrapper<_Tp>(__t); }

template<typename _Tp>
constexpr
inline reference_wrapper<const _Tp>
cref(const _Tp& __t) noexcept
{ return reference_wrapper<const _Tp>(__t); }

template<typename _Tp>
void ref(const _Tp&&) = delete;

template<typename _Tp>
void cref(const _Tp&&) = delete;

template<typename _Tp>
constexpr
inline reference_wrapper<_Tp>
ref(reference_wrapper<_Tp> __t) noexcept
{ return __t; }

template<typename _Tp>
constexpr
inline reference_wrapper<const _Tp>
cref(reference_wrapper<_Tp> __t) noexcept
{ return { __t.get() }; }

}
# 53 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/string" 2 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 1 3
# 37 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3

# 38 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/ext/alloc_traits.h" 1 3
# 32 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/ext/alloc_traits.h" 3

# 33 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/ext/alloc_traits.h" 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/alloc_traits.h" 1 3
# 46 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/alloc_traits.h" 3
namespace std
{

struct __allocator_traits_base
{
template<typename _Tp, typename _Up, typename = void>
struct __rebind : __replace_first_arg<_Tp, _Up>
{
static_assert(is_same<
typename __replace_first_arg<_Tp, typename _Tp::value_type>::type,
_Tp>::value,
"allocator_traits<A>::rebind_alloc<A::value_type> must be A");
};

template<typename _Tp, typename _Up>

struct __rebind<_Tp, _Up,
__void_t<typename _Tp::template rebind<_Up>::other>>
{
using type = typename _Tp::template rebind<_Up>::other;

static_assert(is_same<
typename _Tp::template rebind<typename _Tp::value_type>::other,
_Tp>::value,
"allocator_traits<A>::rebind_alloc<A::value_type> must be A");
};

protected:
template<typename _Tp>
using __pointer = typename _Tp::pointer;
template<typename _Tp>
using __c_pointer = typename _Tp::const_pointer;
template<typename _Tp>
using __v_pointer = typename _Tp::void_pointer;
template<typename _Tp>
using __cv_pointer = typename _Tp::const_void_pointer;
template<typename _Tp>
using __pocca = typename _Tp::propagate_on_container_copy_assignment;
template<typename _Tp>
using __pocma = typename _Tp::propagate_on_container_move_assignment;
template<typename _Tp>
using __pocs = typename _Tp::propagate_on_container_swap;
template<typename _Tp>
using __equal = __type_identity<typename _Tp::is_always_equal>;
};

template<typename _Alloc, typename _Up>

using __alloc_rebind
= typename __allocator_traits_base::template __rebind<_Alloc, _Up>::type;
# 105 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/alloc_traits.h" 3
template<typename _Alloc>
struct allocator_traits : __allocator_traits_base
{

typedef _Alloc allocator_type;

typedef typename _Alloc::value_type value_type;

using pointer = __detected_or_t<value_type*, __pointer, _Alloc>;

private:

template<template<typename> class _Func, typename _Tp, typename = void>

struct _Ptr
{
using type = typename pointer_traits<pointer>::template rebind<_Tp>;
};

template<template<typename> class _Func, typename _Tp>

struct _Ptr<_Func, _Tp, __void_t<_Func<_Alloc>>>
{
using type = _Func<_Alloc>;
};

template<typename _A2, typename _PtrT, typename = void>

struct _Diff
{ using type = typename pointer_traits<_PtrT>::difference_type; };

template<typename _A2, typename _PtrT>

struct _Diff<_A2, _PtrT, __void_t<typename _A2::difference_type>>
{ using type = typename _A2::difference_type; };

template<typename _A2, typename _DiffT, typename = void>

struct _Size : make_unsigned<_DiffT> { };

template<typename _A2, typename _DiffT>

struct _Size<_A2, _DiffT, __void_t<typename _A2::size_type>>
{ using type = typename _A2::size_type; };

public:

using const_pointer = typename _Ptr<__c_pointer, const value_type>::type;

using void_pointer = typename _Ptr<__v_pointer, void>::type;

using const_void_pointer = typename _Ptr<__cv_pointer, const void>::type;

using difference_type = typename _Diff<_Alloc, pointer>::type;

using size_type = typename _Size<_Alloc, difference_type>::type;

using propagate_on_container_copy_assignment
= __detected_or_t<false_type, __pocca, _Alloc>;

using propagate_on_container_move_assignment
= __detected_or_t<false_type, __pocma, _Alloc>;

using propagate_on_container_swap
= __detected_or_t<false_type, __pocs, _Alloc>;

using is_always_equal
= typename __detected_or_t<is_empty<_Alloc>, __equal, _Alloc>::type;

template<typename _Tp>
using rebind_alloc = __alloc_rebind<_Alloc, _Tp>;
template<typename _Tp>
using rebind_traits = allocator_traits<rebind_alloc<_Tp>>;

private:
template<typename _Alloc2>
static constexpr auto
_S_allocate(_Alloc2& __a, size_type __n, const_void_pointer __hint, int)
-> decltype(__a.allocate(__n, __hint))
{ return __a.allocate(__n, __hint); }

template<typename _Alloc2>
static constexpr pointer
_S_allocate(_Alloc2& __a, size_type __n, const_void_pointer, ...)
{ return __a.allocate(__n); }

template<typename _Tp, typename... _Args>

struct __construct_helper
{
template<typename _Alloc2,
typename = decltype(std::declval<_Alloc2*>()->construct(
std::declval<_Tp*>(), std::declval<_Args>()...))>
static true_type __test(int);

template<typename>
static false_type __test(...);

using type = decltype(__test<_Alloc>(0));

};

template<typename _Tp, typename... _Args>

using __has_construct
= typename __construct_helper<_Tp, _Args...>::type;

template<typename _Tp, typename... _Args>

static constexpr _Require<__has_construct<_Tp, _Args...>>
_S_construct(_Alloc& __a, _Tp* __p, _Args&&... __args)
noexcept(noexcept(__a.construct(__p, std::forward<_Args>(__args)...)))
{ __a.construct(__p, std::forward<_Args>(__args)...); }

template<typename _Tp, typename... _Args>

static constexpr
_Require<__and_<__not_<__has_construct<_Tp, _Args...>>,
is_constructible<_Tp, _Args...>>>
_S_construct(_Alloc&, _Tp* __p, _Args&&... __args)
noexcept(std::is_nothrow_constructible<_Tp, _Args...>::value)
{

std::construct_at(__p, std::forward<_Args>(__args)...);

template<typename _Alloc2, typename _Tp>

static constexpr auto
_S_destroy(_Alloc2& __a, _Tp* __p, int)
noexcept(noexcept(__a.destroy(__p)))
-> decltype(__a.destroy(__p))
{ __a.destroy(__p); }

template<typename _Alloc2, typename _Tp>

static constexpr void
_S_destroy(_Alloc2&, _Tp* __p, ...)
noexcept(std::is_nothrow_destructible<_Tp>::value)
{ std::_Destroy(__p); }

template<typename _Alloc2>
static constexpr auto
_S_max_size(_Alloc2& __a, int)
-> decltype(__a.max_size())
{ return __a.max_size(); }

template<typename _Alloc2>
static constexpr size_type
_S_max_size(_Alloc2&, ...)
{
return __gnu_cxx::__numeric_traits<size_type>::__max
/ sizeof(value_type);
}

template<typename _Alloc2>
static constexpr auto
_S_select(_Alloc2& __a, int)
-> decltype(__a.select_on_container_copy_construction())
{ return __a.select_on_container_copy_construction(); }

template<typename _Alloc2>
static constexpr _Alloc2
_S_select(_Alloc2& __a, ...)
{ return __a; }

public:
# 332 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/alloc_traits.h" 3
[[__nodiscard__]] static constexpr pointer
allocate(_Alloc& __a, size_type __n)
{ return __a.allocate(__n); }
# 347 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/alloc_traits.h" 3
[[__nodiscard__]] static constexpr pointer
allocate(_Alloc& __a, size_type __n, const_void_pointer __hint)
{ return _S_allocate(__a, __n, __hint, 0); }
# 359 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/alloc_traits.h" 3
static constexpr void
deallocate(_Alloc& __a, pointer __p, size_type __n)
{ __a.deallocate(__p, __n); }
# 374 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/alloc_traits.h" 3
template<typename _Tp, typename... _Args>
static constexpr auto
construct(_Alloc& __a, _Tp* __p, _Args&&... __args)
noexcept(noexcept(_S_construct(__a, __p,
std::forward<_Args>(__args)...)))
-> decltype(_S_construct(__a, __p, std::forward<_Args>(__args)...))
{ _S_construct(__a, __p, std::forward<_Args>(__args)...); }
# 390 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/alloc_traits.h" 3
template<typename _Tp>
static constexpr void
destroy(_Alloc& __a, _Tp* __p)
noexcept(noexcept(_S_destroy(__a, __p, 0)))
{ _S_destroy(__a, __p, 0); }
# 404 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/alloc_traits.h" 3
static constexpr size_type
max_size(const _Alloc& __a) noexcept
{ return _S_max_size(__a, 0); }
# 416 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/alloc_traits.h" 3
static constexpr _Alloc
select_on_container_copy_construction(const _Alloc& __rhs)
{ return _S_select(__rhs, 0); }
};

template<typename _Tp>
struct allocator_traits<allocator<_Tp>>
{

using allocator_type = allocator<_Tp>;

using value_type = _Tp;

using pointer = _Tp*;

using const_pointer = const _Tp*;

using void_pointer = void*;

using const_void_pointer = const void*;

using difference_type = std::ptrdiff_t;

using size_type = std::size_t;

using propagate_on_container_copy_assignment = false_type;

using propagate_on_container_move_assignment = true_type;

using propagate_on_container_swap = false_type;

using is_always_equal = true_type;

template<typename _Up>
using rebind_alloc = allocator<_Up>;

template<typename _Up>
using rebind_traits = allocator_traits<allocator<_Up>>;
# 475 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/alloc_traits.h" 3
[[__nodiscard__,__gnu__::__always_inline__]]
static constexpr pointer
allocate(allocator_type& __a, size_type __n)
{ return __a.allocate(__n); }
# 490 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/alloc_traits.h" 3
[[__nodiscard__,__gnu__::__always_inline__]]
static constexpr pointer
allocate(allocator_type& __a, size_type __n,
[[maybe_unused]] const_void_pointer __hint)
{

return __a.allocate(__n);

}
# 510 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/alloc_traits.h" 3
[[__gnu__::__always_inline__]]
static constexpr void
deallocate(allocator_type& __a, pointer __p, size_type __n)
{ __a.deallocate(__p, __n); }
# 526 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/alloc_traits.h" 3
template<typename _Up, typename... _Args>
[[__gnu__::__always_inline__]]
static constexpr void
construct(allocator_type& __a __attribute__((__unused__)), _Up* __p,
_Args&&... __args)
noexcept(std::is_nothrow_constructible<_Up, _Args...>::value)
{

std::construct_at(__p, std::forward<_Args>(__args)...);

}
# 547 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/alloc_traits.h" 3
template<typename _Up>
[[__gnu__::__always_inline__]]
static constexpr void
destroy(allocator_type& __a __attribute__((__unused__)), _Up* __p)
noexcept(is_nothrow_destructible<_Up>::value)
{

std::destroy_at(__p);

[[__gnu__::__always_inline__]]
static constexpr size_type
max_size(const allocator_type& __a __attribute__((__unused__))) noexcept
{

return size_t(-1) / sizeof(value_type);

[[__gnu__::__always_inline__]]
static constexpr allocator_type
select_on_container_copy_construction(const allocator_type& __rhs)
{ return __rhs; }
};

template<>
struct allocator_traits<allocator<void>>
{

using allocator_type = allocator<void>;

using value_type = void;

using pointer = void*;

using const_pointer = const void*;

using void_pointer = void*;

using const_void_pointer = const void*;

using difference_type = std::ptrdiff_t;

using size_type = std::size_t;

using propagate_on_container_copy_assignment = false_type;

using propagate_on_container_move_assignment = true_type;

using propagate_on_container_swap = false_type;

using is_always_equal = true_type;

template<typename _Up>
using rebind_alloc = allocator<_Up>;

template<typename _Up>
using rebind_traits = allocator_traits<allocator<_Up>>;

static void*
allocate(allocator_type&, size_type, const void* = nullptr) = delete;

static void
deallocate(allocator_type&, void*, size_type) = delete;
# 652 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/alloc_traits.h" 3
template<typename _Up, typename... _Args>
[[__gnu__::__always_inline__]]
static constexpr void
construct(allocator_type&, _Up* __p, _Args&&... __args)
noexcept(std::is_nothrow_constructible<_Up, _Args...>::value)
{ std::_Construct(__p, std::forward<_Args>(__args)...); }
# 666 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/alloc_traits.h" 3
template<typename _Up>
[[__gnu__::__always_inline__]]
static constexpr void
destroy(allocator_type&, _Up* __p)
noexcept(is_nothrow_destructible<_Up>::value)
{ std::_Destroy(__p); }

static size_type
max_size(const allocator_type&) = delete;

[[__gnu__::__always_inline__]]
static constexpr allocator_type
select_on_container_copy_construction(const allocator_type& __rhs)
{ return __rhs; }
};
# 704 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/alloc_traits.h" 3
template<typename _Alloc>
[[__gnu__::__always_inline__]]
constexpr inline void
__alloc_on_copy(_Alloc& __one, const _Alloc& __two)
{
using __traits = allocator_traits<_Alloc>;
using __pocca =
typename __traits::propagate_on_container_copy_assignment::type;

if constexpr (__pocca::value)
__one = __two;

template<typename _Alloc>
[[__gnu__::__always_inline__]]
constexpr _Alloc
__alloc_on_copy(const _Alloc& __a)
{
typedef allocator_traits<_Alloc> __traits;
return __traits::select_on_container_copy_construction(__a);
}
# 741 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/alloc_traits.h" 3
template<typename _Alloc>
[[__gnu__::__always_inline__]]
constexpr inline void
__alloc_on_move(_Alloc& __one, _Alloc& __two)
{
using __traits = allocator_traits<_Alloc>;
using __pocma
= typename __traits::propagate_on_container_move_assignment::type;

if constexpr (__pocma::value)
__one = std::move(__two);
}
# 772 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/alloc_traits.h" 3
template<typename _Alloc>
[[__gnu__::__always_inline__]]
constexpr inline void
__alloc_on_swap(_Alloc& __one, _Alloc& __two)
{
using __traits = allocator_traits<_Alloc>;
using __pocs = typename __traits::propagate_on_container_swap::type;

if constexpr (__pocs::value)
{
using std::swap;
swap(__one, __two);
}

template<typename _Alloc, typename _Tp,

typename _ValueT = __remove_cvref_t<typename _Alloc::value_type>,
typename = void>
struct __is_alloc_insertable_impl
: false_type
{ };

template<typename _Alloc, typename _Tp, typename _ValueT>

struct __is_alloc_insertable_impl<_Alloc, _Tp, _ValueT,
__void_t<decltype(allocator_traits<_Alloc>::construct(
std::declval<_Alloc&>(), std::declval<_ValueT*>(),
std::declval<_Tp>()))>>
: true_type
{ };

template<typename _Alloc>
struct __is_copy_insertable
: __is_alloc_insertable_impl<_Alloc,
typename _Alloc::value_type const&>::type
{ };

template<typename _Tp>
struct __is_copy_insertable<allocator<_Tp>>
: is_copy_constructible<_Tp>
{ };

template<typename _Alloc>
struct __is_move_insertable
: __is_alloc_insertable_impl<_Alloc, typename _Alloc::value_type>::type
{ };

template<typename _Tp>
struct __is_move_insertable<allocator<_Tp>>
: is_move_constructible<_Tp>
{ };

template<typename _Alloc, typename = void>

struct __is_allocator : false_type { };

template<typename _Alloc>
struct __is_allocator<_Alloc,
__void_t<typename _Alloc::value_type,
decltype(std::declval<_Alloc&>().allocate(size_t{}))>>
: true_type { };

template<typename _Alloc>
using _RequireAllocator
= typename enable_if<__is_allocator<_Alloc>::value, _Alloc>::type;

template<typename _Alloc>
using _RequireNotAllocator
= typename enable_if<!__is_allocator<_Alloc>::value, _Alloc>::type;

template<typename _Alloc>
concept __allocator_like = requires (_Alloc& __a) {
typename _Alloc::value_type;
__a.deallocate(__a.allocate(1u), 1u);
};

template<typename _Alloc, bool = __is_empty(_Alloc)>

struct __alloc_swap
{ static void _S_do_it(_Alloc&, _Alloc&) noexcept { } };

template<typename _Alloc>
struct __alloc_swap<_Alloc, false>
{
static void
_S_do_it(_Alloc& __one, _Alloc& __two) noexcept
{

if (__one != __two)
swap(__one, __two);
}
};
template<typename _Tp, bool
= __or_<is_copy_constructible<typename _Tp::value_type>,
is_nothrow_move_constructible<typename _Tp::value_type>>::value>
struct __shrink_to_fit_aux
{ static bool _S_do_it(_Tp&) noexcept { return false; } };

template<typename _Tp>
struct __shrink_to_fit_aux<_Tp, true>
{
constexpr
static bool
_S_do_it(_Tp& __c) noexcept
{

try
{
_Tp(__make_move_if_noexcept_iterator(__c.begin()),
__make_move_if_noexcept_iterator(__c.end()),
__c.get_allocator()).swap(__c);
return true;
}
catch(...)
{ return false; }

}
};
# 922 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/alloc_traits.h" 3
template<typename _ForwardIterator, typename _Allocator>
constexpr
void
_Destroy(_ForwardIterator __first, _ForwardIterator __last,
_Allocator& __alloc)
{
for (; __first != __last; ++__first)

allocator_traits<_Allocator>::destroy(__alloc,
std::__addressof(*__first));

template<typename _ForwardIterator, typename _Tp>

__attribute__((__always_inline__)) constexpr
inline void
_Destroy(_ForwardIterator __first, _ForwardIterator __last,
allocator<_Tp>&)
{
std::_Destroy(__first, __last);
}

}
# 35 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/ext/alloc_traits.h" 2 3
namespace __gnu_cxx
{

template<typename _Alloc, typename = typename _Alloc::value_type>

struct __alloc_traits

: std::allocator_traits<_Alloc>

{
typedef _Alloc allocator_type;

typedef std::allocator_traits<_Alloc> _Base_type;

typedef typename _Base_type::value_type value_type;
typedef typename _Base_type::pointer pointer;
typedef typename _Base_type::const_pointer const_pointer;
typedef typename _Base_type::size_type size_type;
typedef typename _Base_type::difference_type difference_type;

typedef value_type& reference;

typedef const value_type& const_reference;
using _Base_type::allocate;
using _Base_type::deallocate;
using _Base_type::construct;
using _Base_type::destroy;
using _Base_type::max_size;

private:
template<typename _Ptr>
using __is_custom_pointer
= std::__and_<std::is_same<pointer, _Ptr>,
std::__not_<std::is_pointer<_Ptr>>>;

public:

template<typename _Ptr, typename... _Args>

[[__gnu__::__always_inline__]]
static constexpr
std::__enable_if_t<__is_custom_pointer<_Ptr>::value>
construct(_Alloc& __a, _Ptr __p, _Args&&... __args)
noexcept(noexcept(_Base_type::construct(__a, std::__to_address(__p),
std::forward<_Args>(__args)...)))
{
_Base_type::construct(__a, std::__to_address(__p),
std::forward<_Args>(__args)...);
}

template<typename _Ptr>
[[__gnu__::__always_inline__]]
static constexpr
std::__enable_if_t<__is_custom_pointer<_Ptr>::value>
destroy(_Alloc& __a, _Ptr __p)
noexcept(noexcept(_Base_type::destroy(__a, std::__to_address(__p))))
{ _Base_type::destroy(__a, std::__to_address(__p)); }

[[__gnu__::__always_inline__]]
static constexpr _Alloc _S_select_on_copy(const _Alloc& __a)
{ return _Base_type::select_on_container_copy_construction(__a); }

[[__gnu__::__always_inline__]]
static constexpr void _S_on_swap(_Alloc& __a, _Alloc& __b)
{ std::__alloc_on_swap(__a, __b); }

[[__gnu__::__always_inline__]]
static constexpr bool _S_propagate_on_copy_assign()
{ return _Base_type::propagate_on_container_copy_assignment::value; }

[[__gnu__::__always_inline__]]
static constexpr bool _S_propagate_on_move_assign()
{ return _Base_type::propagate_on_container_move_assignment::value; }

[[__gnu__::__always_inline__]]
static constexpr bool _S_propagate_on_swap()
{ return _Base_type::propagate_on_container_swap::value; }

[[__gnu__::__always_inline__]]
static constexpr bool _S_always_equal()
{ return _Base_type::is_always_equal::value; }

__attribute__((__always_inline__))
static constexpr bool _S_nothrow_move()
{ return _S_propagate_on_move_assign() || _S_always_equal(); }

template<typename _Tp>
struct rebind
{ typedef typename _Base_type::template rebind_alloc<_Tp> other; };
# 180 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/ext/alloc_traits.h" 3
};

}
# 40 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 2 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/string_view" 1 3
# 36 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/string_view" 3

# 37 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/string_view" 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 1 3
# 47 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 3
# 48 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 3
# 45 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/string_view" 2 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/functional_hash.h" 1 3
# 33 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/functional_hash.h" 3

# 34 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/functional_hash.h" 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/hash_bytes.h" 1 3
# 33 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/hash_bytes.h" 3

# 34 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/hash_bytes.h" 3

namespace std
{

size_t
_Hash_bytes(const void* __ptr, size_t __len, size_t __seed);

size_t
_Fnv_hash_bytes(const void* __ptr, size_t __len, size_t __seed);

}
# 37 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/functional_hash.h" 2 3

namespace std
{

# 50 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/functional_hash.h" 3
template<typename _Result, typename _Arg>
struct __hash_base
{
typedef _Result result_type [[__deprecated__]];
typedef _Arg argument_type [[__deprecated__]];
};

template<typename _Tp>
struct hash;
template<typename _Tp, typename = void>
struct __poison_hash
{
static constexpr bool __enable_hash_call = false;
private:

__poison_hash(__poison_hash&&);
~__poison_hash();
};

template<typename _Tp>
struct __poison_hash<_Tp, __void_t<decltype(hash<_Tp>()(declval<_Tp>()))>>
{
static constexpr bool __enable_hash_call = true;
};

template<typename _Tp, bool = is_enum<_Tp>::value>

struct __hash_enum
{
private:

__hash_enum(__hash_enum&&);
~__hash_enum();
};

template<typename _Tp>
struct __hash_enum<_Tp, true> : public __hash_base<size_t, _Tp>
{
size_t
operator()(_Tp __val) const noexcept
{
using __type = typename underlying_type<_Tp>::type;
return hash<__type>{}(static_cast<__type>(__val));
}
};

template<typename _Tp>
struct hash : __hash_enum<_Tp>
{ };

template<typename _Tp>
struct hash<_Tp*> : public __hash_base<size_t, _Tp*>
{
size_t
operator()(_Tp* __p) const noexcept
{ return reinterpret_cast<size_t>(__p); }
};
# 125 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/functional_hash.h" 3
template<> struct hash<bool> : public __hash_base<size_t, bool> { size_t
operator()(bool __val) const noexcept { return static_cast<size_t>(__val); } };

template<> struct hash<char> : public __hash_base<size_t, char> { size_t

operator()(char __val) const noexcept { return static_cast<size_t>(__val); } };
template<> struct hash<signed char> : public __hash_base<size_t, signed char>
{ size_t operator()(signed char __val) const noexcept { return
static_cast<size_t>(__val); } };

template<> struct hash<unsigned char> : public __hash_base<size_t, unsigned char>

{ size_t operator()(unsigned char __val) const noexcept { return
static_cast<size_t>(__val); } };

template<> struct hash<wchar_t> : public __hash_base<size_t, wchar_t> { size_t

operator()(wchar_t __val) const noexcept { return static_cast<size_t>(__val); } };

template<> struct hash<char8_t> : public __hash_base<size_t, char8_t> { size_t

operator()(char8_t __val) const noexcept { return static_cast<size_t>(__val); } };

template<> struct hash<char16_t> : public __hash_base<size_t, char16_t> { size_t

operator()(char16_t __val) const noexcept { return static_cast<size_t>(__val); } };

template<> struct hash<char32_t> : public __hash_base<size_t, char32_t> { size_t

operator()(char32_t __val) const noexcept { return static_cast<size_t>(__val); } };

template<> struct hash<short> : public __hash_base<size_t, short> { size_t

operator()(short __val) const noexcept { return static_cast<size_t>(__val); } };

template<> struct hash<int> : public __hash_base<size_t, int> { size_t operator()

(int __val) const noexcept { return static_cast<size_t>(__val); } };

template<> struct hash<long> : public __hash_base<size_t, long> { size_t

operator()(long __val) const noexcept { return static_cast<size_t>(__val); } };

template<> struct hash<long long> : public __hash_base<size_t, long long>

{ size_t operator()(long long __val) const noexcept { return
static_cast<size_t>(__val); } };

template<> struct hash<unsigned short> : public __hash_base<size_t, unsigned

short> { size_t operator()(unsigned short __val) const noexcept { return
static_cast<size_t>(__val); } };

template<> struct hash<unsigned int> : public __hash_base<size_t, unsigned int> {

size_t operator()(unsigned int __val) const noexcept { return
static_cast<size_t>(__val); } };

template<> struct hash<unsigned long> : public __hash_base<size_t, unsigned long>

{ size_t operator()(unsigned long __val) const noexcept { return
static_cast<size_t>(__val); } };

template<> struct hash<unsigned long long> : public __hash_base<size_t, unsigned

long long> { size_t operator()(unsigned long long __val) const noexcept { return
static_cast<size_t>(__val); } };

__extension__
template<> struct hash<__int128> : public __hash_base<size_t, __int128> { size_t
operator()(__int128 __val) const noexcept { return static_cast<size_t>(__val); } };
__extension__
template<> struct hash<__int128 unsigned> : public __hash_base<size_t, __int128
unsigned> { size_t operator()(__int128 unsigned __val) const noexcept { return
static_cast<size_t>(__val); } };
# 201 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/functional_hash.h" 3
struct _Hash_impl
{
static size_t
hash(const void* __ptr, size_t __clength,
size_t __seed = static_cast<size_t>(0xc70f6907UL))
{ return _Hash_bytes(__ptr, __clength, __seed); }

template<typename _Tp>
static size_t
hash(const _Tp& __val)
{ return hash(&__val, sizeof(__val)); }

template<typename _Tp>
static size_t
__hash_combine(const _Tp& __val, size_t __hash)
{ return hash(&__val, sizeof(__val), __hash); }
};

struct _Fnv_hash_impl
{
static size_t
hash(const void* __ptr, size_t __clength,
size_t __seed = static_cast<size_t>(2166136261UL))
{ return _Fnv_hash_bytes(__ptr, __clength, __seed); }

template<typename _Tp>
static size_t
hash(const _Tp& __val)
{ return hash(&__val, sizeof(__val)); }

template<typename _Tp>
static size_t
__hash_combine(const _Tp& __val, size_t __hash)
{ return hash(&__val, sizeof(__val), __hash); }
};

template<>
struct hash<float> : public __hash_base<size_t, float>
{
size_t
operator()(float __val) const noexcept
{

return __val != 0.0f ? std::_Hash_impl::hash(__val) : 0;

}
};

template<>
struct hash<double> : public __hash_base<size_t, double>
{
size_t
operator()(double __val) const noexcept
{

return __val != 0.0 ? std::_Hash_impl::hash(__val) : 0;

}
};

template<>
struct hash<long double>
: public __hash_base<size_t, long double>
{
__attribute__ ((__pure__)) size_t
operator()(long double __val) const noexcept;
};

template<>
struct hash<nullptr_t> : public __hash_base<size_t, nullptr_t>
{
size_t
operator()(nullptr_t) const noexcept
{ return 0; }
};
# 294 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/functional_hash.h" 3
template<typename _Hash>
struct __is_fast_hash : public std::true_type
{ };

template<>
struct __is_fast_hash<hash<long double>> : public std::false_type
{ };

}
# 51 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/string_view" 2 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/ranges_base.h" 1 3
# 33 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/ranges_base.h" 3

# 34 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/ranges_base.h" 3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/max_size_type.h" 1 3
# 33 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/max_size_type.h" 3

# 34 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/max_size_type.h" 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/numbers" 1 3
# 32 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/numbers" 3

# 33 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/numbers" 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 1 3
# 47 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 3

# 48 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 3
# 36 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/numbers" 2 3

namespace std
{

namespace numbers
{

template<typename _Tp>
using _Enable_if_floating = enable_if_t<is_floating_point_v<_Tp>, _Tp>;

template<typename _Tp>
inline constexpr _Tp e_v
= _Enable_if_floating<_Tp>(2.718281828459045235360287471352662498L);

template<typename _Tp>
inline constexpr _Tp log2e_v
= _Enable_if_floating<_Tp>(1.442695040888963407359924681001892137L);

template<typename _Tp>
inline constexpr _Tp log10e_v
= _Enable_if_floating<_Tp>(0.434294481903251827651128918916605082L);
template<typename _Tp>
inline constexpr _Tp pi_v
= _Enable_if_floating<_Tp>(3.141592653589793238462643383279502884L);

template<typename _Tp>
inline constexpr _Tp inv_pi_v
= _Enable_if_floating<_Tp>(0.318309886183790671537767526745028724L);

template<typename _Tp>
inline constexpr _Tp inv_sqrtpi_v
= _Enable_if_floating<_Tp>(0.564189583547756286948079451560772586L);

template<typename _Tp>
inline constexpr _Tp ln2_v
= _Enable_if_floating<_Tp>(0.693147180559945309417232121458176568L);

template<typename _Tp>
inline constexpr _Tp ln10_v
= _Enable_if_floating<_Tp>(2.302585092994045684017991454684364208L);

template<typename _Tp>
inline constexpr _Tp sqrt2_v
= _Enable_if_floating<_Tp>(1.414213562373095048801688724209698079L);

template<typename _Tp>
inline constexpr _Tp sqrt3_v
= _Enable_if_floating<_Tp>(1.732050807568877293527446341505872367L);

template<typename _Tp>
inline constexpr _Tp inv_sqrt3_v
= _Enable_if_floating<_Tp>(0.577350269189625764509148780501957456L);

template<typename _Tp>
inline constexpr _Tp egamma_v
= _Enable_if_floating<_Tp>(0.577215664901532860606512090082402431L);

template<typename _Tp>
inline constexpr _Tp phi_v
= _Enable_if_floating<_Tp>(1.618033988749894848204586834365638118L);

inline constexpr double e = e_v<double>;

inline constexpr double log2e = log2e_v<double>;
inline constexpr double log10e = log10e_v<double>;
inline constexpr double pi = pi_v<double>;
inline constexpr double inv_pi = inv_pi_v<double>;
inline constexpr double inv_sqrtpi = inv_sqrtpi_v<double>;
inline constexpr double ln2 = ln2_v<double>;
inline constexpr double ln10 = ln10_v<double>;
inline constexpr double sqrt2 = sqrt2_v<double>;
inline constexpr double sqrt3 = sqrt3_v<double>;
inline constexpr double inv_sqrt3 = inv_sqrt3_v<double>;
inline constexpr double egamma = egamma_v<double>;
inline constexpr double phi = phi_v<double>;
# 205 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/numbers" 3
template<> inline constexpr _Float16 e_v<_Float16> =
2.718281828459045235360287471352662498F16; template<> inline constexpr _Float16
log2e_v<_Float16> = 1.442695040888963407359924681001892137F16; template<> inline
constexpr _Float16 log10e_v<_Float16> = 0.434294481903251827651128918916605082F16;
template<> inline constexpr _Float16 pi_v<_Float16> =
3.141592653589793238462643383279502884F16; template<> inline constexpr _Float16
inv_pi_v<_Float16> = 0.318309886183790671537767526745028724F16; template<> inline
constexpr _Float16 inv_sqrtpi_v<_Float16> =
0.564189583547756286948079451560772586F16; template<> inline constexpr _Float16
ln2_v<_Float16> = 0.693147180559945309417232121458176568F16; template<> inline
constexpr _Float16 ln10_v<_Float16> = 2.302585092994045684017991454684364208F16;
template<> inline constexpr _Float16 sqrt2_v<_Float16> =
1.414213562373095048801688724209698079F16; template<> inline constexpr _Float16
sqrt3_v<_Float16> = 1.732050807568877293527446341505872367F16; template<> inline
constexpr _Float16 inv_sqrt3_v<_Float16> =
0.577350269189625764509148780501957456F16; template<> inline constexpr _Float16
egamma_v<_Float16> = 0.577215664901532860606512090082402431F16; template<> inline
constexpr _Float16 phi_v<_Float16> = 1.618033988749894848204586834365638118F16;

template<> inline constexpr _Float32 e_v<_Float32> =

2.718281828459045235360287471352662498F32; template<> inline constexpr _Float32
log2e_v<_Float32> = 1.442695040888963407359924681001892137F32; template<> inline
constexpr _Float32 log10e_v<_Float32> = 0.434294481903251827651128918916605082F32;
template<> inline constexpr _Float32 pi_v<_Float32> =
3.141592653589793238462643383279502884F32; template<> inline constexpr _Float32
inv_pi_v<_Float32> = 0.318309886183790671537767526745028724F32; template<> inline
constexpr _Float32 inv_sqrtpi_v<_Float32> =
0.564189583547756286948079451560772586F32; template<> inline constexpr _Float32
ln2_v<_Float32> = 0.693147180559945309417232121458176568F32; template<> inline
constexpr _Float32 ln10_v<_Float32> = 2.302585092994045684017991454684364208F32;
template<> inline constexpr _Float32 sqrt2_v<_Float32> =
1.414213562373095048801688724209698079F32; template<> inline constexpr _Float32
sqrt3_v<_Float32> = 1.732050807568877293527446341505872367F32; template<> inline
constexpr _Float32 inv_sqrt3_v<_Float32> =
0.577350269189625764509148780501957456F32; template<> inline constexpr _Float32
egamma_v<_Float32> = 0.577215664901532860606512090082402431F32; template<> inline
constexpr _Float32 phi_v<_Float32> = 1.618033988749894848204586834365638118F32;

template<> inline constexpr _Float64 e_v<_Float64> =

2.718281828459045235360287471352662498F64; template<> inline constexpr _Float64
log2e_v<_Float64> = 1.442695040888963407359924681001892137F64; template<> inline
constexpr _Float64 log10e_v<_Float64> = 0.434294481903251827651128918916605082F64;
template<> inline constexpr _Float64 pi_v<_Float64> =
3.141592653589793238462643383279502884F64; template<> inline constexpr _Float64
inv_pi_v<_Float64> = 0.318309886183790671537767526745028724F64; template<> inline
constexpr _Float64 inv_sqrtpi_v<_Float64> =
0.564189583547756286948079451560772586F64; template<> inline constexpr _Float64
ln2_v<_Float64> = 0.693147180559945309417232121458176568F64; template<> inline
constexpr _Float64 ln10_v<_Float64> = 2.302585092994045684017991454684364208F64;
template<> inline constexpr _Float64 sqrt2_v<_Float64> =
1.414213562373095048801688724209698079F64; template<> inline constexpr _Float64
sqrt3_v<_Float64> = 1.732050807568877293527446341505872367F64; template<> inline
constexpr _Float64 inv_sqrt3_v<_Float64> =
0.577350269189625764509148780501957456F64; template<> inline constexpr _Float64
egamma_v<_Float64> = 0.577215664901532860606512090082402431F64; template<> inline
constexpr _Float64 phi_v<_Float64> = 1.618033988749894848204586834365638118F64;

template<> inline constexpr _Float128 e_v<_Float128> =

2.718281828459045235360287471352662498F128; template<> inline constexpr _Float128
log2e_v<_Float128> = 1.442695040888963407359924681001892137F128; template<> inline
constexpr _Float128 log10e_v<_Float128> =
0.434294481903251827651128918916605082F128; template<> inline constexpr _Float128
pi_v<_Float128> = 3.141592653589793238462643383279502884F128; template<> inline
constexpr _Float128 inv_pi_v<_Float128> =
0.318309886183790671537767526745028724F128; template<> inline constexpr _Float128
inv_sqrtpi_v<_Float128> = 0.564189583547756286948079451560772586F128; template<>
inline constexpr _Float128 ln2_v<_Float128> =
0.693147180559945309417232121458176568F128; template<> inline constexpr _Float128
ln10_v<_Float128> = 2.302585092994045684017991454684364208F128; template<> inline
constexpr _Float128 sqrt2_v<_Float128> =
1.414213562373095048801688724209698079F128; template<> inline constexpr _Float128
sqrt3_v<_Float128> = 1.732050807568877293527446341505872367F128; template<> inline
constexpr _Float128 inv_sqrt3_v<_Float128> =
0.577350269189625764509148780501957456F128; template<> inline constexpr _Float128
egamma_v<_Float128> = 0.577215664901532860606512090082402431F128; template<> inline
constexpr _Float128 phi_v<_Float128> = 1.618033988749894848204586834365638118F128;

template<> inline constexpr __float128 e_v<__float128> =

2.718281828459045235360287471352662498Q; template<> inline constexpr __float128
log2e_v<__float128> = 1.442695040888963407359924681001892137Q; template<> inline
constexpr __float128 log10e_v<__float128> =
0.434294481903251827651128918916605082Q; template<> inline constexpr __float128
pi_v<__float128> = 3.141592653589793238462643383279502884Q; template<> inline
constexpr __float128 inv_pi_v<__float128> =
0.318309886183790671537767526745028724Q; template<> inline constexpr __float128
inv_sqrtpi_v<__float128> = 0.564189583547756286948079451560772586Q; template<>
inline constexpr __float128 ln2_v<__float128> =
0.693147180559945309417232121458176568Q; template<> inline constexpr __float128
ln10_v<__float128> = 2.302585092994045684017991454684364208Q; template<> inline
constexpr __float128 sqrt2_v<__float128> = 1.414213562373095048801688724209698079Q;
template<> inline constexpr __float128 sqrt3_v<__float128> =
1.732050807568877293527446341505872367Q; template<> inline constexpr __float128
inv_sqrt3_v<__float128> = 0.577350269189625764509148780501957456Q; template<>
inline constexpr __float128 egamma_v<__float128> =
0.577215664901532860606512090082402431Q; template<> inline constexpr __float128
phi_v<__float128> = 1.618033988749894848204586834365638118Q;

}
}
# 38 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/max_size_type.h" 2 3
# 48 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/max_size_type.h" 3
namespace std
{

template<typename _Tp>
struct numeric_limits;

namespace ranges
{
namespace __detail
{
class __max_size_type
{
public:
__max_size_type() = default;

template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>

constexpr
__max_size_type(_Tp __i) noexcept
: _M_val(__i), _M_msb(__i < 0)
{ }

constexpr explicit
__max_size_type(const __max_diff_type& __d) noexcept;

template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>

constexpr explicit
operator _Tp() const noexcept
{ return _M_val; }

constexpr explicit
operator bool() const noexcept
{ return _M_val != 0 || _M_msb != 0; }

constexpr __max_size_type
operator+() const noexcept
{ return *this; }

constexpr __max_size_type
operator~() const noexcept
{ return __max_size_type{~_M_val, !_M_msb}; }

constexpr __max_size_type
operator-() const noexcept
{ return operator~() + 1; }

constexpr __max_size_type&
operator++() noexcept
{ return *this += 1; }

constexpr __max_size_type
operator++(int) noexcept
{
auto __tmp = *this;
++*this;
return __tmp;
}

constexpr __max_size_type&
operator--() noexcept
{ return *this -= 1; }

constexpr __max_size_type
operator--(int) noexcept
{
auto __tmp = *this;
--*this;
return __tmp;
}

constexpr __max_size_type&
operator+=(const __max_size_type& __r) noexcept
{
const auto __sum = _M_val + __r._M_val;
const bool __overflow = (__sum < _M_val);
_M_msb = _M_msb ^ __r._M_msb ^ __overflow;
_M_val = __sum;
return *this;
}

constexpr __max_size_type&
operator-=(const __max_size_type& __r) noexcept
{ return *this += -__r; }

constexpr __max_size_type&
operator*=(__max_size_type __r) noexcept
{
constexpr __max_size_type __threshold
= __rep(1) << (_S_rep_bits / 2 - 1);
if (_M_val < __threshold && __r < __threshold)

_M_val = _M_val * __r._M_val;

else
{

const bool __lsb = _M_val & 1;

const bool __rlsb = __r._M_val & 1;
*this >>= 1;
__r >>= 1;
_M_val = (2 * _M_val * __r._M_val
+ _M_val * __rlsb + __r._M_val * __lsb);
*this <<= 1;
*this += __rlsb * __lsb;
}

return *this;
}

constexpr __max_size_type&
operator/=(const __max_size_type& __r) noexcept
{
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__r != 0),
false)) std::__glibcxx_assert_fail(); } while (false);

if (!_M_msb && !__r._M_msb) [[likely]]

_M_val /= __r._M_val;
else if (_M_msb && __r._M_msb)
{
_M_val = (_M_val >= __r._M_val);
_M_msb = 0;
}
else if (!_M_msb && __r._M_msb)
_M_val = 0;
else if (_M_msb && !__r._M_msb)
{

const auto __orig = *this;

*this >>= 1;
_M_val /= __r._M_val;
*this <<= 1;
if (__orig - *this * __r >= __r)
++_M_val;
}
return *this;
}

constexpr __max_size_type&
operator%=(const __max_size_type& __r) noexcept
{
if (!_M_msb && !__r._M_msb) [[likely]]
_M_val %= __r._M_val;
else
*this -= (*this / __r) * __r;
return *this;
}

constexpr __max_size_type&
operator<<=(const __max_size_type& __r) noexcept
{
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__r <=
_S_rep_bits), false)) std::__glibcxx_assert_fail(); } while (false);
if (__r != 0)
{
_M_msb = (_M_val >> (_S_rep_bits - __r._M_val)) & 1;

if (__r._M_val == _S_rep_bits) [[unlikely]]

_M_val = 0;
else
_M_val <<= __r._M_val;
}
return *this;
}

constexpr __max_size_type&
operator>>=(const __max_size_type& __r) noexcept
{
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__r <=
_S_rep_bits), false)) std::__glibcxx_assert_fail(); } while (false);
if (__r != 0)
{
if (__r._M_val == _S_rep_bits) [[unlikely]]
_M_val = 0;
else
_M_val >>= __r._M_val;

if (_M_msb) [[unlikely]]
{
_M_val |= __rep(1) << (_S_rep_bits - __r._M_val);
_M_msb = 0;
}
}
return *this;
}

constexpr __max_size_type&
operator&=(const __max_size_type& __r) noexcept
{
_M_val &= __r._M_val;
_M_msb &= __r._M_msb;
return *this;
}

constexpr __max_size_type&
operator|=(const __max_size_type& __r) noexcept
{
_M_val |= __r._M_val;
_M_msb |= __r._M_msb;
return *this;
}

constexpr __max_size_type&
operator^=(const __max_size_type& __r) noexcept
{
_M_val ^= __r._M_val;
_M_msb ^= __r._M_msb;
return *this;
}

template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>

friend constexpr _Tp&
operator+=(_Tp& __a, const __max_size_type& __b) noexcept
{ return (__a = static_cast<_Tp>(__a + __b)); }

template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>

friend constexpr _Tp&
operator-=(_Tp& __a, const __max_size_type& __b) noexcept
{ return (__a = static_cast<_Tp>(__a - __b)); }

template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>

friend constexpr _Tp&
operator*=(_Tp& __a, const __max_size_type& __b) noexcept
{ return (__a = static_cast<_Tp>(__a * __b)); }

template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>

friend constexpr _Tp&
operator/=(_Tp& __a, const __max_size_type& __b) noexcept
{ return (__a = static_cast<_Tp>(__a / __b)); }

template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>

friend constexpr _Tp&
operator%=(_Tp& __a, const __max_size_type& __b) noexcept
{ return (__a = static_cast<_Tp>(__a % __b)); }

template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>

friend constexpr _Tp&
operator&=(_Tp& __a, const __max_size_type& __b) noexcept
{ return (__a = static_cast<_Tp>(__a & __b)); }

template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>

friend constexpr _Tp&
operator|=(_Tp& __a, const __max_size_type& __b) noexcept
{ return (__a = static_cast<_Tp>(__a | __b)); }

template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>

friend constexpr _Tp&
operator^=(_Tp& __a, const __max_size_type& __b) noexcept
{ return (__a = static_cast<_Tp>(__a ^ __b)); }

template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>

friend constexpr _Tp&
operator<<=(_Tp& __a, const __max_size_type& __b) noexcept
{ return (__a = static_cast<_Tp>(__a << __b)); }

template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>

friend constexpr _Tp&
operator>>=(_Tp& __a, const __max_size_type& __b) noexcept
{ return (__a = static_cast<_Tp>(__a >> __b)); }

friend constexpr __max_size_type

operator+(__max_size_type __l, const __max_size_type& __r) noexcept
{
__l += __r;
return __l;
}

friend constexpr __max_size_type

operator-(__max_size_type __l, const __max_size_type& __r) noexcept
{
__l -= __r;
return __l;
}

friend constexpr __max_size_type

operator*(__max_size_type __l, const __max_size_type& __r) noexcept
{
__l *= __r;
return __l;
}

friend constexpr __max_size_type

operator/(__max_size_type __l, const __max_size_type& __r) noexcept
{
__l /= __r;
return __l;
}
friend constexpr __max_size_type
operator%(__max_size_type __l, const __max_size_type& __r) noexcept
{
__l %= __r;
return __l;
}

friend constexpr __max_size_type

operator<<(__max_size_type __l, const __max_size_type& __r) noexcept
{
__l <<= __r;
return __l;
}

friend constexpr __max_size_type

operator>>(__max_size_type __l, const __max_size_type& __r) noexcept
{
__l >>= __r;
return __l;
}

friend constexpr __max_size_type

operator&(__max_size_type __l, const __max_size_type& __r) noexcept
{
__l &= __r;
return __l;
}

friend constexpr __max_size_type

operator|(__max_size_type __l, const __max_size_type& __r) noexcept
{
__l |= __r;
return __l;
}

friend constexpr __max_size_type

operator^(__max_size_type __l, const __max_size_type& __r) noexcept
{
__l ^= __r;
return __l;
}

friend constexpr bool

operator==(const __max_size_type& __l, const __max_size_type& __r) noexcept
{ return __l._M_val == __r._M_val && __l._M_msb == __r._M_msb; }

friend constexpr strong_ordering

operator<=>(const __max_size_type& __l, const __max_size_type& __r) noexcept
{
if (__l._M_msb ^ __r._M_msb)
return __l._M_msb ? strong_ordering::greater : strong_ordering::less;
else
return __l._M_val <=> __r._M_val;
}
# 420 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/max_size_type.h" 3
__extension__
using __rep = unsigned __int128;
static constexpr size_t _S_rep_bits = sizeof(__rep) * 8;
private:
__rep _M_val = 0;
unsigned _M_msb:1 = 0;

constexpr explicit
__max_size_type(__rep __val, int __msb) noexcept
: _M_val(__val), _M_msb(__msb)
{ }

friend __max_diff_type;
friend std::numeric_limits<__max_size_type>;
friend std::numeric_limits<__max_diff_type>;
};

class __max_diff_type
{
public:
__max_diff_type() = default;

template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>

constexpr
__max_diff_type(_Tp __i) noexcept
: _M_rep(__i)
{ }

constexpr explicit
__max_diff_type(const __max_size_type& __d) noexcept
: _M_rep(__d)
{ }

template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>

constexpr explicit
operator _Tp() const noexcept
{ return static_cast<_Tp>(_M_rep); }

constexpr explicit
operator bool() const noexcept
{ return _M_rep != 0; }

constexpr __max_diff_type
operator+() const noexcept
{ return *this; }

constexpr __max_diff_type
operator-() const noexcept
{ return __max_diff_type(-_M_rep); }

constexpr __max_diff_type
operator~() const noexcept
{ return __max_diff_type(~_M_rep); }

constexpr __max_diff_type&
operator++() noexcept
{ return *this += 1; }
constexpr __max_diff_type
operator++(int) noexcept
{
auto __tmp = *this;
++*this;
return __tmp;
}

constexpr __max_diff_type&
operator--() noexcept
{ return *this -= 1; }

constexpr __max_diff_type
operator--(int) noexcept
{
auto __tmp = *this;
--*this;
return __tmp;
}

constexpr __max_diff_type&
operator+=(const __max_diff_type& __r) noexcept
{
_M_rep += __r._M_rep;
return *this;
}

constexpr __max_diff_type&
operator-=(const __max_diff_type& __r) noexcept
{
_M_rep -= __r._M_rep;
return *this;
}

constexpr __max_diff_type&
operator*=(const __max_diff_type& __r) noexcept
{
_M_rep *= __r._M_rep;
return *this;
}

constexpr __max_diff_type&
operator/=(const __max_diff_type& __r) noexcept
{
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__r != 0),
false)) std::__glibcxx_assert_fail(); } while (false);
const bool __neg = *this < 0;
const bool __rneg = __r < 0;
if (!__neg && !__rneg)
_M_rep = _M_rep / __r._M_rep;
else if (__neg && __rneg)
_M_rep = -_M_rep / -__r._M_rep;
else if (__neg && !__rneg)
_M_rep = -(-_M_rep / __r._M_rep);
else
_M_rep = -(_M_rep / -__r._M_rep);
return *this ;
}
constexpr __max_diff_type&
operator%=(const __max_diff_type& __r) noexcept
{
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__r != 0),
false)) std::__glibcxx_assert_fail(); } while (false);
if (*this >= 0 && __r > 0)
_M_rep %= __r._M_rep;
else
*this -= (*this / __r) * __r;
return *this;
}

constexpr __max_diff_type&
operator<<=(const __max_diff_type& __r) noexcept
{
_M_rep.operator<<=(__r._M_rep);
return *this;
}

constexpr __max_diff_type&
operator>>=(const __max_diff_type& __r) noexcept
{

const auto __msb = _M_rep._M_msb;

_M_rep >>= __r._M_rep;
if (__msb)
_M_rep |= ~(__max_size_type(-1) >> __r._M_rep);
return *this;
}

constexpr __max_diff_type&
operator&=(const __max_diff_type& __r) noexcept
{
_M_rep &= __r._M_rep;
return *this;
}

constexpr __max_diff_type&
operator|=(const __max_diff_type& __r) noexcept
{
_M_rep |= __r._M_rep;
return *this;
}

constexpr __max_diff_type&
operator^=(const __max_diff_type& __r) noexcept
{
_M_rep ^= __r._M_rep;
return *this;
}

template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>

friend constexpr _Tp&
operator+=(_Tp& __a, const __max_diff_type& __b) noexcept
{ return (__a = static_cast<_Tp>(__a + __b)); }

template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>

friend constexpr _Tp&
operator-=(_Tp& __a, const __max_diff_type& __b) noexcept
{ return (__a = static_cast<_Tp>(__a - __b)); }

template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>

friend constexpr _Tp&
operator*=(_Tp& __a, const __max_diff_type& __b) noexcept
{ return (__a = static_cast<_Tp>(__a * __b)); }

template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>

friend constexpr _Tp&
operator/=(_Tp& __a, const __max_diff_type& __b) noexcept
{ return (__a = static_cast<_Tp>(__a / __b)); }

template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>

friend constexpr _Tp&
operator%=(_Tp& __a, const __max_diff_type& __b) noexcept
{ return (__a = static_cast<_Tp>(__a % __b)); }

template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>

friend constexpr _Tp&
operator&=(_Tp& __a, const __max_diff_type& __b) noexcept
{ return (__a = static_cast<_Tp>(__a & __b)); }

template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>

friend constexpr _Tp&
operator|=(_Tp& __a, const __max_diff_type& __b) noexcept
{ return (__a = static_cast<_Tp>(__a | __b)); }

template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>

friend constexpr _Tp&
operator^=(_Tp& __a, const __max_diff_type& __b) noexcept
{ return (__a = static_cast<_Tp>(__a ^ __b)); }

template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>

friend constexpr _Tp&
operator<<=(_Tp& __a, const __max_diff_type& __b) noexcept
{ return (__a = static_cast<_Tp>(__a << __b)); }

template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>

friend constexpr _Tp&
operator>>=(_Tp& __a, const __max_diff_type& __b) noexcept
{ return (__a = static_cast<_Tp>(__a >> __b)); }

friend constexpr __max_diff_type

operator+(__max_diff_type __l, const __max_diff_type& __r) noexcept
{
__l += __r;
return __l;
}

friend constexpr __max_diff_type

operator-(__max_diff_type __l, const __max_diff_type& __r) noexcept
{
__l -= __r;
return __l;
}

friend constexpr __max_diff_type

operator*(__max_diff_type __l, const __max_diff_type& __r) noexcept
{
__l *= __r;
return __l;
}

friend constexpr __max_diff_type

operator/(__max_diff_type __l, const __max_diff_type& __r) noexcept
{
__l /= __r;
return __l;
}

friend constexpr __max_diff_type

operator%(__max_diff_type __l, const __max_diff_type& __r) noexcept
{
__l %= __r;
return __l;
}

friend constexpr __max_diff_type

operator<<(__max_diff_type __l, const __max_diff_type& __r) noexcept
{
__l <<= __r;
return __l;
}

friend constexpr __max_diff_type

operator>>(__max_diff_type __l, const __max_diff_type& __r) noexcept
{
__l >>= __r;
return __l;
}

friend constexpr __max_diff_type

operator&(__max_diff_type __l, const __max_diff_type& __r) noexcept
{
__l &= __r;
return __l;
}

friend constexpr __max_diff_type

operator|(__max_diff_type __l, const __max_diff_type& __r) noexcept
{
__l |= __r;
return __l;
}

friend constexpr __max_diff_type

operator^(__max_diff_type __l, const __max_diff_type& __r) noexcept
{
__l ^= __r;
return __l;
}

friend constexpr bool

operator==(const __max_diff_type& __l, const __max_diff_type& __r) noexcept
{ return __l._M_rep == __r._M_rep; }

constexpr strong_ordering
operator<=>(const __max_diff_type& __r) const noexcept
{
const auto __lsign = _M_rep._M_msb;
const auto __rsign = __r._M_rep._M_msb;
if (__lsign ^ __rsign)
return __lsign ? strong_ordering::less : strong_ordering::greater;
else
return _M_rep <=> __r._M_rep;
}
# 753 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/max_size_type.h" 3
private:
__max_size_type _M_rep = 0;

friend class __max_size_type;

};

constexpr
__max_size_type::__max_size_type(const __max_diff_type& __d) noexcept
: __max_size_type(__d._M_rep)
{ }

}
}

template<>
struct numeric_limits<ranges::__detail::__max_size_type>
{
using _Sp = ranges::__detail::__max_size_type;
static constexpr bool is_specialized = true;
static constexpr bool is_signed = false;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int digits
= __gnu_cxx::__int_traits<_Sp::__rep>::__digits + 1;
static constexpr int digits10
= static_cast<int>(digits * numbers::ln2 / numbers::ln10);

static constexpr _Sp

min() noexcept
{ return 0; }

static constexpr _Sp

max() noexcept
{ return _Sp(static_cast<_Sp::__rep>(-1), 1); }

static constexpr _Sp

lowest() noexcept
{ return min(); }
};

template<>
struct numeric_limits<ranges::__detail::__max_diff_type>
{
using _Dp = ranges::__detail::__max_diff_type;
using _Sp = ranges::__detail::__max_size_type;
static constexpr bool is_specialized = true;
static constexpr bool is_signed = true;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr int digits = numeric_limits<_Sp>::digits - 1;
static constexpr int digits10
= static_cast<int>(digits * numbers::ln2 / numbers::ln10);

static constexpr _Dp

min() noexcept
{ return _Dp(_Sp(0, 1)); }

static constexpr _Dp

max() noexcept
{ return _Dp(_Sp(static_cast<_Sp::__rep>(-1), 0)); }

static constexpr _Dp

lowest() noexcept
{ return min(); }
};

}
# 40 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/ranges_base.h" 2 3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 1 3
# 47 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 3

# 48 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 3
# 41 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/ranges_base.h" 2 3

namespace std
{

namespace ranges
{
template<typename>
inline constexpr bool disable_sized_range = false;

template<typename _Tp>
inline constexpr bool enable_borrowed_range = false;

namespace __detail
{
constexpr __max_size_type
__to_unsigned_like(__max_size_type __t) noexcept
{ return __t; }

constexpr __max_size_type
__to_unsigned_like(__max_diff_type __t) noexcept
{ return __max_size_type(__t); }

template<integral _Tp>
constexpr auto
__to_unsigned_like(_Tp __t) noexcept
{ return static_cast<make_unsigned_t<_Tp>>(__t); }
# 79 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/ranges_base.h" 3
template<typename _Tp>
using __make_unsigned_like_t
= decltype(__detail::__to_unsigned_like(std::declval<_Tp>()));

template<typename _Tp>
concept __maybe_borrowed_range
= is_lvalue_reference_v<_Tp>
|| enable_borrowed_range<remove_cvref_t<_Tp>>;

namespace __access
{
using std::ranges::__detail::__maybe_borrowed_range;
using std::__detail::__range_iter_t;

struct _Begin
{
private:
template<typename _Tp>
static constexpr bool
_S_noexcept()
{
if constexpr (is_array_v<remove_reference_t<_Tp>>)
return true;
else if constexpr (__member_begin<_Tp>)
return noexcept(__decay_copy(std::declval<_Tp&>().begin()));
else
return noexcept(__decay_copy(begin(std::declval<_Tp&>())));
}

public:
template<__maybe_borrowed_range _Tp>
requires is_array_v<remove_reference_t<_Tp>> || __member_begin<_Tp>
|| __adl_begin<_Tp>
constexpr auto
operator()[[nodiscard]](_Tp&& __t) const noexcept(_S_noexcept<_Tp&>())
{
if constexpr (is_array_v<remove_reference_t<_Tp>>)
{
static_assert(is_lvalue_reference_v<_Tp>);
return __t + 0;
}
else if constexpr (__member_begin<_Tp>)
return __t.begin();
else
return begin(__t);
}
};

template<typename _Tp>
concept __member_end = requires(_Tp& __t)
{
{ __decay_copy(__t.end()) } -> sentinel_for<__range_iter_t<_Tp>>;
};

void end() = delete;

template<typename _Tp>
concept __adl_end = __class_or_enum<remove_reference_t<_Tp>>
&& requires(_Tp& __t)
{
{ __decay_copy(end(__t)) } -> sentinel_for<__range_iter_t<_Tp>>;
};

struct _End
{
private:
template<typename _Tp>
static constexpr bool
_S_noexcept()
{
if constexpr (is_bounded_array_v<remove_reference_t<_Tp>>)
return true;
else if constexpr (__member_end<_Tp>)
return noexcept(__decay_copy(std::declval<_Tp&>().end()));
else
return noexcept(__decay_copy(end(std::declval<_Tp&>())));
}

public:
template<__maybe_borrowed_range _Tp>
requires is_bounded_array_v<remove_reference_t<_Tp>>
|| __member_end<_Tp> || __adl_end<_Tp>
constexpr auto
operator()[[nodiscard]](_Tp&& __t) const noexcept(_S_noexcept<_Tp&>())
{
if constexpr (is_bounded_array_v<remove_reference_t<_Tp>>)
{
static_assert(is_lvalue_reference_v<_Tp>);
return __t + extent_v<remove_reference_t<_Tp>>;
}
else if constexpr (__member_end<_Tp>)
return __t.end();
else
return end(__t);
}
};

template<typename _Tp>
concept __member_rbegin = requires(_Tp& __t)
{
{ __decay_copy(__t.rbegin()) } -> input_or_output_iterator;
};

void rbegin() = delete;

template<typename _Tp>
concept __adl_rbegin = __class_or_enum<remove_reference_t<_Tp>>
&& requires(_Tp& __t)
{
{ __decay_copy(rbegin(__t)) } -> input_or_output_iterator;
};

template<typename _Tp>
concept __reversable = requires(_Tp& __t)
{
{ _Begin{}(__t) } -> bidirectional_iterator;
{ _End{}(__t) } -> same_as<decltype(_Begin{}(__t))>;
};
struct _RBegin
{
private:
template<typename _Tp>
static constexpr bool
_S_noexcept()
{
if constexpr (__member_rbegin<_Tp>)
return noexcept(__decay_copy(std::declval<_Tp&>().rbegin()));
else if constexpr (__adl_rbegin<_Tp>)
return noexcept(__decay_copy(rbegin(std::declval<_Tp&>())));
else
{
if constexpr (noexcept(_End{}(std::declval<_Tp&>())))
{
using _It = decltype(_End{}(std::declval<_Tp&>()));

return is_nothrow_copy_constructible_v<_It>;
}
else
return false;
}
}

public:
template<__maybe_borrowed_range _Tp>
requires __member_rbegin<_Tp> || __adl_rbegin<_Tp> || __reversable<_Tp>
constexpr auto
operator()[[nodiscard]](_Tp&& __t) const
noexcept(_S_noexcept<_Tp&>())
{
if constexpr (__member_rbegin<_Tp>)
return __t.rbegin();
else if constexpr (__adl_rbegin<_Tp>)
return rbegin(__t);
else
return std::make_reverse_iterator(_End{}(__t));
}
};

template<typename _Tp>
concept __member_rend = requires(_Tp& __t)
{
{ __decay_copy(__t.rend()) }
-> sentinel_for<decltype(_RBegin{}(std::forward<_Tp>(__t)))>;
};

void rend() = delete;

template<typename _Tp>
concept __adl_rend = __class_or_enum<remove_reference_t<_Tp>>
&& requires(_Tp& __t)
{
{ __decay_copy(rend(__t)) }
-> sentinel_for<decltype(_RBegin{}(std::forward<_Tp>(__t)))>;
};

struct _REnd
{
private:
template<typename _Tp>
static constexpr bool
_S_noexcept()
{
if constexpr (__member_rend<_Tp>)
return noexcept(__decay_copy(std::declval<_Tp&>().rend()));
else if constexpr (__adl_rend<_Tp>)
return noexcept(__decay_copy(rend(std::declval<_Tp&>())));
else
{
if constexpr (noexcept(_Begin{}(std::declval<_Tp&>())))
{
using _It = decltype(_Begin{}(std::declval<_Tp&>()));

return is_nothrow_copy_constructible_v<_It>;
}
else
return false;
}
}

public:
template<__maybe_borrowed_range _Tp>
requires __member_rend<_Tp> || __adl_rend<_Tp> || __reversable<_Tp>
constexpr auto
operator()[[nodiscard]](_Tp&& __t) const
noexcept(_S_noexcept<_Tp&>())
{
if constexpr (__member_rend<_Tp>)
return __t.rend();
else if constexpr (__adl_rend<_Tp>)
return rend(__t);
else
return std::make_reverse_iterator(_Begin{}(__t));
}
};

template<typename _Tp>
concept __member_size = !disable_sized_range<remove_cvref_t<_Tp>>
&& requires(_Tp& __t)
{
{ __decay_copy(__t.size()) } -> __detail::__is_integer_like;
};

void size() = delete;

template<typename _Tp>
concept __adl_size = __class_or_enum<remove_reference_t<_Tp>>
&& !disable_sized_range<remove_cvref_t<_Tp>>
&& requires(_Tp& __t)
{
{ __decay_copy(size(__t)) } -> __detail::__is_integer_like;
};

template<typename _Tp>
concept __sentinel_size = requires(_Tp& __t)
{
requires (!is_unbounded_array_v<remove_reference_t<_Tp>>);
{ _Begin{}(__t) } -> forward_iterator;

{ _End{}(__t) } -> sized_sentinel_for<decltype(_Begin{}(__t))>;

__detail::__to_unsigned_like(_End{}(__t) - _Begin{}(__t));
};

struct _Size
{
private:
template<typename _Tp>
static constexpr bool
_S_noexcept()
{
if constexpr (is_bounded_array_v<remove_reference_t<_Tp>>)
return true;
else if constexpr (__member_size<_Tp>)
return noexcept(__decay_copy(std::declval<_Tp&>().size()));
else if constexpr (__adl_size<_Tp>)
return noexcept(__decay_copy(size(std::declval<_Tp&>())));
else if constexpr (__sentinel_size<_Tp>)
return noexcept(_End{}(std::declval<_Tp&>())
- _Begin{}(std::declval<_Tp&>()));
}

public:
template<typename _Tp>
requires is_bounded_array_v<remove_reference_t<_Tp>>
|| __member_size<_Tp> || __adl_size<_Tp> || __sentinel_size<_Tp>
constexpr auto
operator()[[nodiscard]](_Tp&& __t) const noexcept(_S_noexcept<_Tp&>())
{
if constexpr (is_bounded_array_v<remove_reference_t<_Tp>>)
return extent_v<remove_reference_t<_Tp>>;
else if constexpr (__member_size<_Tp>)
return __t.size();
else if constexpr (__adl_size<_Tp>)
return size(__t);
else if constexpr (__sentinel_size<_Tp>)
return __detail::__to_unsigned_like(_End{}(__t) - _Begin{}(__t));
}
};

struct _SSize
{

template<typename _Tp>
requires requires (_Tp& __t) { _Size{}(__t); }
constexpr auto
operator()[[nodiscard]](_Tp&& __t) const noexcept(noexcept(_Size{}(__t)))
{
auto __size = _Size{}(__t);
using __size_type = decltype(__size);

if constexpr (integral<__size_type>)
{
using __gnu_cxx::__int_traits;
if constexpr (__int_traits<__size_type>::__digits
< __int_traits<ptrdiff_t>::__digits)
return static_cast<ptrdiff_t>(__size);
else
return static_cast<make_signed_t<__size_type>>(__size);
}

else
return __detail::__max_diff_type(__size);
}
};

template<typename _Tp>
concept __member_empty = requires(_Tp& __t) { bool(__t.empty()); };

template<typename _Tp>
concept __size0_empty = requires(_Tp& __t) { _Size{}(__t) == 0; };

template<typename _Tp>
concept __eq_iter_empty = requires(_Tp& __t)
{
requires (!is_unbounded_array_v<remove_reference_t<_Tp>>);

{ _Begin{}(__t) } -> forward_iterator;

bool(_Begin{}(__t) == _End{}(__t));
};

struct _Empty
{
private:
template<typename _Tp>
static constexpr bool
_S_noexcept()
{
if constexpr (__member_empty<_Tp>)
return noexcept(bool(std::declval<_Tp&>().empty()));
else if constexpr (__size0_empty<_Tp>)
return noexcept(_Size{}(std::declval<_Tp&>()) == 0);
else
return noexcept(bool(_Begin{}(std::declval<_Tp&>())
== _End{}(std::declval<_Tp&>())));
}

public:
template<typename _Tp>
requires __member_empty<_Tp> || __size0_empty<_Tp>
|| __eq_iter_empty<_Tp>
constexpr bool
operator()[[nodiscard]](_Tp&& __t) const noexcept(_S_noexcept<_Tp&>())
{
if constexpr (__member_empty<_Tp>)
return bool(__t.empty());
else if constexpr (__size0_empty<_Tp>)
return _Size{}(__t) == 0;
else
return bool(_Begin{}(__t) == _End{}(__t));
}
};

template<typename _Tp>
concept __pointer_to_object = is_pointer_v<_Tp>
&& is_object_v<remove_pointer_t<_Tp>>;

template<typename _Tp>
concept __member_data = requires(_Tp& __t)
{
{ __decay_copy(__t.data()) } -> __pointer_to_object;
};

template<typename _Tp>
concept __begin_data = contiguous_iterator<__range_iter_t<_Tp>>;

struct _Data
{
private:
template<typename _Tp>
static constexpr bool
_S_noexcept()
{
if constexpr (__member_data<_Tp>)
return noexcept(__decay_copy(std::declval<_Tp&>().data()));
else
return noexcept(_Begin{}(std::declval<_Tp&>()));
}

public:
template<__maybe_borrowed_range _Tp>
requires __member_data<_Tp> || __begin_data<_Tp>
constexpr auto
operator()[[nodiscard]](_Tp&& __t) const noexcept(_S_noexcept<_Tp>())
{
if constexpr (__member_data<_Tp>)
return __t.data();
else
return std::to_address(_Begin{}(__t));
}
};

inline namespace _Cpo

{
inline constexpr ranges::__access::_Begin begin{};
inline constexpr ranges::__access::_End end{};
inline constexpr ranges::__access::_RBegin rbegin{};
inline constexpr ranges::__access::_REnd rend{};
inline constexpr ranges::__access::_Size size{};
inline constexpr ranges::__access::_SSize ssize{};
inline constexpr ranges::__access::_Empty empty{};
inline constexpr ranges::__access::_Data data{};
}
template<typename _Tp>
concept range = requires(_Tp& __t)
{
ranges::begin(__t);
ranges::end(__t);
};

template<typename _Tp>
concept borrowed_range
= range<_Tp> && __detail::__maybe_borrowed_range<_Tp>;

template<typename _Tp>
using iterator_t = std::__detail::__range_iter_t<_Tp>;

template<range _Range>
using sentinel_t = decltype(ranges::end(std::declval<_Range&>()));

template<range _Range>
using const_iterator_t = const_iterator<iterator_t<_Range>>;

template<range _Range>
using const_sentinel_t = const_sentinel<sentinel_t<_Range>>;

template<range _Range>
using range_const_reference_t = iter_const_reference_t<iterator_t<_Range>>;

template<range _Range>
using range_difference_t = iter_difference_t<iterator_t<_Range>>;

template<range _Range>
using range_value_t = iter_value_t<iterator_t<_Range>>;

template<range _Range>
using range_reference_t = iter_reference_t<iterator_t<_Range>>;

template<range _Range>
using range_rvalue_reference_t
= iter_rvalue_reference_t<iterator_t<_Range>>;

template<typename _Tp>
concept sized_range = range<_Tp>
&& requires(_Tp& __t) { ranges::size(__t); };

template<sized_range _Range>
using range_size_t = decltype(ranges::size(std::declval<_Range&>()));

template<typename _Derived>
requires is_class_v<_Derived> && same_as<_Derived, remove_cv_t<_Derived>>
class view_interface;

namespace __detail
{
template<typename _Tp, typename _Up>
requires (!same_as<_Tp, view_interface<_Up>>)
void __is_derived_from_view_interface_fn(const _Tp&,
const view_interface<_Up>&);

template<typename _Tp>
concept __is_derived_from_view_interface
= requires (_Tp __t) { __is_derived_from_view_interface_fn(__t, __t); };
}

struct view_base { };

template<typename _Tp>
inline constexpr bool enable_view = derived_from<_Tp, view_base>
|| __detail::__is_derived_from_view_interface<_Tp>;

template<typename _Tp>
concept view
= range<_Tp> && movable<_Tp> && enable_view<_Tp>;

template<typename _Range, typename _Tp>

concept output_range
= range<_Range> && output_iterator<iterator_t<_Range>, _Tp>;

template<typename _Tp>
concept input_range = range<_Tp> && input_iterator<iterator_t<_Tp>>;

template<typename _Tp>
concept forward_range
= input_range<_Tp> && forward_iterator<iterator_t<_Tp>>;

template<typename _Tp>
concept bidirectional_range
= forward_range<_Tp> && bidirectional_iterator<iterator_t<_Tp>>;

template<typename _Tp>
concept random_access_range
= bidirectional_range<_Tp> && random_access_iterator<iterator_t<_Tp>>;

template<typename _Tp>
concept contiguous_range
= random_access_range<_Tp> && contiguous_iterator<iterator_t<_Tp>>
&& requires(_Tp& __t)
{
{ ranges::data(__t) } -> same_as<add_pointer_t<range_reference_t<_Tp>>>;
};

template<typename _Tp>
concept common_range
= range<_Tp> && same_as<iterator_t<_Tp>, sentinel_t<_Tp>>;

template<typename _Tp>
concept constant_range
= input_range<_Tp> && std::__detail::__constant_iterator<iterator_t<_Tp>>;

namespace __access
{

template<typename _Range>
constexpr auto&
__possibly_const_range(_Range& __r) noexcept
{
if constexpr (constant_range<const _Range> && !constant_range<_Range>)
return const_cast<const _Range&>(__r);
else
return __r;
}
# 652 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/ranges_base.h" 3
struct _CBegin
{

template<__maybe_borrowed_range _Tp>
[[nodiscard]]
constexpr auto
operator()(_Tp&& __t) const
noexcept(noexcept(std::make_const_iterator
(ranges::begin(__access::__possibly_const_range(__t)))))
requires requires { std::make_const_iterator
(ranges::begin(__access::__possibly_const_range(__t))); }
{
auto& __r = __access::__possibly_const_range(__t);
return const_iterator_t<decltype(__r)>(ranges::begin(__r));
}
# 678 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/ranges_base.h" 3
};

struct _CEnd final

{

template<__maybe_borrowed_range _Tp>
[[nodiscard]]
constexpr auto
operator()(_Tp&& __t) const
noexcept(noexcept(std::make_const_sentinel
(ranges::end(__access::__possibly_const_range(__t)))))
requires requires { std::make_const_sentinel
(ranges::end(__access::__possibly_const_range(__t))); }
{
auto& __r = __access::__possibly_const_range(__t);
return const_sentinel_t<decltype(__r)>(ranges::end(__r));
}
# 706 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/ranges_base.h" 3
};

struct _CRBegin
{

template<__maybe_borrowed_range _Tp>
[[nodiscard]]
constexpr auto
operator()(_Tp&& __t) const
noexcept(noexcept(std::make_const_iterator
(ranges::rbegin(__access::__possibly_const_range(__t)))))
requires requires { std::make_const_iterator
(ranges::rbegin(__access::__possibly_const_range(__t))); }
{
auto& __r = __access::__possibly_const_range(__t);
return const_iterator<decltype(ranges::rbegin(__r))>(ranges::rbegin(__r));
}
# 734 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/ranges_base.h" 3
};

struct _CREnd
{

template<__maybe_borrowed_range _Tp>
[[nodiscard]]
constexpr auto
operator()(_Tp&& __t) const
noexcept(noexcept(std::make_const_sentinel
(ranges::rend(__access::__possibly_const_range(__t)))))
requires requires { std::make_const_sentinel
(ranges::rend(__access::__possibly_const_range(__t))); }
{
auto& __r = __access::__possibly_const_range(__t);
return const_sentinel<decltype(ranges::rend(__r))>(ranges::rend(__r));
}
# 762 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/ranges_base.h" 3
};

struct _CData
{

template<__maybe_borrowed_range _Tp>
[[nodiscard]]
constexpr const auto*
operator()(_Tp&& __t) const
noexcept(noexcept(ranges::data(__access::__possibly_const_range(__t))))
requires requires { ranges::data(__access::__possibly_const_range(__t)); }
{ return ranges::data(__access::__possibly_const_range(__t)); }
# 785 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/ranges_base.h" 3
};
}

inline namespace _Cpo

{
inline constexpr ranges::__access::_CBegin cbegin{};
inline constexpr ranges::__access::_CEnd cend{};
inline constexpr ranges::__access::_CRBegin crbegin{};
inline constexpr ranges::__access::_CREnd crend{};
inline constexpr ranges::__access::_CData cdata{};
}

namespace __detail
{
template<typename _Tp>
inline constexpr bool __is_initializer_list = false;

template<typename _Tp>
inline constexpr bool __is_initializer_list<initializer_list<_Tp>> = true;
}

template<typename _Tp>
concept viewable_range = range<_Tp>
&& ((view<remove_cvref_t<_Tp>> && constructible_from<remove_cvref_t<_Tp>,
_Tp>)
|| (!view<remove_cvref_t<_Tp>>
&& (is_lvalue_reference_v<_Tp>
|| (movable<remove_reference_t<_Tp>>
&& !__detail::__is_initializer_list<remove_cvref_t<_Tp>>))));

struct __advance_fn final

{
template<input_or_output_iterator _It>
constexpr void
operator()(_It& __it, iter_difference_t<_It> __n) const
{
if constexpr (random_access_iterator<_It>)
__it += __n;
else if constexpr (bidirectional_iterator<_It>)
{
if (__n > 0)
{
do
{
++__it;
}
while (--__n);
}
else if (__n < 0)
{
do
{
--__it;
}
while (++__n);
}
}
else
{

do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__n >= 0),

false)) std::__glibcxx_assert_fail(); } while (false);
while (__n-- > 0)
++__it;
}
}

template<input_or_output_iterator _It, sentinel_for<_It> _Sent>

constexpr void
operator()(_It& __it, _Sent __bound) const
{
if constexpr (assignable_from<_It&, _Sent>)
__it = std::move(__bound);
else if constexpr (sized_sentinel_for<_Sent, _It>)
(*this)(__it, __bound - __it);
else
{
while (__it != __bound)
++__it;
}
}

template<input_or_output_iterator _It, sentinel_for<_It> _Sent>

constexpr iter_difference_t<_It>
operator()(_It& __it, iter_difference_t<_It> __n, _Sent __bound) const
{
if constexpr (sized_sentinel_for<_Sent, _It>)
{
const auto __diff = __bound - __it;

if (__diff == 0)
return __n;
else if (__diff > 0 ? __n >= __diff : __n <= __diff)
{
(*this)(__it, __bound);
return __n - __diff;
}
else if (__n != 0) [[likely]]
{

do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool((__n < 0) ==

(__diff < 0)), false)) std::__glibcxx_assert_fail(); } while (false);

(*this)(__it, __n);
return 0;
}
else
return 0;
}
else if (__it == __bound || __n == 0)
return __n;
else if (__n > 0)
{
iter_difference_t<_It> __m = 0;
do
{
++__it;
++__m;
}
while (__m != __n && __it != __bound);
return __n - __m;
}
else if constexpr (bidirectional_iterator<_It> && same_as<_It, _Sent>)
{
iter_difference_t<_It> __m = 0;
do
{
--__it;
--__m;
}
while (__m != __n && __it != __bound);
return __n - __m;
}
else
{

do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__n >= 0),

false)) std::__glibcxx_assert_fail(); } while (false);
return __n;
}
}

void operator&() const = delete;

};

inline constexpr __advance_fn advance{};

struct __distance_fn final

{
template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
requires (!sized_sentinel_for<_Sent, _It>)
constexpr iter_difference_t<_It>
operator()[[nodiscard]](_It __first, _Sent __last) const
{
iter_difference_t<_It> __n = 0;
while (__first != __last)
{
++__first;
++__n;
}
return __n;
}

template<input_or_output_iterator _It, sized_sentinel_for<_It> _Sent>

[[nodiscard]]
constexpr iter_difference_t<_It>
operator()(const _It& __first, const _Sent& __last) const
{
return __last - __first;
}

template<range _Range>
[[nodiscard]]
constexpr range_difference_t<_Range>
operator()(_Range&& __r) const
{
if constexpr (sized_range<_Range>)
return static_cast<range_difference_t<_Range>>(ranges::size(__r));
else
return (*this)(ranges::begin(__r), ranges::end(__r));
}

void operator&() const = delete;

};

inline constexpr __distance_fn distance{};

struct __next_fn final
{
template<input_or_output_iterator _It>
[[nodiscard]]
constexpr _It
operator()(_It __x) const
{
++__x;
return __x;
}

template<input_or_output_iterator _It>
[[nodiscard]]
constexpr _It
operator()(_It __x, iter_difference_t<_It> __n) const
{
ranges::advance(__x, __n);
return __x;
}

template<input_or_output_iterator _It, sentinel_for<_It> _Sent>

[[nodiscard]]
constexpr _It
operator()(_It __x, _Sent __bound) const
{
ranges::advance(__x, __bound);
return __x;
}

template<input_or_output_iterator _It, sentinel_for<_It> _Sent>

[[nodiscard]]
constexpr _It
operator()(_It __x, iter_difference_t<_It> __n, _Sent __bound) const
{
ranges::advance(__x, __n, __bound);
return __x;
}

void operator&() const = delete;

};

inline constexpr __next_fn next{};

struct __prev_fn final

{
template<bidirectional_iterator _It>
[[nodiscard]]
constexpr _It
operator()(_It __x) const
{
--__x;
return __x;
}

template<bidirectional_iterator _It>
[[nodiscard]]
constexpr _It
operator()(_It __x, iter_difference_t<_It> __n) const
{
ranges::advance(__x, -__n);
return __x;
}

template<bidirectional_iterator _It>
[[nodiscard]]
constexpr _It
operator()(_It __x, iter_difference_t<_It> __n, _It __bound) const
{
ranges::advance(__x, -__n, __bound);
return __x;
}

void operator&() const = delete;

};

inline constexpr __prev_fn prev{};

struct dangling
{
constexpr dangling() noexcept = default;
template<typename... _Args>
constexpr dangling(_Args&&...) noexcept { }
};

template<range _Range>
using borrowed_iterator_t = __conditional_t<borrowed_range<_Range>,
iterator_t<_Range>,
dangling>;
}

struct from_range_t { explicit from_range_t() = default; };

inline constexpr from_range_t from_range{};

}
# 57 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/string_view" 2 3

namespace std
{

constexpr size_t
__sv_check(size_t __size, size_t __pos, const char* __s)
{
if (__pos > __size)
__throw_out_of_range_fmt(("%s: __pos (which is %zu) > __size " "(which is
%zu)")
, __s, __pos, __size);
return __pos;
}

constexpr size_t
__sv_limit(size_t __size, size_t __pos, size_t __off) noexcept
{
const bool __testoff = __off < __size - __pos;
return __testoff ? __off : __size - __pos;
}
# 105 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/string_view" 3
template<typename _CharT, typename _Traits = std::char_traits<_CharT>>
class basic_string_view
{
static_assert(!is_array_v<_CharT>);
static_assert(is_trivial_v<_CharT> && is_standard_layout_v<_CharT>);
static_assert(is_same_v<_CharT, typename _Traits::char_type>);

public:

using traits_type = _Traits;

using value_type = _CharT;
using pointer = value_type*;
using const_pointer = const value_type*;
using reference = value_type&;
using const_reference = const value_type&;
using const_iterator = const value_type*;
using iterator = const_iterator;
using const_reverse_iterator = std::reverse_iterator<const_iterator>;
using reverse_iterator = const_reverse_iterator;
using size_type = size_t;
using difference_type = ptrdiff_t;
static constexpr size_type npos = size_type(-1);

constexpr
basic_string_view() noexcept
: _M_len{0}, _M_str{nullptr}
{ }

constexpr basic_string_view(const basic_string_view&) noexcept = default;

[[__gnu__::__nonnull__]]
constexpr
basic_string_view(const _CharT* __str) noexcept
: _M_len{traits_type::length(__str)},
_M_str{__str}
{ }

constexpr
basic_string_view(const _CharT* __str, size_type __len) noexcept
: _M_len{__len}, _M_str{__str}
{ }

template<contiguous_iterator _It, sized_sentinel_for<_It> _End>

requires same_as<iter_value_t<_It>, _CharT>
&& (!convertible_to<_End, size_type>)
constexpr
basic_string_view(_It __first, _End __last)
noexcept(noexcept(__last - __first))
: _M_len(__last - __first), _M_str(std::to_address(__first))
{ }

template<typename _Range, typename _DRange = remove_cvref_t<_Range>>

requires (!is_same_v<_DRange, basic_string_view>)
&& ranges::contiguous_range<_Range>
&& ranges::sized_range<_Range>
&& is_same_v<ranges::range_value_t<_Range>, _CharT>
&& (!is_convertible_v<_Range, const _CharT*>)
&& (!requires (_DRange& __d) {
__d.operator ::std::basic_string_view<_CharT, _Traits>();
})
constexpr explicit
basic_string_view(_Range&& __r)
noexcept(noexcept(ranges::size(__r)) && noexcept(ranges::data(__r)))
: _M_len(ranges::size(__r)), _M_str(ranges::data(__r))
{ }

basic_string_view(nullptr_t) = delete;

constexpr basic_string_view&
operator=(const basic_string_view&) noexcept = default;

[[nodiscard]]
constexpr const_iterator
begin() const noexcept
{ return this->_M_str; }

[[nodiscard]]
constexpr const_iterator
end() const noexcept
{ return this->_M_str + this->_M_len; }

[[nodiscard]]
constexpr const_iterator
cbegin() const noexcept
{ return this->_M_str; }

[[nodiscard]]
constexpr const_iterator
cend() const noexcept
{ return this->_M_str + this->_M_len; }

[[nodiscard]]
constexpr const_reverse_iterator
rbegin() const noexcept
{ return const_reverse_iterator(this->end()); }

[[nodiscard]]
constexpr const_reverse_iterator
rend() const noexcept
{ return const_reverse_iterator(this->begin()); }

[[nodiscard]]
constexpr const_reverse_iterator
crbegin() const noexcept
{ return const_reverse_iterator(this->end()); }

[[nodiscard]]
constexpr const_reverse_iterator
crend() const noexcept
{ return const_reverse_iterator(this->begin()); }

[[nodiscard]]
constexpr size_type
size() const noexcept
{ return this->_M_len; }

[[nodiscard]]
constexpr size_type
length() const noexcept
{ return _M_len; }

[[nodiscard]]
constexpr size_type
max_size() const noexcept
{
return (npos - sizeof(size_type) - sizeof(void*))
/ sizeof(value_type) / 4;
}

[[nodiscard]]
constexpr bool
empty() const noexcept
{ return this->_M_len == 0; }

[[nodiscard]]
constexpr const_reference
operator[](size_type __pos) const noexcept
{
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__pos < this-
>_M_len), false)) std::__glibcxx_assert_fail(); } while (false);
return *(this->_M_str + __pos);
}

[[nodiscard]]
constexpr const_reference
at(size_type __pos) const
{
if (__pos >= _M_len)
__throw_out_of_range_fmt(("basic_string_view::at: __pos " "(which is %zu) >=
this->size() " "(which is %zu)")

, __pos, this->size());
return *(this->_M_str + __pos);
}

[[nodiscard]]
constexpr const_reference
front() const noexcept
{
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(this->_M_len >
0), false)) std::__glibcxx_assert_fail(); } while (false);
return *this->_M_str;
}

[[nodiscard]]
constexpr const_reference
back() const noexcept
{
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(this->_M_len >
0), false)) std::__glibcxx_assert_fail(); } while (false);
return *(this->_M_str + this->_M_len - 1);
}

[[nodiscard]]
constexpr const_pointer
data() const noexcept
{ return this->_M_str; }

constexpr void
remove_prefix(size_type __n) noexcept
{
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(this->_M_len
>= __n), false)) std::__glibcxx_assert_fail(); } while (false);
this->_M_str += __n;
this->_M_len -= __n;
}

constexpr void
remove_suffix(size_type __n) noexcept
{
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(this->_M_len
>= __n), false)) std::__glibcxx_assert_fail(); } while (false);
this->_M_len -= __n;
}

constexpr void
swap(basic_string_view& __sv) noexcept
{
auto __tmp = *this;
*this = __sv;
__sv = __tmp;
}

constexpr
size_type
copy(_CharT* __str, size_type __n, size_type __pos = 0) const
{
;
__pos = std::__sv_check(size(), __pos, "basic_string_view::copy");
const size_type __rlen = std::min<size_t>(__n, _M_len - __pos);

traits_type::copy(str, data() + pos, __rlen);

return __rlen;
}

[[nodiscard]]
constexpr basic_string_view
substr(size_type __pos = 0, size_type __n = npos) const noexcept(false)
{
__pos = std::__sv_check(size(), __pos, "basic_string_view::substr");
const size_type __rlen = std::min<size_t>(__n, _M_len - __pos);
return basic_string_view{_M_str + __pos, __rlen};
}

[[nodiscard]]
constexpr int
compare(basic_string_view __str) const noexcept
{
const size_type __rlen = std::min(this->_M_len, __str._M_len);
int __ret = traits_type::compare(this->_M_str, __str._M_str, __rlen);
if (__ret == 0)
__ret = _S_compare(this->_M_len, __str._M_len);
return __ret;
}

[[nodiscard]]
constexpr int
compare(size_type __pos1, size_type __n1, basic_string_view __str) const
{ return this->substr(__pos1, __n1).compare(__str); }

[[nodiscard]]
constexpr int
compare(size_type __pos1, size_type __n1,
basic_string_view __str, size_type __pos2, size_type __n2) const
{
return this->substr(__pos1, __n1).compare(__str.substr(__pos2, __n2));
}

[[nodiscard, __gnu__::__nonnull__]]
constexpr int
compare(const _CharT* __str) const noexcept
{ return this->compare(basic_string_view{__str}); }

[[nodiscard, __gnu__::__nonnull__]]
constexpr int
compare(size_type __pos1, size_type __n1, const _CharT* __str) const
{ return this->substr(__pos1, __n1).compare(basic_string_view{__str}); }

[[nodiscard]]
constexpr int
compare(size_type __pos1, size_type __n1,
const _CharT* __str, size_type __n2) const noexcept(false)
{
return this->substr(__pos1, __n1)
.compare(basic_string_view(__str, __n2));
}

[[nodiscard]]
constexpr bool
starts_with(basic_string_view __x) const noexcept
{ return this->substr(0, __x.size()) == __x; }

[[nodiscard]]
constexpr bool
starts_with(_CharT __x) const noexcept
{ return !this->empty() && traits_type::eq(this->front(), __x); }

[[nodiscard, __gnu__::__nonnull__]]
constexpr bool
starts_with(const _CharT* __x) const noexcept
{ return this->starts_with(basic_string_view(__x)); }

[[nodiscard]]
constexpr bool
ends_with(basic_string_view __x) const noexcept
{
const auto __len = this->size();
const auto __xlen = __x.size();
return __len >= __xlen
&& traits_type::compare(end() - __xlen, __x.data(), __xlen) == 0;
}

[[nodiscard]]
constexpr bool
ends_with(_CharT __x) const noexcept
{ return !this->empty() && traits_type::eq(this->back(), __x); }

[[nodiscard, __gnu__::__nonnull__]]
constexpr bool
ends_with(const _CharT* __x) const noexcept
{ return this->ends_with(basic_string_view(__x)); }
# 427 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/string_view" 3
[[nodiscard]]
constexpr bool
contains(basic_string_view __x) const noexcept
{ return this->find(__x) != npos; }

[[nodiscard]]
constexpr bool
contains(_CharT __x) const noexcept
{ return this->find(__x) != npos; }

[[nodiscard, __gnu__::__nonnull__]]
constexpr bool
contains(const _CharT* __x) const noexcept
{ return this->find(__x) != npos; }

[[nodiscard]]
constexpr size_type
find(basic_string_view __str, size_type __pos = 0) const noexcept
{ return this->find(__str._M_str, __pos, __str._M_len); }

[[nodiscard]]
constexpr size_type
find(_CharT __c, size_type __pos = 0) const noexcept;

[[nodiscard]]
constexpr size_type
find(const _CharT* __str, size_type __pos, size_type __n) const noexcept;

[[nodiscard, __gnu__::__nonnull__]]
constexpr size_type
find(const _CharT* __str, size_type __pos = 0) const noexcept
{ return this->find(__str, __pos, traits_type::length(__str)); }

[[nodiscard]]
constexpr size_type
rfind(basic_string_view __str, size_type __pos = npos) const noexcept
{ return this->rfind(__str._M_str, __pos, __str._M_len); }

[[nodiscard]]
constexpr size_type
rfind(_CharT __c, size_type __pos = npos) const noexcept;

[[nodiscard]]
constexpr size_type
rfind(const _CharT* __str, size_type __pos, size_type __n) const noexcept;

[[nodiscard, __gnu__::__nonnull__]]
constexpr size_type
rfind(const _CharT* __str, size_type __pos = npos) const noexcept
{ return this->rfind(__str, __pos, traits_type::length(__str)); }

[[nodiscard]]
constexpr size_type
find_first_of(basic_string_view __str, size_type __pos = 0) const noexcept
{ return this->find_first_of(__str._M_str, __pos, __str._M_len); }

[[nodiscard]]
constexpr size_type
find_first_of(_CharT __c, size_type __pos = 0) const noexcept
{ return this->find(__c, __pos); }

[[nodiscard]]
constexpr size_type
find_first_of(const _CharT* __str, size_type __pos,
size_type __n) const noexcept;

[[nodiscard, __gnu__::__nonnull__]]
constexpr size_type
find_first_of(const _CharT* __str, size_type __pos = 0) const noexcept
{ return this->find_first_of(__str, __pos, traits_type::length(__str)); }

[[nodiscard]]
constexpr size_type
find_last_of(basic_string_view __str,
size_type __pos = npos) const noexcept
{ return this->find_last_of(__str._M_str, __pos, __str._M_len); }
[[nodiscard]]
constexpr size_type
find_last_of(_CharT __c, size_type __pos=npos) const noexcept
{ return this->rfind(__c, __pos); }

[[nodiscard]]
constexpr size_type
find_last_of(const _CharT* __str, size_type __pos,
size_type __n) const noexcept;

[[nodiscard, __gnu__::__nonnull__]]
constexpr size_type
find_last_of(const _CharT* __str, size_type __pos = npos) const noexcept
{ return this->find_last_of(__str, __pos, traits_type::length(__str)); }

[[nodiscard]]
constexpr size_type
find_first_not_of(basic_string_view __str,
size_type __pos = 0) const noexcept
{ return this->find_first_not_of(__str._M_str, __pos, __str._M_len); }

[[nodiscard]]
constexpr size_type
find_first_not_of(_CharT __c, size_type __pos = 0) const noexcept;

[[nodiscard]]
constexpr size_type
find_first_not_of(const _CharT* __str,
size_type __pos, size_type __n) const noexcept;

[[nodiscard, __gnu__::__nonnull__]]
constexpr size_type
find_first_not_of(const _CharT* __str, size_type __pos = 0) const noexcept
{
return this->find_first_not_of(__str, __pos,
traits_type::length(__str));
}

[[nodiscard]]
constexpr size_type
find_last_not_of(basic_string_view __str,
size_type __pos = npos) const noexcept
{ return this->find_last_not_of(__str._M_str, __pos, __str._M_len); }

[[nodiscard]]
constexpr size_type
find_last_not_of(_CharT __c, size_type __pos = npos) const noexcept;

[[nodiscard]]
constexpr size_type
find_last_not_of(const _CharT* __str,
size_type __pos, size_type __n) const noexcept;

[[nodiscard, __gnu__::__nonnull__]]
constexpr size_type
find_last_not_of(const _CharT* __str,
size_type __pos = npos) const noexcept
{
return this->find_last_not_of(__str, __pos,
traits_type::length(__str));
}

private:

static constexpr int

_S_compare(size_type __n1, size_type __n2) noexcept
{
using __limits = __gnu_cxx::__int_traits<int>;
const difference_type __diff = __n1 - __n2;
if (__diff > __limits::__max)
return __limits::__max;
if (__diff < __limits::__min)
return __limits::__min;
return static_cast<int>(__diff);
}

size_t _M_len;
const _CharT* _M_str;
};

template<contiguous_iterator _It, sized_sentinel_for<_It> _End>

basic_string_view(_It, _End) -> basic_string_view<iter_value_t<_It>>;

template<ranges::contiguous_range _Range>
basic_string_view(_Range&&)
-> basic_string_view<ranges::range_value_t<_Range>>;
# 606 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/string_view" 3
template<typename _CharT, typename _Traits>
[[nodiscard]]
constexpr bool
operator==(basic_string_view<_CharT, _Traits> __x,
type_identity_t<basic_string_view<_CharT, _Traits>> __y)
noexcept
{ return __x.size() == __y.size() && __x.compare(__y) == 0; }

template<typename _CharT, typename _Traits>

[[nodiscard]]
constexpr auto
operator<=>(basic_string_view<_CharT, _Traits> __x,
__type_identity_t<basic_string_view<_CharT, _Traits>> __y)
noexcept
-> decltype(__detail::__char_traits_cmp_cat<_Traits>(0))
{ return __detail::__char_traits_cmp_cat<_Traits>(__x.compare(__y)); }
# 758 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/string_view" 3
template<typename _CharT, typename _Traits>
inline basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os,
basic_string_view<_CharT,_Traits> __str)
{ return __ostream_insert(__os, __str.data(), __str.size()); }

using string_view = basic_string_view<char>;

using wstring_view = basic_string_view<wchar_t>;
using u8string_view = basic_string_view<char8_t>;

using u16string_view = basic_string_view<char16_t>;

using u32string_view = basic_string_view<char32_t>;

template<typename _Tp>
struct hash;

template<>
struct hash<string_view>
: public __hash_base<size_t, string_view>
{
[[nodiscard]]
size_t
operator()(const string_view& __str) const noexcept
{ return std::_Hash_impl::hash(__str.data(), __str.length()); }
};

template<>
struct __is_fast_hash<hash<string_view>> : std::false_type
{ };

template<>
struct hash<wstring_view>
: public __hash_base<size_t, wstring_view>
{
[[nodiscard]]
size_t
operator()(const wstring_view& __s) const noexcept
{ return std::_Hash_impl::hash(__s.data(),
__s.length() * sizeof(wchar_t)); }
};

template<>
struct __is_fast_hash<hash<wstring_view>> : std::false_type
{ };

template<>
struct hash<u8string_view>
: public __hash_base<size_t, u8string_view>
{
[[nodiscard]]
size_t
operator()(const u8string_view& __str) const noexcept
{ return std::_Hash_impl::hash(__str.data(), __str.length()); }
};

template<>
struct __is_fast_hash<hash<u8string_view>> : std::false_type
{ };

template<>
struct hash<u16string_view>
: public __hash_base<size_t, u16string_view>
{
[[nodiscard]]
size_t
operator()(const u16string_view& __s) const noexcept
{ return std::_Hash_impl::hash(__s.data(),
__s.length() * sizeof(char16_t)); }
};

template<>
struct __is_fast_hash<hash<u16string_view>> : std::false_type
{ };

template<>
struct hash<u32string_view>
: public __hash_base<size_t, u32string_view>
{
[[nodiscard]]
size_t
operator()(const u32string_view& __s) const noexcept
{ return std::_Hash_impl::hash(__s.data(),
__s.length() * sizeof(char32_t)); }
};

template<>
struct __is_fast_hash<hash<u32string_view>> : std::false_type
{ };

inline namespace literals

{
inline namespace string_view_literals
{
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wliteral-suffix"
inline constexpr basic_string_view<char>
operator""sv(const char* __str, size_t __len) noexcept
{ return basic_string_view<char>{__str, __len}; }

inline constexpr basic_string_view<wchar_t>

operator""sv(const wchar_t* __str, size_t __len) noexcept
{ return basic_string_view<wchar_t>{__str, __len}; }

inline constexpr basic_string_view<char8_t>

operator""sv(const char8_t* __str, size_t __len) noexcept
{ return basic_string_view<char8_t>{__str, __len}; }

inline constexpr basic_string_view<char16_t>

operator""sv(const char16_t* __str, size_t __len) noexcept
{ return basic_string_view<char16_t>{__str, __len}; }

inline constexpr basic_string_view<char32_t>

operator""sv(const char32_t* __str, size_t __len) noexcept
{ return basic_string_view<char32_t>{__str, __len}; }

#pragma GCC diagnostic pop

}
}
namespace ranges
{

template<typename _CharT, typename _Traits>

inline constexpr bool
enable_borrowed_range<basic_string_view<_CharT, _Traits>> = true;

template<typename _CharT, typename _Traits>

inline constexpr bool
enable_view<basic_string_view<_CharT, _Traits>> = true;
}

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/string_view.tcc" 1 3
# 37 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/string_view.tcc" 3

# 38 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/string_view.tcc" 3

namespace std
{

template<typename _CharT, typename _Traits>

constexpr typename basic_string_view<_CharT, _Traits>::size_type
basic_string_view<_CharT, _Traits>::
find(const _CharT* __str, size_type __pos, size_type __n) const noexcept
{
;

if (__n == 0)
return __pos <= _M_len ? __pos : npos;
if (__pos >= _M_len)
return npos;

const _CharT elem0 = str[0];

const _CharT* __first = _M_str + __pos;
const _CharT* const __last = _M_str + _M_len;
size_type __len = _M_len - __pos;

while (len >= n)

{

__first = traits_type::find(first, len - n + 1, elem0);

if (!__first)
return npos;

if (traits_type::compare(first, str, __n) == 0)

return __first - _M_str;
__len = __last - ++__first;
}
return npos;
}
template<typename _CharT, typename _Traits>
constexpr typename basic_string_view<_CharT, _Traits>::size_type
basic_string_view<_CharT, _Traits>::
find(_CharT __c, size_type __pos) const noexcept
{
size_type __ret = npos;
if (__pos < this->_M_len)
{
const size_type __n = this->_M_len - __pos;
const _CharT* __p = traits_type::find(this->_M_str + __pos, __n, __c);
if (__p)
__ret = __p - this->_M_str;
}
return __ret;
}

template<typename _CharT, typename _Traits>

constexpr typename basic_string_view<_CharT, _Traits>::size_type
basic_string_view<_CharT, _Traits>::
rfind(const _CharT* __str, size_type __pos, size_type __n) const noexcept
{
;

if (__n <= this->_M_len)

{
__pos = std::min(size_type(this->_M_len - __n), __pos);
do
{
if (traits_type::compare(this->_M_str + __pos, __str, __n) == 0)
return __pos;
}
while (__pos-- > 0);
}
return npos;
}

template<typename _CharT, typename _Traits>

constexpr typename basic_string_view<_CharT, _Traits>::size_type
basic_string_view<_CharT, _Traits>::
rfind(_CharT __c, size_type __pos) const noexcept
{
size_type __size = this->_M_len;
if (__size > 0)
{
if (--__size > __pos)
__size = __pos;
for (++__size; __size-- > 0; )
if (traits_type::eq(this->_M_str[__size], __c))
return __size;
}
return npos;
}

template<typename _CharT, typename _Traits>

constexpr typename basic_string_view<_CharT, _Traits>::size_type
basic_string_view<_CharT, _Traits>::
find_first_of(const _CharT* __str, size_type __pos,
size_type __n) const noexcept
{
;
for (; __n && __pos < this->_M_len; ++__pos)
{
const _CharT* __p = traits_type::find(__str, __n,
this->_M_str[__pos]);
if (__p)
return __pos;
}
return npos;
}

template<typename _CharT, typename _Traits>

constexpr typename basic_string_view<_CharT, _Traits>::size_type
basic_string_view<_CharT, _Traits>::
find_last_of(const _CharT* __str, size_type __pos,
size_type __n) const noexcept
{
;
size_type __size = this->size();
if (__size && __n)
{
if (--__size > __pos)
__size = __pos;
do
{
if (traits_type::find(__str, __n, this->_M_str[__size]))
return __size;
}
while (__size-- != 0);
}
return npos;
}

template<typename _CharT, typename _Traits>

constexpr typename basic_string_view<_CharT, _Traits>::size_type
basic_string_view<_CharT, _Traits>::
find_first_not_of(const _CharT* __str, size_type __pos,
size_type __n) const noexcept
{
;
for (; __pos < this->_M_len; ++__pos)
if (!traits_type::find(__str, __n, this->_M_str[__pos]))
return __pos;
return npos;
}

template<typename _CharT, typename _Traits>

constexpr typename basic_string_view<_CharT, _Traits>::size_type
basic_string_view<_CharT, _Traits>::
find_first_not_of(_CharT __c, size_type __pos) const noexcept
{
for (; __pos < this->_M_len; ++__pos)
if (!traits_type::eq(this->_M_str[__pos], __c))
return __pos;
return npos;
}

template<typename _CharT, typename _Traits>

constexpr typename basic_string_view<_CharT, _Traits>::size_type
basic_string_view<_CharT, _Traits>::
find_last_not_of(const _CharT* __str, size_type __pos,
size_type __n) const noexcept
{
;
size_type __size = this->_M_len;
if (__size)
{
if (--__size > __pos)
__size = __pos;
do
{
if (!traits_type::find(__str, __n, this->_M_str[__size]))
return __size;
}
while (__size--);
}
return npos;
}

template<typename _CharT, typename _Traits>

constexpr typename basic_string_view<_CharT, _Traits>::size_type
basic_string_view<_CharT, _Traits>::
find_last_not_of(_CharT __c, size_type __pos) const noexcept
{
size_type __size = this->_M_len;
if (__size)
{
if (--__size > __pos)
__size = __pos;
do
{
if (!traits_type::eq(this->_M_str[__size], __c))
return __size;
}
while (__size--);
}
return npos;
}

}
# 905 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/string_view" 2 3
# 48 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 2 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 1 3
# 47 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 3

# 48 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 3
# 55 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 2 3
namespace std
{

namespace __cxx11 {
# 85 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
template<typename _CharT, typename _Traits, typename _Alloc>
class basic_string
{

static_assert(is_same_v<_CharT, typename _Traits::char_type>);

static_assert(is_same_v<_CharT, typename _Alloc::value_type>);
using _Char_alloc_type = _Alloc;

typedef __gnu_cxx::__alloc_traits<_Char_alloc_type> _Alloc_traits;

public:
typedef _Traits traits_type;
typedef typename _Traits::char_type value_type;
typedef _Char_alloc_type allocator_type;
typedef typename _Alloc_traits::size_type size_type;
typedef typename _Alloc_traits::difference_type difference_type;
typedef typename _Alloc_traits::reference reference;
typedef typename _Alloc_traits::const_reference const_reference;
typedef typename _Alloc_traits::pointer pointer;
typedef typename _Alloc_traits::const_pointer const_pointer;
typedef __gnu_cxx::__normal_iterator<pointer, basic_string> iterator;
typedef __gnu_cxx::__normal_iterator<const_pointer, basic_string>
const_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
typedef std::reverse_iterator<iterator> reverse_iterator;

static const size_type npos = static_cast<size_type>(-1);

protected:

typedef const_iterator __const_iterator;

private:
static constexpr pointer
_S_allocate(_Char_alloc_type& __a, size_type __n)
{
pointer __p = _Alloc_traits::allocate(__a, __n);

if constexpr (!is_same_v<_Traits, char_traits<_CharT>>)

if (std::__is_constant_evaluated())
for (size_type __i = 0; __i < __n; ++__i)
std::construct_at(__builtin_addressof(__p[__i]));

return __p;
}

typedef basic_string_view<_CharT, _Traits> __sv_type;

template<typename _Tp, typename _Res>

using _If_sv = enable_if_t<
__and_<is_convertible<const _Tp&, __sv_type>,
__not_<is_convertible<const _Tp*, const basic_string*>>,
__not_<is_convertible<const _Tp&, const _CharT*>>>::value,
_Res>;

constexpr
static __sv_type
_S_to_string_view(__sv_type __svt) noexcept
{ return __svt; }

struct __sv_wrapper
{
constexpr explicit
__sv_wrapper(__sv_type __sv) noexcept : _M_sv(__sv) { }

__sv_type _M_sv;
};

constexpr
explicit
basic_string(__sv_wrapper __svw, const _Alloc& __a)
: basic_string(__svw._M_sv.data(), __svw._M_sv.size(), __a) { }

struct _Alloc_hider : allocator_type

{

constexpr
_Alloc_hider(pointer __dat, const _Alloc& __a)
: allocator_type(__a), _M_p(__dat) { }
constexpr
_Alloc_hider(pointer __dat, _Alloc&& __a = _Alloc())
: allocator_type(std::move(__a)), _M_p(__dat) { }

pointer _M_p;
};

_Alloc_hider _M_dataplus;
size_type _M_string_length;

enum { _S_local_capacity = 15 / sizeof(_CharT) };

union
{
_CharT _M_local_buf[_S_local_capacity + 1];
size_type _M_allocated_capacity;
};

constexpr
void
_M_data(pointer __p)
{ _M_dataplus._M_p = __p; }

constexpr
void
_M_length(size_type __length)
{ _M_string_length = __length; }

constexpr
pointer
_M_data() const
{ return _M_dataplus._M_p; }

constexpr
pointer
_M_local_data()
{

return std::pointer_traits<pointer>::pointer_to(*_M_local_buf);

constexpr
const_pointer
_M_local_data() const
{

return std::pointer_traits<const_pointer>::pointer_to(*_M_local_buf);

constexpr
void
_M_capacity(size_type __capacity)
{ _M_allocated_capacity = __capacity; }

constexpr
void
_M_set_length(size_type __n)
{
_M_length(__n);
traits_type::assign(_M_data()[__n], _CharT());
}

constexpr
bool
_M_is_local() const
{
if (_M_data() == _M_local_data())
{
if (_M_string_length > _S_local_capacity)
__builtin_unreachable();
return true;
}
return false;
}

constexpr
pointer
_M_create(size_type&, size_type);

constexpr
void
_M_dispose()
{
if (!_M_is_local())
_M_destroy(_M_allocated_capacity);
}

constexpr
void
_M_destroy(size_type __size) throw()
{ _Alloc_traits::deallocate(_M_get_allocator(), _M_data(), __size + 1); }
# 321 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
template<typename _InIterator>
constexpr
void
_M_construct(_InIterator __beg, _InIterator __end,
std::input_iterator_tag);

template<typename _FwdIterator>
constexpr
void
_M_construct(_FwdIterator __beg, _FwdIterator __end,
std::forward_iterator_tag);

constexpr
void
_M_construct(size_type __req, _CharT __c);
constexpr
allocator_type&
_M_get_allocator()
{ return _M_dataplus; }

constexpr
const allocator_type&
_M_get_allocator() const
{ return _M_dataplus; }

__attribute__((__always_inline__))
constexpr
void
_M_init_local_buf() noexcept
{

if (std::is_constant_evaluated())
for (size_type __i = 0; __i <= _S_local_capacity; ++__i)
_M_local_buf[__i] = _CharT();

__attribute__((__always_inline__))
constexpr
pointer
_M_use_local_data() noexcept
{

_M_init_local_buf();

return _M_local_data();
}

private:
# 389 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
constexpr
size_type
_M_check(size_type __pos, const char* __s) const
{
if (__pos > this->size())
__throw_out_of_range_fmt(("%s: __pos (which is %zu) > " "this->size() (which is
%zu)")
,
__s, __pos, this->size());
return __pos;
}

constexpr
void
_M_check_length(size_type __n1, size_type __n2, const char* __s) const
{
if (this->max_size() - (this->size() - __n1) < __n2)
__throw_length_error((__s));
}

constexpr
size_type
_M_limit(size_type __pos, size_type __off) const noexcept
{
const bool __testoff = __off < this->size() - __pos;
return __testoff ? __off : this->size() - __pos;
}

bool
_M_disjunct(const _CharT* __s) const noexcept
{
return (less<const _CharT*>()(__s, _M_data())
|| less<const _CharT*>()(_M_data() + this->size(), __s));
}

constexpr
static void
_S_copy(_CharT* __d, const _CharT* __s, size_type __n)
{
if (__n == 1)
traits_type::assign(*__d, *__s);
else
traits_type::copy(__d, __s, __n);
}

constexpr
static void
_S_move(_CharT* __d, const _CharT* __s, size_type __n)
{
if (__n == 1)
traits_type::assign(*__d, *__s);
else
traits_type::move(__d, __s, __n);
}

constexpr
static void
_S_assign(_CharT* __d, size_type __n, _CharT __c)
{
if (__n == 1)
traits_type::assign(*__d, __c);
else
traits_type::assign(__d, __n, __c);
}

template<class _Iterator>
constexpr
static void
_S_copy_chars(_CharT* __p, _Iterator __k1, _Iterator __k2)
{
for (; __k1 != __k2; ++__k1, (void)++__p)
traits_type::assign(*__p, *__k1);
}

constexpr
static void
_S_copy_chars(_CharT* __p, iterator __k1, iterator __k2) noexcept
{ _S_copy_chars(__p, __k1.base(), __k2.base()); }

constexpr
static void
_S_copy_chars(_CharT* __p, const_iterator __k1, const_iterator __k2)
noexcept
{ _S_copy_chars(__p, __k1.base(), __k2.base()); }

constexpr
static void
_S_copy_chars(_CharT* __p, _CharT* __k1, _CharT* __k2) noexcept
{ _S_copy(__p, __k1, __k2 - __k1); }

constexpr
static void
_S_copy_chars(_CharT* __p, const _CharT* __k1, const _CharT* __k2)
noexcept
{ _S_copy(__p, __k1, __k2 - __k1); }

constexpr
static int
_S_compare(size_type __n1, size_type __n2) noexcept
{
const difference_type __d = difference_type(__n1 - __n2);

if (d > gnu_cxx::__numeric_traits<int>::__max)

return __gnu_cxx::__numeric_traits<int>::__max;
else if (__d < __gnu_cxx::__numeric_traits<int>::__min)
return __gnu_cxx::__numeric_traits<int>::__min;
else
return int(__d);
}

constexpr
void
_M_assign(const basic_string&);

constexpr
void
_M_mutate(size_type __pos, size_type __len1, const _CharT* __s,
size_type __len2);

constexpr
void
_M_erase(size_type __pos, size_type __n);

public:

constexpr
basic_string()
noexcept(is_nothrow_default_constructible<_Alloc>::value)
: _M_dataplus(_M_local_data())
{
_M_init_local_buf();
_M_set_length(0);
}

constexpr
explicit
basic_string(const _Alloc& __a) noexcept
: _M_dataplus(_M_local_data(), __a)
{
_M_init_local_buf();
_M_set_length(0);
}

constexpr
basic_string(const basic_string& __str)
: _M_dataplus(_M_local_data(),
_Alloc_traits::_S_select_on_copy(__str._M_get_allocator()))
{
_M_construct(__str._M_data(), __str._M_data() + __str.length(),
std::forward_iterator_tag());
}
# 568 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
constexpr
basic_string(const basic_string& __str, size_type __pos,
const _Alloc& __a = _Alloc())
: _M_dataplus(_M_local_data(), __a)
{
const _CharT* __start = __str._M_data()
+ __str._M_check(__pos, "basic_string::basic_string");
_M_construct(__start, __start + __str._M_limit(__pos, npos),
std::forward_iterator_tag());
}

constexpr
basic_string(const basic_string& __str, size_type __pos,
size_type __n)
: _M_dataplus(_M_local_data())
{
const _CharT* __start = __str._M_data()
+ __str._M_check(__pos, "basic_string::basic_string");
_M_construct(__start, __start + __str._M_limit(__pos, __n),
std::forward_iterator_tag());
}
# 603 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
constexpr
basic_string(const basic_string& __str, size_type __pos,
size_type __n, const _Alloc& __a)
: _M_dataplus(_M_local_data(), __a)
{
const _CharT* __start
= __str._M_data() + __str._M_check(__pos, "string::string");
_M_construct(__start, __start + __str._M_limit(__pos, __n),
std::forward_iterator_tag());
}
# 623 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
constexpr
basic_string(const _CharT* __s, size_type __n,
const _Alloc& __a = _Alloc())
: _M_dataplus(_M_local_data(), __a)
{

if (s == 0 && n > 0)

std::__throw_logic_error(("basic_string: " "construction from null is not
valid")
);
_M_construct(__s, __s + __n, std::forward_iterator_tag());
}
# 643 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
template<typename = _RequireAllocator<_Alloc>>

constexpr
basic_string(const _CharT* __s, const _Alloc& __a = _Alloc())
: _M_dataplus(_M_local_data(), __a)
{

if (__s == 0)
std::__throw_logic_error(("basic_string: " "construction from null is not
valid")
);
const _CharT* __end = __s + traits_type::length(__s);
_M_construct(__s, __end, forward_iterator_tag());
}
# 666 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
template<typename = _RequireAllocator<_Alloc>>

constexpr
basic_string(size_type __n, _CharT __c, const _Alloc& __a = _Alloc())
: _M_dataplus(_M_local_data(), __a)
{ _M_construct(__n, __c); }
# 681 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
constexpr
basic_string(basic_string&& __str) noexcept
: _M_dataplus(_M_local_data(), std::move(__str._M_get_allocator()))
{
if (__str._M_is_local())
{
_M_init_local_buf();
traits_type::copy(_M_local_buf, __str._M_local_buf,
__str.length() + 1);
}
else
{
_M_data(__str._M_data());
_M_capacity(__str._M_allocated_capacity);
}

_M_length(__str.length());
__str._M_data(__str._M_use_local_data());
__str._M_set_length(0);
}

constexpr
basic_string(initializer_list<_CharT> __l, const _Alloc& __a = _Alloc())
: _M_dataplus(_M_local_data(), __a)
{ _M_construct(__l.begin(), __l.end(), std::forward_iterator_tag()); }

constexpr
basic_string(const basic_string& __str, const _Alloc& __a)
: _M_dataplus(_M_local_data(), __a)
{ _M_construct(__str.begin(), __str.end(), std::forward_iterator_tag()); }

constexpr
basic_string(basic_string&& __str, const _Alloc& __a)
noexcept(_Alloc_traits::_S_always_equal())
: _M_dataplus(_M_local_data(), __a)
{
if (__str._M_is_local())
{
_M_init_local_buf();
traits_type::copy(_M_local_buf, __str._M_local_buf,
__str.length() + 1);
_M_length(__str.length());
__str._M_set_length(0);
}
else if (_Alloc_traits::_S_always_equal()
|| __str.get_allocator() == __a)
{
_M_data(__str._M_data());
_M_length(__str.length());
_M_capacity(__str._M_allocated_capacity);
__str._M_data(__str._M_use_local_data());
__str._M_set_length(0);
}
else
_M_construct(__str.begin(), __str.end(), std::forward_iterator_tag());
}

basic_string(nullptr_t) = delete;
basic_string& operator=(nullptr_t) = delete;
# 759 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
template<typename _InputIterator,
typename = std::_RequireInputIter<_InputIterator>>
constexpr
basic_string(_InputIterator __beg, _InputIterator __end,
const _Alloc& __a = _Alloc())
: _M_dataplus(_M_local_data(), __a), _M_string_length(0)
{

_M_construct(beg, end, std::__iterator_category(__beg));

}
# 785 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
template<typename _Tp,
typename = enable_if_t<is_convertible_v<const _Tp&, __sv_type>>>
constexpr
basic_string(const _Tp& __t, size_type __pos, size_type __n,
const _Alloc& __a = _Alloc())
: basic_string(_S_to_string_view(__t).substr(__pos, __n), __a) { }

template<typename _Tp, typename = _If_sv<_Tp, void>>

constexpr
explicit
basic_string(const _Tp& __t, const _Alloc& __a = _Alloc())
: basic_string(__sv_wrapper(_S_to_string_view(__t)), __a) { }

constexpr
~basic_string()
{ _M_dispose(); }

constexpr
basic_string&
operator=(const basic_string& __str)
{
return this->assign(__str);
}

constexpr
basic_string&
operator=(const _CharT* __s)
{ return this->assign(__s); }
# 838 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
constexpr
basic_string&
operator=(_CharT __c)
{
this->assign(1, __c);
return *this;
}
# 856 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
constexpr
basic_string&
operator=(basic_string&& __str)
noexcept(_Alloc_traits::_S_nothrow_move())
{
const bool __equal_allocs = _Alloc_traits::_S_always_equal()
|| _M_get_allocator() == __str._M_get_allocator();
if (!_M_is_local() && _Alloc_traits::_S_propagate_on_move_assign()
&& !__equal_allocs)
{

_M_destroy(_M_allocated_capacity);
_M_data(_M_local_data());
_M_set_length(0);
}

std::__alloc_on_move(_M_get_allocator(), __str._M_get_allocator());

if (__str._M_is_local())
{

if (__builtin_expect(std::addressof(str) != this, true))

{
if (__str.size())
this->_S_copy(_M_data(), __str._M_data(), __str.size());
_M_set_length(__str.size());
}
}
else if (_Alloc_traits::_S_propagate_on_move_assign() || __equal_allocs)
{

pointer __data = nullptr;

size_type __capacity;
if (!_M_is_local())
{
if (__equal_allocs)
{

__data = _M_data();
__capacity = _M_allocated_capacity;
}
else
_M_destroy(_M_allocated_capacity);
}

_M_data(__str._M_data());
_M_length(__str.length());
_M_capacity(__str._M_allocated_capacity);
if (__data)
{
__str._M_data(__data);
__str._M_capacity(__capacity);
}
else
__str._M_data(__str._M_use_local_data());
}
else
assign(__str);
__str.clear();
return *this;
}

constexpr
basic_string&
operator=(initializer_list<_CharT> __l)
{
this->assign(__l.begin(), __l.size());
return *this;
}

template<typename _Tp>
constexpr
_If_sv<_Tp, basic_string&>
operator=(const _Tp& __svt)
{ return this->assign(__svt); }

constexpr
operator __sv_type() const noexcept
{ return __sv_type(data(), size()); }

[[__nodiscard__]] constexpr
iterator
begin() noexcept
{ return iterator(_M_data()); }
[[__nodiscard__]] constexpr
const_iterator
begin() const noexcept
{ return const_iterator(_M_data()); }

[[__nodiscard__]] constexpr
iterator
end() noexcept
{ return iterator(_M_data() + this->size()); }

[[__nodiscard__]] constexpr
const_iterator
end() const noexcept
{ return const_iterator(_M_data() + this->size()); }

[[__nodiscard__]] constexpr
reverse_iterator
rbegin() noexcept
{ return reverse_iterator(this->end()); }

[[__nodiscard__]] constexpr
const_reverse_iterator
rbegin() const noexcept
{ return const_reverse_iterator(this->end()); }

[[__nodiscard__]] constexpr
reverse_iterator
rend() noexcept
{ return reverse_iterator(this->begin()); }
[[__nodiscard__]] constexpr
const_reverse_iterator
rend() const noexcept
{ return const_reverse_iterator(this->begin()); }

[[__nodiscard__]] constexpr
const_iterator
cbegin() const noexcept
{ return const_iterator(this->_M_data()); }

[[__nodiscard__]] constexpr
const_iterator
cend() const noexcept
{ return const_iterator(this->_M_data() + this->size()); }

[[__nodiscard__]] constexpr
const_reverse_iterator
crbegin() const noexcept
{ return const_reverse_iterator(this->end()); }

[[__nodiscard__]] constexpr
const_reverse_iterator
crend() const noexcept
{ return const_reverse_iterator(this->begin()); }

public:

[[__nodiscard__]] constexpr
size_type
size() const noexcept
{ return _M_string_length; }
[[__nodiscard__]] constexpr
size_type
length() const noexcept
{ return _M_string_length; }

[[__nodiscard__]] constexpr
size_type
max_size() const noexcept
{ return (_Alloc_traits::max_size(_M_get_allocator()) - 1) / 2; }
# 1102 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
constexpr
void
resize(size_type __n, _CharT __c);
# 1116 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
constexpr
void
resize(size_type __n)
{ this->resize(__n, _CharT()); }

#pragma GCC diagnostic push

#pragma GCC diagnostic ignored "-Wdeprecated-declarations"

constexpr
void
shrink_to_fit() noexcept
{ reserve(); }
#pragma GCC diagnostic pop
# 1162 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
template<typename _Operation>
constexpr void
resize_and_overwrite(size_type __n, _Operation __op);

template<typename _Operation>
constexpr void
__resize_and_overwrite(size_type __n, _Operation __op);

[[__nodiscard__]] constexpr
size_type
capacity() const noexcept
{
return _M_is_local() ? size_type(_S_local_capacity)
: _M_allocated_capacity;
}
# 1203 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
constexpr
void
reserve(size_type __res_arg);
[[deprecated("use shrink_to_fit() instead")]]

constexpr
void
reserve();

constexpr
void
clear() noexcept
{ _M_set_length(0); }

[[__nodiscard__]] constexpr
bool
empty() const noexcept
{ return this->size() == 0; }
# 1245 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
[[__nodiscard__]] constexpr
const_reference
operator[] (size_type __pos) const noexcept
{
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__pos <=
size()), false)) std::__glibcxx_assert_fail(); } while (false);
return _M_data()[__pos];
}
# 1263 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
[[__nodiscard__]] constexpr
reference
operator[](size_type __pos)
{

do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__pos <=

size()), false)) std::__glibcxx_assert_fail(); } while (false);

;
return _M_data()[__pos];
}
# 1285 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
[[__nodiscard__]] constexpr
const_reference
at(size_type __n) const
{
if (__n >= this->size())
__throw_out_of_range_fmt(("basic_string::at: __n " "(which is %zu) >= this-
>size() " "(which is %zu)")

,
__n, this->size());
return _M_data()[__n];
}
# 1307 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
[[__nodiscard__]] constexpr
reference
at(size_type __n)
{
if (__n >= size())
__throw_out_of_range_fmt(("basic_string::at: __n " "(which is %zu) >= this-
>size() " "(which is %zu)")

,
__n, this->size());
return _M_data()[__n];
}

[[__nodiscard__]] constexpr
reference
front() noexcept
{
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(!empty()),
false)) std::__glibcxx_assert_fail(); } while (false);
return operator[](0);
}

[[__nodiscard__]] constexpr
const_reference
front() const noexcept
{
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(!empty()),
false)) std::__glibcxx_assert_fail(); } while (false);
return operator[](0);
}

[[__nodiscard__]] constexpr
reference
back() noexcept
{
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(!empty()),
false)) std::__glibcxx_assert_fail(); } while (false);
return operator[](this->size() - 1);
}
[[__nodiscard__]] constexpr
const_reference
back() const noexcept
{
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(!empty()),
false)) std::__glibcxx_assert_fail(); } while (false);
return operator[](this->size() - 1);
}
# 1375 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
constexpr
basic_string&
operator+=(const basic_string& __str)
{ return this->append(__str); }

constexpr
basic_string&
operator+=(const _CharT* __s)
{ return this->append(__s); }

constexpr
basic_string&
operator+=(_CharT __c)
{
this->push_back(__c);
return *this;
}

constexpr
basic_string&
operator+=(initializer_list<_CharT> __l)
{ return this->append(__l.begin(), __l.size()); }
# 1421 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
template<typename _Tp>
constexpr
_If_sv<_Tp, basic_string&>
operator+=(const _Tp& __svt)
{ return this->append(__svt); }
constexpr
basic_string&
append(const basic_string& __str)
{ return this->append(__str._M_data(), __str.size()); }
# 1451 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
constexpr
basic_string&
append(const basic_string& __str, size_type __pos, size_type __n = npos)
{ return this->append(__str._M_data()
+ __str._M_check(__pos, "basic_string::append"),
__str._M_limit(__pos, __n)); }

constexpr
basic_string&
append(const _CharT* __s, size_type __n)
{
;
_M_check_length(size_type(0), __n, "basic_string::append");
return _M_append(__s, __n);
}

constexpr
basic_string&
append(const _CharT* __s)
{
;
const size_type __n = traits_type::length(__s);
_M_check_length(size_type(0), __n, "basic_string::append");
return _M_append(__s, __n);
}
# 1496 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
constexpr
basic_string&
append(size_type __n, _CharT __c)
{ return _M_replace_aux(this->size(), size_type(0), __n, __c); }

constexpr
basic_string&
append(initializer_list<_CharT> __l)
{ return this->append(__l.begin(), __l.size()); }
# 1522 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
template<class _InputIterator,
typename = std::_RequireInputIter<_InputIterator>>
constexpr

basic_string&
append(_InputIterator __first, _InputIterator __last)
{ return this->replace(end(), end(), __first, __last); }

template<typename _Tp>
constexpr
_If_sv<_Tp, basic_string&>
append(const _Tp& __svt)
{
__sv_type __sv = __svt;
return this->append(__sv.data(), __sv.size());
}
# 1554 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
template<typename _Tp>
constexpr
_If_sv<_Tp, basic_string&>
append(const _Tp& __svt, size_type __pos, size_type __n = npos)
{
__sv_type __sv = __svt;
return _M_append(__sv.data()
+ std::__sv_check(__sv.size(), __pos, "basic_string::append"),
std::__sv_limit(__sv.size(), __pos, __n));
}

constexpr
void
push_back(_CharT __c)
{
const size_type __size = this->size();
if (__size + 1 > this->capacity())
this->_M_mutate(__size, size_type(0), 0, size_type(1));
traits_type::assign(this->_M_data()[__size], __c);
this->_M_set_length(__size + 1);
}

constexpr
basic_string&
assign(const basic_string& __str)
{

if (_Alloc_traits::_S_propagate_on_copy_assign())
{
if (!_Alloc_traits::_S_always_equal() && !_M_is_local()
&& _M_get_allocator() != __str._M_get_allocator())
{

if (__str.size() <= _S_local_capacity)

{
_M_destroy(_M_allocated_capacity);
_M_data(_M_use_local_data());
_M_set_length(0);
}
else
{
const auto __len = __str.size();
auto __alloc = __str._M_get_allocator();

auto __ptr = _S_allocate(alloc, len + 1);

_M_destroy(_M_allocated_capacity);
_M_data(__ptr);
_M_capacity(__len);
_M_set_length(__len);
}
}
std::__alloc_on_copy(_M_get_allocator(), __str._M_get_allocator());
}

this->_M_assign(__str);
return *this;
}
# 1632 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
constexpr
basic_string&
assign(basic_string&& __str)
noexcept(_Alloc_traits::_S_nothrow_move())
{

return *this = std::move(__str);

}
# 1656 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
constexpr
basic_string&
assign(const basic_string& __str, size_type __pos, size_type __n = npos)
{ return _M_replace(size_type(0), this->size(), __str._M_data()
+ __str._M_check(__pos, "basic_string::assign"),
__str._M_limit(__pos, __n)); }
# 1673 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
constexpr
basic_string&
assign(const _CharT* __s, size_type __n)
{
;
return _M_replace(size_type(0), this->size(), __s, __n);
}
# 1690 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
constexpr
basic_string&
assign(const _CharT* __s)
{
;
return _M_replace(size_type(0), this->size(), __s,
traits_type::length(__s));
}
# 1708 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
constexpr
basic_string&
assign(size_type __n, _CharT __c)
{ return _M_replace_aux(size_type(0), this->size(), __n, __c); }
# 1722 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++17-extensions"
template<class _InputIterator,
typename = std::_RequireInputIter<_InputIterator>>
constexpr
basic_string&
assign(_InputIterator __first, _InputIterator __last)
{

if constexpr (contiguous_iterator<_InputIterator>
&& is_same_v<iter_value_t<_InputIterator>, _CharT>)

{
;
return _M_replace(size_type(0), size(),
std::__to_address(__first), __last - __first);
}
else
return *this = basic_string(__first, __last, get_allocator());
}
#pragma GCC diagnostic pop
# 1759 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
constexpr
basic_string&
assign(initializer_list<_CharT> __l)
{

const size_type n = l.size();

if (__n > capacity())
*this = basic_string(__l.begin(), __l.end(), get_allocator());
else
{
if (__n)
_S_copy(_M_data(), __l.begin(), __n);
_M_set_length(__n);
}
return *this;
}
# 1784 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
template<typename _Tp>
constexpr
_If_sv<_Tp, basic_string&>
assign(const _Tp& __svt)
{
__sv_type __sv = __svt;
return this->assign(__sv.data(), __sv.size());
}
# 1800 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
template<typename _Tp>
constexpr
_If_sv<_Tp, basic_string&>
assign(const _Tp& __svt, size_type __pos, size_type __n = npos)
{
__sv_type __sv = __svt;
return _M_replace(size_type(0), this->size(),
__sv.data()
+ std::__sv_check(__sv.size(), __pos, "basic_string::assign"),
std::__sv_limit(__sv.size(), __pos, __n));
}
# 1829 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
constexpr
iterator
insert(const_iterator __p, size_type __n, _CharT __c)
{
;
const size_type __pos = __p - begin();
this->replace(__p, __p, __n, __c);
return iterator(this->_M_data() + __pos);
}
# 1872 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
template<class _InputIterator,
typename = std::_RequireInputIter<_InputIterator>>
constexpr
iterator
insert(const_iterator __p, _InputIterator __beg, _InputIterator __end)
{
;
const size_type __pos = __p - begin();
this->replace(__p, __p, __beg, __end);
return iterator(this->_M_data() + __pos);
}
# 1909 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
constexpr
iterator
insert(const_iterator __p, initializer_list<_CharT> __l)
{ return this->insert(__p, __l.begin(), __l.end()); }
# 1937 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
constexpr
basic_string&
insert(size_type __pos1, const basic_string& __str)
{ return this->replace(__pos1, size_type(0),
__str._M_data(), __str.size()); }
# 1961 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
constexpr
basic_string&
insert(size_type __pos1, const basic_string& __str,
size_type __pos2, size_type __n = npos)
{ return this->replace(__pos1, size_type(0), __str._M_data()
+ __str._M_check(__pos2, "basic_string::insert"),
__str._M_limit(__pos2, __n)); }
# 1985 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
constexpr
basic_string&
insert(size_type __pos, const _CharT* __s, size_type __n)
{ return this->replace(__pos, size_type(0), __s, __n); }
# 2005 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
constexpr
basic_string&
insert(size_type __pos, const _CharT* __s)
{
;
return this->replace(__pos, size_type(0), __s,
traits_type::length(__s));
}
# 2030 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
constexpr
basic_string&
insert(size_type __pos, size_type __n, _CharT __c)
{ return _M_replace_aux(_M_check(__pos, "basic_string::insert"),
size_type(0), __n, __c); }
# 2049 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
constexpr
iterator
insert(__const_iterator __p, _CharT __c)
{
;
const size_type __pos = __p - begin();
_M_replace_aux(__pos, size_type(0), size_type(1), __c);
return iterator(_M_data() + __pos);
}
# 2066 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
template<typename _Tp>
constexpr
_If_sv<_Tp, basic_string&>
insert(size_type __pos, const _Tp& __svt)
{
__sv_type __sv = __svt;
return this->insert(__pos, __sv.data(), __sv.size());
}
# 2083 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
template<typename _Tp>
constexpr
_If_sv<_Tp, basic_string&>
insert(size_type __pos1, const _Tp& __svt,
size_type __pos2, size_type __n = npos)
{
__sv_type __sv = __svt;
return this->replace(__pos1, size_type(0),
__sv.data()
+ std::__sv_check(__sv.size(), __pos2, "basic_string::insert"),
std::__sv_limit(__sv.size(), __pos2, __n));
}
# 2112 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
constexpr
basic_string&
erase(size_type __pos = 0, size_type __n = npos)
{
_M_check(__pos, "basic_string::erase");
if (__n == npos)
this->_M_set_length(__pos);
else if (__n != 0)
this->_M_erase(__pos, _M_limit(__pos, __n));
return *this;
}
# 2132 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
constexpr
iterator
erase(__const_iterator __position)
{

;
const size_type __pos = __position - begin();
this->_M_erase(__pos, size_type(1));
return iterator(_M_data() + __pos);
}
# 2152 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
constexpr
iterator
erase(__const_iterator __first, __const_iterator __last)
{

;
const size_type __pos = __first - begin();
if (__last == end())
this->_M_set_length(__pos);
else
this->_M_erase(__pos, __last - __first);
return iterator(this->_M_data() + __pos);
}

constexpr
void
pop_back() noexcept
{
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(!empty()),
false)) std::__glibcxx_assert_fail(); } while (false);
_M_erase(size() - 1, 1);
}
# 2198 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
constexpr
basic_string&
replace(size_type __pos, size_type __n, const basic_string& __str)
{ return this->replace(__pos, __n, __str._M_data(), __str.size()); }
# 2221 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
constexpr
basic_string&
replace(size_type __pos1, size_type __n1, const basic_string& __str,
size_type __pos2, size_type __n2 = npos)
{ return this->replace(__pos1, __n1, __str._M_data()
+ __str._M_check(__pos2, "basic_string::replace"),
__str._M_limit(__pos2, __n2)); }
# 2247 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
constexpr
basic_string&
replace(size_type __pos, size_type __n1, const _CharT* __s,
size_type __n2)
{
;
return _M_replace(_M_check(__pos, "basic_string::replace"),
_M_limit(__pos, __n1), __s, __n2);
}
# 2273 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
constexpr
basic_string&
replace(size_type __pos, size_type __n1, const _CharT* __s)
{
;
return this->replace(__pos, __n1, __s, traits_type::length(__s));
}
# 2298 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
constexpr
basic_string&
replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c)
{ return _M_replace_aux(_M_check(__pos, "basic_string::replace"),
_M_limit(__pos, __n1), __n2, __c); }
# 2317 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
constexpr
basic_string&
replace(__const_iterator __i1, __const_iterator __i2,
const basic_string& __str)
{ return this->replace(__i1, __i2, __str._M_data(), __str.size()); }
# 2338 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
constexpr
basic_string&
replace(__const_iterator __i1, __const_iterator __i2,
const _CharT* __s, size_type __n)
{

;
return this->replace(__i1 - begin(), __i2 - __i1, __s, __n);
}
# 2361 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
constexpr
basic_string&
replace(__const_iterator __i1, __const_iterator __i2, const _CharT* __s)
{
;
return this->replace(__i1, __i2, __s, traits_type::length(__s));
}
# 2383 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
constexpr
basic_string&
replace(__const_iterator __i1, __const_iterator __i2, size_type __n,
_CharT __c)
{

;
return _M_replace_aux(__i1 - begin(), __i2 - __i1, __n, __c);
}
# 2409 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
template<class _InputIterator,
typename = std::_RequireInputIter<_InputIterator>>
constexpr
basic_string&
replace(const_iterator __i1, const_iterator __i2,
_InputIterator __k1, _InputIterator __k2)
{

;
;
return this->_M_replace_dispatch(__i1, __i2, __k1, __k2,
std::__false_type());
}
# 2442 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
constexpr
basic_string&
replace(__const_iterator __i1, __const_iterator __i2,
_CharT* __k1, _CharT* __k2)
{

;
;
return this->replace(__i1 - begin(), __i2 - __i1,
__k1, __k2 - __k1);
}

constexpr
basic_string&
replace(__const_iterator __i1, __const_iterator __i2,
const _CharT* __k1, const _CharT* __k2)
{

;
;
return this->replace(__i1 - begin(), __i2 - __i1,
__k1, __k2 - __k1);
}

constexpr
basic_string&
replace(__const_iterator __i1, __const_iterator __i2,
iterator __k1, iterator __k2)
{

;
;
return this->replace(__i1 - begin(), __i2 - __i1,
__k1.base(), __k2 - __k1);
}

constexpr
basic_string&
replace(__const_iterator __i1, __const_iterator __i2,
const_iterator __k1, const_iterator __k2)
{

;
;
return this->replace(__i1 - begin(), __i2 - __i1,
__k1.base(), __k2 - __k1);
}
# 2505 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
constexpr
basic_string& replace(const_iterator __i1, const_iterator __i2,
initializer_list<_CharT> __l)
{ return this->replace(__i1, __i2, __l.begin(), __l.size()); }
# 2519 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
template<typename _Tp>
constexpr
_If_sv<_Tp, basic_string&>
replace(size_type __pos, size_type __n, const _Tp& __svt)
{
__sv_type __sv = __svt;
return this->replace(__pos, __n, __sv.data(), __sv.size());
}
# 2537 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
template<typename _Tp>
constexpr
_If_sv<_Tp, basic_string&>
replace(size_type __pos1, size_type __n1, const _Tp& __svt,
size_type __pos2, size_type __n2 = npos)
{
__sv_type __sv = __svt;
return this->replace(__pos1, __n1,
__sv.data()
+ std::__sv_check(__sv.size(), __pos2, "basic_string::replace"),
std::__sv_limit(__sv.size(), __pos2, __n2));
}
# 2559 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
template<typename _Tp>
constexpr
_If_sv<_Tp, basic_string&>
replace(const_iterator __i1, const_iterator __i2, const _Tp& __svt)
{
__sv_type __sv = __svt;
return this->replace(__i1 - begin(), __i2 - __i1, __sv);
}

private:
template<class _Integer>
constexpr
basic_string&
_M_replace_dispatch(const_iterator __i1, const_iterator __i2,
_Integer __n, _Integer __val, __true_type)
{ return _M_replace_aux(__i1 - begin(), __i2 - __i1, __n, __val); }

template<class _InputIterator>
constexpr
basic_string&
_M_replace_dispatch(const_iterator __i1, const_iterator __i2,
_InputIterator __k1, _InputIterator __k2,
__false_type);

constexpr
basic_string&
_M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
_CharT __c);
__attribute__((__noinline__, __noclone__, __cold__)) void
_M_replace_cold(pointer __p, size_type __len1, const _CharT* __s,
const size_type __len2, const size_type __how_much);

constexpr
basic_string&
_M_replace(size_type __pos, size_type __len1, const _CharT* __s,
const size_type __len2);

constexpr
basic_string&
_M_append(const _CharT* __s, size_type __n);

public:
# 2616 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
constexpr
size_type
copy(_CharT* __s, size_type __n, size_type __pos = 0) const;
# 2627 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
constexpr
void
swap(basic_string& __s) noexcept;
# 2638 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
[[__nodiscard__]] constexpr
const _CharT*
c_str() const noexcept
{ return _M_data(); }
# 2651 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
[[__nodiscard__]] constexpr
const _CharT*
data() const noexcept
{ return _M_data(); }
# 2663 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
[[__nodiscard__]] constexpr
_CharT*
data() noexcept
{ return _M_data(); }

[[__nodiscard__]] constexpr
allocator_type
get_allocator() const noexcept
{ return _M_get_allocator(); }
# 2689 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
[[__nodiscard__]] constexpr
size_type
find(const _CharT* __s, size_type __pos, size_type __n) const
noexcept;
# 2704 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
[[__nodiscard__]] constexpr
size_type
find(const basic_string& __str, size_type __pos = 0) const
noexcept
{ return this->find(__str.data(), __pos, __str.size()); }
# 2717 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
template<typename _Tp>
[[__nodiscard__]] constexpr
_If_sv<_Tp, size_type>
find(const _Tp& __svt, size_type __pos = 0) const
noexcept(is_same<_Tp, __sv_type>::value)
{
__sv_type __sv = __svt;
return this->find(__sv.data(), __pos, __sv.size());
}
# 2738 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
[[__nodiscard__]] constexpr
size_type
find(const _CharT* __s, size_type __pos = 0) const noexcept
{
;
return this->find(__s, __pos, traits_type::length(__s));
}
# 2756 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
[[__nodiscard__]] constexpr
size_type
find(_CharT __c, size_type __pos = 0) const noexcept;
# 2770 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
[[__nodiscard__]] constexpr
size_type
rfind(const basic_string& __str, size_type __pos = npos) const
noexcept
{ return this->rfind(__str.data(), __pos, __str.size()); }
# 2783 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
template<typename _Tp>
[[__nodiscard__]] constexpr
_If_sv<_Tp, size_type>
rfind(const _Tp& __svt, size_type __pos = npos) const
noexcept(is_same<_Tp, __sv_type>::value)
{
__sv_type __sv = __svt;
return this->rfind(__sv.data(), __pos, __sv.size());
}
# 2806 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
[[__nodiscard__]] constexpr
size_type
rfind(const _CharT* __s, size_type __pos, size_type __n) const
noexcept;
# 2821 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
[[__nodiscard__]] constexpr
size_type
rfind(const _CharT* __s, size_type __pos = npos) const
{
;
return this->rfind(__s, __pos, traits_type::length(__s));
}
# 2839 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
[[__nodiscard__]] constexpr
size_type
rfind(_CharT __c, size_type __pos = npos) const noexcept;
# 2854 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
[[__nodiscard__]] constexpr
size_type
find_first_of(const basic_string& __str, size_type __pos = 0) const
noexcept
{ return this->find_first_of(__str.data(), __pos, __str.size()); }
# 2868 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
template<typename _Tp>
[[__nodiscard__]] constexpr
_If_sv<_Tp, size_type>
find_first_of(const _Tp& __svt, size_type __pos = 0) const
noexcept(is_same<_Tp, __sv_type>::value)
{
__sv_type __sv = __svt;
return this->find_first_of(__sv.data(), __pos, __sv.size());
}
# 2891 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
[[__nodiscard__]] constexpr
size_type
find_first_of(const _CharT* __s, size_type __pos, size_type __n) const
noexcept;
# 2906 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
[[__nodiscard__]] constexpr
size_type
find_first_of(const _CharT* __s, size_type __pos = 0) const
noexcept
{
;
return this->find_first_of(__s, __pos, traits_type::length(__s));
}
# 2927 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
[[__nodiscard__]] constexpr
size_type
find_first_of(_CharT __c, size_type __pos = 0) const noexcept
{ return this->find(__c, __pos); }
# 2943 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
[[__nodiscard__]] constexpr
size_type
find_last_of(const basic_string& __str, size_type __pos = npos) const
noexcept
{ return this->find_last_of(__str.data(), __pos, __str.size()); }
# 2957 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
template<typename _Tp>
[[__nodiscard__]] constexpr
_If_sv<_Tp, size_type>
find_last_of(const _Tp& __svt, size_type __pos = npos) const
noexcept(is_same<_Tp, __sv_type>::value)
{
__sv_type __sv = __svt;
return this->find_last_of(__sv.data(), __pos, __sv.size());
}
# 2980 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
[[__nodiscard__]] constexpr
size_type
find_last_of(const _CharT* __s, size_type __pos, size_type __n) const
noexcept;
# 2995 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
[[__nodiscard__]] constexpr
size_type
find_last_of(const _CharT* __s, size_type __pos = npos) const
noexcept
{
;
return this->find_last_of(__s, __pos, traits_type::length(__s));
}
# 3016 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
[[__nodiscard__]] constexpr
size_type
find_last_of(_CharT __c, size_type __pos = npos) const noexcept
{ return this->rfind(__c, __pos); }
# 3031 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
[[__nodiscard__]] constexpr
size_type
find_first_not_of(const basic_string& __str, size_type __pos = 0) const
noexcept
{ return this->find_first_not_of(__str.data(), __pos, __str.size()); }
# 3045 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
template<typename _Tp>
[[__nodiscard__]] constexpr
_If_sv<_Tp, size_type>
find_first_not_of(const _Tp& __svt, size_type __pos = 0) const
noexcept(is_same<_Tp, __sv_type>::value)
{
__sv_type __sv = __svt;
return this->find_first_not_of(__sv.data(), __pos, __sv.size());
}
# 3068 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
[[__nodiscard__]] constexpr
size_type
find_first_not_of(const _CharT* __s, size_type __pos,
size_type __n) const noexcept;
# 3083 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
[[__nodiscard__]] constexpr
size_type
find_first_not_of(const _CharT* __s, size_type __pos = 0) const
noexcept
{
;
return this->find_first_not_of(__s, __pos, traits_type::length(__s));
}
# 3102 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
[[__nodiscard__]] constexpr
size_type
find_first_not_of(_CharT __c, size_type __pos = 0) const
noexcept;
# 3118 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
[[__nodiscard__]] constexpr
size_type
find_last_not_of(const basic_string& __str, size_type __pos = npos) const
noexcept
{ return this->find_last_not_of(__str.data(), __pos, __str.size()); }
# 3132 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
template<typename _Tp>
[[__nodiscard__]] constexpr
_If_sv<_Tp, size_type>
find_last_not_of(const _Tp& __svt, size_type __pos = npos) const
noexcept(is_same<_Tp, __sv_type>::value)
{
__sv_type __sv = __svt;
return this->find_last_not_of(__sv.data(), __pos, __sv.size());
}
# 3155 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
[[__nodiscard__]] constexpr
size_type
find_last_not_of(const _CharT* __s, size_type __pos,
size_type __n) const noexcept;
# 3170 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
[[__nodiscard__]] constexpr
size_type
find_last_not_of(const _CharT* __s, size_type __pos = npos) const
noexcept
{
;
return this->find_last_not_of(__s, __pos, traits_type::length(__s));
}
# 3189 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
[[__nodiscard__]] constexpr
size_type
find_last_not_of(_CharT __c, size_type __pos = npos) const
noexcept;
# 3206 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
[[__nodiscard__]] constexpr
basic_string
substr(size_type __pos = 0, size_type __n = npos) const
{ return basic_string(*this,
_M_check(__pos, "basic_string::substr"), __n); }
# 3226 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
[[__nodiscard__]] constexpr
int
compare(const basic_string& __str) const
{
const size_type __size = this->size();
const size_type __osize = __str.size();
const size_type __len = std::min(__size, __osize);

int __r = traits_type::compare(_M_data(), str.data(), len);

if (!__r)
__r = _S_compare(__size, __osize);
return __r;
}

template<typename _Tp>
[[__nodiscard__]] constexpr
_If_sv<_Tp, int>
compare(const _Tp& __svt) const
noexcept(is_same<_Tp, __sv_type>::value)
{
__sv_type __sv = __svt;
const size_type __size = this->size();
const size_type __osize = __sv.size();
const size_type __len = std::min(__size, __osize);

int __r = traits_type::compare(_M_data(), sv.data(), len);

if (!__r)
__r = _S_compare(__size, __osize);
return __r;
}
# 3271 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
template<typename _Tp>
[[__nodiscard__]] constexpr
_If_sv<_Tp, int>
compare(size_type __pos, size_type __n, const _Tp& __svt) const
noexcept(is_same<_Tp, __sv_type>::value)
{
__sv_type __sv = __svt;
return __sv_type(*this).substr(__pos, __n).compare(__sv);
}
# 3291 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
template<typename _Tp>
[[__nodiscard__]] constexpr
_If_sv<_Tp, int>
compare(size_type __pos1, size_type __n1, const _Tp& __svt,
size_type __pos2, size_type __n2 = npos) const
noexcept(is_same<_Tp, __sv_type>::value)
{
__sv_type __sv = __svt;
return __sv_type(*this)
.substr(__pos1, __n1).compare(__sv.substr(__pos2, __n2));
}
# 3323 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
[[__nodiscard__]] constexpr
int
compare(size_type __pos, size_type __n, const basic_string& __str) const
{
_M_check(__pos, "basic_string::compare");
__n = _M_limit(__pos, __n);
const size_type __osize = __str.size();
const size_type __len = std::min(__n, __osize);
int __r = traits_type::compare(_M_data() + __pos, __str.data(), __len);
if (!__r)
__r = _S_compare(__n, __osize);
return __r;
}
# 3360 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
[[__nodiscard__]] constexpr
int
compare(size_type __pos1, size_type __n1, const basic_string& __str,
size_type __pos2, size_type __n2 = npos) const
{
_M_check(__pos1, "basic_string::compare");
__str._M_check(__pos2, "basic_string::compare");
__n1 = _M_limit(__pos1, __n1);
__n2 = __str._M_limit(__pos2, __n2);
const size_type __len = std::min(__n1, __n2);
int __r = traits_type::compare(_M_data() + __pos1,
__str.data() + __pos2, __len);
if (!__r)
__r = _S_compare(__n1, __n2);
return __r;
}
# 3391 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
[[__nodiscard__]] constexpr
int
compare(const _CharT* __s) const noexcept
{
;
const size_type __size = this->size();
const size_type __osize = traits_type::length(__s);
const size_type __len = std::min(__size, __osize);
int __r = traits_type::compare(_M_data(), __s, __len);
if (!__r)
__r = _S_compare(__size, __osize);
return __r;
}
# 3426 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
[[__nodiscard__]] constexpr
int
compare(size_type __pos, size_type __n1, const _CharT* __s) const
{
;
_M_check(__pos, "basic_string::compare");
__n1 = _M_limit(__pos, __n1);
const size_type __osize = traits_type::length(__s);
const size_type __len = std::min(__n1, __osize);
int __r = traits_type::compare(_M_data() + __pos, __s, __len);
if (!__r)
__r = _S_compare(__n1, __osize);
return __r;
}
# 3465 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
[[__nodiscard__]] constexpr
int
compare(size_type __pos, size_type __n1, const _CharT* __s,
size_type __n2) const
{
;
_M_check(__pos, "basic_string::compare");
__n1 = _M_limit(__pos, __n1);
const size_type __len = std::min(__n1, __n2);
int __r = traits_type::compare(_M_data() + __pos, __s, __len);
if (!__r)
__r = _S_compare(__n1, __n2);
return __r;
}

[[nodiscard]]
constexpr bool
starts_with(basic_string_view<_CharT, _Traits> __x) const noexcept
{ return __sv_type(this->data(), this->size()).starts_with(__x); }

[[nodiscard]]
constexpr bool
starts_with(_CharT __x) const noexcept
{ return __sv_type(this->data(), this->size()).starts_with(__x); }

[[nodiscard, __gnu__::__nonnull__]]
constexpr bool
starts_with(const _CharT* __x) const noexcept
{ return __sv_type(this->data(), this->size()).starts_with(__x); }

[[nodiscard]]
constexpr bool
ends_with(basic_string_view<_CharT, _Traits> __x) const noexcept
{ return __sv_type(this->data(), this->size()).ends_with(__x); }

[[nodiscard]]
constexpr bool
ends_with(_CharT __x) const noexcept
{ return __sv_type(this->data(), this->size()).ends_with(__x); }

[[nodiscard, __gnu__::__nonnull__]]
constexpr bool
ends_with(const _CharT* __x) const noexcept
{ return __sv_type(this->data(), this->size()).ends_with(__x); }

[[nodiscard]]
constexpr bool
contains(basic_string_view<_CharT, _Traits> __x) const noexcept
{ return __sv_type(this->data(), this->size()).contains(__x); }

[[nodiscard]]
constexpr bool
contains(_CharT __x) const noexcept
{ return __sv_type(this->data(), this->size()).contains(__x); }

[[nodiscard, __gnu__::__nonnull__]]
constexpr bool
contains(const _CharT* __x) const noexcept
{ return __sv_type(this->data(), this->size()).contains(__x); }

template<typename, typename, typename> friend class basic_stringbuf;

};
}

namespace std
{

namespace __cxx11 {
template<typename _InputIterator, typename _CharT
= typename iterator_traits<_InputIterator>::value_type,
typename _Allocator = allocator<_CharT>,
typename = _RequireInputIter<_InputIterator>,
typename = _RequireAllocator<_Allocator>>
basic_string(_InputIterator, _InputIterator, _Allocator = _Allocator())
-> basic_string<_CharT, char_traits<_CharT>, _Allocator>;

template<typename _CharT, typename _Traits,

typename _Allocator = allocator<_CharT>,
typename = _RequireAllocator<_Allocator>>
basic_string(basic_string_view<_CharT, _Traits>, const _Allocator& =
_Allocator())
-> basic_string<_CharT, _Traits, _Allocator>;

template<typename _CharT, typename _Traits,

typename _Allocator = allocator<_CharT>,
typename = _RequireAllocator<_Allocator>>
basic_string(basic_string_view<_CharT, _Traits>,
typename basic_string<_CharT, _Traits, _Allocator>::size_type,
typename basic_string<_CharT, _Traits, _Allocator>::size_type,
const _Allocator& = _Allocator())
-> basic_string<_CharT, _Traits, _Allocator>;
}

template<typename _Str>
constexpr
inline _Str
__str_concat(typename _Str::value_type const* __lhs,
typename _Str::size_type __lhs_len,
typename _Str::value_type const* __rhs,
typename _Str::size_type __rhs_len,
typename _Str::allocator_type const& __a)
{
typedef typename _Str::allocator_type allocator_type;
typedef __gnu_cxx::__alloc_traits<allocator_type> _Alloc_traits;
_Str __str(_Alloc_traits::_S_select_on_copy(__a));
__str.reserve(__lhs_len + __rhs_len);
__str.append(__lhs, __lhs_len);
__str.append(__rhs, __rhs_len);
return __str;
}
# 3595 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
template<typename _CharT, typename _Traits, typename _Alloc>
[[__nodiscard__]] constexpr
inline basic_string<_CharT, _Traits, _Alloc>
operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
{
typedef basic_string<_CharT, _Traits, _Alloc> _Str;
return std::__str_concat<_Str>(__lhs.c_str(), __lhs.size(),
__rhs.c_str(), __rhs.size(),
__lhs.get_allocator());
}

template<typename _CharT, typename _Traits, typename _Alloc>

[[__nodiscard__]] constexpr
inline basic_string<_CharT,_Traits,_Alloc>
operator+(const _CharT* __lhs,
const basic_string<_CharT,_Traits,_Alloc>& __rhs)
{
;
typedef basic_string<_CharT, _Traits, _Alloc> _Str;
return std::__str_concat<_Str>(__lhs, _Traits::length(__lhs),
__rhs.c_str(), __rhs.size(),
__rhs.get_allocator());
}

template<typename _CharT, typename _Traits, typename _Alloc>

[[__nodiscard__]] constexpr
inline basic_string<_CharT,_Traits,_Alloc>
operator+(_CharT __lhs, const basic_string<_CharT,_Traits,_Alloc>& __rhs)
{
typedef basic_string<_CharT, _Traits, _Alloc> _Str;
return std::__str_concat<_Str>(__builtin_addressof(__lhs), 1,
__rhs.c_str(), __rhs.size(),
__rhs.get_allocator());
}

template<typename _CharT, typename _Traits, typename _Alloc>

[[__nodiscard__]] constexpr
inline basic_string<_CharT, _Traits, _Alloc>
operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const _CharT* __rhs)
{
;
typedef basic_string<_CharT, _Traits, _Alloc> _Str;
return std::__str_concat<_Str>(__lhs.c_str(), __lhs.size(),
__rhs, _Traits::length(__rhs),
__lhs.get_allocator());
}

template<typename _CharT, typename _Traits, typename _Alloc>

[[__nodiscard__]] constexpr
inline basic_string<_CharT, _Traits, _Alloc>
operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, _CharT __rhs)
{
typedef basic_string<_CharT, _Traits, _Alloc> _Str;
return std::__str_concat<_Str>(__lhs.c_str(), __lhs.size(),
__builtin_addressof(__rhs), 1,
__lhs.get_allocator());
}

template<typename _CharT, typename _Traits, typename _Alloc>

[[__nodiscard__]] constexpr
inline basic_string<_CharT, _Traits, _Alloc>
operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
{ return std::move(__lhs.append(__rhs)); }

template<typename _CharT, typename _Traits, typename _Alloc>

constexpr
inline basic_string<_CharT, _Traits, _Alloc>
operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
basic_string<_CharT, _Traits, _Alloc>&& __rhs)
{ return std::move(__rhs.insert(0, __lhs)); }

template<typename _CharT, typename _Traits, typename _Alloc>

[[__nodiscard__]] constexpr
inline basic_string<_CharT, _Traits, _Alloc>
operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
basic_string<_CharT, _Traits, _Alloc>&& __rhs)
{

using _Alloc_traits = allocator_traits<_Alloc>;

bool __use_rhs = false;
if constexpr (typename _Alloc_traits::is_always_equal{})
__use_rhs = true;
else if (__lhs.get_allocator() == __rhs.get_allocator())
__use_rhs = true;
if (__use_rhs)

{
const auto __size = __lhs.size() + __rhs.size();
if (__size > __lhs.capacity() && __size <= __rhs.capacity())
return std::move(__rhs.insert(0, __lhs));
}
return std::move(__lhs.append(__rhs));
}

template<typename _CharT, typename _Traits, typename _Alloc>

[[__nodiscard__]] [[__nodiscard__]] constexpr
inline basic_string<_CharT, _Traits, _Alloc>
operator+(const _CharT* __lhs,
basic_string<_CharT, _Traits, _Alloc>&& __rhs)
{ return std::move(__rhs.insert(0, __lhs)); }

template<typename _CharT, typename _Traits, typename _Alloc>

[[__nodiscard__]] constexpr
inline basic_string<_CharT, _Traits, _Alloc>
operator+(_CharT __lhs,
basic_string<_CharT, _Traits, _Alloc>&& __rhs)
{ return std::move(__rhs.insert(0, 1, __lhs)); }

template<typename _CharT, typename _Traits, typename _Alloc>

[[__nodiscard__]] constexpr
inline basic_string<_CharT, _Traits, _Alloc>
operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
const _CharT* __rhs)
{ return std::move(__lhs.append(__rhs)); }

template<typename _CharT, typename _Traits, typename _Alloc>

[[__nodiscard__]] constexpr
inline basic_string<_CharT, _Traits, _Alloc>
operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
_CharT __rhs)
{ return std::move(__lhs.append(1, __rhs)); }
# 3752 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
template<typename _CharT, typename _Traits, typename _Alloc>
[[__nodiscard__]] constexpr
inline bool
operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
noexcept
{
return __lhs.size() == __rhs.size()
&& !_Traits::compare(__lhs.data(), __rhs.data(), __lhs.size());
}

template<typename _CharT, typename _Traits, typename _Alloc>

[[__nodiscard__]] constexpr
inline bool
operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const _CharT* __rhs)
{
return __lhs.size() == _Traits::length(__rhs)
&& !_Traits::compare(__lhs.data(), __rhs, __lhs.size());
}
# 3787 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
template<typename _CharT, typename _Traits, typename _Alloc>
[[nodiscard]]
constexpr auto
operator<=>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs) noexcept
-> decltype(__detail::__char_traits_cmp_cat<_Traits>(0))
{ return __detail::__char_traits_cmp_cat<_Traits>(__lhs.compare(__rhs)); }
# 3802 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
template<typename _CharT, typename _Traits, typename _Alloc>
[[nodiscard]]
constexpr auto
operator<=>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const _CharT* __rhs) noexcept
-> decltype(__detail::__char_traits_cmp_cat<_Traits>(0))
{ return __detail::__char_traits_cmp_cat<_Traits>(__lhs.compare(__rhs)); }
# 4036 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
template<typename _CharT, typename _Traits, typename _Alloc>
constexpr
inline void
swap(basic_string<_CharT, _Traits, _Alloc>& __lhs,
basic_string<_CharT, _Traits, _Alloc>& __rhs)
noexcept(noexcept(__lhs.swap(__rhs)))
{ __lhs.swap(__rhs); }
# 4057 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
template<typename _CharT, typename _Traits, typename _Alloc>
basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __is,
basic_string<_CharT, _Traits, _Alloc>& __str);
template<>
basic_istream<char>&
operator>>(basic_istream<char>& __is, basic_string<char>& __str);
# 4075 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
template<typename _CharT, typename _Traits, typename _Alloc>
inline basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os,
const basic_string<_CharT, _Traits, _Alloc>& __str)
{

return __ostream_insert(os, str.data(), __str.size());

}
# 4098 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
template<typename _CharT, typename _Traits, typename _Alloc>
basic_istream<_CharT, _Traits>&
getline(basic_istream<_CharT, _Traits>& __is,
basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim);
# 4115 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
template<typename _CharT, typename _Traits, typename _Alloc>
inline basic_istream<_CharT, _Traits>&
getline(basic_istream<_CharT, _Traits>& __is,
basic_string<_CharT, _Traits, _Alloc>& __str)
{ return std::getline(__is, __str, __is.widen('\n')); }

template<typename _CharT, typename _Traits, typename _Alloc>

inline basic_istream<_CharT, _Traits>&
getline(basic_istream<_CharT, _Traits>&& __is,
basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim)
{ return std::getline(__is, __str, __delim); }

template<typename _CharT, typename _Traits, typename _Alloc>

inline basic_istream<_CharT, _Traits>&
getline(basic_istream<_CharT, _Traits>&& __is,
basic_string<_CharT, _Traits, _Alloc>& __str)
{ return std::getline(__is, __str); }

template<>
basic_istream<char>&
getline(basic_istream<char>& __in, basic_string<char>& __str,
char __delim);

template<>
basic_istream<wchar_t>&
getline(basic_istream<wchar_t>& __in, basic_string<wchar_t>& __str,
wchar_t __delim);

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/ext/string_conversions.h" 1 3
# 32 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/ext/string_conversions.h" 3

# 33 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/ext/string_conversions.h" 3
# 43 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/ext/string_conversions.h" 3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cstdlib" 1 3
# 39 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cstdlib" 3

# 40 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cstdlib" 3
# 79 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cstdlib" 3
# 1 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/stdlib.h" 1 3
# 11 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/stdlib.h" 3
# 1 "D:/Enviroments/mingw64_msvcrt/lib/gcc/x86_64-w64-mingw32/14.1.0/include/
limits.h" 1 3 4
# 34 "D:/Enviroments/mingw64_msvcrt/lib/gcc/x86_64-w64-mingw32/14.1.0/include/
limits.h" 3 4
# 1 "D:/Enviroments/mingw64_msvcrt/lib/gcc/x86_64-w64-mingw32/14.1.0/include/
syslimits.h" 1 3 4

# 1 "D:/Enviroments/mingw64_msvcrt/lib/gcc/x86_64-w64-mingw32/14.1.0/include/
limits.h" 1 3 4
# 210 "D:/Enviroments/mingw64_msvcrt/lib/gcc/x86_64-w64-mingw32/14.1.0/include/
limits.h" 3 4
# 1 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/limits.h" 1 3 4
# 211 "D:/Enviroments/mingw64_msvcrt/lib/gcc/x86_64-w64-mingw32/14.1.0/include/
limits.h" 2 3 4
# 8 "D:/Enviroments/mingw64_msvcrt/lib/gcc/x86_64-w64-mingw32/14.1.0/include/
syslimits.h" 2 3 4
# 35 "D:/Enviroments/mingw64_msvcrt/lib/gcc/x86_64-w64-mingw32/14.1.0/include/
limits.h" 2 3 4
# 12 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/stdlib.h" 2 3
# 26 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/stdlib.h" 3
#pragma pack(push,_CRT_PACKING)

extern "C" {
# 50 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/stdlib.h" 3
typedef int (__attribute__((__cdecl__)) *_onexit_t)(void);
# 60 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/stdlib.h" 3
typedef struct _div_t {
int quot;
int rem;
} div_t;

typedef struct _ldiv_t {

long quot;
long rem;
} ldiv_t;

#pragma pack(4)
typedef struct {
unsigned char ld[10];
} _LDOUBLE;
#pragma pack()

typedef struct {
double x;
} _CRT_DOUBLE;

typedef struct {
float f;
} _CRT_FLOAT;

typedef struct {
long double x;
} _LONGDOUBLE;

#pragma pack(4)
typedef struct {
unsigned char ld12[12];
} _LDBL12;
#pragma pack()
# 143 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/stdlib.h" 3
typedef void (__attribute__((__cdecl__)) *_purecall_handler)(void);

attribute ((dllimport)) _purecall_handler attribute((cdecl))

_set_purecall_handler(_purecall_handler _Handler);
__attribute__ ((__dllimport__)) _purecall_handler __attribute__((__cdecl__))
_get_purecall_handler(void);

typedef void (attribute((cdecl)) *_invalid_parameter_handler)(const

wchar_t *,const wchar_t *,const wchar_t *,unsigned int,uintptr_t);
__attribute__ ((__dllimport__)) _invalid_parameter_handler
__attribute__((__cdecl__))
_set_invalid_parameter_handler(_invalid_parameter_handler _Handler);
__attribute__ ((__dllimport__)) _invalid_parameter_handler
__attribute__((__cdecl__)) _get_invalid_parameter_handler(void);
# 159 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/stdlib.h" 3
__attribute__ ((__dllimport__)) unsigned long *__attribute__((__cdecl__))
__doserrno(void);

errno_t attribute((cdecl)) _set_doserrno(unsigned long _Value);

errno_t __attribute__((__cdecl__)) _get_doserrno(unsigned long *_Value);
# 173 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/stdlib.h" 3
extern __attribute__((dllimport)) char *_sys_errlist[1];
extern __attribute__((dllimport)) int _sys_nerr;

attribute ((dllimport)) char ***attribute((cdecl))

__p___argv(void);
__attribute__ ((__dllimport__)) int *__attribute__((__cdecl__)) __p__fmode(void);
# 191 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/stdlib.h" 3
errno_t __attribute__((__cdecl__)) _get_pgmptr(char **_Value);
errno_t __attribute__((__cdecl__)) _get_wpgmptr(wchar_t **_Value);
__attribute__ ((__dllimport__)) errno_t __attribute__((__cdecl__)) _set_fmode(int
_Mode);
__attribute__ ((__dllimport__)) errno_t __attribute__((__cdecl__)) _get_fmode(int
*_PMode);
# 282 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/stdlib.h" 3
extern int * __imp___argc;

extern char *** imp_argv;

extern wchar_t *** imp_wargv;

# 322 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/stdlib.h" 3
extern char *** __imp__environ;

extern wchar_t *** impwenviron;

extern char ** imppgmptr;

extern wchar_t ** impwpgmptr;

extern unsigned int * imposplatform;

extern unsigned int * imposver;

extern unsigned int * impwinver;

extern unsigned int * impwinmajor;

extern unsigned int * __imp__winminor;

errno_t attribute((cdecl)) _get_osplatform(unsigned int *_Value);

errno_t __attribute__((__cdecl__)) _get_osver(unsigned int *_Value);
errno_t __attribute__((__cdecl__)) _get_winver(unsigned int *_Value);
errno_t __attribute__((__cdecl__)) _get_winmajor(unsigned int *_Value);
errno_t __attribute__((__cdecl__)) _get_winminor(unsigned int *_Value);

extern "C++" {
template <typename _CountofType,size_t _SizeOfArray> char
(*__countof_helper( _CountofType (&_Array)[_SizeOfArray]))[_SizeOfArray];

void attribute((cdecl)) attribute ((nothrow)) exit(int _Code)

__attribute__ ((__noreturn__));
void __attribute__((__cdecl__)) __attribute__ ((__nothrow__)) _exit(int _Code)
__attribute__ ((__noreturn__));

void attribute((cdecl)) _Exit(int) attribute ((noreturn));

inline attribute ((noreturn)) void attribute((cdecl)) _Exit(int

status)
{ _exit(status); }

void attribute((cdecl)) attribute ((noreturn)) abort(void);

attribute ((dllimport)) unsigned int attribute((cdecl))

_set_abort_behavior(unsigned int _Flags,unsigned int _Mask);

int attribute((cdecl)) abs(int _X);

long __attribute__((__cdecl__)) labs(long _X);
__extension__ long long __attribute__((__cdecl__)) _abs64(long long);

extern inline attribute((__always_inline,gnu_inline__)) long long

__attribute__((__cdecl__)) _abs64(long long x) {
return __builtin_llabs(x);
}

int attribute((cdecl)) atexit(void (attribute((cdecl)) *)(void));

double attribute((cdecl)) atof(const char *_String);

double __attribute__((__cdecl__)) _atof_l(const char *_String,_locale_t _Locale);

int attribute((cdecl)) atoi(const char *_Str);

__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _atoi_l(const char
*_Str,_locale_t _Locale);
long __attribute__((__cdecl__)) atol(const char *_Str);
__attribute__ ((__dllimport__)) long __attribute__((__cdecl__)) _atol_l(const
char *_Str,_locale_t _Locale);

void attribute((cdecl)) bsearch(const void _Key,const void

*_Base,size_t _NumOfElements,size_t _SizeOfElements,int (__attribute__((__cdecl__))
*_PtFuncCompare)(const void *,const void *));
void __attribute__((__cdecl__)) qsort(void *_Base,size_t _NumOfElements,size_t
_SizeOfElements,int (__attribute__((__cdecl__)) *_PtFuncCompare)(const void *,const
void *));

unsigned short attribute((cdecl)) _byteswap_ushort(unsigned short

_Short);
unsigned long __attribute__((__cdecl__)) _byteswap_ulong (unsigned long _Long);
__extension__ unsigned long long __attribute__((__cdecl__))
_byteswap_uint64(unsigned long long _Int64);
div_t __attribute__((__cdecl__)) div(int _Numerator,int _Denominator);
char *__attribute__((__cdecl__)) getenv(const char *_VarName) ;
__attribute__ ((__dllimport__)) char *__attribute__((__cdecl__)) _itoa(int
_Value,char *_Dest,int _Radix);
__extension__ __attribute__ ((__dllimport__)) char *__attribute__((__cdecl__))
_i64toa(long long _Val,char *_DstBuf,int _Radix) ;
__extension__ __attribute__ ((__dllimport__)) char *__attribute__((__cdecl__))
_ui64toa(unsigned long long _Val,char *_DstBuf,int _Radix) ;
__extension__ __attribute__ ((__dllimport__)) long long
__attribute__((__cdecl__)) _atoi64(const char *_String);
__extension__ __attribute__ ((__dllimport__)) long long
__attribute__((__cdecl__)) _atoi64_l(const char *_String,_locale_t _Locale);
__extension__ __attribute__ ((__dllimport__)) long long
__attribute__((__cdecl__)) _strtoi64(const char *_String,char **_EndPtr,int
_Radix);
__extension__ __attribute__ ((__dllimport__)) long long
__attribute__((__cdecl__)) _strtoi64_l(const char *_String,char **_EndPtr,int
_Radix,_locale_t _Locale);
__extension__ __attribute__ ((__dllimport__)) unsigned long long
__attribute__((__cdecl__)) _strtoui64(const char *_String,char **_EndPtr,int
_Radix);
__extension__ __attribute__ ((__dllimport__)) unsigned long long
__attribute__((__cdecl__)) _strtoui64_l(const char *_String,char **_EndPtr,int
_Radix,_locale_t _Locale);
ldiv_t __attribute__((__cdecl__)) ldiv(long _Numerator,long _Denominator);
__attribute__ ((__dllimport__)) char *__attribute__((__cdecl__)) _ltoa(long
_Value,char *_Dest,int _Radix) ;
int __attribute__((__cdecl__)) mblen(const char *_Ch,size_t _MaxCount);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _mblen_l(const
char *_Ch,size_t _MaxCount,_locale_t _Locale);
__attribute__ ((__dllimport__)) size_t __attribute__((__cdecl__)) _mbstrlen(const
char *_Str);
__attribute__ ((__dllimport__)) size_t __attribute__((__cdecl__))
_mbstrlen_l(const char *_Str,_locale_t _Locale);
__attribute__ ((__dllimport__)) size_t __attribute__((__cdecl__))
_mbstrnlen(const char *_Str,size_t _MaxCount);
__attribute__ ((__dllimport__)) size_t __attribute__((__cdecl__))
_mbstrnlen_l(const char *_Str,size_t _MaxCount,_locale_t _Locale);
int __attribute__((__cdecl__)) mbtowc(wchar_t * __restrict__ _DstCh,const char *
__restrict__ _SrcCh,size_t _SrcSizeInBytes);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _mbtowc_l(wchar_t
* __restrict__ _DstCh,const char * __restrict__ _SrcCh,size_t
_SrcSizeInBytes,_locale_t _Locale);
size_t __attribute__((__cdecl__)) mbstowcs(wchar_t * __restrict__ _Dest,const
char * __restrict__ _Source,size_t _MaxCount);
__attribute__ ((__dllimport__)) size_t __attribute__((__cdecl__))
_mbstowcs_l(wchar_t * __restrict__ _Dest,const char * __restrict__ _Source,size_t
_MaxCount,_locale_t _Locale);
int __attribute__((__cdecl__)) mkstemp(char *template_name);
int __attribute__((__cdecl__)) rand(void);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__))
_set_error_mode(int _Mode);
void __attribute__((__cdecl__)) srand(unsigned int _Seed);
# 483 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/stdlib.h" 3
inline __attribute__((__cdecl__))
double __attribute__((__cdecl__)) __attribute__ ((__nothrow__)) strtod(const char *
__restrict__ _Str,char ** __restrict__ _EndPtr)
{
double __attribute__((__cdecl__)) __mingw_strtod (const char * __restrict__, char
** __restrict__);
return __mingw_strtod( _Str, _EndPtr);
}

inline __attribute__((__cdecl__))
float __attribute__((__cdecl__)) __attribute__ ((__nothrow__)) strtof(const char *
__restrict__ _Str,char ** __restrict__ _EndPtr)
{
float __attribute__((__cdecl__)) __mingw_strtof (const char * __restrict__, char
** __restrict__);
return __mingw_strtof( _Str, _EndPtr);
}

long double attribute((cdecl)) attribute ((nothrow))

strtold(const char * __restrict__ , char ** __restrict__ );
extern double __attribute__((__cdecl__)) __attribute__ ((__nothrow__))
__strtod (const char * __restrict__ , char ** __restrict__);

float attribute((cdecl)) __mingw_strtof (const char * restrict, char

** __restrict__);
double __attribute__((__cdecl__)) __mingw_strtod (const char * __restrict__, char
** __restrict__);
long double __attribute__((__cdecl__)) __mingw_strtold(const char * __restrict__,
char ** __restrict__);

attribute ((dllimport)) float attribute((cdecl)) _strtof_l(const

char * __restrict__ _Str,char ** __restrict__ _EndPtr,_locale_t _Locale);
__attribute__ ((__dllimport__)) double __attribute__((__cdecl__)) _strtod_l(const
char * __restrict__ _Str,char ** __restrict__ _EndPtr,_locale_t _Locale);
long __attribute__((__cdecl__)) strtol(const char * __restrict__ _Str,char **
__restrict__ _EndPtr,int _Radix);
__attribute__ ((__dllimport__)) long __attribute__((__cdecl__)) _strtol_l(const
char * __restrict__ _Str,char ** __restrict__ _EndPtr,int _Radix,_locale_t
_Locale);
unsigned long __attribute__((__cdecl__)) strtoul(const char * __restrict__
_Str,char ** __restrict__ _EndPtr,int _Radix);
__attribute__ ((__dllimport__)) unsigned long __attribute__((__cdecl__))
_strtoul_l(const char * __restrict__ _Str,char ** __restrict__ _EndPtr,int
_Radix,_locale_t _Locale);

int attribute((cdecl)) system(const char *_Command);

attribute ((dllimport)) char *attribute((cdecl)) _ultoa(unsigned

long _Value,char *_Dest,int _Radix) ;
int __attribute__((__cdecl__)) wctomb(char *_MbCh,wchar_t _WCh) ;
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _wctomb_l(char
*_MbCh,wchar_t _WCh,_locale_t _Locale) ;
size_t __attribute__((__cdecl__)) wcstombs(char * __restrict__ _Dest,const
wchar_t * __restrict__ _Source,size_t _MaxCount) ;
__attribute__ ((__dllimport__)) size_t __attribute__((__cdecl__))
_wcstombs_l(char * __restrict__ _Dest,const wchar_t * __restrict__ _Source,size_t
_MaxCount,_locale_t _Locale) ;

void *attribute((cdecl)) calloc(size_t _NumOfElements,size_t

_SizeOfElements);
void __attribute__((__cdecl__)) free(void *_Memory);
void *__attribute__((__cdecl__)) malloc(size_t _Size);
void *__attribute__((__cdecl__)) realloc(void *_Memory,size_t _NewSize);
__attribute__ ((__dllimport__)) void __attribute__((__cdecl__))
_aligned_free(void *_Memory);
__attribute__ ((__dllimport__)) void *__attribute__((__cdecl__))
_aligned_malloc(size_t _Size,size_t _Alignment);
__attribute__ ((__dllimport__)) void *__attribute__((__cdecl__))
_aligned_offset_malloc(size_t _Size,size_t _Alignment,size_t _Offset);
__attribute__ ((__dllimport__)) void *__attribute__((__cdecl__))
_aligned_realloc(void *_Memory,size_t _Size,size_t _Alignment);
__attribute__ ((__dllimport__)) void *__attribute__((__cdecl__))
_aligned_offset_realloc(void *_Memory,size_t _Size,size_t _Alignment,size_t
_Offset);
# 609 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/stdlib.h" 3
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _putenv(const char
*_EnvString);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _wputenv(const
wchar_t *_EnvString);

attribute ((dllimport)) char *attribute((cdecl)) _fullpath(char

*_FullPath,const char *_Path,size_t _SizeInBytes);
__attribute__ ((__dllimport__)) char *__attribute__((__cdecl__)) _ecvt(double
_Val,int _NumOfDigits,int *_PtDec,int *_PtSign) ;
__attribute__ ((__dllimport__)) char *__attribute__((__cdecl__)) _fcvt(double
_Val,int _NumOfDec,int *_PtDec,int *_PtSign) ;
__attribute__ ((__dllimport__)) char *__attribute__((__cdecl__)) _gcvt(double
_Val,int _NumOfDigits,char *_DstBuf) ;
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__))
_atodbl(_CRT_DOUBLE *_Result,char *_Str);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _atoldbl(_LDOUBLE
*_Result,char *_Str);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _atoflt(_CRT_FLOAT
*_Result,char *_Str);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__))
_atodbl_l(_CRT_DOUBLE *_Result,char *_Str,_locale_t _Locale);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__))
_atoldbl_l(_LDOUBLE *_Result,char *_Str,_locale_t _Locale);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__))
_atoflt_l(_CRT_FLOAT *_Result,char *_Str,_locale_t _Locale);
# 639 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/stdlib.h" 3
unsigned long __attribute__((__cdecl__)) _lrotl(unsigned long,int);
unsigned long __attribute__((__cdecl__)) _lrotr(unsigned long,int);

attribute ((dllimport)) void attribute((cdecl)) _makepath(char

*_Path,const char *_Drive,const char *_Dir,const char *_Filename,const char *_Ext);
_onexit_t __attribute__((__cdecl__)) _onexit(_onexit_t _Func);

extension unsigned long long attribute((cdecl)) _rotl64(unsigned long

long _Val,int _Shift);
__extension__ unsigned long long __attribute__((__cdecl__)) _rotr64(unsigned long
long Value,int Shift);
unsigned int __attribute__((__cdecl__)) _rotr(unsigned int _Val,int _Shift);
unsigned int __attribute__((__cdecl__)) _rotl(unsigned int _Val,int _Shift);

extension unsigned long long attribute((cdecl)) _rotr64(unsigned long

long _Val,int _Shift);
__attribute__ ((__dllimport__)) void __attribute__((__cdecl__)) _searchenv(const
char *_Filename,const char *_EnvVar,char *_ResultPath) ;
__attribute__ ((__dllimport__)) void __attribute__((__cdecl__)) _splitpath(const
char *_FullPath,char *_Drive,char *_Dir,char *_Filename,char *_Ext) ;
__attribute__ ((__dllimport__)) void __attribute__((__cdecl__)) _swab(char
*_Buf1,char *_Buf2,int _SizeInBytes);
# 686 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/stdlib.h" 3
__attribute__ ((__dllimport__)) void __attribute__((__cdecl__)) _beep(unsigned
_Frequency,unsigned _Duration) __attribute__ ((__deprecated__));

attribute ((dllimport)) void attribute((cdecl)) _seterrormode(int

_Mode) __attribute__ ((__deprecated__));
__attribute__ ((__dllimport__)) void __attribute__((__cdecl__)) _sleep(unsigned
long _Duration) __attribute__ ((__deprecated__));
# 710 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/stdlib.h" 3
char *__attribute__((__cdecl__)) ecvt(double _Val,int _NumOfDigits,int
*_PtDec,int *_PtSign) ;
char *__attribute__((__cdecl__)) fcvt(double _Val,int _NumOfDec,int *_PtDec,int
*_PtSign) ;
char *__attribute__((__cdecl__)) gcvt(double _Val,int _NumOfDigits,char *_DstBuf)
;
char *__attribute__((__cdecl__)) itoa(int _Val,char *_DstBuf,int _Radix) ;
char *__attribute__((__cdecl__)) ltoa(long _Val,char *_DstBuf,int _Radix) ;
int __attribute__((__cdecl__)) putenv(const char *_EnvString) ;

void attribute((cdecl)) swab(char _Buf1,char _Buf2,int _SizeInBytes) ;

char attribute((cdecl)) ultoa(unsigned long _Val,char _Dstbuf,int

_Radix) ;
_onexit_t __attribute__((__cdecl__)) onexit(_onexit_t _Func);

typedef struct { extension long long quot, rem; } lldiv_t;

extension lldiv_t attribute((cdecl)) lldiv(long long, long long);

extension long long attribute((cdecl)) llabs(long long);

extension inline long long attribute((cdecl)) llabs(long long _j)

{ return (_j >= 0 ? _j : -_j); }
__extension__ long long __attribute__((__cdecl__)) strtoll(const char *
__restrict__, char ** __restrict, int);
__extension__ unsigned long long __attribute__((__cdecl__)) strtoull(const char *
__restrict__, char ** __restrict__, int);

extension long long attribute((cdecl)) atoll (const char *);

extension long long attribute((cdecl)) wtoll (const wchar_t *);

__extension__ char *__attribute__((__cdecl__)) lltoa (long long, char *, int);
__extension__ char *__attribute__((__cdecl__)) ulltoa (unsigned long long , char
*, int);
__extension__ wchar_t *__attribute__((__cdecl__)) lltow (long long, wchar_t *,
int);
__extension__ wchar_t *__attribute__((__cdecl__)) ulltow (unsigned long long,
wchar_t *, int);

extension inline char attribute((cdecl)) lltoa (long long _n, char

_c, int _i) { return _i64toa (_n, _c, _i); }
__extension__ inline char *__attribute__((__cdecl__)) ulltoa (unsigned long long
_n, char * _c, int _i) { return _ui64toa (_n, _c, _i); }
__extension__ inline long long __attribute__((__cdecl__)) wtoll (const wchar_t *
_w) { return _wtoi64 (_w); }
__extension__ inline wchar_t *__attribute__((__cdecl__)) lltow (long long _n,
wchar_t * _w, int _i) { return _i64tow (_n, _w, _i); }
__extension__ inline wchar_t *__attribute__((__cdecl__)) ulltow (unsigned long
long _n, wchar_t * _w, int _i) { return _ui64tow (_n, _w, _i); }

#pragma pack(pop)

# 1 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/sec_api/stdlib_s.h" 1
3
# 9 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/sec_api/stdlib_s.h" 3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/stdlib.h" 1 3
# 30 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/stdlib.h" 3
# 1 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/stdlib.h" 1 3
# 31 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/stdlib.h" 2 3
# 10 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/sec_api/stdlib_s.h"
2 3

extern "C" {

attribute ((dllimport)) void * attribute((cdecl)) bsearch_s(const

void *_Key,const void *_Base,rsize_t _NumOfElements,rsize_t _SizeOfElements,int
(__attribute__((__cdecl__)) * _PtFuncCompare)(void *, const void *, const void *),
void *_Context);
__attribute__ ((__dllimport__)) errno_t __attribute__((__cdecl__)) _dupenv_s(char
**_PBuffer,size_t *_PBufferSizeInBytes,const char *_VarName);
__attribute__ ((__dllimport__)) errno_t __attribute__((__cdecl__))
getenv_s(size_t *_ReturnSize,char *_DstBuf,rsize_t _DstSize,const char *_VarName);
extern "C++" { template <size_t __size> inline errno_t __attribute__((__cdecl__))
getenv_s(size_t * _ReturnSize, char (&_Dest)[__size], const char * _VarName)
{ return getenv_s(_ReturnSize, _Dest, __size, _VarName); } }
__attribute__ ((__dllimport__)) errno_t __attribute__((__cdecl__)) _itoa_s(int
_Value,char *_DstBuf,size_t _Size,int _Radix);
extern "C++" { template <size_t __size> inline errno_t __attribute__((__cdecl__))
_itoa_s(int _Value, char (&_Dest)[__size], int _Radix) { return _itoa_s(_Value,
_Dest, __size, _Radix); } }
__attribute__ ((__dllimport__)) errno_t __attribute__((__cdecl__)) _i64toa_s(long
long _Val,char *_DstBuf,size_t _Size,int _Radix);
__attribute__ ((__dllimport__)) errno_t __attribute__((__cdecl__))
_ui64toa_s(unsigned long long _Val,char *_DstBuf,size_t _Size,int _Radix);
__attribute__ ((__dllimport__)) errno_t __attribute__((__cdecl__)) _ltoa_s(long
_Val,char *_DstBuf,size_t _Size,int _Radix);
extern "C++" { template <size_t __size> inline errno_t __attribute__((__cdecl__))
_ltoa_s(long _Value, char (&_Dest)[__size], int _Radix) { return _ltoa_s(_Value,
_Dest, __size, _Radix); } }
__attribute__ ((__dllimport__)) errno_t __attribute__((__cdecl__))
mbstowcs_s(size_t *_PtNumOfCharConverted,wchar_t *_DstBuf,size_t _SizeInWords,const
char *_SrcBuf,size_t _MaxCount);
extern "C++" { template <size_t __size> inline errno_t __attribute__((__cdecl__))
mbstowcs_s(size_t * _PtNumOfCharConverted, wchar_t (&_Dest)[__size], const char *
_Source, size_t _MaxCount) { return mbstowcs_s(_PtNumOfCharConverted, _Dest,
__size, _Source, _MaxCount); } }
__attribute__ ((__dllimport__)) errno_t __attribute__((__cdecl__))
_mbstowcs_s_l(size_t *_PtNumOfCharConverted,wchar_t *_DstBuf,size_t
_SizeInWords,const char *_SrcBuf,size_t _MaxCount,_locale_t _Locale);
extern "C++" { template <size_t __size> inline errno_t __attribute__((__cdecl__))
_mbstowcs_s_l(size_t * _PtNumOfCharConverted, wchar_t (&_Dest)[__size], const char
* _Source, size_t _MaxCount, _locale_t _Locale) { return
_mbstowcs_s_l(_PtNumOfCharConverted, _Dest, __size, _Source, _MaxCount, _Locale); }
}
__attribute__ ((__dllimport__)) errno_t __attribute__((__cdecl__))
_ultoa_s(unsigned long _Val,char *_DstBuf,size_t _Size,int _Radix);
extern "C++" { template <size_t __size> inline errno_t __attribute__((__cdecl__))
_ultoa_s(unsigned long _Value, char (&_Dest)[__size], int _Radix) { return
_ultoa_s(_Value, _Dest, __size, _Radix); } }
__attribute__ ((__dllimport__)) errno_t __attribute__((__cdecl__)) wctomb_s(int
*_SizeConverted,char *_MbCh,rsize_t _SizeInBytes,wchar_t _WCh);
__attribute__ ((__dllimport__)) errno_t __attribute__((__cdecl__))
_wctomb_s_l(int *_SizeConverted,char *_MbCh,size_t _SizeInBytes,wchar_t
_WCh,_locale_t _Locale);
__attribute__ ((__dllimport__)) errno_t __attribute__((__cdecl__))
wcstombs_s(size_t *_PtNumOfCharConverted,char *_Dst,size_t _DstSizeInBytes,const
wchar_t *_Src,size_t _MaxCountInBytes);
extern "C++" { template <size_t __size> inline errno_t __attribute__((__cdecl__))
wcstombs_s(size_t* _PtNumOfCharConverted, char (&_Dst)[__size], const wchar_t*
_Src, size_t _MaxCountInBytes) { return wcstombs_s(_PtNumOfCharConverted, _Dst,
__size, _Src, _MaxCountInBytes); } }
__attribute__ ((__dllimport__)) errno_t __attribute__((__cdecl__))
_wcstombs_s_l(size_t *_PtNumOfCharConverted,char *_Dst,size_t _DstSizeInBytes,const
wchar_t *_Src,size_t _MaxCountInBytes,_locale_t _Locale);
extern "C++" { template <size_t __size> inline errno_t __attribute__((__cdecl__))
_wcstombs_s_l(size_t* _PtNumOfCharConverted, char (&_Dst)[__size], const wchar_t*
_Src, size_t _MaxCountInBytes, _locale_t _Locale) { return
_wcstombs_s_l(_PtNumOfCharConverted, _Dst, __size, _Src, _MaxCountInBytes,
_Locale); } }

attribute ((dllimport)) errno_t attribute((cdecl)) _ecvt_s(char

*_DstBuf,size_t _Size,double _Val,int _NumOfDights,int *_PtDec,int *_PtSign);
__attribute__ ((__dllimport__)) errno_t __attribute__((__cdecl__)) _fcvt_s(char
*_DstBuf,size_t _Size,double _Val,int _NumOfDec,int *_PtDec,int *_PtSign);
__attribute__ ((__dllimport__)) errno_t __attribute__((__cdecl__)) _gcvt_s(char
*_DstBuf,size_t _Size,double _Val,int _NumOfDigits);
__attribute__ ((__dllimport__)) errno_t __attribute__((__cdecl__))
_makepath_s(char *_PathResult,size_t _Size,const char *_Drive,const char
*_Dir,const char *_Filename,const char *_Ext);
extern "C++" { template <size_t __size> inline errno_t __attribute__((__cdecl__))
_makepath_s(char (&_PathResult)[__size], const char* _Drive, const char* _Dir,
const char* _Filename, const char* _Ext) { return
_makepath_s(_PathResult,__size,_Drive,_Dir,_Filename,_Ext); } }
__attribute__ ((__dllimport__)) errno_t __attribute__((__cdecl__))
_putenv_s(const char *_Name,const char *_Value);
__attribute__ ((__dllimport__)) errno_t __attribute__((__cdecl__))
_searchenv_s(const char *_Filename,const char *_EnvVar,char *_ResultPath,size_t
_SizeInBytes);

attribute ((dllimport)) errno_t attribute((cdecl))

_splitpath_s(const char *_FullPath,char *_Drive,size_t _DriveSize,char *_Dir,size_t
_DirSize,char *_Filename,size_t _FilenameSize,char *_Ext,size_t _ExtSize);
extern "C++" { template <size_t __drive_size, size_t __dir_size, size_t
__name_size, size_t __ext_size> inline errno_t __attribute__((__cdecl__))
_splitpath_s(const char *_Dest, char (&__drive)[__drive_size], char (&__dir)
[__dir_size], char (&__name)[__name_size], char (&__ext)[__ext_size]) { return
_splitpath_s(_Dest, __drive, __drive_size, __dir, __dir_size, __name, __name_size,
__ext, __ext_size); } }

attribute ((dllimport)) void attribute((cdecl)) qsort_s(void

*_Base,size_t _NumOfElements,size_t _SizeOfElements,int (__attribute__((__cdecl__))
*_PtFuncCompare)(void *,const void *,const void *),void *_Context);

}
# 770 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/stdlib.h" 2 3
# 1 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/malloc.h" 1 3
# 11 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/malloc.h" 3
#pragma pack(push,_CRT_PACKING)

extern "C" {
# 46 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/malloc.h" 3
typedef struct _heapinfo {
int *_pentry;
size_t _size;
int _useflag;
} _HEAPINFO;
extern unsigned int _amblksiz;
# 77 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/malloc.h" 3
void * __mingw_aligned_malloc (size_t _Size, size_t _Alignment);
void __mingw_aligned_free (void *_Memory);
void * __mingw_aligned_offset_realloc (void *_Memory, size_t _Size, size_t
_Alignment, size_t _Offset);
void * __mingw_aligned_realloc (void *_Memory, size_t _Size, size_t _Offset);

# 1 "D:/Enviroments/mingw64_msvcrt/lib/gcc/x86_64-w64-mingw32/14.1.0/include/
mm_malloc.h" 1 3 4
# 27 "D:/Enviroments/mingw64_msvcrt/lib/gcc/x86_64-w64-mingw32/14.1.0/include/
mm_malloc.h" 3 4
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/stdlib.h" 1 3 4
# 28 "D:/Enviroments/mingw64_msvcrt/lib/gcc/x86_64-w64-mingw32/14.1.0/include/
mm_malloc.h" 2 3 4

static inline void *

_mm_malloc (size_t __size, size_t __align)
{
void * __malloc_ptr;
void * __aligned_ptr;

if (align & (align - 1))

{

(*_errno()) = 22;

return ((void *) 0);

}

if (__size == 0)
return ((void *) 0);

if (__align < 2 * sizeof (void *))

__align = 2 * sizeof (void *);

__malloc_ptr = malloc (size + align);

if (!__malloc_ptr)
return ((void *) 0);

__aligned_ptr = (void *) (((size_t) __malloc_ptr + __align)

& ~((size_t) (__align) - 1));

((void **) __aligned_ptr)[-1] = __malloc_ptr;

return __aligned_ptr;
}
static __inline__ void
_mm_free (void *__aligned_ptr)
{
if (__aligned_ptr)
free (((void **) __aligned_ptr)[-1]);
}
# 85 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/malloc.h" 2 3

attribute ((dllimport)) int attribute((cdecl)) _resetstkoflw

(void);

attribute ((dllimport)) unsigned long attribute((cdecl))

_set_malloc_crt_max_wait(unsigned long _NewValue);

attribute ((dllimport)) void *attribute((cdecl)) _expand(void

*_Memory,size_t _NewSize);
__attribute__ ((__dllimport__)) size_t __attribute__((__cdecl__)) _msize(void
*_Memory);

attribute ((dllimport)) size_t attribute((cdecl))

_get_sbh_threshold(void);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__))
_set_sbh_threshold(size_t _NewValue);
__attribute__ ((__dllimport__)) errno_t __attribute__((__cdecl__))
_set_amblksiz(size_t _Value);
__attribute__ ((__dllimport__)) errno_t __attribute__((__cdecl__))
_get_amblksiz(size_t *_Value);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _heapadd(void
*_Memory,size_t _Size);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _heapchk(void);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _heapmin(void);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _heapset(unsigned
int _Fill);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__))
_heapwalk(_HEAPINFO *_EntryInfo);
__attribute__ ((__dllimport__)) size_t __attribute__((__cdecl__))
_heapused(size_t *_Used,size_t *_Commit);
__attribute__ ((__dllimport__)) intptr_t __attribute__((__cdecl__))
_get_heap_handle(void);
# 125 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/malloc.h" 3
static __inline void *_MarkAllocaS(void *_Ptr,unsigned int _Marker) {
if(_Ptr) {
*((unsigned int*)_Ptr) = _Marker;
_Ptr = (char*)_Ptr + 16;
}
return _Ptr;
}
# 144 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/malloc.h" 3
static __inline void __attribute__((__cdecl__)) _freea(void *_Memory) {
unsigned int _Marker;
if(_Memory) {
_Memory = (char*)_Memory - 16;
_Marker = *(unsigned int *)_Memory;
if(_Marker==0xDDDD) {
free(_Memory);
}

}
}
# 187 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/malloc.h" 3
}

#pragma pack(pop)
# 771 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/stdlib.h" 2 3
# 80 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cstdlib" 2 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/std_abs.h" 1 3
# 33 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/std_abs.h" 3

# 34 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/std_abs.h" 3
# 46 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/std_abs.h" 3
extern "C++"
{
namespace std
{

using ::abs;

inline long
abs(long __i) { return __builtin_labs(__i); }

inline long long

abs(long long __x) { return __builtin_llabs (__x); }
# 70 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/std_abs.h" 3
inline constexpr double
abs(double __x)
{ return __builtin_fabs(__x); }

inline constexpr float

abs(float __x)
{ return __builtin_fabsf(__x); }

inline constexpr long double

abs(long double __x)
{ return __builtin_fabsl(__x); }

extension inline constexpr __int128

abs(__int128 __x) { return __x >= 0 ? __x : -__x; }
# 101 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/std_abs.h" 3
constexpr _Float16
abs(_Float16 __x)
{ return _Float16(__builtin_fabsf(__x)); }

constexpr _Float32
abs(_Float32 __x)
{ return __builtin_fabsf(__x); }

constexpr _Float64
abs(_Float64 __x)
{ return __builtin_fabs(__x); }
# 129 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/std_abs.h" 3
constexpr __gnu_cxx::__bfloat16_t
abs(__gnu_cxx::__bfloat16_t __x)
{ return __gnu_cxx::__bfloat16_t(__builtin_fabsf(__x)); }

extension inline constexpr

__float128
abs(__float128 __x)
{

return __builtin_signbit(x) ? -x : __x;

}
}
# 82 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cstdlib" 2 3
# 125 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cstdlib" 3
extern "C++"
{
namespace std
{

using ::div_t;
using ::ldiv_t;

using ::abort;

using ::atexit;
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 ::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 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cstdlib" 3
namespace __gnu_cxx
{

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 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cstdlib" 3
using ::atoll;
using ::strtoll;
using ::strtoull;

using ::strtof;
using ::strtold;

namespace std
{

using ::__gnu_cxx::lldiv_t;

using ::__gnu_cxx::_Exit;

using ::__gnu_cxx::llabs;
using ::__gnu_cxx::div;
using ::__gnu_cxx::lldiv;

using ::__gnu_cxx::atoll;
using ::__gnu_cxx::strtof;
using ::__gnu_cxx::strtoll;
using ::__gnu_cxx::strtoull;
using ::__gnu_cxx::strtold;
}
# 275 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cstdlib" 3
}
# 44 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/ext/string_conversions.h" 2
3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cwchar" 1 3
# 39 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cwchar" 3

# 40 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cwchar" 3
# 45 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/ext/string_conversions.h" 2
3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cstdio" 1 3
# 39 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cstdio" 3

# 40 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cstdio" 3
# 96 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cstdio" 3
namespace std
{
using ::FILE;
using ::fpos_t;
using ::clearerr;
using ::fclose;
using ::feof;
using ::ferror;
using ::fflush;
using ::fgetc;
using ::fgetpos;
using ::fgets;
using ::fopen;
using ::fprintf;
using ::fputc;
using ::fputs;
using ::fread;
using ::freopen;
using ::fscanf;
using ::fseek;
using ::fsetpos;
using ::ftell;
using ::fwrite;
using ::getc;
using ::getchar;

using ::perror;
using ::printf;
using ::putc;
using ::putchar;
using ::puts;
using ::remove;
using ::rename;
using ::rewind;
using ::scanf;
using ::setbuf;
using ::setvbuf;
using ::sprintf;
using ::sscanf;
using ::tmpfile;

using ::tmpnam;

using ::ungetc;
using ::vfprintf;
using ::vprintf;
using ::vsprintf;
}
# 157 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cstdio" 3
namespace __gnu_cxx
{
# 175 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cstdio" 3
using ::snprintf;
using ::vfscanf;
using ::vscanf;
using ::vsnprintf;
using ::vsscanf;

}
namespace std
{
using ::__gnu_cxx::snprintf;
using ::__gnu_cxx::vfscanf;
using ::__gnu_cxx::vscanf;
using ::__gnu_cxx::vsnprintf;
using ::__gnu_cxx::vsscanf;
}
# 46 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/ext/string_conversions.h" 2
3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cerrno" 1 3
# 39 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cerrno" 3

# 40 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cerrno" 3
# 47 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/ext/string_conversions.h" 2
3

namespace __gnu_cxx
{

template<typename _TRet, typename _Ret = _TRet, typename _CharT,

typename... _Base>
_Ret
__stoa(_TRet (*__convf) (const _CharT*, _CharT**, _Base...),
const char* __name, const _CharT* __str, std::size_t* __idx,
_Base... __base)
{
_Ret __ret;

_CharT* __endptr;

struct _Save_errno {
_Save_errno() : _M_errno((*_errno())) { (*_errno()) = 0; }
~_Save_errno() { if ((*_errno()) == 0) (*_errno()) = _M_errno; }
int _M_errno;
} const __save_errno;

struct _Range_chk {
static bool
_S_chk(_TRet, std::false_type) { return false; }

static bool
_S_chk(_TRet __val, std::true_type)
{
return __val < _TRet(__numeric_traits<int>::__min)
|| __val > _TRet(__numeric_traits<int>::__max);
}
};

const _TRet tmp = convf(str, &endptr, __base...);

if (__endptr == __str)
std::__throw_invalid_argument(__name);
else if ((*_errno()) == 34
|| _Range_chk::_S_chk(__tmp, std::is_same<_Ret, int>{}))
std::__throw_out_of_range(__name);
else
__ret = __tmp;

if (__idx)
*__idx = __endptr - __str;

return __ret;
}

template<typename _String, typename _CharT = typename _String::value_type>

_String
__to_xstring(int (*__convf) (_CharT*, std::size_t, const _CharT*,
__builtin_va_list), std::size_t __n,
const _CharT* __fmt, ...)
{

_CharT* __s = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)

* __n));

__builtin_va_list __args;
__builtin_va_start(__args, __fmt);

const int len = convf(s, n, fmt, args);

__builtin_va_end(__args);

return _String(s, s + __len);

}

}
# 4155 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 2 3

namespace std
{

namespace __cxx11 {

inline int
stoi(const string& __str, size_t* __idx = 0, int __base = 10)
{ return __gnu_cxx::__stoa<long, int>(&std::strtol, "stoi", __str.c_str(),
__idx, __base); }

inline long
stol(const string& __str, size_t* __idx = 0, int __base = 10)
{ return __gnu_cxx::__stoa(&std::strtol, "stol", __str.c_str(),
__idx, __base); }

inline unsigned long

stoul(const string& __str, size_t* __idx = 0, int __base = 10)
{ return __gnu_cxx::__stoa(&std::strtoul, "stoul", __str.c_str(),
__idx, __base); }

inline long long

stoll(const string& __str, size_t* __idx = 0, int __base = 10)
{ return __gnu_cxx::__stoa(&std::strtoll, "stoll", __str.c_str(),
__idx, __base); }

inline unsigned long long

stoull(const string& __str, size_t* __idx = 0, int __base = 10)
{ return __gnu_cxx::__stoa(&std::strtoull, "stoull", __str.c_str(),
__idx, __base); }
# 4198 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
inline double
stod(const string& __str, size_t* __idx = 0)
{ return __gnu_cxx::__stoa(&std::strtod, "stod", __str.c_str(), __idx); }

inline float
stof(const string& __str, size_t* __idx = 0)
{ return __gnu_cxx::__stoa(&std::strtof, "stof", __str.c_str(), __idx); }
# 4226 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
inline long double
stold(const string& __str, size_t* __idx = 0)
{ return __gnu_cxx::__stoa(&std::strtold, "stold", __str.c_str(), __idx); }
# 4238 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
[[__nodiscard__]]
inline string
to_string(int __val)

noexcept

{
const bool __neg = __val < 0;
const unsigned __uval = __neg ? (unsigned)~__val + 1u : __val;
const auto __len = __detail::__to_chars_len(__uval);
string __str;
__str.__resize_and_overwrite(__neg + __len, [=](char* __p, size_t __n) {
__p[0] = '-';
__detail::__to_chars_10_impl(__p + (int)__neg, __len, __uval);
return __n;
});
return __str;
}

[[__nodiscard__]]
inline string
to_string(unsigned __val)

noexcept

{
const auto __len = __detail::__to_chars_len(__val);
string __str;
__str.__resize_and_overwrite(__len, [__val](char* __p, size_t __n) {
__detail::__to_chars_10_impl(__p, __n, __val);
return __n;
});
return __str;
}

[[__nodiscard__]]
inline string
to_string(long __val)

noexcept

{
const bool __neg = __val < 0;
const unsigned long __uval = __neg ? (unsigned long)~__val + 1ul : __val;
const auto __len = __detail::__to_chars_len(__uval);
string __str;
__str.__resize_and_overwrite(__neg + __len, [=](char* __p, size_t __n) {
__p[0] = '-';
__detail::__to_chars_10_impl(__p + (int)__neg, __len, __uval);
return __n;
});
return __str;
}

[[__nodiscard__]]
inline string
to_string(unsigned long __val)

noexcept

[[__nodiscard__]]
inline string
to_string(long long __val)
{
const bool __neg = __val < 0;
const unsigned long long __uval
= __neg ? (unsigned long long)~__val + 1ull : __val;
const auto __len = __detail::__to_chars_len(__uval);
string __str;
__str.__resize_and_overwrite(__neg + __len, [=](char* __p, size_t __n) {
__p[0] = '-';
__detail::__to_chars_10_impl(__p + (int)__neg, __len, __uval);
return __n;
});
return __str;
}

[[__nodiscard__]]
inline string
to_string(unsigned long long __val)
{
const auto __len = __detail::__to_chars_len(__val);
string __str;
__str.__resize_and_overwrite(__len, [__val](char* __p, size_t __n) {
__detail::__to_chars_10_impl(__p, __n, __val);
return __n;
});
return __str;
}

[[nodiscard]]
inline string
to_string(float __val)
{
string __str;
size_t __len = 15;
do {
__str.resize_and_overwrite(__len,
[__val, &__len] (char* __p, size_t __n) {
auto [__end, __err] = std::to_chars(__p, __p + __n, __val);
if (__err == errc{}) [[likely]]
return __end - __p;
__len *= 2;
return __p - __p;;
});
} while (__str.empty());
return __str;
}

[[nodiscard]]
inline string
to_string(double __val)
{
string __str;
size_t __len = 15;
do {
__str.resize_and_overwrite(__len,
[__val, &__len] (char* __p, size_t __n) {
auto [__end, __err] = std::to_chars(__p, __p + __n, __val);
if (__err == errc{}) [[likely]]
return __end - __p;
__len *= 2;
return __p - __p;;
});
} while (__str.empty());
return __str;
}

[[nodiscard]]
inline string
to_string(long double __val)
{
string __str;
size_t __len = 15;
do {
__str.resize_and_overwrite(__len,
[__val, &__len] (char* __p, size_t __n) {
auto [__end, __err] = std::to_chars(__p, __p + __n, __val);
if (__err == errc{}) [[likely]]
return __end - __p;
__len *= 2;
return __p - __p;;
});
} while (__str.empty());
return __str;
}
# 4431 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
inline int
stoi(const wstring& __str, size_t* __idx = 0, int __base = 10)
{ return __gnu_cxx::__stoa<long, int>(&std::wcstol, "stoi", __str.c_str(),
__idx, __base); }

inline long
stol(const wstring& __str, size_t* __idx = 0, int __base = 10)
{ return __gnu_cxx::__stoa(&std::wcstol, "stol", __str.c_str(),
__idx, __base); }

inline unsigned long

stoul(const wstring& __str, size_t* __idx = 0, int __base = 10)
{ return __gnu_cxx::__stoa(&std::wcstoul, "stoul", __str.c_str(),
__idx, __base); }

inline long long

stoll(const wstring& __str, size_t* __idx = 0, int __base = 10)
{ return __gnu_cxx::__stoa(&std::wcstoll, "stoll", __str.c_str(),
__idx, __base); }

inline unsigned long long

stoull(const wstring& __str, size_t* __idx = 0, int __base = 10)
{ return __gnu_cxx::__stoa(&std::wcstoull, "stoull", __str.c_str(),
__idx, __base); }

inline float
stof(const wstring& __str, size_t* __idx = 0)
{ return __gnu_cxx::__stoa(&std::wcstof, "stof", __str.c_str(), __idx); }

inline double
stod(const wstring& __str, size_t* __idx = 0)
{ return __gnu_cxx::__stoa(&std::wcstod, "stod", __str.c_str(), __idx); }

inline long double

stold(const wstring& __str, size_t* __idx = 0)
{ return __gnu_cxx::__stoa(&std::wcstold, "stold", __str.c_str(), __idx); }

#pragma GCC diagnostic push

#pragma GCC diagnostic ignored "-Wc++17-extensions"
constexpr
inline void
__to_wstring_numeric(const char* __s, int __len, wchar_t* __wout)
{

if constexpr (wchar_t('0') == L'0' && wchar_t('-') == L'-'

&& wchar_t('.') == L'.' && wchar_t('e') == L'e')
{
for (int __i = 0; __i < __len; ++__i)
__wout[__i] = (wchar_t) __s[__i];
}
else
{
wchar_t __wc[256];
for (int __i = '0'; __i <= '9'; ++__i)
__wc[__i] = L'0' + __i;
__wc['.'] = L'.';
__wc['+'] = L'+';
__wc['-'] = L'-';
__wc['a'] = L'a';
__wc['b'] = L'b';
__wc['c'] = L'c';
__wc['d'] = L'd';
__wc['e'] = L'e';
__wc['f'] = L'f';
__wc['n'] = L'n';
__wc['p'] = L'p';
__wc['x'] = L'x';
__wc['A'] = L'A';
__wc['B'] = L'B';
__wc['C'] = L'C';
__wc['D'] = L'D';
__wc['E'] = L'E';
__wc['F'] = L'F';
__wc['N'] = L'N';
__wc['P'] = L'P';
__wc['X'] = L'X';

for (int i = 0; i < len; ++i)

__wout[__i] = __wc[(int)__s[__i]];
}
}

constexpr

inline wstring

__to_wstring_numeric(string_view __s)

{
if constexpr (wchar_t('0') == L'0' && wchar_t('-') == L'-'
&& wchar_t('.') == L'.' && wchar_t('e') == L'e')
return wstring(__s.data(), __s.data() + __s.size());
else
{
wstring __ws;
auto __f = __s.data();
__ws.__resize_and_overwrite(__s.size(),
[__f] (wchar_t* __to, int __n) {
std::__to_wstring_numeric(__f, __n, __to);
return __n;
});
return __ws;
}
}
#pragma GCC diagnostic pop

[[__nodiscard__]]
inline wstring
to_wstring(int __val)
{ return std::__to_wstring_numeric(std::to_string(__val)); }

[[__nodiscard__]]
inline wstring
to_wstring(unsigned __val)
{ return std::__to_wstring_numeric(std::to_string(__val)); }

[[__nodiscard__]]
inline wstring
to_wstring(long __val)
{ return std::__to_wstring_numeric(std::to_string(__val)); }

[[__nodiscard__]]
inline wstring
to_wstring(unsigned long __val)
{ return std::__to_wstring_numeric(std::to_string(__val)); }

[[__nodiscard__]]
inline wstring
to_wstring(long long __val)
{ return std::__to_wstring_numeric(std::to_string(__val)); }

[[__nodiscard__]]
inline wstring
to_wstring(unsigned long long __val)
{ return std::__to_wstring_numeric(std::to_string(__val)); }

[[__nodiscard__]]
inline wstring
to_wstring(float __val)
{ return std::__to_wstring_numeric(std::to_string(__val)); }

[[__nodiscard__]]
inline wstring
to_wstring(double __val)
{ return std::__to_wstring_numeric(std::to_string(__val)); }

[[__nodiscard__]]
inline wstring
to_wstring(long double __val)
{ return std::__to_wstring_numeric(std::to_string(__val)); }

namespace std
{
template<typename _CharT, typename _Alloc,
typename _StrT = basic_string<_CharT, char_traits<_CharT>, _Alloc>>
struct __str_hash_base
: public __hash_base<size_t, _StrT>
{
[[__nodiscard__]]
size_t
operator()(const _StrT& __s) const noexcept
{ return _Hash_impl::hash(__s.data(), __s.length() * sizeof(_CharT)); }
};

template<typename _Alloc>
struct hash<basic_string<char, char_traits<char>, _Alloc>>
: public __str_hash_base<char, _Alloc>
{ };

template<typename _Alloc>
struct hash<basic_string<wchar_t, char_traits<wchar_t>, _Alloc>>
: public __str_hash_base<wchar_t, _Alloc>
{ };

template<typename _Alloc>
struct __is_fast_hash<hash<basic_string<wchar_t, char_traits<wchar_t>,
_Alloc>>>
: std::false_type
{ };

template<typename _Alloc>
struct hash<basic_string<char8_t, char_traits<char8_t>, _Alloc>>
: public __str_hash_base<char8_t, _Alloc>
{ };

template<typename _Alloc>
struct hash<basic_string<char16_t, char_traits<char16_t>, _Alloc>>
: public __str_hash_base<char16_t, _Alloc>
{ };

template<typename _Alloc>
struct hash<basic_string<char32_t, char_traits<char32_t>, _Alloc>>
: public __str_hash_base<char32_t, _Alloc>
{ };

template<> struct __is_fast_hash<hash<string>> : std::false_type { };

template<> struct __is_fast_hash<hash<wstring>> : std::false_type { };
template<> struct __is_fast_hash<hash<u16string>> : std::false_type { };
template<> struct __is_fast_hash<hash<u32string>> : std::false_type { };

template<> struct __is_fast_hash<hash<u8string>> : std::false_type { };

# 4678 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.h" 3
inline namespace literals
{
inline namespace string_literals
{
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wliteral-suffix"

attribute ((abi_tag__ ("cxx11"))) constexpr

inline basic_string<char>
operator""s(const char* __str, size_t __len)
{ return basic_string<char>{__str, __len}; }

attribute ((abi_tag__ ("cxx11"))) constexpr

inline basic_string<wchar_t>
operator""s(const wchar_t* __str, size_t __len)
{ return basic_string<wchar_t>{__str, __len}; }

attribute ((abi_tag__ ("cxx11"))) constexpr

inline basic_string<char8_t>
operator""s(const char8_t* __str, size_t __len)
{ return basic_string<char8_t>{__str, __len}; }

attribute ((abi_tag__ ("cxx11"))) constexpr

inline basic_string<char16_t>
operator""s(const char16_t* __str, size_t __len)
{ return basic_string<char16_t>{__str, __len}; }

attribute ((abi_tag__ ("cxx11"))) constexpr

inline basic_string<char32_t>
operator""s(const char32_t* __str, size_t __len)
{ return basic_string<char32_t>{__str, __len}; }

#pragma GCC diagnostic pop

}
}

namespace __detail::__variant
{
template<typename> struct _Never_valueless_alt;
template<typename _Tp, typename _Traits, typename _Alloc>
struct _Never_valueless_alt<std::basic_string<_Tp, _Traits, _Alloc>>
: __and_<
is_nothrow_move_constructible<std::basic_string<_Tp, _Traits, _Alloc>>,
is_nothrow_move_assignable<std::basic_string<_Tp, _Traits, _Alloc>>
>::type
{ };
}

}
# 55 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/string" 2 3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.tcc" 1 3
# 42 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.tcc" 3

# 43 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.tcc" 3

namespace std
{

template<typename _CharT, typename _Traits, typename _Alloc>

const typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::npos;

template<typename _CharT, typename _Traits, typename _Alloc>

constexpr
void
basic_string<_CharT, _Traits, _Alloc>::
swap(basic_string& __s) noexcept
{
if (this == std::__addressof(__s))
return;

_Alloc_traits::_S_on_swap(_M_get_allocator(), __s._M_get_allocator());

if (_M_is_local())
if (__s._M_is_local())
{
if (length() && __s.length())
{
_CharT __tmp_data[_S_local_capacity + 1];
traits_type::copy(__tmp_data, __s._M_local_buf,
__s.length() + 1);
traits_type::copy(__s._M_local_buf, _M_local_buf,
length() + 1);
traits_type::copy(_M_local_buf, __tmp_data,
__s.length() + 1);
}
else if (__s.length())
{
_M_init_local_buf();
traits_type::copy(_M_local_buf, __s._M_local_buf,
__s.length() + 1);
_M_length(__s.length());
__s._M_set_length(0);
return;
}
else if (length())
{
__s._M_init_local_buf();
traits_type::copy(__s._M_local_buf, _M_local_buf,
length() + 1);
__s._M_length(length());
_M_set_length(0);
return;
}
}
else
{
const size_type __tmp_capacity = __s._M_allocated_capacity;
__s._M_init_local_buf();
traits_type::copy(__s._M_local_buf, _M_local_buf,
length() + 1);
_M_data(__s._M_data());
__s._M_data(__s._M_local_buf);
_M_capacity(__tmp_capacity);
}
else
{
const size_type __tmp_capacity = _M_allocated_capacity;
if (__s._M_is_local())
{
_M_init_local_buf();
traits_type::copy(_M_local_buf, __s._M_local_buf,
__s.length() + 1);
__s._M_data(_M_data());
_M_data(_M_local_buf);
}
else
{
pointer __tmp_ptr = _M_data();
_M_data(__s._M_data());
__s._M_data(__tmp_ptr);
_M_capacity(__s._M_allocated_capacity);
}
__s._M_capacity(__tmp_capacity);
}

const size_type __tmp_length = length();

_M_length(__s.length());
__s._M_length(__tmp_length);
}

template<typename _CharT, typename _Traits, typename _Alloc>

constexpr
typename basic_string<_CharT, _Traits, _Alloc>::pointer
basic_string<_CharT, _Traits, _Alloc>::
_M_create(size_type& __capacity, size_type __old_capacity)
{

if (__capacity > max_size())

std::__throw_length_error(("basic_string::_M_create"));

if (capacity > old_capacity && capacity < 2 * old_capacity)

{
__capacity = 2 * __old_capacity;

if (__capacity > max_size())

__capacity = max_size();
}

return _S_allocate(_M_get_allocator(), __capacity + 1);

}

template<typename _CharT, typename _Traits, typename _Alloc>

template<typename _InIterator>
constexpr
void
basic_string<_CharT, _Traits, _Alloc>::
_M_construct(_InIterator __beg, _InIterator __end,
std::input_iterator_tag)
{
size_type __len = 0;
size_type __capacity = size_type(_S_local_capacity);

_M_init_local_buf();

while (beg != end && len < capacity)

{
_M_local_buf[__len++] = *__beg;
++__beg;
}

struct _Guard
{
constexpr
explicit _Guard(basic_string* __s) : _M_guarded(__s) { }

constexpr
~_Guard() { if (_M_guarded) _M_guarded->_M_dispose(); }

basic_string* _M_guarded;
} __guard(this);

while (beg != end)

{
if (__len == __capacity)
{

__capacity = __len + 1;
pointer __another = _M_create(__capacity, __len);
this->_S_copy(__another, _M_data(), __len);
_M_dispose();
_M_data(__another);
_M_capacity(__capacity);
}
traits_type::assign(_M_data()[__len++], *__beg);
++__beg;
}

__guard._M_guarded = 0;

_M_set_length(__len);
}

template<typename _CharT, typename _Traits, typename _Alloc>

template<typename _InIterator>
constexpr
void
basic_string<_CharT, _Traits, _Alloc>::
_M_construct(_InIterator __beg, _InIterator __end,
std::forward_iterator_tag)
{
size_type __dnew = static_cast<size_type>(std::distance(__beg, __end));

if (__dnew > size_type(_S_local_capacity))

{
_M_data(_M_create(__dnew, size_type(0)));
_M_capacity(__dnew);
}
else
_M_init_local_buf();

struct _Guard
{
constexpr
explicit _Guard(basic_string* __s) : _M_guarded(__s) { }

constexpr
~_Guard() { if (_M_guarded) _M_guarded->_M_dispose(); }

basic_string* _M_guarded;
} __guard(this);

this->_S_copy_chars(_M_data(), beg, end);

__guard._M_guarded = 0;

_M_set_length(__dnew);
}

template<typename _CharT, typename _Traits, typename _Alloc>

constexpr
void
basic_string<_CharT, _Traits, _Alloc>::
_M_construct(size_type __n, _CharT __c)
{
if (__n > size_type(_S_local_capacity))
{
_M_data(_M_create(__n, size_type(0)));
_M_capacity(__n);
}
else
_M_init_local_buf();

if (__n)
this->_S_assign(_M_data(), __n, __c);

_M_set_length(__n);
}

template<typename _CharT, typename _Traits, typename _Alloc>

constexpr
void
basic_string<_CharT, _Traits, _Alloc>::
_M_assign(const basic_string& __str)
{
if (this != std::__addressof(__str))
{
const size_type __rsize = __str.length();
const size_type __capacity = capacity();

if (rsize > capacity)

{
size_type __new_capacity = __rsize;
pointer __tmp = _M_create(__new_capacity, __capacity);
_M_dispose();
_M_data(__tmp);
_M_capacity(__new_capacity);
}

if (__rsize)
this->_S_copy(_M_data(), __str._M_data(), __rsize);

_M_set_length(__rsize);
}
}

template<typename _CharT, typename _Traits, typename _Alloc>

constexpr
void
basic_string<_CharT, _Traits, _Alloc>::
reserve(size_type __res)
{
const size_type __capacity = capacity();

if (res <= capacity)

return;

pointer __tmp = _M_create(res, capacity);

this->_S_copy(__tmp, _M_data(), length() + 1);
_M_dispose();
_M_data(__tmp);
_M_capacity(__res);
}
template<typename _CharT, typename _Traits, typename _Alloc>
constexpr
void
basic_string<_CharT, _Traits, _Alloc>::
_M_mutate(size_type __pos, size_type __len1, const _CharT* __s,
size_type __len2)
{
const size_type __how_much = length() - __pos - __len1;

size_type __new_capacity = length() + len2 - len1;

pointer __r = _M_create(__new_capacity, capacity());

if (__pos)
this->_S_copy(__r, _M_data(), __pos);
if (__s && __len2)
this->_S_copy(__r + __pos, __s, __len2);
if (__how_much)
this->_S_copy(__r + __pos + __len2,
_M_data() + __pos + __len1, __how_much);

_M_dispose();
_M_data(__r);
_M_capacity(__new_capacity);
}

template<typename _CharT, typename _Traits, typename _Alloc>

constexpr
void
basic_string<_CharT, _Traits, _Alloc>::
_M_erase(size_type __pos, size_type __n)
{
const size_type __how_much = length() - __pos - __n;

if (__how_much && __n)

this->_S_move(_M_data() + __pos, _M_data() + __pos + __n, __how_much);

_M_set_length(length() - __n);
}

template<typename _CharT, typename _Traits, typename _Alloc>

constexpr
void
basic_string<_CharT, _Traits, _Alloc>::
reserve()
{
if (_M_is_local())
return;

const size_type __length = length();

const size_type __capacity = _M_allocated_capacity;

if (__length <= size_type(_S_local_capacity))

{
_M_init_local_buf();
this->_S_copy(_M_local_buf, _M_data(), __length + 1);
_M_destroy(__capacity);
_M_data(_M_local_data());
}
else if (__length < __capacity)
try
{
pointer __tmp = _S_allocate(_M_get_allocator(), __length + 1);
this->_S_copy(__tmp, _M_data(), __length + 1);
_M_dispose();
_M_data(__tmp);
_M_capacity(__length);
}
catch (const __cxxabiv1::__forced_unwind&)
{ throw; }
catch (...)
{ }

template<typename _CharT, typename _Traits, typename _Alloc>

constexpr
void
basic_string<_CharT, _Traits, _Alloc>::
resize(size_type __n, _CharT __c)
{
const size_type __size = this->size();
if (__size < __n)
this->append(__n - __size, __c);
else if (__n < __size)
this->_M_set_length(__n);
}

template<typename _CharT, typename _Traits, typename _Alloc>

constexpr
basic_string<_CharT, _Traits, _Alloc>&
basic_string<_CharT, _Traits, _Alloc>::
_M_append(const _CharT* __s, size_type __n)
{
const size_type __len = __n + this->size();

if (__len <= this->capacity())

{
if (__n)
this->_S_copy(this->_M_data() + this->size(), __s, __n);
}
else
this->_M_mutate(this->size(), size_type(0), __s, __n);

this->_M_set_length(__len);
return *this;
}

template<typename _CharT, typename _Traits, typename _Alloc>

template<typename _InputIterator>
constexpr
basic_string<_CharT, _Traits, _Alloc>&
basic_string<_CharT, _Traits, _Alloc>::
_M_replace_dispatch(const_iterator __i1, const_iterator __i2,
_InputIterator __k1, _InputIterator __k2,
std::__false_type)
{
const basic_string __s(__k1, __k2, this->get_allocator());
const size_type __n1 = __i2 - __i1;
return _M_replace(__i1 - begin(), __n1, __s._M_data(),
__s.size());
}

template<typename _CharT, typename _Traits, typename _Alloc>

constexpr
basic_string<_CharT, _Traits, _Alloc>&
basic_string<_CharT, _Traits, _Alloc>::
_M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
_CharT __c)
{
_M_check_length(__n1, __n2, "basic_string::_M_replace_aux");

const size_type __old_size = this->size();

const size_type __new_size = __old_size + __n2 - __n1;

if (__new_size <= this->capacity())

{
pointer __p = this->_M_data() + __pos1;

const size_type __how_much = __old_size - pos1 - n1;

if (__how_much && __n1 != __n2)
this->_S_move(__p + __n2, __p + __n1, __how_much);
}
else
this->_M_mutate(__pos1, __n1, 0, __n2);

if (__n2)
this->_S_assign(this->_M_data() + __pos1, __n2, __c);

this->_M_set_length(__new_size);
return *this;
}

template<typename _CharT, typename _Traits, typename _Alloc>

__attribute__((__noinline__, __noclone__, __cold__)) void
basic_string<_CharT, _Traits, _Alloc>::
_M_replace_cold(pointer __p, size_type __len1, const _CharT* __s,
const size_type __len2, const size_type __how_much)
{

if (len2 && len2 <= __len1)

this->_S_move(__p, __s, __len2);
if (__how_much && __len1 != __len2)
this->_S_move(__p + __len2, __p + __len1, __how_much);
if (__len2 > __len1)
{
if (__s + __len2 <= __p + __len1)
this->_S_move(__p, __s, __len2);
else if (__s >= __p + __len1)
{

const size_type poff = (s - p) + (len2 - __len1);

this->_S_copy(__p, __p + __poff, __len2);
}
else
{
const size_type __nleft = (__p + __len1) - __s;
this->_S_move(__p, __s, __nleft);
this->_S_copy(__p + __nleft, __p + __len2, __len2 - __nleft);
}
}
}

template<typename _CharT, typename _Traits, typename _Alloc>

constexpr
basic_string<_CharT, _Traits, _Alloc>&
basic_string<_CharT, _Traits, _Alloc>::
_M_replace(size_type __pos, size_type __len1, const _CharT* __s,
const size_type __len2)
{
_M_check_length(__len1, __len2, "basic_string::_M_replace");

const size_type __old_size = this->size();

const size_type __new_size = __old_size + __len2 - __len1;

if (__new_size <= this->capacity())

{
pointer __p = this->_M_data() + __pos;

const size_type __how_much = __old_size - pos - len1;

if (std::is_constant_evaluated())
{
auto __newp = _S_allocate(_M_get_allocator(), __new_size);
_S_copy(__newp, this->_M_data(), __pos);
_S_copy(__newp + __pos, __s, __len2);
_S_copy(__newp + __pos + __len2, __p + __len1, __how_much);
_S_copy(this->_M_data(), __newp, __new_size);
this->_M_get_allocator().deallocate(__newp, __new_size);
}
else

if (__builtin_expect(_M_disjunct(__s), true))
{
if (__how_much && __len1 != __len2)
this->_S_move(__p + __len2, __p + __len1, __how_much);
if (__len2)
this->_S_copy(__p, __s, __len2);
}
else
_M_replace_cold(__p, __len1, __s, __len2, __how_much);
}
else
this->_M_mutate(__pos, __len1, __s, __len2);

this->_M_set_length(__new_size);
return *this;
}

template<typename _CharT, typename _Traits, typename _Alloc>

constexpr
typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::
copy(_CharT* __s, size_type __n, size_type __pos) const
{
_M_check(__pos, "basic_string::copy");
__n = _M_limit(__pos, __n);
;
if (__n)
_S_copy(__s, _M_data() + __pos, __n);

return __n;
}

template<typename _CharT, typename _Traits, typename _Alloc>

template<typename _Operation>
[[__gnu__::__always_inline__]]
constexpr void
basic_string<_CharT, _Traits, _Alloc>::
__resize_and_overwrite(const size_type __n, _Operation __op)
{ resize_and_overwrite<_Operation&>(__n, __op); }

template<typename _CharT, typename _Traits, typename _Alloc>

template<typename _Operation>
constexpr void
basic_string<_CharT, _Traits, _Alloc>::

resize_and_overwrite(const size_type __n, _Operation __op)

{
reserve(__n);
_CharT* const __p = _M_data();

if (std::__is_constant_evaluated() && __n > size())

traits_type::assign(__p + size(), __n - size(), _CharT());

struct _Terminator {
constexpr ~_Terminator() { _M_this->_M_set_length(_M_r); }
basic_string* _M_this;
size_type _M_r;
};
_Terminator __term{this, 0};
auto __r = std::move(__op)(__p + 0, __n + 0);

static_assert(ranges::__detail::__is_integer_like<decltype(__r)>);

;
__term._M_r = size_type(__r);
if (__term._M_r > __n)
__builtin_unreachable();
}
# 623 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.tcc" 3
template<typename _CharT, typename _Traits, typename _Alloc>
constexpr
typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::
find(const _CharT* __s, size_type __pos, size_type __n) const
noexcept
{
;
const size_type __size = this->size();

if (__n == 0)
return __pos <= __size ? __pos : npos;
if (__pos >= __size)
return npos;

const _CharT elem0 = s[0];

const _CharT* const __data = data();
const _CharT* __first = __data + __pos;
const _CharT* const __last = __data + __size;
size_type __len = __size - __pos;

while (len >= n)

{

__first = traits_type::find(first, len - n + 1, elem0);

if (!__first)
return npos;

if (traits_type::compare(first, s, __n) == 0)

return __first - __data;
__len = __last - ++__first;
}
return npos;
}

template<typename _CharT, typename _Traits, typename _Alloc>

constexpr
typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::
find(_CharT __c, size_type __pos) const noexcept
{
size_type __ret = npos;
const size_type __size = this->size();
if (__pos < __size)
{
const _CharT* __data = _M_data();
const size_type __n = __size - __pos;
const _CharT* __p = traits_type::find(__data + __pos, __n, __c);
if (__p)
__ret = __p - __data;
}
return __ret;
}

template<typename _CharT, typename _Traits, typename _Alloc>

constexpr
typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::
rfind(const _CharT* __s, size_type __pos, size_type __n) const
noexcept
{
;
const size_type __size = this->size();
if (__n <= __size)
{
__pos = std::min(size_type(__size - __n), __pos);
const _CharT* __data = _M_data();
do
{
if (traits_type::compare(__data + __pos, __s, __n) == 0)
return __pos;
}
while (__pos-- > 0);
}
return npos;
}

template<typename _CharT, typename _Traits, typename _Alloc>

constexpr
typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::
rfind(_CharT __c, size_type __pos) const noexcept
{
size_type __size = this->size();
if (__size)
{
if (--__size > __pos)
__size = __pos;
for (++__size; __size-- > 0; )
if (traits_type::eq(_M_data()[__size], __c))
return __size;
}
return npos;
}

template<typename _CharT, typename _Traits, typename _Alloc>

constexpr
typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::
find_first_of(const _CharT* __s, size_type __pos, size_type __n) const
noexcept
{
;
for (; __n && __pos < this->size(); ++__pos)
{
const _CharT* __p = traits_type::find(__s, __n, _M_data()[__pos]);
if (__p)
return __pos;
}
return npos;
}

template<typename _CharT, typename _Traits, typename _Alloc>

constexpr
typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::
find_last_of(const _CharT* __s, size_type __pos, size_type __n) const
noexcept
{
;
size_type __size = this->size();
if (__size && __n)
{
if (--__size > __pos)
__size = __pos;
do
{
if (traits_type::find(__s, __n, _M_data()[__size]))
return __size;
}
while (__size-- != 0);
}
return npos;
}

template<typename _CharT, typename _Traits, typename _Alloc>

constexpr
typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::
find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const
noexcept
{
;
for (; __pos < this->size(); ++__pos)
if (!traits_type::find(__s, __n, _M_data()[__pos]))
return __pos;
return npos;
}

template<typename _CharT, typename _Traits, typename _Alloc>

constexpr
typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::
find_first_not_of(_CharT __c, size_type __pos) const noexcept
{
for (; __pos < this->size(); ++__pos)
if (!traits_type::eq(_M_data()[__pos], __c))
return __pos;
return npos;
}

template<typename _CharT, typename _Traits, typename _Alloc>

constexpr
typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::
find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const
noexcept
{
;
size_type __size = this->size();
if (__size)
{
if (--__size > __pos)
__size = __pos;
do
{
if (!traits_type::find(__s, __n, _M_data()[__size]))
return __size;
}
while (__size--);
}
return npos;
}

template<typename _CharT, typename _Traits, typename _Alloc>

constexpr
typename basic_string<_CharT, _Traits, _Alloc>::size_type
basic_string<_CharT, _Traits, _Alloc>::
find_last_not_of(_CharT __c, size_type __pos) const noexcept
{
size_type __size = this->size();
if (__size)
{
if (--__size > __pos)
__size = __pos;
do
{
if (!traits_type::eq(_M_data()[__size], __c))
return __size;
}
while (__size--);
}
return npos;
}

template<typename _CharT, typename _Traits, typename _Alloc>

basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __in,
basic_string<_CharT, _Traits, _Alloc>& __str)
{
typedef basic_istream<_CharT, _Traits> __istream_type;
typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
typedef typename __istream_type::ios_base __ios_base;
typedef typename __istream_type::int_type __int_type;
typedef typename __string_type::size_type __size_type;
typedef ctype<_CharT> __ctype_type;
typedef typename __ctype_type::ctype_base __ctype_base;

__size_type __extracted = 0;
typename __ios_base::iostate __err = __ios_base::goodbit;
typename __istream_type::sentry __cerb(__in, false);
if (__cerb)
{
try
{

__str.erase();
_CharT __buf[128];
__size_type __len = 0;
const streamsize __w = __in.width();
const __size_type __n = __w > 0 ? static_cast<__size_type>(__w)
: __str.max_size();
const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
const __int_type __eof = _Traits::eof();
__int_type __c = __in.rdbuf()->sgetc();

while (extracted < n

&& !_Traits::eq_int_type(__c, __eof)
&& !__ct.is(__ctype_base::space,
_Traits::to_char_type(__c)))
{
if (__len == sizeof(__buf) / sizeof(_CharT))
{
__str.append(__buf, sizeof(__buf) / sizeof(_CharT));
__len = 0;
}
__buf[__len++] = _Traits::to_char_type(__c);
++__extracted;
__c = __in.rdbuf()->snextc();
}
__str.append(__buf, __len);

if (extracted < n && _Traits::eq_int_type(c, eof))

__err |= __ios_base::eofbit;
__in.width(0);
}
catch(__cxxabiv1::__forced_unwind&)
{
__in._M_setstate(__ios_base::badbit);
throw;
}
catch(...)
{

__in._M_setstate(__ios_base::badbit);
}
}

if (!__extracted)
__err |= __ios_base::failbit;
if (__err)
__in.setstate(__err);
return __in;
}

template<typename _CharT, typename _Traits, typename _Alloc>

basic_istream<_CharT, _Traits>&
getline(basic_istream<_CharT, _Traits>& __in,
basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim)
{
typedef basic_istream<_CharT, _Traits> __istream_type;
typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
typedef typename __istream_type::ios_base __ios_base;
typedef typename __istream_type::int_type __int_type;
typedef typename __string_type::size_type __size_type;

__size_type __extracted = 0;
const __size_type __n = __str.max_size();
typename __ios_base::iostate __err = __ios_base::goodbit;
typename __istream_type::sentry __cerb(__in, true);
if (__cerb)
{
try
{
__str.erase();
const __int_type __idelim = _Traits::to_int_type(__delim);
const __int_type __eof = _Traits::eof();
__int_type __c = __in.rdbuf()->sgetc();

while (extracted < n

&& !_Traits::eq_int_type(__c, __eof)
&& !_Traits::eq_int_type(__c, __idelim))
{
__str += _Traits::to_char_type(__c);
++__extracted;
__c = __in.rdbuf()->snextc();
}

if (_Traits::eq_int_type(__c, __eof))
__err |= __ios_base::eofbit;
else if (_Traits::eq_int_type(__c, __idelim))
{
++__extracted;
__in.rdbuf()->sbumpc();
}
else
__err |= __ios_base::failbit;
}
catch(__cxxabiv1::__forced_unwind&)
{
__in._M_setstate(__ios_base::badbit);
throw;
}
catch(...)
{

__in._M_setstate(__ios_base::badbit);
}
}
if (!__extracted)
__err |= __ios_base::failbit;
if (__err)
__in.setstate(__err);
return __in;
}
# 985 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.tcc" 3
extern template void
basic_string<char>::_M_replace_cold(char *, size_type, const char*,
const size_type, const size_type);

extern template
basic_istream<char>&
operator>>(basic_istream<char>&, string&);
extern template
basic_ostream<char>&
operator<<(basic_ostream<char>&, const string&);
extern template
basic_istream<char>&
getline(basic_istream<char>&, string&, char);
extern template
basic_istream<char>&
getline(basic_istream<char>&, string&);
# 1011 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/basic_string.tcc" 3
extern template void
basic_string<wchar_t>::_M_replace_cold(wchar_t*, size_type, const wchar_t*,
const size_type, const size_type);

extern template
basic_istream<wchar_t>&
operator>>(basic_istream<wchar_t>&, wstring&);
extern template
basic_ostream<wchar_t>&
operator<<(basic_ostream<wchar_t>&, const wstring&);
extern template
basic_istream<wchar_t>&
getline(basic_istream<wchar_t>&, wstring&, wchar_t);
extern template
basic_istream<wchar_t>&
getline(basic_istream<wchar_t>&, wstring&);

}
# 56 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/string" 2 3
# 64 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/string" 3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 1 3
# 47 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 3

# 48 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 3
# 65 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/string" 2 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/memory_resource.h" 1 3
# 33 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/memory_resource.h" 3

# 34 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/memory_resource.h" 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cstddef" 1 3
# 42 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cstddef" 3

# 43 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cstddef" 3

# 1 "D:/Enviroments/mingw64_msvcrt/lib/gcc/x86_64-w64-mingw32/14.1.0/include/
stddef.h" 1 3 4
# 1 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/stddef.h" 1 3 4
# 13 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/stddef.h" 3 4
extern "C" {
# 24 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/stddef.h" 3 4
__attribute__ ((__dllimport__)) extern unsigned long __attribute__((__cdecl__))
__threadid(void);

attribute ((dllimport)) extern uintptr_t attribute((cdecl))

__threadhandle(void);

}
# 424 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/stddef.h" 3 4
typedef struct {
long long __max_align_ll __attribute__((__aligned__(__alignof__(long long))));
long double __max_align_ld __attribute__((__aligned__(__alignof__(long
double))));
} max_align_t;
# 2 "D:/Enviroments/mingw64_msvcrt/lib/gcc/x86_64-w64-mingw32/14.1.0/include/
stddef.h" 2 3 4
# 51 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cstddef" 2 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 1 3
# 47 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 3

# 48 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 3
# 54 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cstddef" 2 3

extern "C++"
{

namespace std
{

using ::max_align_t;
}

namespace std
{

enum class byte : unsigned char {};

template<typename _IntegerType> struct __byte_operand { };

template<> struct __byte_operand<bool> { using __type = byte; };
template<> struct __byte_operand<char> { using __type = byte; };
template<> struct __byte_operand<signed char> { using __type = byte; };
template<> struct __byte_operand<unsigned char> { using __type = byte; };
template<> struct __byte_operand<wchar_t> { using __type = byte; };

template<> struct __byte_operand<char8_t> { using __type = byte; };

template<> struct __byte_operand<char16_t> { using __type = byte; };

template<> struct __byte_operand<char32_t> { using __type = byte; };
template<> struct __byte_operand<short> { using __type = byte; };
template<> struct __byte_operand<unsigned short> { using __type = byte; };
template<> struct __byte_operand<int> { using __type = byte; };
template<> struct __byte_operand<unsigned int> { using __type = byte; };
template<> struct __byte_operand<long> { using __type = byte; };
template<> struct __byte_operand<unsigned long> { using __type = byte; };
template<> struct __byte_operand<long long> { using __type = byte; };
template<> struct __byte_operand<unsigned long long> { using __type = byte; };

template<> struct __byte_operand<__int128>

{ using __type = byte; };
template<> struct __byte_operand<unsigned __int128>
{ using __type = byte; };
# 109 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cstddef" 3
template<typename _IntegerType>
struct __byte_operand<const _IntegerType>
: __byte_operand<_IntegerType> { };
template<typename _IntegerType>
struct __byte_operand<volatile _IntegerType>
: __byte_operand<_IntegerType> { };
template<typename _IntegerType>
struct __byte_operand<const volatile _IntegerType>
: __byte_operand<_IntegerType> { };

template<typename _IntegerType>
using __byte_op_t = typename __byte_operand<_IntegerType>::__type;

template<typename _IntegerType>
[[__gnu__::__always_inline__]]
constexpr __byte_op_t<_IntegerType>
operator<<(byte __b, _IntegerType __shift) noexcept
{ return (byte)(unsigned char)((unsigned)__b << __shift); }

template<typename _IntegerType>
[[__gnu__::__always_inline__]]
constexpr __byte_op_t<_IntegerType>
operator>>(byte __b, _IntegerType __shift) noexcept
{ return (byte)(unsigned char)((unsigned)__b >> __shift); }

[[__gnu__::__always_inline__]]
constexpr byte
operator|(byte __l, byte __r) noexcept
{ return (byte)(unsigned char)((unsigned)__l | (unsigned)__r); }

[[__gnu__::__always_inline__]]
constexpr byte
operator&(byte __l, byte __r) noexcept
{ return (byte)(unsigned char)((unsigned)__l & (unsigned)__r); }

[[__gnu__::__always_inline__]]
constexpr byte
operator^(byte __l, byte __r) noexcept
{ return (byte)(unsigned char)((unsigned)__l ^ (unsigned)__r); }

[[__gnu__::__always_inline__]]
constexpr byte
operator~(byte __b) noexcept
{ return (byte)(unsigned char)~(unsigned)__b; }

template<typename _IntegerType>
[[__gnu__::__always_inline__]]
constexpr __byte_op_t<_IntegerType>&
operator<<=(byte& __b, _IntegerType __shift) noexcept
{ return __b = __b << __shift; }

template<typename _IntegerType>
[[__gnu__::__always_inline__]]
constexpr __byte_op_t<_IntegerType>&
operator>>=(byte& __b, _IntegerType __shift) noexcept
{ return __b = __b >> __shift; }

[[__gnu__::__always_inline__]]
constexpr byte&
operator|=(byte& __l, byte __r) noexcept
{ return __l = __l | __r; }

[[__gnu__::__always_inline__]]
constexpr byte&
operator&=(byte& __l, byte __r) noexcept
{ return __l = __l & __r; }

[[__gnu__::__always_inline__]]
constexpr byte&
operator^=(byte& __l, byte __r) noexcept
{ return __l = __l ^ __r; }

template<typename _IntegerType>
[[nodiscard,__gnu__::__always_inline__]]
constexpr _IntegerType
to_integer(__byte_op_t<_IntegerType> __b) noexcept
{ return _IntegerType(__b); }

}
# 39 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/memory_resource.h" 2 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/uses_allocator.h" 1 3
# 40 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/uses_allocator.h" 3
namespace std
{

struct __erased_type { };

template<typename _Alloc, typename _Tp>

using __is_erased_or_convertible
= __or_<is_convertible<_Alloc, _Tp>, is_same<_Tp, __erased_type>>;

struct allocator_arg_t { explicit allocator_arg_t() = default; };

inline constexpr allocator_arg_t allocator_arg =

allocator_arg_t();

template<typename _Tp, typename _Alloc, typename = __void_t<>>

struct __uses_allocator_helper
: false_type { };

template<typename _Tp, typename _Alloc>

struct __uses_allocator_helper<_Tp, _Alloc,
__void_t<typename _Tp::allocator_type>>
: __is_erased_or_convertible<_Alloc, typename _Tp::allocator_type>::type
{ };

template<typename _Tp, typename _Alloc>

struct uses_allocator
: __uses_allocator_helper<_Tp, _Alloc>::type
{ };

struct __uses_alloc_base { };

struct __uses_alloc0 : __uses_alloc_base

{
struct _Sink { void constexpr operator=(const void*) { } } _M_a;
};

template<typename _Alloc>
struct __uses_alloc1 : __uses_alloc_base { const _Alloc* _M_a; };

template<typename _Alloc>
struct __uses_alloc2 : __uses_alloc_base { const _Alloc* _M_a; };

template<bool, typename _Tp, typename _Alloc, typename... _Args>

struct __uses_alloc;

template<typename _Tp, typename _Alloc, typename... _Args>

struct __uses_alloc<true, _Tp, _Alloc, _Args...>
: __conditional_t<
is_constructible<_Tp, allocator_arg_t, const _Alloc&, _Args...>::value,
__uses_alloc1<_Alloc>,
__uses_alloc2<_Alloc>>
{

static_assert(__or_<
is_constructible<_Tp, allocator_arg_t, const _Alloc&, _Args...>,
is_constructible<_Tp, _Args..., const _Alloc&>>::value,
"construction with an allocator must be possible"
" if uses_allocator is true");
};

template<typename _Tp, typename _Alloc, typename... _Args>

struct __uses_alloc<false, _Tp, _Alloc, _Args...>
: __uses_alloc0 { };

template<typename _Tp, typename _Alloc, typename... _Args>

using __uses_alloc_t =
__uses_alloc<uses_allocator<_Tp, _Alloc>::value, _Tp, _Alloc, _Args...>;

template<typename _Tp, typename _Alloc, typename... _Args>

constexpr
inline __uses_alloc_t<_Tp, _Alloc, _Args...>
__use_alloc(const _Alloc& __a)
{
__uses_alloc_t<_Tp, _Alloc, _Args...> __ret;
__ret._M_a = std::__addressof(__a);
return __ret;
}

template<typename _Tp, typename _Alloc, typename... _Args>

void
__use_alloc(const _Alloc&&) = delete;

template <typename _Tp, typename _Alloc>

inline constexpr bool uses_allocator_v =
uses_allocator<_Tp, _Alloc>::value;

template<template<typename...> class _Predicate,

typename _Tp, typename _Alloc, typename... _Args>
struct __is_uses_allocator_predicate
: __conditional_t<uses_allocator<_Tp, _Alloc>::value,
__or_<_Predicate<_Tp, allocator_arg_t, _Alloc, _Args...>,
_Predicate<_Tp, _Args..., _Alloc>>,
_Predicate<_Tp, _Args...>> { };

template<typename _Tp, typename _Alloc, typename... _Args>

struct __is_uses_allocator_constructible
: __is_uses_allocator_predicate<is_constructible, _Tp, _Alloc, _Args...>
{ };

template<typename _Tp, typename _Alloc, typename... _Args>

inline constexpr bool __is_uses_allocator_constructible_v =
__is_uses_allocator_constructible<_Tp, _Alloc, _Args...>::value;

template<typename _Tp, typename _Alloc, typename... _Args>

struct __is_nothrow_uses_allocator_constructible
: __is_uses_allocator_predicate<is_nothrow_constructible,
_Tp, _Alloc, _Args...>
{ };

template<typename _Tp, typename _Alloc, typename... _Args>

inline constexpr bool
__is_nothrow_uses_allocator_constructible_v =
__is_nothrow_uses_allocator_constructible<_Tp, _Alloc, _Args...>::value;

template<typename _Tp, typename... _Args>

void __uses_allocator_construct_impl(__uses_alloc0, _Tp* __ptr,
_Args&&... __args)
{ ::new ((void*)__ptr) _Tp(std::forward<_Args>(__args)...); }

template<typename _Tp, typename _Alloc, typename... _Args>

void __uses_allocator_construct_impl(__uses_alloc1<_Alloc> __a, _Tp* __ptr,
_Args&&... __args)
{
::new ((void*)__ptr) _Tp(allocator_arg, *__a._M_a,
std::forward<_Args>(__args)...);
}

template<typename _Tp, typename _Alloc, typename... _Args>

void __uses_allocator_construct_impl(__uses_alloc2<_Alloc> __a, _Tp* __ptr,
_Args&&... __args)
{ ::new ((void*)__ptr) _Tp(std::forward<_Args>(__args)..., *__a._M_a); }

template<typename _Tp, typename _Alloc, typename... _Args>

void __uses_allocator_construct(const _Alloc& __a, _Tp* __ptr,
_Args&&... __args)
{
std::__uses_allocator_construct_impl(
std::__use_alloc<_Tp, _Alloc, _Args...>(__a), __ptr,
std::forward<_Args>(__args)...);
}

}
# 41 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/memory_resource.h" 2 3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/uses_allocator_args.h" 1
3
# 33 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/uses_allocator_args.h"
3

# 34 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/uses_allocator_args.h"
3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 1 3
# 47 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 3

# 48 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 3
# 36 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/uses_allocator_args.h"
2 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/tuple" 1 3
# 32 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/tuple" 3

# 33 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/tuple" 3
# 44 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/tuple" 3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/ranges_util.h" 1 3
# 39 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/ranges_util.h" 3
namespace std
{

namespace ranges
{

namespace __detail
{
template<typename _Range>
concept __simple_view = view<_Range> && range<const _Range>
&& same_as<iterator_t<_Range>, iterator_t<const _Range>>
&& same_as<sentinel_t<_Range>, sentinel_t<const _Range>>;

template<typename _It>
concept __has_arrow = input_iterator<_It>
&& (is_pointer_v<_It> || requires(_It __it) { __it.operator->(); });

using std::__detail::__different_from;
}

template<typename _Derived>
requires is_class_v<_Derived> && same_as<_Derived, remove_cv_t<_Derived>>
class view_interface
{
private:
constexpr _Derived& _M_derived() noexcept
{
static_assert(derived_from<_Derived, view_interface<_Derived>>);
static_assert(view<_Derived>);
return static_cast<_Derived&>(*this);
}

constexpr const _Derived& _M_derived() const noexcept

{
static_assert(derived_from<_Derived, view_interface<_Derived>>);
static_assert(view<_Derived>);
return static_cast<const _Derived&>(*this);
}

static constexpr bool

_S_bool(bool) noexcept;

template<typename _Tp>
static constexpr bool
_S_empty(_Tp& __t)
noexcept(noexcept(_S_bool(ranges::begin(__t) == ranges::end(__t))))
{ return ranges::begin(__t) == ranges::end(__t); }

template<typename _Tp>
static constexpr auto
_S_size(_Tp& __t)
noexcept(noexcept(ranges::end(__t) - ranges::begin(__t)))
{ return ranges::end(__t) - ranges::begin(__t); }

public:
constexpr bool
empty()
noexcept(noexcept(_S_empty(_M_derived())))
requires forward_range<_Derived> && (!sized_range<_Derived>)
{ return _S_empty(_M_derived()); }

constexpr bool
empty()
noexcept(noexcept(ranges::size(_M_derived()) == 0))
requires sized_range<_Derived>
{ return ranges::size(_M_derived()) == 0; }

constexpr bool
empty() const
noexcept(noexcept(_S_empty(_M_derived())))
requires forward_range<const _Derived> && (!sized_range<const _Derived>)
{ return _S_empty(_M_derived()); }

constexpr bool
empty() const
noexcept(noexcept(ranges::size(_M_derived()) == 0))
requires sized_range<const _Derived>
{ return ranges::size(_M_derived()) == 0; }

constexpr explicit
operator bool() noexcept(noexcept(ranges::empty(_M_derived())))
requires requires { ranges::empty(_M_derived()); }
{ return !ranges::empty(_M_derived()); }

constexpr explicit
operator bool() const noexcept(noexcept(ranges::empty(_M_derived())))
requires requires { ranges::empty(_M_derived()); }
{ return !ranges::empty(_M_derived()); }

constexpr auto
data() noexcept(noexcept(ranges::begin(_M_derived())))
requires contiguous_iterator<iterator_t<_Derived>>
{ return std::to_address(ranges::begin(_M_derived())); }

constexpr auto
data() const noexcept(noexcept(ranges::begin(_M_derived())))
requires range<const _Derived>
&& contiguous_iterator<iterator_t<const _Derived>>
{ return std::to_address(ranges::begin(_M_derived())); }

constexpr auto
size() noexcept(noexcept(_S_size(_M_derived())))
requires forward_range<_Derived>
&& sized_sentinel_for<sentinel_t<_Derived>, iterator_t<_Derived>>
{ return _S_size(_M_derived()); }

constexpr auto
size() const noexcept(noexcept(_S_size(_M_derived())))
requires forward_range<const _Derived>
&& sized_sentinel_for<sentinel_t<const _Derived>,
iterator_t<const _Derived>>
{ return _S_size(_M_derived()); }

constexpr decltype(auto)
front() requires forward_range<_Derived>
{
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(!empty()),
false)) std::__glibcxx_assert_fail(); } while (false);
return *ranges::begin(_M_derived());
}

constexpr decltype(auto)
front() const requires forward_range<const _Derived>
{
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(!empty()),
false)) std::__glibcxx_assert_fail(); } while (false);
return *ranges::begin(_M_derived());
}

constexpr decltype(auto)
back()
requires bidirectional_range<_Derived> && common_range<_Derived>
{
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(!empty()),
false)) std::__glibcxx_assert_fail(); } while (false);
return *ranges::prev(ranges::end(_M_derived()));
}

constexpr decltype(auto)
back() const
requires bidirectional_range<const _Derived>
&& common_range<const _Derived>
{
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(!empty()),
false)) std::__glibcxx_assert_fail(); } while (false);
return *ranges::prev(ranges::end(_M_derived()));
}

template<random_access_range _Range = _Derived>

constexpr decltype(auto)
operator[](range_difference_t<_Range> __n)
{ return ranges::begin(_M_derived())[__n]; }

template<random_access_range _Range = const _Derived>

constexpr decltype(auto)
operator[](range_difference_t<_Range> __n) const
{ return ranges::begin(_M_derived())[__n]; }

constexpr auto
cbegin() requires input_range<_Derived>
{ return ranges::cbegin(_M_derived()); }

constexpr auto
cbegin() const requires input_range<const _Derived>
{ return ranges::cbegin(_M_derived()); }

constexpr auto
cend() requires input_range<_Derived>
{ return ranges::cend(_M_derived()); }

constexpr auto
cend() const requires input_range<const _Derived>
{ return ranges::cend(_M_derived()); }

};

namespace __detail
{
template<typename _From, typename _To>
concept __uses_nonqualification_pointer_conversion
= is_pointer_v<_From> && is_pointer_v<_To>
&& !convertible_to<remove_pointer_t<_From>(*)[],
remove_pointer_t<_To>(*)[]>;

template<typename _From, typename _To>

concept __convertible_to_non_slicing = convertible_to<_From, _To>
&& !__uses_nonqualification_pointer_conversion<decay_t<_From>,
decay_t<_To>>;
# 244 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/ranges_util.h" 3
template<typename _Tp, typename _Up, typename _Vp>
concept __pair_like_convertible_from
= !range<_Tp> && !is_reference_v<_Vp> && __pair_like<_Tp>
&& constructible_from<_Tp, _Up, _Vp>
&& __convertible_to_non_slicing<_Up, tuple_element_t<0, _Tp>>
&& convertible_to<_Vp, tuple_element_t<1, _Tp>>;

namespace views { struct _Drop; }

enum class subrange_kind : bool { unsized, sized };

template<input_or_output_iterator _It, sentinel_for<_It> _Sent = _It,

subrange_kind _Kind = sized_sentinel_for<_Sent, _It>
? subrange_kind::sized : subrange_kind::unsized>
requires (_Kind == subrange_kind::sized || !sized_sentinel_for<_Sent, _It>)
class subrange : public view_interface<subrange<_It, _Sent, _Kind>>
{
private:
static constexpr bool _S_store_size
= _Kind == subrange_kind::sized && !sized_sentinel_for<_Sent, _It>;

friend struct views::_Drop;

_It _M_begin = _It();

[[no_unique_address]] _Sent _M_end = _Sent();

using __size_type
= __detail::__make_unsigned_like_t<iter_difference_t<_It>>;

template<typename _Tp, bool = _S_store_size>

struct _Size
{
[[__gnu__::__always_inline__]]
constexpr _Size(_Tp = {}) { }
};

template<typename _Tp>
struct _Size<_Tp, true>
{
[[__gnu__::__always_inline__]]
constexpr _Size(_Tp __s = {}) : _M_size(__s) { }

_Tp _M_size;
};

[[no_unique_address]] _Size<__size_type> _M_size = {};

public:
subrange() requires default_initializable<_It> = default;

constexpr
subrange(__detail::__convertible_to_non_slicing<_It> auto __i, _Sent __s)
noexcept(is_nothrow_constructible_v<_It, decltype(__i)>
&& is_nothrow_constructible_v<_Sent, _Sent&>)
requires (!_S_store_size)
: _M_begin(std::move(__i)), _M_end(__s)
{ }

constexpr
subrange(__detail::__convertible_to_non_slicing<_It> auto __i, _Sent __s,
__size_type __n)
noexcept(is_nothrow_constructible_v<_It, decltype(__i)>
&& is_nothrow_constructible_v<_Sent, _Sent&>)
requires (_Kind == subrange_kind::sized)
: _M_begin(std::move(__i)), _M_end(__s), _M_size(__n)
{ }

template<__detail::__different_from<subrange> _Rng>
requires borrowed_range<_Rng>
&& __detail::__convertible_to_non_slicing<iterator_t<_Rng>, _It>
&& convertible_to<sentinel_t<_Rng>, _Sent>
constexpr
subrange(_Rng&& __r)
noexcept(noexcept(subrange(__r, ranges::size(__r))))
requires _S_store_size && sized_range<_Rng>
: subrange(__r, ranges::size(__r))
{ }

template<__detail::__different_from<subrange> _Rng>
requires borrowed_range<_Rng>
&& __detail::__convertible_to_non_slicing<iterator_t<_Rng>, _It>
&& convertible_to<sentinel_t<_Rng>, _Sent>
constexpr
subrange(_Rng&& __r)
noexcept(noexcept(subrange(ranges::begin(__r), ranges::end(__r))))
requires (!_S_store_size)
: subrange(ranges::begin(__r), ranges::end(__r))
{ }

template<borrowed_range _Rng>
requires __detail::__convertible_to_non_slicing<iterator_t<_Rng>, _It>
&& convertible_to<sentinel_t<_Rng>, _Sent>
constexpr
subrange(_Rng&& __r, __size_type __n)
noexcept(noexcept(subrange(ranges::begin(__r), ranges::end(__r), __n)))
requires (_Kind == subrange_kind::sized)
: subrange{ranges::begin(__r), ranges::end(__r), __n}
{ }

template<__detail::__different_from<subrange> _PairLike>
requires __detail::__pair_like_convertible_from<_PairLike, const _It&,
const _Sent&>
constexpr
operator _PairLike() const
{ return _PairLike(_M_begin, _M_end); }

constexpr _It
begin() const requires copyable<_It>
{ return _M_begin; }

[[nodiscard]] constexpr _It

begin() requires (!copyable<_It>)
{ return std::move(_M_begin); }

constexpr _Sent end() const { return _M_end; }

constexpr bool empty() const { return _M_begin == _M_end; }

constexpr __size_type
size() const requires (_Kind == subrange_kind::sized)
{
if constexpr (_S_store_size)
return _M_size._M_size;
else
return __detail::__to_unsigned_like(_M_end - _M_begin);
}

[[nodiscard]] constexpr subrange

next(iter_difference_t<_It> __n = 1) const &
requires forward_iterator<_It>
{
auto __tmp = *this;
__tmp.advance(__n);
return __tmp;
}

[[nodiscard]] constexpr subrange

next(iter_difference_t<_It> __n = 1) &&
{
advance(__n);
return std::move(*this);
}

[[nodiscard]] constexpr subrange

prev(iter_difference_t<_It> __n = 1) const
requires bidirectional_iterator<_It>
{
auto __tmp = *this;
__tmp.advance(-__n);
return __tmp;
}

constexpr subrange&
advance(iter_difference_t<_It> __n)
{

if constexpr (bidirectional_iterator<_It>)
if (__n < 0)
{
ranges::advance(_M_begin, __n);
if constexpr (_S_store_size)
_M_size._M_size += __detail::__to_unsigned_like(-__n);
return *this;
}

do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__n >= 0),

false)) std::__glibcxx_assert_fail(); } while (false);
auto __d = __n - ranges::advance(_M_begin, __n, _M_end);
if constexpr (_S_store_size)
_M_size._M_size -= __detail::__to_unsigned_like(__d);
return *this;
}
};

template<input_or_output_iterator _It, sentinel_for<_It> _Sent>

subrange(_It, _Sent) -> subrange<_It, _Sent>;

template<input_or_output_iterator _It, sentinel_for<_It> _Sent>

subrange(_It, _Sent,
__detail::__make_unsigned_like_t<iter_difference_t<_It>>)
-> subrange<_It, _Sent, subrange_kind::sized>;

template<borrowed_range _Rng>
subrange(_Rng&&)
-> subrange<iterator_t<_Rng>, sentinel_t<_Rng>,
(sized_range<_Rng>
|| sized_sentinel_for<sentinel_t<_Rng>, iterator_t<_Rng>>)
? subrange_kind::sized : subrange_kind::unsized>;

template<borrowed_range _Rng>
subrange(_Rng&&,
__detail::__make_unsigned_like_t<range_difference_t<_Rng>>)
-> subrange<iterator_t<_Rng>, sentinel_t<_Rng>, subrange_kind::sized>;

template<size_t _Num, class _It, class _Sent, subrange_kind _Kind>

requires (_Num < 2)
constexpr auto
get(const subrange<_It, _Sent, _Kind>& __r)
{
if constexpr (_Num == 0)
return __r.begin();
else
return __r.end();
}

template<size_t _Num, class _It, class _Sent, subrange_kind _Kind>

requires (_Num < 2)
constexpr auto
get(subrange<_It, _Sent, _Kind>&& __r)
{
if constexpr (_Num == 0)
return __r.begin();
else
return __r.end();
}

template<typename _It, typename _Sent, subrange_kind _Kind>

inline constexpr bool
enable_borrowed_range<subrange<_It, _Sent, _Kind>> = true;

template<range _Range>
using borrowed_subrange_t = __conditional_t<borrowed_range<_Range>,
subrange<iterator_t<_Range>>,
dangling>;

template<typename _Iter, typename _Sent, subrange_kind _Kind>

inline constexpr bool __detail::__is_subrange<subrange<_Iter, _Sent, _Kind>> =
true;
}

template<typename _It, typename _Sent, ranges::subrange_kind _Kind>

inline constexpr bool __is_tuple_like_v<ranges::subrange<_It, _Sent, _Kind>> =
true;

namespace ranges
{
struct __find_fn
{
template<input_iterator _Iter, sentinel_for<_Iter> _Sent, typename _Tp,
typename _Proj = identity>
requires indirect_binary_predicate<ranges::equal_to,
projected<_Iter, _Proj>, const _Tp*>
constexpr _Iter
operator()(_Iter __first, _Sent __last,
const _Tp& __value, _Proj __proj = {}) const
{
while (__first != __last
&& !(std::__invoke(__proj, *__first) == __value))
++__first;
return __first;
}

template<input_range _Range, typename _Tp, typename _Proj = identity>

requires indirect_binary_predicate<ranges::equal_to,
projected<iterator_t<_Range>, _Proj>,
const _Tp*>
constexpr borrowed_iterator_t<_Range>
operator()(_Range&& __r, const _Tp& __value, _Proj __proj = {}) const
{
return (*this)(ranges::begin(__r), ranges::end(__r),
__value, std::move(__proj));
}
};

inline constexpr __find_fn find{};

struct __find_if_fn
{
template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
typename _Proj = identity,
indirect_unary_predicate<projected<_Iter, _Proj>> _Pred>
constexpr _Iter
operator()(_Iter __first, _Sent __last,
_Pred __pred, _Proj __proj = {}) const
{
while (__first != __last
&& !(bool)std::__invoke(__pred, std::__invoke(__proj, *__first)))
++__first;
return __first;
}
template<input_range _Range, typename _Proj = identity,
indirect_unary_predicate<projected<iterator_t<_Range>, _Proj>>
_Pred>
constexpr borrowed_iterator_t<_Range>
operator()(_Range&& __r, _Pred __pred, _Proj __proj = {}) const
{
return (*this)(ranges::begin(__r), ranges::end(__r),
std::move(__pred), std::move(__proj));
}
};

inline constexpr __find_if_fn find_if{};

struct __find_if_not_fn
{
template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
typename _Proj = identity,
indirect_unary_predicate<projected<_Iter, _Proj>> _Pred>
constexpr _Iter
operator()(_Iter __first, _Sent __last,
_Pred __pred, _Proj __proj = {}) const
{
while (__first != __last
&& (bool)std::__invoke(__pred, std::__invoke(__proj, *__first)))
++__first;
return __first;
}

template<input_range _Range, typename _Proj = identity,

indirect_unary_predicate<projected<iterator_t<_Range>, _Proj>>
_Pred>
constexpr borrowed_iterator_t<_Range>
operator()(_Range&& __r, _Pred __pred, _Proj __proj = {}) const
{
return (*this)(ranges::begin(__r), ranges::end(__r),
std::move(__pred), std::move(__proj));
}
};

inline constexpr __find_if_not_fn find_if_not{};

template<typename _Iter1, typename _Iter2>

struct in_in_result
{
[[no_unique_address]] _Iter1 in1;
[[no_unique_address]] _Iter2 in2;

template<typename _IIter1, typename _IIter2>

requires convertible_to<const _Iter1&, _IIter1>
&& convertible_to<const _Iter2&, _IIter2>
constexpr
operator in_in_result<_IIter1, _IIter2>() const &
{ return {in1, in2}; }

template<typename _IIter1, typename _IIter2>

requires convertible_to<_Iter1, _IIter1>
&& convertible_to<_Iter2, _IIter2>
constexpr
operator in_in_result<_IIter1, _IIter2>() &&
{ return {std::move(in1), std::move(in2)}; }
};

template<typename _Iter1, typename _Iter2>

using mismatch_result = in_in_result<_Iter1, _Iter2>;

struct __mismatch_fn
{
template<input_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
input_iterator _Iter2, sentinel_for<_Iter2> _Sent2,
typename _Pred = ranges::equal_to,
typename _Proj1 = identity, typename _Proj2 = identity>
requires indirectly_comparable<_Iter1, _Iter2, _Pred, _Proj1, _Proj2>
constexpr mismatch_result<_Iter1, _Iter2>
operator()(_Iter1 __first1, _Sent1 __last1,
_Iter2 __first2, _Sent2 __last2, _Pred __pred = {},
_Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const
{
while (__first1 != __last1 && __first2 != __last2
&& (bool)std::__invoke(__pred,
std::__invoke(__proj1, *__first1),
std::__invoke(__proj2, *__first2)))
{
++__first1;
++__first2;
}
return { std::move(__first1), std::move(__first2) };
}

template<input_range _Range1, input_range _Range2,

typename _Pred = ranges::equal_to,
typename _Proj1 = identity, typename _Proj2 = identity>
requires indirectly_comparable<iterator_t<_Range1>, iterator_t<_Range2>,
_Pred, _Proj1, _Proj2>
constexpr mismatch_result<iterator_t<_Range1>, iterator_t<_Range2>>
operator()(_Range1&& __r1, _Range2&& __r2, _Pred __pred = {},
_Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const
{
return (*this)(ranges::begin(__r1), ranges::end(__r1),
ranges::begin(__r2), ranges::end(__r2),
std::move(__pred),
std::move(__proj1), std::move(__proj2));
}
};

inline constexpr __mismatch_fn mismatch{};

struct __search_fn
{
template<forward_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
forward_iterator _Iter2, sentinel_for<_Iter2> _Sent2,
typename _Pred = ranges::equal_to,
typename _Proj1 = identity, typename _Proj2 = identity>
requires indirectly_comparable<_Iter1, _Iter2, _Pred, _Proj1, _Proj2>
constexpr subrange<_Iter1>
operator()(_Iter1 __first1, _Sent1 __last1,
_Iter2 __first2, _Sent2 __last2, _Pred __pred = {},
_Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const
{
if (__first1 == __last1 || __first2 == __last2)
return {__first1, __first1};

for (;;)
{
for (;;)
{
if (__first1 == __last1)
return {__first1, __first1};
if (std::__invoke(__pred,
std::__invoke(__proj1, *__first1),
std::__invoke(__proj2, *__first2)))
break;
++__first1;
}
auto __cur1 = __first1;
auto __cur2 = __first2;
for (;;)
{
if (++__cur2 == __last2)
return {__first1, ++__cur1};
if (++__cur1 == __last1)
return {__cur1, __cur1};
if (!(bool)std::__invoke(__pred,
std::__invoke(__proj1, *__cur1),
std::__invoke(__proj2, *__cur2)))
{
++__first1;
break;
}
}
}
}

template<forward_range _Range1, forward_range _Range2,

typename _Pred = ranges::equal_to,
typename _Proj1 = identity, typename _Proj2 = identity>
requires indirectly_comparable<iterator_t<_Range1>, iterator_t<_Range2>,
_Pred, _Proj1, _Proj2>
constexpr borrowed_subrange_t<_Range1>
operator()(_Range1&& __r1, _Range2&& __r2, _Pred __pred = {},
_Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const
{
return (*this)(ranges::begin(__r1), ranges::end(__r1),
ranges::begin(__r2), ranges::end(__r2),
std::move(__pred),
std::move(__proj1), std::move(__proj2));
}
};

inline constexpr __search_fn search{};

struct __min_fn
{
template<typename _Tp, typename _Proj = identity,
indirect_strict_weak_order<projected<const _Tp*, _Proj>>
_Comp = ranges::less>
constexpr const _Tp&
operator()(const _Tp& __a, const _Tp& __b,
_Comp __comp = {}, _Proj __proj = {}) const
{
if (std::__invoke(__comp,
std::__invoke(__proj, __b),
std::__invoke(__proj, __a)))
return __b;
else
return __a;
}

template<input_range _Range, typename _Proj = identity,

indirect_strict_weak_order<projected<iterator_t<_Range>, _Proj>>
_Comp = ranges::less>
requires indirectly_copyable_storable<iterator_t<_Range>,
range_value_t<_Range>*>
constexpr range_value_t<_Range>
operator()(_Range&& __r, _Comp __comp = {}, _Proj __proj = {}) const
{
auto __first = ranges::begin(__r);
auto __last = ranges::end(__r);
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__first !=
__last), false)) std::__glibcxx_assert_fail(); } while (false);
auto __result = *__first;
while (++__first != __last)
{
auto __tmp = *__first;
if (std::__invoke(__comp,
std::__invoke(__proj, __tmp),
std::__invoke(__proj, __result)))
__result = std::move(__tmp);
}
return __result;
}

template<copyable _Tp, typename _Proj = identity,

indirect_strict_weak_order<projected<const _Tp*, _Proj>>
_Comp = ranges::less>
constexpr _Tp
operator()(initializer_list<_Tp> __r,
_Comp __comp = {}, _Proj __proj = {}) const
{
return (*this)(ranges::subrange(__r),
std::move(__comp), std::move(__proj));
}
};

inline constexpr __min_fn min{};

struct __adjacent_find_fn
{
template<forward_iterator _Iter, sentinel_for<_Iter> _Sent,
typename _Proj = identity,
indirect_binary_predicate<projected<_Iter, _Proj>,
projected<_Iter, _Proj>> _Pred
= ranges::equal_to>
constexpr _Iter
operator()(_Iter __first, _Sent __last,
_Pred __pred = {}, _Proj __proj = {}) const
{
if (__first == __last)
return __first;
auto __next = __first;
for (; ++__next != __last; __first = __next)
{
if (std::__invoke(__pred,
std::__invoke(__proj, *__first),
std::__invoke(__proj, *__next)))
return __first;
}
return __next;
}

template<forward_range _Range, typename _Proj = identity,

indirect_binary_predicate<
projected<iterator_t<_Range>, _Proj>,
projected<iterator_t<_Range>, _Proj>> _Pred = ranges::equal_to>
constexpr borrowed_iterator_t<_Range>
operator()(_Range&& __r, _Pred __pred = {}, _Proj __proj = {}) const
{
return (*this)(ranges::begin(__r), ranges::end(__r),
std::move(__pred), std::move(__proj));
}
};

inline constexpr __adjacent_find_fn adjacent_find{};

using ranges::get;

template<typename _Iter, typename _Sent, ranges::subrange_kind _Kind>

struct tuple_size<ranges::subrange<_Iter, _Sent, _Kind>>
: integral_constant<size_t, 2>
{ };

template<typename _Iter, typename _Sent, ranges::subrange_kind _Kind>

struct tuple_element<0, ranges::subrange<_Iter, _Sent, _Kind>>
{ using type = _Iter; };

template<typename _Iter, typename _Sent, ranges::subrange_kind _Kind>

struct tuple_element<1, ranges::subrange<_Iter, _Sent, _Kind>>
{ using type = _Sent; };

template<typename _Iter, typename _Sent, ranges::subrange_kind _Kind>

struct tuple_element<0, const ranges::subrange<_Iter, _Sent, _Kind>>
{ using type = _Iter; };

template<typename _Iter, typename _Sent, ranges::subrange_kind _Kind>

struct tuple_element<1, const ranges::subrange<_Iter, _Sent, _Kind>>
{ using type = _Sent; };

}
# 45 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/tuple" 2 3
# 54 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/tuple" 3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 1 3
# 47 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 3
# 48 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 3
# 55 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/tuple" 2 3

namespace std
{

template<typename... _Elements>
class tuple;

template<typename _Tp>
struct __is_empty_non_tuple : is_empty<_Tp> { };

template<typename _El0, typename... _El>

struct __is_empty_non_tuple<tuple<_El0, _El...>> : false_type { };

template<typename _Tp>
using __empty_not_final
= __conditional_t<__is_final(_Tp), false_type,
__is_empty_non_tuple<_Tp>>;

template<size_t _Idx, typename _Head,

bool = __empty_not_final<_Head>::value>
struct _Head_base;

template<size_t _Idx, typename _Head>

struct _Head_base<_Idx, _Head, true>
{
constexpr _Head_base()
: _M_head_impl() { }

constexpr _Head_base(const _Head& __h)

: _M_head_impl(__h) { }

constexpr _Head_base(const _Head_base&) = default;

constexpr _Head_base(_Head_base&&) = default;

template<typename _UHead>
constexpr _Head_base(_UHead&& __h)
: _M_head_impl(std::forward<_UHead>(__h)) { }

constexpr
_Head_base(allocator_arg_t, __uses_alloc0)
: _M_head_impl() { }

template<typename _Alloc>
constexpr
_Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a)
: _M_head_impl(allocator_arg, *__a._M_a) { }

template<typename _Alloc>
constexpr
_Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a)
: _M_head_impl(*__a._M_a) { }

template<typename _UHead>
constexpr
_Head_base(__uses_alloc0, _UHead&& __uhead)
: _M_head_impl(std::forward<_UHead>(__uhead)) { }

template<typename _Alloc, typename _UHead>

constexpr
_Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead)
: _M_head_impl(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead))
{ }

template<typename _Alloc, typename _UHead>

constexpr
_Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead)
: _M_head_impl(std::forward<_UHead>(__uhead), *__a._M_a) { }

static constexpr _Head&

_M_head(_Head_base& __b) noexcept { return __b._M_head_impl; }

static constexpr const _Head&

_M_head(const _Head_base& __b) noexcept { return __b._M_head_impl; }

[[__no_unique_address__]] _Head _M_head_impl;

};
# 195 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/tuple" 3
template<size_t _Idx, typename _Head>
struct _Head_base<_Idx, _Head, false>
{
constexpr _Head_base()
: _M_head_impl() { }

constexpr _Head_base(const _Head& __h)

: _M_head_impl(__h) { }

constexpr _Head_base(const _Head_base&) = default;

constexpr _Head_base(_Head_base&&) = default;

template<typename _UHead>
constexpr _Head_base(_UHead&& __h)
: _M_head_impl(std::forward<_UHead>(__h)) { }

constexpr
_Head_base(allocator_arg_t, __uses_alloc0)
: _M_head_impl() { }

template<typename _Alloc>
constexpr
_Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a)
: _M_head_impl(allocator_arg, *__a._M_a) { }

template<typename _Alloc>
constexpr
_Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a)
: _M_head_impl(*__a._M_a) { }
template<typename _UHead>
constexpr
_Head_base(__uses_alloc0, _UHead&& __uhead)
: _M_head_impl(std::forward<_UHead>(__uhead)) { }

template<typename _Alloc, typename _UHead>

constexpr
_Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead)
: _M_head_impl(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead))
{ }

template<typename _Alloc, typename _UHead>

constexpr
_Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead)
: _M_head_impl(std::forward<_UHead>(__uhead), *__a._M_a) { }

static constexpr _Head&

_M_head(_Head_base& __b) noexcept { return __b._M_head_impl; }

static constexpr const _Head&

_M_head(const _Head_base& __b) noexcept { return __b._M_head_impl; }

_Head _M_head_impl;
};

struct __tuple_like_tag_t { explicit __tuple_like_tag_t() = default; };

template<typename _Cat, typename _Tp, typename _Up>

constexpr _Cat
__tuple_cmp(const _Tp&, const _Up&, index_sequence<>);

template<typename _Cat, typename _Tp, typename _Up,

size_t _Idx0, size_t... _Idxs>
constexpr _Cat
__tuple_cmp(const _Tp& __t, const _Up& __u,
index_sequence<_Idx0, _Idxs...>);
# 274 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/tuple" 3
template<size_t _Idx, typename... _Elements>
struct _Tuple_impl;

template<size_t _Idx, typename _Head, typename... _Tail>

struct _Tuple_impl<_Idx, _Head, _Tail...>
: public _Tuple_impl<_Idx + 1, _Tail...>,
private _Head_base<_Idx, _Head>
{
template<size_t, typename...> friend struct _Tuple_impl;

typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited;

typedef _Head_base<_Idx, _Head> _Base;

static constexpr _Head&

_M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }

static constexpr const _Head&

_M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }

static constexpr _Inherited&

_M_tail(_Tuple_impl& __t) noexcept { return __t; }

static constexpr const _Inherited&

_M_tail(const _Tuple_impl& __t) noexcept { return __t; }

constexpr _Tuple_impl()
: _Inherited(), _Base() { }

explicit constexpr
_Tuple_impl(const _Head& __head, const _Tail&... __tail)
: _Inherited(__tail...), _Base(__head)
{ }

template<typename _UHead, typename... _UTail,

typename = __enable_if_t<sizeof...(_Tail) == sizeof...(_UTail)>>
explicit constexpr
_Tuple_impl(_UHead&& __head, _UTail&&... __tail)
: _Inherited(std::forward<_UTail>(__tail)...),
_Base(std::forward<_UHead>(__head))
{ }

constexpr _Tuple_impl(const _Tuple_impl&) = default;

_Tuple_impl& operator=(const _Tuple_impl&) = delete;

_Tuple_impl(_Tuple_impl&&) = default;

template<typename... _UElements>
constexpr
_Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in)
: _Inherited(_Tuple_impl<_Idx, _UElements...>::_M_tail(__in)),
_Base(_Tuple_impl<_Idx, _UElements...>::_M_head(__in))
{ }

template<typename _UHead, typename... _UTails>

constexpr
_Tuple_impl(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
: _Inherited(std::move
(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),
_Base(std::forward<_UHead>
(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in)))
{ }

template<typename... _UElements>
constexpr
_Tuple_impl(_Tuple_impl<_Idx, _UElements...>& __in)
: _Inherited(_Tuple_impl<_Idx, _UElements...>::_M_tail(__in)),
_Base(_Tuple_impl<_Idx, _UElements...>::_M_head(__in))
{ }
template<typename _UHead, typename... _UTails>
constexpr
_Tuple_impl(const _Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
: _Inherited(std::move
(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),
_Base(std::forward<const _UHead>
(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in)))
{ }

template<typename _UTuple, size_t... _Is>

constexpr
_Tuple_impl(__tuple_like_tag_t, _UTuple&& __u, index_sequence<_Is...>)
: _Tuple_impl(std::get<_Is>(std::forward<_UTuple>(__u))...)
{ }

template<typename _Alloc>
constexpr
_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a)
: _Inherited(__tag, __a),
_Base(__tag, __use_alloc<_Head>(__a))
{ }

template<typename _Alloc>
constexpr
_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
const _Head& __head, const _Tail&... __tail)
: _Inherited(__tag, __a, __tail...),
_Base(__use_alloc<_Head, _Alloc, _Head>(__a), __head)
{ }

template<typename _Alloc, typename _UHead, typename... _UTail,

typename = __enable_if_t<sizeof...(_Tail) == sizeof...(_UTail)>>
constexpr
_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
_UHead&& __head, _UTail&&... __tail)
: _Inherited(__tag, __a, std::forward<_UTail>(__tail)...),
_Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
std::forward<_UHead>(__head))
{ }

template<typename _Alloc>
constexpr
_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
const _Tuple_impl& __in)
: _Inherited(__tag, __a, _M_tail(__in)),
_Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(__in))
{ }

template<typename _Alloc>
constexpr
_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
_Tuple_impl&& __in)
: _Inherited(__tag, __a, std::move(_M_tail(__in))),
_Base(__use_alloc<_Head, _Alloc, _Head>(__a),
std::forward<_Head>(_M_head(__in)))
{ }
template<typename _Alloc, typename _UHead, typename... _UTails>
constexpr
_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
const _Tuple_impl<_Idx, _UHead, _UTails...>& __in)
: _Inherited(__tag, __a,
_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in)),
_Base(__use_alloc<_Head, _Alloc, const _UHead&>(__a),
_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))
{ }

template<typename _Alloc, typename _UHead, typename... _UTails>

constexpr
_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
: _Inherited(__tag, __a, std::move
(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),
_Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
std::forward<_UHead>
(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in)))
{ }

template<typename _Alloc, typename _UHead, typename... _UTails>

constexpr
_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
_Tuple_impl<_Idx, _UHead, _UTails...>& __in)
: _Inherited(__tag, __a,
_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in)),
_Base(__use_alloc<_Head, _Alloc, _UHead&>(__a),
_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))
{ }

template<typename _Alloc, typename _UHead, typename... _UTails>

constexpr
_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
const _Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
: _Inherited(__tag, __a, std::move
(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),
_Base(__use_alloc<_Head, _Alloc, const _UHead>(__a),
std::forward<const _UHead>
(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in)))
{ }

template<typename _Alloc, typename _UTuple, size_t... _Is>

constexpr
_Tuple_impl(__tuple_like_tag_t, allocator_arg_t __tag, const _Alloc& __a,
_UTuple&& __u, index_sequence<_Is...>)
: _Tuple_impl(__tag, __a, std::get<_Is>(std::forward<_UTuple>(__u))...)
{ }

template<typename... _UElements>
constexpr
void
_M_assign(const _Tuple_impl<_Idx, _UElements...>& __in)
{
_M_head(*this) = _Tuple_impl<_Idx, _UElements...>::_M_head(__in);
_M_tail(*this)._M_assign(
_Tuple_impl<_Idx, _UElements...>::_M_tail(__in));
}

template<typename _UHead, typename... _UTails>

constexpr
void
_M_assign(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
{
_M_head(*this) = std::forward<_UHead>
(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in));
_M_tail(*this)._M_assign(
std::move(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in)));
}

template<typename... _UElements>
constexpr void
_M_assign(const _Tuple_impl<_Idx, _UElements...>& __in) const
{
_M_head(*this) = _Tuple_impl<_Idx, _UElements...>::_M_head(__in);
_M_tail(*this)._M_assign(
_Tuple_impl<_Idx, _UElements...>::_M_tail(__in));
}

template<typename _UHead, typename... _UTails>

constexpr void
_M_assign(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in) const
{
_M_head(*this) = std::forward<_UHead>
(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in));
_M_tail(*this)._M_assign(
std::move(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in)));
}

template<typename _UTuple>
constexpr void
_M_assign(__tuple_like_tag_t __tag, _UTuple&& __u)
{
_M_head(*this) = std::get<_Idx>(std::forward<_UTuple>(__u));
_M_tail(*this)._M_assign(__tag, std::forward<_UTuple>(__u));
}

template<typename _UTuple>
constexpr void
_M_assign(__tuple_like_tag_t __tag, _UTuple&& __u) const
{
_M_head(*this) = std::get<_Idx>(std::forward<_UTuple>(__u));
_M_tail(*this)._M_assign(__tag, std::forward<_UTuple>(__u));
}

protected:
constexpr
void
_M_swap(_Tuple_impl& __in)
{
using std::swap;
swap(_M_head(*this), _M_head(__in));
_Inherited::_M_swap(_M_tail(__in));
}

constexpr void
_M_swap(const _Tuple_impl& __in) const
{
using std::swap;
swap(_M_head(*this), _M_head(__in));
_Inherited::_M_swap(_M_tail(__in));
}

};

template<size_t _Idx, typename _Head>

struct _Tuple_impl<_Idx, _Head>
: private _Head_base<_Idx, _Head>
{
template<size_t, typename...> friend struct _Tuple_impl;

typedef _Head_base<_Idx, _Head> _Base;

static constexpr _Head&

_M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }

static constexpr const _Head&

_M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }

constexpr
_Tuple_impl()
: _Base() { }

explicit constexpr
_Tuple_impl(const _Head& __head)
: _Base(__head)
{ }

template<typename _UHead>
explicit constexpr
_Tuple_impl(_UHead&& __head)
: _Base(std::forward<_UHead>(__head))
{ }

constexpr _Tuple_impl(const _Tuple_impl&) = default;

_Tuple_impl& operator=(const _Tuple_impl&) = delete;

constexpr
_Tuple_impl(_Tuple_impl&& __in)
noexcept(is_nothrow_move_constructible<_Head>::value)
: _Base(static_cast<_Base&&>(__in))
{ }

template<typename _UHead>
constexpr
_Tuple_impl(const _Tuple_impl<_Idx, _UHead>& __in)
: _Base(_Tuple_impl<_Idx, _UHead>::_M_head(__in))
{ }

template<typename _UHead>
constexpr
_Tuple_impl(_Tuple_impl<_Idx, _UHead>&& __in)
: _Base(std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)))
{ }

template<typename _UHead>
constexpr
_Tuple_impl(_Tuple_impl<_Idx, _UHead>& __in)
: _Base(_Tuple_impl<_Idx, _UHead>::_M_head(__in))
{ }

template<typename _UHead>
constexpr
_Tuple_impl(const _Tuple_impl<_Idx, _UHead>&& __in)
: _Base(std::forward<const _UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)))
{ }

template<typename _UTuple>
constexpr
_Tuple_impl(__tuple_like_tag_t, _UTuple&& __u, index_sequence<0>)
: _Tuple_impl(std::get<0>(std::forward<_UTuple>(__u)))
{ }

template<typename _Alloc>
constexpr
_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a)
: _Base(__tag, __use_alloc<_Head>(__a))
{ }

template<typename _Alloc>
constexpr
_Tuple_impl(allocator_arg_t, const _Alloc& __a,
const _Head& __head)
: _Base(__use_alloc<_Head, _Alloc, const _Head&>(__a), __head)
{ }

template<typename _Alloc, typename _UHead>

constexpr
_Tuple_impl(allocator_arg_t, const _Alloc& __a,
_UHead&& __head)
: _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
std::forward<_UHead>(__head))
{ }
template<typename _Alloc>
constexpr
_Tuple_impl(allocator_arg_t, const _Alloc& __a,
const _Tuple_impl& __in)
: _Base(__use_alloc<_Head, _Alloc, const _Head&>(__a), _M_head(__in))
{ }

template<typename _Alloc>
constexpr
_Tuple_impl(allocator_arg_t, const _Alloc& __a,
_Tuple_impl&& __in)
: _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
std::forward<_Head>(_M_head(__in)))
{ }

template<typename _Alloc, typename _UHead>

constexpr
_Tuple_impl(allocator_arg_t, const _Alloc& __a,
const _Tuple_impl<_Idx, _UHead>& __in)
: _Base(__use_alloc<_Head, _Alloc, const _UHead&>(__a),
_Tuple_impl<_Idx, _UHead>::_M_head(__in))
{ }

template<typename _Alloc, typename _UHead>

constexpr
_Tuple_impl(allocator_arg_t, const _Alloc& __a,
_Tuple_impl<_Idx, _UHead>&& __in)
: _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)))
{ }

template<typename _Alloc, typename _UHead>

constexpr
_Tuple_impl(allocator_arg_t, const _Alloc& __a,
_Tuple_impl<_Idx, _UHead>& __in)
: _Base(__use_alloc<_Head, _Alloc, _UHead&>(__a),
_Tuple_impl<_Idx, _UHead>::_M_head(__in))
{ }

template<typename _Alloc, typename _UHead>

constexpr
_Tuple_impl(allocator_arg_t, const _Alloc& __a,
const _Tuple_impl<_Idx, _UHead>&& __in)
: _Base(__use_alloc<_Head, _Alloc, const _UHead>(__a),
std::forward<const _UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)))
{ }

template<typename _Alloc, typename _UTuple>

constexpr
_Tuple_impl(__tuple_like_tag_t, allocator_arg_t __tag, const _Alloc& __a,
_UTuple&& __u, index_sequence<0>)
: _Tuple_impl(__tag, __a, std::get<0>(std::forward<_UTuple>(__u)))
{ }

template<typename _UHead>
constexpr
void
_M_assign(const _Tuple_impl<_Idx, _UHead>& __in)
{
_M_head(*this) = _Tuple_impl<_Idx, _UHead>::_M_head(__in);
}

template<typename _UHead>
constexpr
void
_M_assign(_Tuple_impl<_Idx, _UHead>&& __in)
{
_M_head(*this)
= std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in));
}

template<typename _UHead>
constexpr void
_M_assign(const _Tuple_impl<_Idx, _UHead>& __in) const
{
_M_head(*this) = _Tuple_impl<_Idx, _UHead>::_M_head(__in);
}

template<typename _UHead>
constexpr void
_M_assign(_Tuple_impl<_Idx, _UHead>&& __in) const
{
_M_head(*this)
= std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in));
}

template<typename _UTuple>
constexpr void
_M_assign(__tuple_like_tag_t, _UTuple&& __u)
{ _M_head(*this) = std::get<_Idx>(std::forward<_UTuple>(__u)); }

template<typename _UTuple>
constexpr void
_M_assign(__tuple_like_tag_t, _UTuple&& __u) const
{ _M_head(*this) = std::get<_Idx>(std::forward<_UTuple>(__u)); }

protected:
constexpr
void
_M_swap(_Tuple_impl& __in)
{
using std::swap;
swap(_M_head(*this), _M_head(__in));
}

constexpr void
_M_swap(const _Tuple_impl& __in) const
{
using std::swap;
swap(_M_head(*this), _M_head(__in));
}

};

template<bool, typename... _Types>

struct _TupleConstraints
{
template<typename... _UTypes>
using __constructible = __and_<is_constructible<_Types, _UTypes>...>;

template<typename... _UTypes>
using __convertible = __and_<is_convertible<_UTypes, _Types>...>;

template<typename... _UTypes>
static constexpr bool __is_implicitly_constructible()
{
return __and_<__constructible<_UTypes...>,
__convertible<_UTypes...>
>::value;
}

template<typename... _UTypes>
static constexpr bool __is_explicitly_constructible()
{
return __and_<__constructible<_UTypes...>,
__not_<__convertible<_UTypes...>>
>::value;
}

static constexpr bool __is_implicitly_default_constructible()

{
return __and_<std::__is_implicitly_default_constructible<_Types>...
>::value;
}

static constexpr bool __is_explicitly_default_constructible()

{
return __and_<is_default_constructible<_Types>...,
__not_<__and_<
std::__is_implicitly_default_constructible<_Types>...>
>>::value;
}
};

template<typename... _Types>
struct _TupleConstraints<false, _Types...>
{
template<typename... _UTypes>
static constexpr bool __is_implicitly_constructible()
{ return false; }

template<typename... _UTypes>
static constexpr bool __is_explicitly_constructible()
{ return false; }
};

template<typename... _Elements>
class tuple : public _Tuple_impl<0, _Elements...>
{
using _Inherited = _Tuple_impl<0, _Elements...>;

template<typename... _UTypes>
static consteval bool
__constructible()
{
if constexpr (sizeof...(_UTypes) == sizeof...(_Elements))
return __and_v<is_constructible<_Elements, _UTypes>...>;
else
return false;
}

template<typename... _UTypes>
static consteval bool
__nothrow_constructible()
{
if constexpr (sizeof...(_UTypes) == sizeof...(_Elements))
return __and_v<is_nothrow_constructible<_Elements, _UTypes>...>;
else
return false;
}

template<typename... _UTypes>
static consteval bool
__convertible()
{
if constexpr (sizeof...(_UTypes) == sizeof...(_Elements))
return __and_v<is_convertible<_UTypes, _Elements>...>;
else
return false;
}

template<typename... _UTypes>
static consteval bool
__disambiguating_constraint()
{
if constexpr (sizeof...(_Elements) != sizeof...(_UTypes))
return false;
else if constexpr (sizeof...(_Elements) == 1)
{
using _U0 = typename _Nth_type<0, _UTypes...>::type;
return !is_same_v<remove_cvref_t<_U0>, tuple>;
}
else if constexpr (sizeof...(_Elements) < 4)
{
using _U0 = typename _Nth_type<0, _UTypes...>::type;
if constexpr (!is_same_v<remove_cvref_t<_U0>, allocator_arg_t>)
return true;
else
{
using _T0 = typename _Nth_type<0, _Elements...>::type;
return is_same_v<remove_cvref_t<_T0>, allocator_arg_t>;
}
}
return true;
}

template<typename _Tuple>
static consteval bool
__use_other_ctor()
{
if constexpr (sizeof...(_Elements) != 1)
return false;
else if constexpr (is_same_v<remove_cvref_t<_Tuple>, tuple>)
return true;
else
{
using _Tp = typename _Nth_type<0, _Elements...>::type;
if constexpr (is_convertible_v<_Tuple, _Tp>)
return true;
else if constexpr (is_constructible_v<_Tp, _Tuple>)
return true;
}
return false;
}

template<typename... _Up>
static consteval bool
__dangles()
{

return (__reference_constructs_from_temporary(_Elements, _Up&&)

|| ...);

template<typename _UTuple>
static consteval bool
__dangles_from_tuple_like()
{
return []<size_t... _Is>(index_sequence<_Is...>) {
return __dangles<decltype(std::get<_Is>(std::declval<_UTuple>()))...>();
}(index_sequence_for<_Elements...>{});
}
template<typename _UTuple>
static consteval bool
__constructible_from_tuple_like()
{
return []<size_t... _Is>(index_sequence<_Is...>) {
return __constructible<decltype(std::get<_Is>(std::declval<_UTuple>()))...>();
}(index_sequence_for<_Elements...>{});
}

template<typename _UTuple>
static consteval bool
__convertible_from_tuple_like()
{
return []<size_t... _Is>(index_sequence<_Is...>) {
return __convertible<decltype(std::get<_Is>(std::declval<_UTuple>()))...>();
}(index_sequence_for<_Elements...>{});
}

public:
constexpr
explicit(!(__is_implicitly_default_constructible_v<_Elements> && ...))
tuple()
noexcept((is_nothrow_default_constructible_v<_Elements> && ...))
requires (is_default_constructible_v<_Elements> && ...)
: _Inherited()
{ }

constexpr explicit(!__convertible<const _Elements&...>())

tuple(const _Elements&... __elements)
noexcept(__nothrow_constructible<const _Elements&...>())
requires (__constructible<const _Elements&...>())
: _Inherited(__elements...)
{ }

template<typename... _UTypes>
requires (__disambiguating_constraint<_UTypes...>())
&& (__constructible<_UTypes...>())
&& (!__dangles<_UTypes...>())
constexpr explicit(!__convertible<_UTypes...>())
tuple(_UTypes&&... __u)
noexcept(__nothrow_constructible<_UTypes...>())
: _Inherited(std::forward<_UTypes>(__u)...)
{ }

template<typename... _UTypes>
requires (__disambiguating_constraint<_UTypes...>())
&& (__constructible<_UTypes...>())
&& (__dangles<_UTypes...>())
tuple(_UTypes&&...) = delete;

constexpr tuple(const tuple&) = default;

constexpr tuple(tuple&&) = default;

template<typename... _UTypes>
requires (__constructible<const _UTypes&...>())
&& (!__use_other_ctor<const tuple<_UTypes...>&>())
&& (!__dangles<const _UTypes&...>())
constexpr explicit(!__convertible<const _UTypes&...>())
tuple(const tuple<_UTypes...>& __u)
noexcept(__nothrow_constructible<const _UTypes&...>())
: _Inherited(static_cast<const _Tuple_impl<0, _UTypes...>&>(__u))
{ }

template<typename... _UTypes>
requires (__constructible<const _UTypes&...>())
&& (!__use_other_ctor<const tuple<_UTypes...>&>())
&& (__dangles<const _UTypes&...>())
tuple(const tuple<_UTypes...>&) = delete;

template<typename... _UTypes>
requires (__constructible<_UTypes...>())
&& (!__use_other_ctor<tuple<_UTypes...>>())
&& (!__dangles<_UTypes...>())
constexpr explicit(!__convertible<_UTypes...>())
tuple(tuple<_UTypes...>&& __u)
noexcept(__nothrow_constructible<_UTypes...>())
: _Inherited(static_cast<_Tuple_impl<0, _UTypes...>&&>(__u))
{ }

template<typename... _UTypes>
requires (__constructible<_UTypes...>())
&& (!__use_other_ctor<tuple<_UTypes...>>())
&& (__dangles<_UTypes...>())
tuple(tuple<_UTypes...>&&) = delete;

template<typename... _UTypes>
requires (__constructible<_UTypes&...>())
&& (!__use_other_ctor<tuple<_UTypes...>&>())
&& (!__dangles<_UTypes&...>())
constexpr explicit(!__convertible<_UTypes&...>())
tuple(tuple<_UTypes...>& __u)
noexcept(__nothrow_constructible<_UTypes&...>())
: _Inherited(static_cast<_Tuple_impl<0, _UTypes...>&>(__u))
{ }

template<typename... _UTypes>
requires (__constructible<_UTypes&...>())
&& (!__use_other_ctor<tuple<_UTypes...>&>())
&& (__dangles<_UTypes&...>())
tuple(tuple<_UTypes...>&) = delete;

template<typename... _UTypes>
requires (__constructible<const _UTypes...>())
&& (!__use_other_ctor<const tuple<_UTypes...>>())
&& (!__dangles<const _UTypes...>())
constexpr explicit(!__convertible<const _UTypes...>())
tuple(const tuple<_UTypes...>&& __u)
noexcept(__nothrow_constructible<const _UTypes...>())
: _Inherited(static_cast<const _Tuple_impl<0, _UTypes...>&&>(__u))
{ }

template<typename... _UTypes>
requires (__constructible<const _UTypes...>())
&& (!__use_other_ctor<const tuple<_UTypes...>>())
&& (__dangles<const _UTypes...>())
tuple(const tuple<_UTypes...>&&) = delete;

template<typename _U1, typename _U2>

requires (sizeof...(_Elements) == 2)
&& (__constructible<const _U1&, const _U2&>())
&& (!__dangles<const _U1&, const _U2&>())
constexpr explicit(!__convertible<const _U1&, const _U2&>())
tuple(const pair<_U1, _U2>& __u)
noexcept(__nothrow_constructible<const _U1&, const _U2&>())
: _Inherited(__u.first, __u.second)
{ }

template<typename _U1, typename _U2>

requires (sizeof...(_Elements) == 2)
&& (__constructible<const _U1&, const _U2&>())
&& (__dangles<const _U1&, const _U2&>())
tuple(const pair<_U1, _U2>&) = delete;

template<typename _U1, typename _U2>

requires (sizeof...(_Elements) == 2)
&& (__constructible<_U1, _U2>())
&& (!__dangles<_U1, _U2>())
constexpr explicit(!__convertible<_U1, _U2>())
tuple(pair<_U1, _U2>&& __u)
noexcept(__nothrow_constructible<_U1, _U2>())
: _Inherited(std::forward<_U1>(__u.first),
std::forward<_U2>(__u.second))
{ }

template<typename _U1, typename _U2>

requires (sizeof...(_Elements) == 2)
&& (__constructible<_U1, _U2>())
&& (__dangles<_U1, _U2>())
tuple(pair<_U1, _U2>&&) = delete;

template<typename _U1, typename _U2>

requires (sizeof...(_Elements) == 2)
&& (__constructible<_U1&, _U2&>())
&& (!__dangles<_U1&, _U2&>())
constexpr explicit(!__convertible<_U1&, _U2&>())
tuple(pair<_U1, _U2>& __u)
noexcept(__nothrow_constructible<_U1&, _U2&>())
: _Inherited(__u.first, __u.second)
{ }

template<typename _U1, typename _U2>

requires (sizeof...(_Elements) == 2)
&& (__constructible<_U1&, _U2&>())
&& (__dangles<_U1&, _U2&>())
tuple(pair<_U1, _U2>&) = delete;

template<typename _U1, typename _U2>

requires (sizeof...(_Elements) == 2)
&& (__constructible<const _U1, const _U2>())
&& (!__dangles<const _U1, const _U2>())
constexpr explicit(!__convertible<const _U1, const _U2>())
tuple(const pair<_U1, _U2>&& __u)
noexcept(__nothrow_constructible<const _U1, const _U2>())
: _Inherited(std::forward<const _U1>(__u.first),
std::forward<const _U2>(__u.second))
{ }

template<typename _U1, typename _U2>

requires (sizeof...(_Elements) == 2)
&& (__constructible<const _U1, const _U2>())
&& (__dangles<const _U1, const _U2>())
tuple(const pair<_U1, _U2>&&) = delete;

template<__eligible_tuple_like<tuple> _UTuple>
requires (__constructible_from_tuple_like<_UTuple>())
&& (!__use_other_ctor<_UTuple>())
&& (!__dangles_from_tuple_like<_UTuple>())
constexpr explicit(!__convertible_from_tuple_like<_UTuple>())
tuple(_UTuple&& __u)
: _Inherited(__tuple_like_tag_t{},
std::forward<_UTuple>(__u),
index_sequence_for<_Elements...>{})
{ }

template<__eligible_tuple_like<tuple> _UTuple>
requires (__constructible_from_tuple_like<_UTuple>())
&& (!__use_other_ctor<_UTuple>())
&& (__dangles_from_tuple_like<_UTuple>())
tuple(_UTuple&&) = delete;

template<typename _Alloc>
constexpr
explicit(!(__is_implicitly_default_constructible_v<_Elements> && ...))
tuple(allocator_arg_t __tag, const _Alloc& __a)
requires (is_default_constructible_v<_Elements> && ...)
: _Inherited(__tag, __a)
{ }

template<typename _Alloc>
constexpr explicit(!__convertible<const _Elements&...>())
tuple(allocator_arg_t __tag, const _Alloc& __a,
const _Elements&... __elements)
requires (__constructible<const _Elements&...>())
: _Inherited(__tag, __a, __elements...)
{ }

template<typename _Alloc, typename... _UTypes>

requires (__disambiguating_constraint<_UTypes...>())
&& (__constructible<_UTypes...>())
&& (!__dangles<_UTypes...>())
constexpr explicit(!__convertible<_UTypes...>())
tuple(allocator_arg_t __tag, const _Alloc& __a, _UTypes&&... __u)
: _Inherited(__tag, __a, std::forward<_UTypes>(__u)...)
{ }

template<typename _Alloc, typename... _UTypes>

requires (__disambiguating_constraint<_UTypes...>())
&& (__constructible<_UTypes...>())
&& (__dangles<_UTypes...>())
tuple(allocator_arg_t, const _Alloc&, _UTypes&&...) = delete;

template<typename _Alloc>
constexpr
tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __u)
: _Inherited(__tag, __a, static_cast<const _Inherited&>(__u))
{ }

template<typename _Alloc>
requires (__constructible<_Elements...>())
constexpr
tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __u)
: _Inherited(__tag, __a, static_cast<_Inherited&&>(__u))
{ }

template<typename _Alloc, typename... _UTypes>

requires (__constructible<const _UTypes&...>())
&& (!__use_other_ctor<const tuple<_UTypes...>&>())
&& (!__dangles<const _UTypes&...>())
constexpr explicit(!__convertible<const _UTypes&...>())
tuple(allocator_arg_t __tag, const _Alloc& __a,
const tuple<_UTypes...>& __u)
: _Inherited(__tag, __a,
static_cast<const _Tuple_impl<0, _UTypes...>&>(__u))
{ }

template<typename _Alloc, typename... _UTypes>

requires (__constructible<const _UTypes&...>())
&& (!__use_other_ctor<const tuple<_UTypes...>&>())
&& (__dangles<const _UTypes&...>())
tuple(allocator_arg_t, const _Alloc&, const tuple<_UTypes...>&) = delete;

template<typename _Alloc, typename... _UTypes>

requires (__constructible<_UTypes...>())
&& (!__use_other_ctor<tuple<_UTypes...>>())
&& (!__dangles<_UTypes...>())
constexpr explicit(!__use_other_ctor<tuple<_UTypes...>>())
tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_UTypes...>&& __u)
: _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _UTypes...>&&>(__u))
{ }

template<typename _Alloc, typename... _UTypes>

requires (__constructible<_UTypes...>())
&& (!__use_other_ctor<tuple<_UTypes...>>())
&& (__dangles<_UTypes...>())
tuple(allocator_arg_t, const _Alloc&, tuple<_UTypes...>&&) = delete;

template<typename _Alloc, typename... _UTypes>

requires (__constructible<_UTypes&...>())
&& (!__use_other_ctor<tuple<_UTypes...>&>())
&& (!__dangles<_UTypes&...>())
constexpr explicit(!__convertible<_UTypes&...>())
tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_UTypes...>& __u)
: _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _UTypes...>&>(__u))
{ }
template<typename _Alloc, typename... _UTypes>
requires (__constructible<_UTypes&...>())
&& (!__use_other_ctor<tuple<_UTypes...>&>())
&& (__dangles<_UTypes&...>())
tuple(allocator_arg_t, const _Alloc&, tuple<_UTypes...>&) = delete;

template<typename _Alloc, typename... _UTypes>

requires (__constructible<const _UTypes...>())
&& (!__use_other_ctor<const tuple<_UTypes...>>())
&& (!__dangles<const _UTypes...>())
constexpr explicit(!__convertible<const _UTypes...>())
tuple(allocator_arg_t __tag, const _Alloc& __a,
const tuple<_UTypes...>&& __u)
: _Inherited(__tag, __a,
static_cast<const _Tuple_impl<0, _UTypes...>&&>(__u))
{ }

template<typename _Alloc, typename... _UTypes>

requires (__constructible<const _UTypes...>())
&& (!__use_other_ctor<const tuple<_UTypes...>>())
&& (__dangles<const _UTypes...>())
tuple(allocator_arg_t, const _Alloc&, const tuple<_UTypes...>&&) = delete;

template<typename _Alloc, typename _U1, typename _U2>

requires (sizeof...(_Elements) == 2)
&& (__constructible<const _U1&, const _U2&>())
&& (!__dangles<const _U1&, const _U2&>())
constexpr explicit(!__convertible<const _U1&, const _U2&>())
tuple(allocator_arg_t __tag, const _Alloc& __a,
const pair<_U1, _U2>& __u)
noexcept(__nothrow_constructible<const _U1&, const _U2&>())
: _Inherited(__tag, __a, __u.first, __u.second)
{ }

template<typename _Alloc, typename _U1, typename _U2>

requires (sizeof...(_Elements) == 2)
&& (__constructible<const _U1&, const _U2&>())
&& (__dangles<const _U1&, const _U2&>())
tuple(allocator_arg_t, const _Alloc&, const pair<_U1, _U2>&) = delete;

template<typename _Alloc, typename _U1, typename _U2>

requires (sizeof...(_Elements) == 2)
&& (__constructible<_U1, _U2>())
&& (!__dangles<_U1, _U2>())
constexpr explicit(!__convertible<_U1, _U2>())
tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>&& __u)
noexcept(__nothrow_constructible<_U1, _U2>())
: _Inherited(__tag, __a, std::move(__u.first), std::move(__u.second))
{ }

template<typename _Alloc, typename _U1, typename _U2>

requires (sizeof...(_Elements) == 2)
&& (__constructible<_U1, _U2>())
&& (__dangles<_U1, _U2>())
tuple(allocator_arg_t, const _Alloc&, pair<_U1, _U2>&&) = delete;
template<typename _Alloc, typename _U1, typename _U2>
requires (sizeof...(_Elements) == 2)
&& (__constructible<_U1&, _U2&>())
&& (!__dangles<_U1&, _U2&>())
constexpr explicit(!__convertible<_U1&, _U2&>())
tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>& __u)
noexcept(__nothrow_constructible<_U1&, _U2&>())
: _Inherited(__tag, __a, __u.first, __u.second)
{ }

template<typename _Alloc, typename _U1, typename _U2>

requires (sizeof...(_Elements) == 2)
&& (__constructible<_U1&, _U2&>())
&& (__dangles<_U1&, _U2&>())
tuple(allocator_arg_t, const _Alloc&, pair<_U1, _U2>&) = delete;

template<typename _Alloc, typename _U1, typename _U2>

requires (sizeof...(_Elements) == 2)
&& (__constructible<const _U1, const _U2>())
&& (!__dangles<const _U1, const _U2>())
constexpr explicit(!__convertible<const _U1, const _U2>())
tuple(allocator_arg_t __tag, const _Alloc& __a,
const pair<_U1, _U2>&& __u)
noexcept(__nothrow_constructible<const _U1, const _U2>())
: _Inherited(__tag, __a, std::move(__u.first), std::move(__u.second))
{ }

template<typename _Alloc, typename _U1, typename _U2>

requires (sizeof...(_Elements) == 2)
&& (__constructible<const _U1, const _U2>())
&& (__dangles<const _U1, const _U2>())
tuple(allocator_arg_t, const _Alloc&, const pair<_U1, _U2>&&) = delete;

template<typename _Alloc, __eligible_tuple_like<tuple> _UTuple>

requires (__constructible_from_tuple_like<_UTuple>())
&& (!__use_other_ctor<_UTuple>())
&& (!__dangles_from_tuple_like<_UTuple>())
constexpr explicit(!__convertible_from_tuple_like<_UTuple>())
tuple(allocator_arg_t __tag, const _Alloc& __a, _UTuple&& __u)
: _Inherited(__tuple_like_tag_t{},
__tag, __a, std::forward<_UTuple>(__u),
index_sequence_for<_Elements...>{})
{ }

template<typename _Alloc, __eligible_tuple_like<tuple> _UTuple>

requires (__constructible_from_tuple_like<_UTuple>())
&& (!__use_other_ctor<_UTuple>())
&& (__dangles_from_tuple_like<_UTuple>())
tuple(allocator_arg_t, const _Alloc&, _UTuple&&) = delete;
# 1654 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/tuple" 3
private:
template<typename... _UTypes>
static consteval bool
__assignable()
{
if constexpr (sizeof...(_UTypes) == sizeof...(_Elements))
return __and_v<is_assignable<_Elements&, _UTypes>...>;
else
return false;
}

template<typename... _UTypes>
static consteval bool
__nothrow_assignable()
{
if constexpr (sizeof...(_UTypes) == sizeof...(_Elements))
return __and_v<is_nothrow_assignable<_Elements&, _UTypes>...>;
else
return false;
}

template<typename... _UTypes>
static consteval bool
__const_assignable()
{
if constexpr (sizeof...(_UTypes) == sizeof...(_Elements))
return __and_v<is_assignable<const _Elements&, _UTypes>...>;
else
return false;
}

template<typename _UTuple>
static consteval bool
__assignable_from_tuple_like()
{
return []<size_t... _Is>(index_sequence<_Is...>) {
return __assignable<decltype(std::get<_Is>(std::declval<_UTuple>()))...>();
}(index_sequence_for<_Elements...>{});
}

template<typename _UTuple>
static consteval bool
__const_assignable_from_tuple_like()
{
return []<size_t... _Is>(index_sequence<_Is...>) {
return
__const_assignable<decltype(std::get<_Is>(std::declval<_UTuple>()))...>();
}(index_sequence_for<_Elements...>{});
}

public:

tuple& operator=(const tuple& __u) = delete;

constexpr tuple&
operator=(const tuple& __u)
noexcept(__nothrow_assignable<const _Elements&...>())
requires (__assignable<const _Elements&...>())
{
this->_M_assign(__u);
return *this;
}
constexpr tuple&
operator=(tuple&& __u)
noexcept(__nothrow_assignable<_Elements...>())
requires (__assignable<_Elements...>())
{
this->_M_assign(std::move(__u));
return *this;
}

template<typename... _UTypes>
requires (__assignable<const _UTypes&...>())
constexpr tuple&
operator=(const tuple<_UTypes...>& __u)
noexcept(__nothrow_assignable<const _UTypes&...>())
{
this->_M_assign(__u);
return *this;
}

template<typename... _UTypes>
requires (__assignable<_UTypes...>())
constexpr tuple&
operator=(tuple<_UTypes...>&& __u)
noexcept(__nothrow_assignable<_UTypes...>())
{
this->_M_assign(std::move(__u));
return *this;
}

constexpr const tuple&

operator=(const tuple& __u) const
requires (__const_assignable<const _Elements&...>())
{
this->_M_assign(__u);
return *this;
}

constexpr const tuple&

operator=(tuple&& __u) const
requires (__const_assignable<_Elements...>())
{
this->_M_assign(std::move(__u));
return *this;
}

template<typename... _UTypes>
constexpr const tuple&
operator=(const tuple<_UTypes...>& __u) const
requires (__const_assignable<const _UTypes&...>())
{
this->_M_assign(__u);
return *this;
}

template<typename... _UTypes>
constexpr const tuple&
operator=(tuple<_UTypes...>&& __u) const
requires (__const_assignable<_UTypes...>())
{
this->_M_assign(std::move(__u));
return *this;
}

template<typename _U1, typename _U2>

requires (__assignable<const _U1&, const _U2&>())
constexpr tuple&
operator=(const pair<_U1, _U2>& __u)
noexcept(__nothrow_assignable<const _U1&, const _U2&>())
{
this->_M_head(*this) = __u.first;
this->_M_tail(*this)._M_head(*this) = __u.second;
return *this;
}

template<typename _U1, typename _U2>

requires (__assignable<_U1, _U2>())
constexpr tuple&
operator=(pair<_U1, _U2>&& __u)
noexcept(__nothrow_assignable<_U1, _U2>())
{
this->_M_head(*this) = std::forward<_U1>(__u.first);
this->_M_tail(*this)._M_head(*this) = std::forward<_U2>(__u.second);
return *this;
}

template<typename _U1, typename _U2>

requires (__const_assignable<const _U1&, const _U2>())
constexpr const tuple&
operator=(const pair<_U1, _U2>& __u) const
{
this->_M_head(*this) = __u.first;
this->_M_tail(*this)._M_head(*this) = __u.second;
return *this;
}

template<typename _U1, typename _U2>

requires (__const_assignable<_U1, _U2>())
constexpr const tuple&
operator=(pair<_U1, _U2>&& __u) const
{
this->_M_head(*this) = std::forward<_U1>(__u.first);
this->_M_tail(*this)._M_head(*this) = std::forward<_U2>(__u.second);
return *this;
}

template<__eligible_tuple_like<tuple> _UTuple>
requires (__assignable_from_tuple_like<_UTuple>())
constexpr tuple&
operator=(_UTuple&& __u)
{
this->_M_assign(__tuple_like_tag_t{}, std::forward<_UTuple>(__u));
return *this;
}

template<__eligible_tuple_like<tuple> _UTuple>
requires (__const_assignable_from_tuple_like<_UTuple>())
constexpr const tuple&
operator=(_UTuple&& __u) const
{
this->_M_assign(__tuple_like_tag_t{}, std::forward<_UTuple>(__u));
return *this;
}

template<__tuple_like _UTuple>
requires (!__is_tuple_v<_UTuple>)
friend constexpr bool
operator==(const tuple& __t, const _UTuple& __u)
{
static_assert(sizeof...(_Elements) == tuple_size_v<_UTuple>,
"tuple objects can only be compared if they have equal sizes.");
return [&]<size_t... _Is>(index_sequence<_Is...>) {
return (bool(std::get<_Is>(__t) == std::get<_Is>(__u))
&& ...);
}(index_sequence_for<_Elements...>{});
}

template<__tuple_like _UTuple,
typename = make_index_sequence<tuple_size_v<_UTuple>>>
struct __tuple_like_common_comparison_category;

template<__tuple_like _UTuple, size_t... _Is>

requires requires
{ typename void_t<__detail::__synth3way_t<_Elements, tuple_element_t<_Is,
_UTuple>>...>; }
struct __tuple_like_common_comparison_category<_UTuple, index_sequence<_Is...>>
{
using type = common_comparison_category_t
<__detail::__synth3way_t<_Elements, tuple_element_t<_Is, _UTuple>>...>;
};

template<__tuple_like _UTuple>
requires (!__is_tuple_v<_UTuple>)
friend constexpr typename __tuple_like_common_comparison_category<_UTuple>::type
operator<=>(const tuple& __t, const _UTuple& __u)
{
using _Cat = typename __tuple_like_common_comparison_category<_UTuple>::type;
return std::__tuple_cmp<_Cat>(__t, __u, index_sequence_for<_Elements...>());
}
# 1947 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/tuple" 3
constexpr
void
swap(tuple& __in)
noexcept(__and_<__is_nothrow_swappable<_Elements>...>::value)
{ _Inherited::_M_swap(__in); }
# 1960 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/tuple" 3
constexpr void
swap(const tuple& __in) const
noexcept(__and_v<__is_nothrow_swappable<const _Elements>...>)
requires (is_swappable_v<const _Elements> && ...)
{ _Inherited::_M_swap(__in); }
};

template<typename... _UTypes>
tuple(_UTypes...) -> tuple<_UTypes...>;
template<typename _T1, typename _T2>
tuple(pair<_T1, _T2>) -> tuple<_T1, _T2>;
template<typename _Alloc, typename... _UTypes>
tuple(allocator_arg_t, _Alloc, _UTypes...) -> tuple<_UTypes...>;
template<typename _Alloc, typename _T1, typename _T2>
tuple(allocator_arg_t, _Alloc, pair<_T1, _T2>) -> tuple<_T1, _T2>;
template<typename _Alloc, typename... _UTypes>
tuple(allocator_arg_t, _Alloc, tuple<_UTypes...>) -> tuple<_UTypes...>;

template<>
class tuple<>
{
public:
constexpr
void swap(tuple&) noexcept { }

constexpr void swap(const tuple&) const noexcept { }

tuple() = default;

template<typename _Alloc>
constexpr
tuple(allocator_arg_t, const _Alloc&) noexcept { }
template<typename _Alloc>
constexpr
tuple(allocator_arg_t, const _Alloc&, const tuple&) noexcept { }
};
# 2402 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/tuple" 3
template<typename... _Elements>
struct tuple_size<tuple<_Elements...>>
: public integral_constant<size_t, sizeof...(_Elements)> { };

template<typename... _Types>
inline constexpr size_t tuple_size_v<tuple<_Types...>>
= sizeof...(_Types);

template<typename... _Types>
inline constexpr size_t tuple_size_v<const tuple<_Types...>>
= sizeof...(_Types);

template<size_t __i, typename... _Types>

struct tuple_element<__i, tuple<_Types...>>
{
static_assert(__i < sizeof...(_Types), "tuple index must be in range");

using type = typename _Nth_type<__i, _Types...>::type;

};
template<size_t __i, typename _Head, typename... _Tail>
constexpr _Head&
__get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
{ return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }

template<size_t __i, typename _Head, typename... _Tail>

constexpr const _Head&
__get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
{ return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }

template<size_t __i, typename... _Types>

__enable_if_t<(__i >= sizeof...(_Types))>
__get_helper(const tuple<_Types...>&) = delete;

template<size_t __i, typename... _Elements>

constexpr __tuple_element_t<__i, tuple<_Elements...>>&
get(tuple<_Elements...>& __t) noexcept
{ return std::__get_helper<__i>(__t); }

template<size_t __i, typename... _Elements>

constexpr const __tuple_element_t<__i, tuple<_Elements...>>&
get(const tuple<_Elements...>& __t) noexcept
{ return std::__get_helper<__i>(__t); }

template<size_t __i, typename... _Elements>

constexpr __tuple_element_t<__i, tuple<_Elements...>>&&
get(tuple<_Elements...>&& __t) noexcept
{
typedef __tuple_element_t<__i, tuple<_Elements...>> __element_type;
return std::forward<__element_type>(std::__get_helper<__i>(__t));
}

template<size_t __i, typename... _Elements>

constexpr const __tuple_element_t<__i, tuple<_Elements...>>&&
get(const tuple<_Elements...>&& __t) noexcept
{
typedef __tuple_element_t<__i, tuple<_Elements...>> __element_type;
return std::forward<const __element_type>(std::__get_helper<__i>(__t));
}

template<size_t __i, typename... _Elements>

constexpr __enable_if_t<(__i >= sizeof...(_Elements))>
get(const tuple<_Elements...>&) = delete;

template <typename _Tp, typename... _Types>

constexpr _Tp&
get(tuple<_Types...>& __t) noexcept
{
constexpr size_t __idx = __find_uniq_type_in_pack<_Tp, _Types...>();
static_assert(__idx < sizeof...(_Types),
"the type T in std::get<T> must occur exactly once in the tuple");
return std::__get_helper<__idx>(__t);
}

template <typename _Tp, typename... _Types>

constexpr _Tp&&
get(tuple<_Types...>&& __t) noexcept
{
constexpr size_t __idx = __find_uniq_type_in_pack<_Tp, _Types...>();
static_assert(__idx < sizeof...(_Types),
"the type T in std::get<T> must occur exactly once in the tuple");
return std::forward<_Tp>(std::__get_helper<__idx>(__t));
}

template <typename _Tp, typename... _Types>

constexpr const _Tp&
get(const tuple<_Types...>& __t) noexcept
{
constexpr size_t __idx = __find_uniq_type_in_pack<_Tp, _Types...>();
static_assert(__idx < sizeof...(_Types),
"the type T in std::get<T> must occur exactly once in the tuple");
return std::__get_helper<__idx>(__t);
}

template <typename _Tp, typename... _Types>

constexpr const _Tp&&
get(const tuple<_Types...>&& __t) noexcept
{
constexpr size_t __idx = __find_uniq_type_in_pack<_Tp, _Types...>();
static_assert(__idx < sizeof...(_Types),
"the type T in std::get<T> must occur exactly once in the tuple");
return std::forward<const _Tp>(std::__get_helper<__idx>(__t));
}

template<typename _Tp, typename _Up, size_t __i, size_t __size>

struct __tuple_compare
{
static constexpr bool
__eq(const _Tp& __t, const _Up& __u)
{
return bool(std::get<__i>(__t) == std::get<__i>(__u))
&& __tuple_compare<_Tp, _Up, __i + 1, __size>::__eq(__t, __u);
}

static constexpr bool

__less(const _Tp& __t, const _Up& __u)
{
return bool(std::get<__i>(__t) < std::get<__i>(__u))
|| (!bool(std::get<__i>(__u) < std::get<__i>(__t))
&& __tuple_compare<_Tp, _Up, __i + 1, __size>::__less(__t, __u));
}
};

template<typename _Tp, typename _Up, size_t __size>

struct __tuple_compare<_Tp, _Up, __size, __size>
{
static constexpr bool
__eq(const _Tp&, const _Up&) { return true; }

static constexpr bool

__less(const _Tp&, const _Up&) { return false; }
};

template<typename... _TElements, typename... _UElements>

constexpr bool
operator==(const tuple<_TElements...>& __t,
const tuple<_UElements...>& __u)
{
static_assert(sizeof...(_TElements) == sizeof...(_UElements),
"tuple objects can only be compared if they have equal sizes.");
using __compare = __tuple_compare<tuple<_TElements...>,
tuple<_UElements...>,
0, sizeof...(_TElements)>;
return __compare::__eq(__t, __u);
}

template<typename _Cat, typename _Tp, typename _Up>

constexpr _Cat
__tuple_cmp(const _Tp&, const _Up&, index_sequence<>)
{ return _Cat::equivalent; }

template<typename _Cat, typename _Tp, typename _Up,

size_t _Idx0, size_t... _Idxs>
constexpr _Cat
__tuple_cmp(const _Tp& __t, const _Up& __u,
index_sequence<_Idx0, _Idxs...>)
{
auto __c
= __detail::__synth3way(std::get<_Idx0>(__t), std::get<_Idx0>(__u));
if (__c != 0)
return __c;
return std::__tuple_cmp<_Cat>(__t, __u, index_sequence<_Idxs...>());
}

template<typename... _Tps, typename... _Ups>

constexpr
common_comparison_category_t<__detail::__synth3way_t<_Tps, _Ups>...>
operator<=>(const tuple<_Tps...>& __t, const tuple<_Ups...>& __u)
{
using _Cat
= common_comparison_category_t<__detail::__synth3way_t<_Tps, _Ups>...>;
return std::__tuple_cmp<_Cat>(__t, __u, index_sequence_for<_Tps...>());
}
# 2636 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/tuple" 3
template<typename... _Elements>
constexpr tuple<typename __decay_and_strip<_Elements>::__type...>
make_tuple(_Elements&&... __args)
{
typedef tuple<typename __decay_and_strip<_Elements>::__type...>
__result_type;
return __result_type(std::forward<_Elements>(__args)...);
}

template<typename... _Elements>
constexpr tuple<_Elements&&...>
forward_as_tuple(_Elements&&... __args) noexcept
{ return tuple<_Elements&&...>(std::forward<_Elements>(__args)...); }

template<size_t, typename, typename, size_t>

struct __make_tuple_impl;

template<size_t _Idx, typename _Tuple, typename... _Tp, size_t _Nm>

struct __make_tuple_impl<_Idx, tuple<_Tp...>, _Tuple, _Nm>
: __make_tuple_impl<_Idx + 1,
tuple<_Tp..., __tuple_element_t<_Idx, _Tuple>>,
_Tuple, _Nm>
{ };

template<size_t _Nm, typename _Tuple, typename... _Tp>

struct __make_tuple_impl<_Nm, tuple<_Tp...>, _Tuple, _Nm>
{
typedef tuple<_Tp...> __type;
};

template<typename _Tuple>
struct __do_make_tuple
: __make_tuple_impl<0, tuple<>, _Tuple, tuple_size<_Tuple>::value>
{ };

template<typename _Tuple>
struct __make_tuple
: public __do_make_tuple<__remove_cvref_t<_Tuple>>
{ };

template<typename...>
struct __combine_tuples;

template<>
struct __combine_tuples<>
{
typedef tuple<> __type;
};

template<typename... _Ts>
struct __combine_tuples<tuple<_Ts...>>
{
typedef tuple<_Ts...> __type;
};

template<typename... _T1s, typename... _T2s, typename... _Rem>

struct __combine_tuples<tuple<_T1s...>, tuple<_T2s...>, _Rem...>
{
typedef typename __combine_tuples<tuple<_T1s..., _T2s...>,
_Rem...>::__type __type;
};

template<typename... _Tpls>
struct __tuple_cat_result
{
typedef typename __combine_tuples
<typename __make_tuple<_Tpls>::__type...>::__type __type;
};

template<typename...>
struct __make_1st_indices;

template<>
struct __make_1st_indices<>
{
typedef _Index_tuple<> __type;
};

template<typename _Tp, typename... _Tpls>

struct __make_1st_indices<_Tp, _Tpls...>
{
typedef typename _Build_index_tuple<tuple_size<
typename remove_reference<_Tp>::type>::value>::__type __type;
};

template<typename _Ret, typename _Indices, typename... _Tpls>

struct __tuple_concater;

template<typename _Ret, size_t... _Is, typename _Tp, typename... _Tpls>

struct __tuple_concater<_Ret, _Index_tuple<_Is...>, _Tp, _Tpls...>
{
template<typename... _Us>
static constexpr _Ret
_S_do(_Tp&& __tp, _Tpls&&... __tps, _Us&&... __us)
{
typedef typename __make_1st_indices<_Tpls...>::__type __idx;
typedef __tuple_concater<_Ret, __idx, _Tpls...> __next;
return __next::_S_do(std::forward<_Tpls>(__tps)...,
std::forward<_Us>(__us)...,
std::get<_Is>(std::forward<_Tp>(__tp))...);
}
};

template<typename _Ret>
struct __tuple_concater<_Ret, _Index_tuple<>>
{
template<typename... _Us>
static constexpr _Ret
_S_do(_Us&&... __us)
{
return _Ret(std::forward<_Us>(__us)...);
}
};

template<typename... _Tps>
struct __is_tuple_like_impl<tuple<_Tps...>> : true_type
{ };

template<__tuple_like... _Tpls>

constexpr auto
tuple_cat(_Tpls&&... __tpls)
-> typename __tuple_cat_result<_Tpls...>::__type
{
typedef typename __tuple_cat_result<_Tpls...>::__type __ret;
typedef typename __make_1st_indices<_Tpls...>::__type __idx;
typedef __tuple_concater<__ret, __idx, _Tpls...> __concater;
return __concater::_S_do(std::forward<_Tpls>(__tpls)...);
}

template<typename... _Elements>
constexpr tuple<_Elements&...>
tie(_Elements&... __args) noexcept
{ return tuple<_Elements&...>(__args...); }

template<typename... _Elements>
constexpr
inline

typename enable_if<__and_<__is_swappable<_Elements>...>::value
>::type

swap(tuple<_Elements...>& __x, tuple<_Elements...>& __y)

noexcept(noexcept(__x.swap(__y)))
{ __x.swap(__y); }

template<typename... _Elements>
requires (is_swappable_v<const _Elements> && ...)
constexpr void
swap(const tuple<_Elements...>& __x, const tuple<_Elements...>& __y)
noexcept(noexcept(__x.swap(__y)))
{ __x.swap(__y); }
template<typename... _Elements>
constexpr
typename enable_if<!__and_<__is_swappable<_Elements>...>::value>::type
swap(tuple<_Elements...>&, tuple<_Elements...>&) = delete;

struct _Swallow_assign
{
template<class _Tp>
constexpr const _Swallow_assign&
operator=(const _Tp&) const
{ return *this; }
};
# 2853 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/tuple" 3
inline constexpr _Swallow_assign ignore{};

template<typename... _Types, typename _Alloc>

struct uses_allocator<tuple<_Types...>, _Alloc> : true_type { };
# 2868 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/tuple" 3
template<class _T1, class _T2>
template<typename... _Args1, typename... _Args2>
constexpr
inline
pair<_T1, _T2>::
pair(piecewise_construct_t,
tuple<_Args1...> __first, tuple<_Args2...> __second)
: pair(__first, __second,
typename _Build_index_tuple<sizeof...(_Args1)>::__type(),
typename _Build_index_tuple<sizeof...(_Args2)>::__type())
{ }

template<class _T1, class _T2>

template<typename... _Args1, size_t... _Indexes1,
typename... _Args2, size_t... _Indexes2>
constexpr inline
pair<_T1, _T2>::
pair(tuple<_Args1...>& __tuple1, tuple<_Args2...>& __tuple2,
_Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>)
: first(std::forward<_Args1>(std::get<_Indexes1>(__tuple1))...),
second(std::forward<_Args2>(std::get<_Indexes2>(__tuple2))...)
{ }

template<template<typename...> class _Trait, typename _Tp, typename _Tuple>

inline constexpr bool __unpack_std_tuple = false;

template<template<typename...> class _Trait, typename _Tp, typename... _Up>

inline constexpr bool __unpack_std_tuple<_Trait, _Tp, tuple<_Up...>>
= _Trait<_Tp, _Up...>::value;
template<template<typename...> class _Trait, typename _Tp, typename... _Up>
inline constexpr bool __unpack_std_tuple<_Trait, _Tp, tuple<_Up...>&>
= _Trait<_Tp, _Up&...>::value;

template<template<typename...> class _Trait, typename _Tp, typename... _Up>

inline constexpr bool __unpack_std_tuple<_Trait, _Tp, const tuple<_Up...>>
= _Trait<_Tp, const _Up...>::value;

template<template<typename...> class _Trait, typename _Tp, typename... _Up>

inline constexpr bool __unpack_std_tuple<_Trait, _Tp, const tuple<_Up...>&>
= _Trait<_Tp, const _Up&...>::value;

template <typename _Fn, typename _Tuple, size_t... _Idx>

constexpr decltype(auto)
__apply_impl(_Fn&& __f, _Tuple&& __t, index_sequence<_Idx...>)
{
return std::__invoke(std::forward<_Fn>(__f),
std::get<_Idx>(std::forward<_Tuple>(__t))...);
}

template <typename _Fn, __tuple_like _Tuple>

constexpr decltype(auto)
apply(_Fn&& __f, _Tuple&& __t)
noexcept(__unpack_std_tuple<is_nothrow_invocable, _Fn, _Tuple>)
{
using _Indices
= make_index_sequence<tuple_size_v<remove_reference_t<_Tuple>>>;
return std::__apply_impl(std::forward<_Fn>(__f),
std::forward<_Tuple>(__t),
_Indices{});
}

template <typename _Tp, typename _Tuple, size_t... _Idx>

constexpr _Tp
__make_from_tuple_impl(_Tuple&& __t, index_sequence<_Idx...>)
{ return _Tp(std::get<_Idx>(std::forward<_Tuple>(__t))...); }

template <typename _Tp, __tuple_like _Tuple>

constexpr _Tp
make_from_tuple(_Tuple&& __t)
noexcept(__unpack_std_tuple<is_nothrow_constructible, _Tp, _Tuple>)
{
constexpr size_t __n = tuple_size_v<remove_reference_t<_Tuple>>;

if constexpr (__n == 1)
{
using _Elt = decltype(std::get<0>(std::declval<_Tuple>()));
static_assert(!__reference_constructs_from_temporary(_Tp, _Elt));
}

return __make_from_tuple_impl<_Tp>(std::forward<_Tuple>(__t),
make_index_sequence<__n>{});
}

template<__tuple_like _TTuple, __tuple_like _UTuple,

template<typename> class _TQual, template<typename> class _UQual,
typename = make_index_sequence<tuple_size_v<_TTuple>>>
struct __tuple_like_common_reference;

template<__tuple_like _TTuple, __tuple_like _UTuple,

template<typename> class _TQual, template<typename> class _UQual,
size_t... _Is>
requires requires
{ typename tuple<common_reference_t<_TQual<tuple_element_t<_Is, _TTuple>>,
_UQual<tuple_element_t<_Is, _UTuple>>>...>; }
struct __tuple_like_common_reference<_TTuple, _UTuple, _TQual, _UQual,
index_sequence<_Is...>>
{
using type = tuple<common_reference_t<_TQual<tuple_element_t<_Is, _TTuple>>,
_UQual<tuple_element_t<_Is, _UTuple>>>...>;
};

template<__tuple_like _TTuple, __tuple_like _UTuple,

template<typename> class _TQual, template<typename> class _UQual>
requires (__is_tuple_v<_TTuple> || __is_tuple_v<_UTuple>)
&& is_same_v<_TTuple, decay_t<_TTuple>>
&& is_same_v<_UTuple, decay_t<_UTuple>>
&& (tuple_size_v<_TTuple> == tuple_size_v<_UTuple>)
&& requires { typename __tuple_like_common_reference<_TTuple, _UTuple,
_TQual, _UQual>::type; }
struct basic_common_reference<_TTuple, _UTuple, _TQual, _UQual>
{
using type = typename __tuple_like_common_reference<_TTuple, _UTuple, _TQual,
_UQual>::type;
};

template<__tuple_like _TTuple, __tuple_like _UTuple,

typename = make_index_sequence<tuple_size_v<_TTuple>>>
struct __tuple_like_common_type;

template<__tuple_like _TTuple, __tuple_like _UTuple, size_t... _Is>

requires requires
{ typename tuple<common_type_t<tuple_element_t<_Is, _TTuple>,
tuple_element_t<_Is, _UTuple>>...>; }
struct __tuple_like_common_type<_TTuple, _UTuple, index_sequence<_Is...>>
{
using type = tuple<common_type_t<tuple_element_t<_Is, _TTuple>,
tuple_element_t<_Is, _UTuple>>...>;
};

template<__tuple_like _TTuple, __tuple_like _UTuple>

requires (__is_tuple_v<_TTuple> || __is_tuple_v<_UTuple>)
&& is_same_v<_TTuple, decay_t<_TTuple>>
&& is_same_v<_UTuple, decay_t<_UTuple>>
&& (tuple_size_v<_TTuple> == tuple_size_v<_UTuple>)
&& requires { typename __tuple_like_common_type<_TTuple, _UTuple>::type; }
struct common_type<_TTuple, _UTuple>
{
using type = typename __tuple_like_common_type<_TTuple, _UTuple>::type;
};

}
# 40 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/uses_allocator_args.h"
2 3

namespace std
{

template<typename _Tp>
concept _Std_pair = __is_pair<remove_cv_t<_Tp>>;

template<typename _Tp, typename _Alloc, typename... _Args>

constexpr auto
uses_allocator_construction_args(const _Alloc& __a,
_Args&&... __args) noexcept
requires (! _Std_pair<_Tp>)
{
if constexpr (uses_allocator_v<remove_cv_t<_Tp>, _Alloc>)
{
if constexpr (is_constructible_v<_Tp, allocator_arg_t,
const _Alloc&, _Args...>)
{
return tuple<allocator_arg_t, const _Alloc&, _Args&&...>(
allocator_arg, __a, std::forward<_Args>(__args)...);
}
else
{
static_assert(is_constructible_v<_Tp, _Args..., const _Alloc&>,
"construction with an allocator must be possible"
" if uses_allocator is true");

return tuple<_Args&&..., const _Alloc&>(

std::forward<_Args>(__args)..., __a);
}
}
else
{
static_assert(is_constructible_v<_Tp, _Args...>);

return tuple<_Args&&...>(std::forward<_Args>(__args)...);
}
}

template<_Std_pair _Tp, typename _Alloc, typename _Tuple1, typename _Tuple2>

constexpr auto
uses_allocator_construction_args(const _Alloc& __a, piecewise_construct_t,
_Tuple1&& __x, _Tuple2&& __y) noexcept;

template<_Std_pair _Tp, typename _Alloc>

constexpr auto
uses_allocator_construction_args(const _Alloc&) noexcept;

template<_Std_pair _Tp, typename _Alloc, typename _Up, typename _Vp>

constexpr auto
uses_allocator_construction_args(const _Alloc&, _Up&&, _Vp&&) noexcept;

template<_Std_pair _Tp, typename _Alloc, typename _Up, typename _Vp>

constexpr auto
uses_allocator_construction_args(const _Alloc&,
const pair<_Up, _Vp>&) noexcept;

template<_Std_pair _Tp, typename _Alloc, typename _Up, typename _Vp>

constexpr auto
uses_allocator_construction_args(const _Alloc&, pair<_Up, _Vp>&&) noexcept;

template<_Std_pair _Tp, typename _Alloc, typename _Up, typename _Vp>

constexpr auto
uses_allocator_construction_args(const _Alloc&,
pair<_Up, _Vp>&) noexcept;

template<_Std_pair _Tp, typename _Alloc, typename _Up, typename _Vp>

constexpr auto
uses_allocator_construction_args(const _Alloc&, const pair<_Up, _Vp>&&)
noexcept;

template<_Std_pair _Tp, typename _Alloc, typename _Tuple1, typename _Tuple2>

constexpr auto
uses_allocator_construction_args(const _Alloc& __a, piecewise_construct_t,
_Tuple1&& __x, _Tuple2&& __y) noexcept
{
using _Tp1 = typename _Tp::first_type;
using _Tp2 = typename _Tp::second_type;

return std::make_tuple(piecewise_construct,
std::apply([&__a](auto&&... __args1) {
return std::uses_allocator_construction_args<_Tp1>(
__a, std::forward<decltype(__args1)>(__args1)...);
}, std::forward<_Tuple1>(__x)),
std::apply([&__a](auto&&... __args2) {
return std::uses_allocator_construction_args<_Tp2>(
__a, std::forward<decltype(__args2)>(__args2)...);
}, std::forward<_Tuple2>(__y)));
}

template<_Std_pair _Tp, typename _Alloc>

constexpr auto
uses_allocator_construction_args(const _Alloc& __a) noexcept
{
using _Tp1 = typename _Tp::first_type;
using _Tp2 = typename _Tp::second_type;

return std::make_tuple(piecewise_construct,
std::uses_allocator_construction_args<_Tp1>(__a),
std::uses_allocator_construction_args<_Tp2>(__a));
}

template<_Std_pair _Tp, typename _Alloc, typename _Up, typename _Vp>

constexpr auto
uses_allocator_construction_args(const _Alloc& __a, _Up&& __u, _Vp&& __v)
noexcept
{
using _Tp1 = typename _Tp::first_type;
using _Tp2 = typename _Tp::second_type;

return std::make_tuple(piecewise_construct,
std::uses_allocator_construction_args<_Tp1>(__a,
std::forward<_Up>(__u)),
std::uses_allocator_construction_args<_Tp2>(__a,
std::forward<_Vp>(__v)));
}

template<_Std_pair _Tp, typename _Alloc, typename _Up, typename _Vp>

constexpr auto
uses_allocator_construction_args(const _Alloc& __a,
const pair<_Up, _Vp>& __pr) noexcept
{
using _Tp1 = typename _Tp::first_type;
using _Tp2 = typename _Tp::second_type;

return std::make_tuple(piecewise_construct,
std::uses_allocator_construction_args<_Tp1>(__a, __pr.first),
std::uses_allocator_construction_args<_Tp2>(__a, __pr.second));
}

template<_Std_pair _Tp, typename _Alloc, typename _Up, typename _Vp>

constexpr auto
uses_allocator_construction_args(const _Alloc& __a,
pair<_Up, _Vp>&& __pr) noexcept
{
using _Tp1 = typename _Tp::first_type;
using _Tp2 = typename _Tp::second_type;

return std::make_tuple(piecewise_construct,
std::uses_allocator_construction_args<_Tp1>(__a,
std::get<0>(std::move(__pr))),
std::uses_allocator_construction_args<_Tp2>(__a,
std::get<1>(std::move(__pr))));
}

template<_Std_pair _Tp, typename _Alloc, typename _Up, typename _Vp>

constexpr auto
uses_allocator_construction_args(const _Alloc& __a,
pair<_Up, _Vp>& __pr) noexcept
{
using _Tp1 = typename _Tp::first_type;
using _Tp2 = typename _Tp::second_type;

return std::make_tuple(piecewise_construct,
std::uses_allocator_construction_args<_Tp1>(__a, __pr.first),
std::uses_allocator_construction_args<_Tp2>(__a, __pr.second));
}

template<_Std_pair _Tp, typename _Alloc, typename _Up, typename _Vp>

constexpr auto
uses_allocator_construction_args(const _Alloc& __a,
const pair<_Up, _Vp>&& __pr) noexcept
{
using _Tp1 = typename _Tp::first_type;
using _Tp2 = typename _Tp::second_type;

template<typename _Tp, typename _Alloc, typename... _Args>

constexpr _Tp
make_obj_using_allocator(const _Alloc& __a, _Args&&... __args)
{
return std::make_from_tuple<_Tp>(
std::uses_allocator_construction_args<_Tp>(__a,
std::forward<_Args>(__args)...));
}

template<typename _Tp, typename _Alloc, typename... _Args>

constexpr _Tp*
uninitialized_construct_using_allocator(_Tp* __p, const _Alloc& __a,
_Args&&... __args)
{
return std::apply([&](auto&&... __xs) {
return std::construct_at(__p, std::forward<decltype(__xs)>(__xs)...);
}, std::uses_allocator_construction_args<_Tp>(__a,
std::forward<_Args>(__args)...));
}

}
# 42 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/memory_resource.h" 2 3
# 50 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/memory_resource.h" 3
namespace std
{

namespace pmr
{
class memory_resource
{
static constexpr size_t _S_max_align = alignof(max_align_t);

public:
memory_resource() = default;
memory_resource(const memory_resource&) = default;
virtual ~memory_resource();

memory_resource& operator=(const memory_resource&) = default;

[[nodiscard]]
void*
allocate(size_t __bytes, size_t __alignment = _S_max_align)
__attribute__((__returns_nonnull__,__alloc_size__(2),__alloc_align__(3)))
{ return ::operator new(__bytes, do_allocate(__bytes, __alignment)); }

void
deallocate(void* __p, size_t __bytes, size_t __alignment = _S_max_align)
__attribute__((__nonnull__))
{ return do_deallocate(__p, __bytes, __alignment); }

[[nodiscard]]
bool
is_equal(const memory_resource& __other) const noexcept
{ return do_is_equal(__other); }

private:
virtual void*
do_allocate(size_t __bytes, size_t __alignment) = 0;

virtual void
do_deallocate(void* __p, size_t __bytes, size_t __alignment) = 0;

virtual bool
do_is_equal(const memory_resource& __other) const noexcept = 0;
};

[[nodiscard]]
inline bool
operator==(const memory_resource& __a, const memory_resource& __b) noexcept
{ return &__a == &__b || __a.is_equal(__b); }
# 119 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/memory_resource.h" 3
template<typename _Tp>
class polymorphic_allocator
{

template<typename _Up>
struct __not_pair { using type = void; };

template<typename _Up1, typename _Up2>

struct __not_pair<pair<_Up1, _Up2>> { };

public:
using value_type = _Tp;

polymorphic_allocator() noexcept
{
extern memory_resource* get_default_resource() noexcept
__attribute__((__returns_nonnull__));
_M_resource = get_default_resource();
}

polymorphic_allocator(memory_resource* __r) noexcept

__attribute__((__nonnull__))
: _M_resource(__r)
{ ; }

polymorphic_allocator(const polymorphic_allocator& __other) = default;

template<typename _Up>
polymorphic_allocator(const polymorphic_allocator<_Up>& __x) noexcept
: _M_resource(__x.resource())
{ }

polymorphic_allocator&
operator=(const polymorphic_allocator&) = delete;

[[nodiscard]]
_Tp*
allocate(size_t __n)
__attribute__((__returns_nonnull__))
{
if ((__gnu_cxx::__int_traits<size_t>::__max / sizeof(_Tp)) < __n)
std::__throw_bad_array_new_length();
return static_cast<_Tp*>(_M_resource->allocate(__n * sizeof(_Tp),
alignof(_Tp)));
}

void
deallocate(_Tp* __p, size_t __n) noexcept
__attribute__((__nonnull__))
{ _M_resource->deallocate(__p, __n * sizeof(_Tp), alignof(_Tp)); }

[[nodiscard]] void*
allocate_bytes(size_t __nbytes,
size_t __alignment = alignof(max_align_t))
{ return _M_resource->allocate(__nbytes, __alignment); }

void
deallocate_bytes(void* __p, size_t __nbytes,
size_t __alignment = alignof(max_align_t))
{ _M_resource->deallocate(__p, __nbytes, __alignment); }

template<typename _Up>
[[nodiscard]] _Up*
allocate_object(size_t __n = 1)
{
if ((__gnu_cxx::__int_traits<size_t>::__max / sizeof(_Up)) < __n)
std::__throw_bad_array_new_length();
return static_cast<_Up*>(allocate_bytes(__n * sizeof(_Up),
alignof(_Up)));
}

template<typename _Up>
void
deallocate_object(_Up* __p, size_t __n = 1)
{ deallocate_bytes(__p, __n * sizeof(_Up), alignof(_Up)); }

template<typename _Up, typename... _CtorArgs>

[[nodiscard]] _Up*
new_object(_CtorArgs&&... __ctor_args)
{
_Up* __p = allocate_object<_Up>();
try
{
construct(__p, std::forward<_CtorArgs>(__ctor_args)...);
}
catch(...)
{
deallocate_object(__p);
throw;
}
return __p;
}

template<typename _Up>
void
delete_object(_Up* __p)
{
__p->~_Up();
deallocate_object(__p);
}
# 297 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/memory_resource.h" 3
template<typename _Tp1, typename... _Args>
__attribute__((__nonnull__))
void
construct(_Tp1* __p, _Args&&... __args)
{
std::uninitialized_construct_using_allocator(__p, *this,
std::forward<_Args>(__args)...);
}

template<typename _Up>
__attribute__ ((__deprecated__ ("use '" "allocator_traits::destroy" "' instead")))
__attribute__((__nonnull__))
void
destroy(_Up* __p)
{ __p->~_Up(); }

polymorphic_allocator
select_on_container_copy_construction() const noexcept
{ return polymorphic_allocator(); }

memory_resource*
resource() const noexcept
__attribute__((__returns_nonnull__))
{ return _M_resource; }

[[nodiscard]]
friend bool
operator==(const polymorphic_allocator& __a,
const polymorphic_allocator& __b) noexcept
{ return *__a.resource() == *__b.resource(); }
# 339 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/memory_resource.h" 3
private:
# 366 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/memory_resource.h" 3
memory_resource* _M_resource;
};

template<typename _Tp1, typename _Tp2>

[[nodiscard]]
inline bool
operator==(const polymorphic_allocator<_Tp1>& __a,
const polymorphic_allocator<_Tp2>& __b) noexcept
{ return *__a.resource() == *__b.resource(); }
# 385 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/memory_resource.h" 3
}

template<typename _Alloc> struct allocator_traits;

template<typename _Tp>
struct allocator_traits<pmr::polymorphic_allocator<_Tp>>
{

using allocator_type = pmr::polymorphic_allocator<_Tp>;

using value_type = _Tp;

using pointer = _Tp*;

using const_pointer = const _Tp*;

using void_pointer = void*;

using const_void_pointer = const void*;

using difference_type = std::ptrdiff_t;

using size_type = std::size_t;

using propagate_on_container_copy_assignment = false_type;

using propagate_on_container_move_assignment = false_type;
using propagate_on_container_swap = false_type;

static allocator_type
select_on_container_copy_construction(const allocator_type&) noexcept
{ return allocator_type(); }
using is_always_equal = false_type;

template<typename _Up>
using rebind_alloc = pmr::polymorphic_allocator<_Up>;

template<typename _Up>
using rebind_traits = allocator_traits<pmr::polymorphic_allocator<_Up>>;
# 446 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/memory_resource.h" 3
[[nodiscard]] static pointer
allocate(allocator_type& __a, size_type __n)
{ return __a.allocate(__n); }
# 461 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/memory_resource.h" 3
[[nodiscard]] static pointer
allocate(allocator_type& __a, size_type __n, const_void_pointer)
{ return __a.allocate(__n); }
# 473 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/memory_resource.h" 3
static void
deallocate(allocator_type& __a, pointer __p, size_type __n)
{ __a.deallocate(__p, __n); }
# 488 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/memory_resource.h" 3
template<typename _Up, typename... _Args>
static void
construct(allocator_type& __a, _Up* __p, _Args&&... __args)
{ __a.construct(__p, std::forward<_Args>(__args)...); }
# 500 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/memory_resource.h" 3
template<typename _Up>
static constexpr void
destroy(allocator_type&, _Up* __p)
noexcept(is_nothrow_destructible<_Up>::value)
{ __p->~_Up(); }

static constexpr size_type

max_size(const allocator_type&) noexcept
{ return size_t(-1) / sizeof(value_type); }
};

}
# 68 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/string" 2 3
namespace std
{

namespace pmr {
template<typename _CharT, typename _Traits = char_traits<_CharT>>
using basic_string = std::basic_string<_CharT, _Traits,
polymorphic_allocator<_CharT>>;
using string = basic_string<char>;

using u8string = basic_string<char8_t>;

using u16string = basic_string<char16_t>;

using u32string = basic_string<char32_t>;
using wstring = basic_string<wchar_t>;
}

namespace std
{

template<typename _CharT, typename _Traits, typename _Alloc,

typename _Predicate>
constexpr
inline typename basic_string<_CharT, _Traits, _Alloc>::size_type
erase_if(basic_string<_CharT, _Traits, _Alloc>& __cont, _Predicate __pred)
{
using namespace __gnu_cxx;
const auto __osz = __cont.size();
const auto __end = __cont.end();
auto __removed = std::__remove_if(__cont.begin(), __end,
__ops::__pred_iter(std::ref(__pred)));
__cont.erase(__removed, __end);
return __osz - __cont.size();
}

template<typename _CharT, typename _Traits, typename _Alloc, typename _Up>

constexpr
inline typename basic_string<_CharT, _Traits, _Alloc>::size_type
erase(basic_string<_CharT, _Traits, _Alloc>& __cont, const _Up& __value)
{
using namespace __gnu_cxx;
const auto __osz = __cont.size();
const auto __end = __cont.end();
auto __removed = std::__remove_if(__cont.begin(), __end,
__ops::__iter_equals_val(__value));
__cont.erase(__removed, __end);
return __osz - __cont.size();
}

}
# 41 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_classes.h" 2 3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/ext/atomicity.h" 1 3
# 32 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/ext/atomicity.h" 3

# 33 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/ext/atomicity.h" 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/x86_64-w64-mingw32/bits/
gthr.h" 1 3
# 30 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/x86_64-w64-mingw32/bits/
gthr.h" 3
#pragma GCC visibility push(default)
# 157 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/x86_64-w64-mingw32/bits/
gthr.h" 3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/x86_64-w64-mingw32/bits/gthr-
default.h" 1 3
# 35 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/x86_64-w64-mingw32/bits/
gthr-default.h" 3
# 1 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/pthread.h" 1 3
# 62 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/pthread.h" 3
# 1 "D:/Enviroments/mingw64_msvcrt/lib/gcc/x86_64-w64-mingw32/14.1.0/include/
stddef.h" 1 3 4
# 1 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/stddef.h" 1 3 4
# 2 "D:/Enviroments/mingw64_msvcrt/lib/gcc/x86_64-w64-mingw32/14.1.0/include/
stddef.h" 2 3 4
# 63 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/pthread.h" 2 3

# 1 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/sys/types.h" 1 3
# 62 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/sys/types.h" 3
__extension__
typedef long long _pid_t;

typedef _pid_t pid_t;

typedef unsigned short _mode_t;

typedef _mode_t mode_t;

typedef unsigned int useconds_t;

struct timespec {
time_t tv_sec;
long tv_nsec;
};

struct itimerspec {
struct timespec it_interval;
struct timespec it_value;
};

__extension__
typedef unsigned long long _sigset_t;
# 65 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/pthread.h" 2 3

# 1 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/process.h" 1 3
# 10 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/process.h" 3
# 1 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/corecrt_startup.h" 1
3
# 11 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/corecrt_startup.h" 3
extern "C" {

attribute ((dllimport)) char **attribute((cdecl))

__p__acmdln(void);

attribute ((dllimport)) wchar_t **attribute((cdecl))

__p__wcmdln(void);

typedef void (attribute((cdecl)) *_PVFV)(void);

typedef int (__attribute__((__cdecl__)) *_PIFV)(void);
typedef void (__attribute__((__cdecl__)) *_PVFI)(int);

typedef struct _onexit_table_t {

_PVFV* _first;
_PVFV* _last;
_PVFV* _end;
} _onexit_table_t;

typedef int (attribute((cdecl)) *_onexit_t)(void);

attribute ((dllimport)) int attribute((cdecl))

_initialize_onexit_table(_onexit_table_t*);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__))
_register_onexit_function(_onexit_table_t*,_onexit_t);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__))
_execute_onexit_table(_onexit_table_t*);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) _crt_atexit(_PVFV
func);
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__))
_crt_at_quick_exit(_PVFV func);

}
# 11 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/process.h" 2 3

extern "C" {
# 32 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/process.h" 3
typedef void (__attribute__((__cdecl__)) *_beginthread_proc_type)(void *);
typedef unsigned (__attribute__((__stdcall__)) *_beginthreadex_proc_type)(void
*);

attribute ((dllimport)) uintptr_t attribute((cdecl))

_beginthread(_beginthread_proc_type _StartAddress,unsigned _StackSize,void
*_ArgList);
__attribute__ ((__dllimport__)) void __attribute__((__cdecl__)) _endthread(void)
__attribute__ ((__noreturn__));
__attribute__ ((__dllimport__)) uintptr_t __attribute__((__cdecl__))
_beginthreadex(void *_Security,unsigned _StackSize,_beginthreadex_proc_type
_StartAddress,void *_ArgList,unsigned _InitFlag,unsigned *_ThrdAddr);
__attribute__ ((__dllimport__)) void __attribute__((__cdecl__))
_endthreadex(unsigned _Retval) __attribute__ ((__noreturn__));
# 64 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/process.h" 3
typedef void (__attribute__((__stdcall__)) *_tls_callback_type)(void*,unsigned
long,void*);
__attribute__ ((__dllimport__)) void __attribute__((__cdecl__))
_register_thread_local_exe_atexit_callback(_tls_callback_type callback);

void attribute((cdecl)) attribute ((nothrow)) _cexit(void);

void __attribute__((__cdecl__)) __attribute__ ((__nothrow__)) _c_exit(void);

attribute ((dllimport)) int attribute((cdecl)) _getpid(void);

__attribute__ ((__dllimport__)) intptr_t __attribute__((__cdecl__)) _cwait(int
*_TermStat,intptr_t _ProcHandle,int _Action);
__attribute__ ((__dllimport__)) intptr_t __attribute__((__cdecl__)) _execl(const
char *_Filename,const char *_ArgList,...);
__attribute__ ((__dllimport__)) intptr_t __attribute__((__cdecl__)) _execle(const
char *_Filename,const char *_ArgList,...);
__attribute__ ((__dllimport__)) intptr_t __attribute__((__cdecl__)) _execlp(const
char *_Filename,const char *_ArgList,...);
__attribute__ ((__dllimport__)) intptr_t __attribute__((__cdecl__))
_execlpe(const char *_Filename,const char *_ArgList,...);
__attribute__ ((__dllimport__)) intptr_t __attribute__((__cdecl__)) _execv(const
char *_Filename,const char *const *_ArgList);
__attribute__ ((__dllimport__)) intptr_t __attribute__((__cdecl__)) _execve(const
char *_Filename,const char *const *_ArgList,const char *const *_Env);
__attribute__ ((__dllimport__)) intptr_t __attribute__((__cdecl__)) _execvp(const
char *_Filename,const char *const *_ArgList);
__attribute__ ((__dllimport__)) intptr_t __attribute__((__cdecl__))
_execvpe(const char *_Filename,const char *const *_ArgList,const char *const
*_Env);
__attribute__ ((__dllimport__)) intptr_t __attribute__((__cdecl__)) _spawnl(int
_Mode,const char *_Filename,const char *_ArgList,...);
__attribute__ ((__dllimport__)) intptr_t __attribute__((__cdecl__)) _spawnle(int
_Mode,const char *_Filename,const char *_ArgList,...);
__attribute__ ((__dllimport__)) intptr_t __attribute__((__cdecl__)) _spawnlp(int
_Mode,const char *_Filename,const char *_ArgList,...);
__attribute__ ((__dllimport__)) intptr_t __attribute__((__cdecl__)) _spawnlpe(int
_Mode,const char *_Filename,const char *_ArgList,...);
# 129 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/process.h" 3
intptr_t __attribute__((__cdecl__)) _loaddll(char *_Filename);
int __attribute__((__cdecl__)) _unloaddll(intptr_t _Handle);
int (__attribute__((__cdecl__)) *__attribute__((__cdecl__))
_getdllprocaddr(intptr_t _Handle,char *_ProcedureName,intptr_t _Ordinal))(void);
# 161 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/process.h" 3
int __attribute__((__cdecl__)) getpid(void) ;

intptr_t attribute((cdecl)) cwait(int *_TermStat,intptr_t _ProcHandle,int

_Action) ;

int attribute((cdecl)) execl(const char *_Filename,const char

*_ArgList,...) ;
int __attribute__((__cdecl__)) execle(const char *_Filename,const char
*_ArgList,...) ;
int __attribute__((__cdecl__)) execlp(const char *_Filename,const char
*_ArgList,...) ;
int __attribute__((__cdecl__)) execlpe(const char *_Filename,const char
*_ArgList,...) ;

intptr_t attribute((cdecl)) spawnl(int,const char *_Filename,const char

*_ArgList,...) ;
intptr_t __attribute__((__cdecl__)) spawnle(int,const char *_Filename,const char
*_ArgList,...) ;
intptr_t __attribute__((__cdecl__)) spawnlp(int,const char *_Filename,const char
*_ArgList,...) ;
intptr_t __attribute__((__cdecl__)) spawnlpe(int,const char *_Filename,const char
*_ArgList,...) ;

attribute ((dllimport)) int attribute((cdecl)) execv(const char

*_Filename,char *const _ArgList[]) ;
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) execve(const char
*_Filename,char *const _ArgList[],char *const _Env[]) ;
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) execvp(const char
*_Filename,char *const _ArgList[]) ;
__attribute__ ((__dllimport__)) int __attribute__((__cdecl__)) execvpe(const char
*_Filename,char *const _ArgList[],char *const _Env[]) ;

attribute ((dllimport)) intptr_t attribute((cdecl))

spawnv(int,const char *_Filename,char *const _ArgList[]) ;
__attribute__ ((__dllimport__)) intptr_t __attribute__((__cdecl__))
spawnve(int,const char *_Filename,char *const _ArgList[],char *const _Env[]) ;
__attribute__ ((__dllimport__)) intptr_t __attribute__((__cdecl__))
spawnvp(int,const char *_Filename,char *const _ArgList[]) ;
__attribute__ ((__dllimport__)) intptr_t __attribute__((__cdecl__))
spawnvpe(int,const char *_Filename,char *const _ArgList[],char *const _Env[]) ;

}
# 67 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/pthread.h" 2 3
# 1 "D:/Enviroments/mingw64_msvcrt/lib/gcc/x86_64-w64-mingw32/14.1.0/include/
limits.h" 1 3 4
# 68 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/pthread.h" 2 3
# 1 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/signal.h" 1 3
# 10 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/signal.h" 3
# 1 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/pthread_signal.h" 1 3
# 11 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/signal.h" 2 3

extern "C" {
typedef int sig_atomic_t;
# 48 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/signal.h" 3
typedef void (*__p_sig_fn_t)(int);
# 57 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/signal.h" 3
extern void **__attribute__((__cdecl__)) __pxcptinfoptrs(void);

__p_sig_fn_t attribute((cdecl)) signal(int _SigNum,__p_sig_fn_t _Func);

int __attribute__((__cdecl__)) raise(int _SigNum);

}
# 69 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/pthread.h" 2 3
# 1 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/time.h" 1 3
# 25 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/time.h" 3
# 1 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/sys/timeb.h" 1 3
# 15 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/sys/timeb.h" 3
#pragma pack(push,_CRT_PACKING)

extern "C" {
# 53 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/sys/timeb.h" 3
struct __timeb32 {
__time32_t time;
unsigned short millitm;
short timezone;
short dstflag;
};

struct timeb {
time_t time;
unsigned short millitm;
short timezone;
short dstflag;
};

struct __timeb64 {
__time64_t time;
unsigned short millitm;
short timezone;
short dstflag;
};

attribute ((dllimport)) void attribute((cdecl)) _ftime64(struct

__timeb64 *_Time);
__attribute__ ((__dllimport__)) void __attribute__((__cdecl__)) _ftime32(struct
__timeb32 *_Time);
# 89 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/sys/timeb.h" 3
struct _timespec32 {
__time32_t tv_sec;
long tv_nsec;
};
struct _timespec64 {
__time64_t tv_sec;
long tv_nsec;
};
# 113 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/sys/timeb.h" 3
void __attribute__((__cdecl__)) ftime (struct timeb *);

inline void attribute((cdecl)) ftime(struct timeb *_Tmb) {

_ftime64((struct __timeb64 *)_Tmb);
}
# 130 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/sys/timeb.h" 3
}

#pragma pack(pop)

# 1 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/sec_api/sys/
timeb_s.h" 1 3
# 10 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/sec_api/sys/
timeb_s.h" 3
# 1 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/sys/timeb.h" 1 3
# 11 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/sec_api/sys/
timeb_s.h" 2 3

extern "C" {

attribute ((dllimport)) errno_t attribute((cdecl))

_ftime32_s(struct __timeb32 *_Time);
__attribute__ ((__dllimport__)) errno_t __attribute__((__cdecl__))
_ftime64_s(struct __timeb64 *_Time);
# 26 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/sec_api/sys/
timeb_s.h" 3
}
# 136 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/sys/timeb.h" 2 3
# 26 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/time.h" 2 3

#pragma pack(push,_CRT_PACKING)

extern "C" {
# 63 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/time.h" 3
typedef long clock_t;
# 129 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/time.h" 3
extern __attribute__ ((__dllimport__)) int _daylight;
extern __attribute__ ((__dllimport__)) long _dstbias;
extern __attribute__ ((__dllimport__)) long _timezone;
extern __attribute__ ((__dllimport__)) char * _tzname[2];
# 145 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/time.h" 3
__attribute__ ((__dllimport__)) errno_t __attribute__((__cdecl__))
_get_daylight(int *_Daylight);
__attribute__ ((__dllimport__)) errno_t __attribute__((__cdecl__))
_get_dstbias(long *_Daylight_savings_bias);
__attribute__ ((__dllimport__)) errno_t __attribute__((__cdecl__))
_get_timezone(long *_Timezone);
__attribute__ ((__dllimport__)) errno_t __attribute__((__cdecl__))
_get_tzname(size_t *_ReturnValue,char *_Buffer,size_t _SizeInBytes,int _Index);
char *__attribute__((__cdecl__)) asctime(const struct tm *_Tm) ;
__attribute__((dllimport)) errno_t __attribute__((__cdecl__)) asctime_s (char
*_Buf,size_t _SizeInWords,const struct tm *_Tm);
__attribute__ ((__dllimport__)) char *__attribute__((__cdecl__)) _ctime32(const
__time32_t *_Time) ;
__attribute__((dllimport)) errno_t __attribute__((__cdecl__)) _ctime32_s (char
*_Buf,size_t _SizeInBytes,const __time32_t *_Time);
clock_t __attribute__((__cdecl__)) clock(void);
__attribute__ ((__dllimport__)) double __attribute__((__cdecl__))
_difftime32(__time32_t _Time1,__time32_t _Time2);
__attribute__ ((__dllimport__)) struct tm *__attribute__((__cdecl__))
_gmtime32(const __time32_t *_Time) ;
__attribute__((dllimport)) errno_t __attribute__((__cdecl__)) _gmtime32_s (struct
tm *_Tm,const __time32_t *_Time);
__attribute__ ((__dllimport__)) struct tm *__attribute__((__cdecl__))
_localtime32(const __time32_t *_Time) ;
__attribute__((dllimport)) errno_t __attribute__((__cdecl__)) _localtime32_s
(struct tm *_Tm,const __time32_t *_Time);
size_t __attribute__((__cdecl__)) strftime(char * __restrict__ _Buf,size_t
_SizeInBytes,const char * __restrict__ _Format,const struct tm * __restrict__ _Tm)
__attribute__((__format__ (ms_strftime, 3, 0)));
__attribute__ ((__dllimport__)) size_t __attribute__((__cdecl__))
_strftime_l(char * __restrict__ _Buf,size_t _Max_size,const char * __restrict__
_Format,const struct tm * __restrict__ _Tm,_locale_t _Locale);
__attribute__ ((__dllimport__)) char *__attribute__((__cdecl__)) _strdate(char
*_Buffer) ;
__attribute__((dllimport)) errno_t __attribute__((__cdecl__)) _strdate_s (char
*_Buf,size_t _SizeInBytes);
extern "C++" { template <size_t __size> inline errno_t __attribute__((__cdecl__))
_strdate_s(char (&_Str)[__size]) { return _strdate_s(_Str,__size); } }
__attribute__ ((__dllimport__)) char *__attribute__((__cdecl__)) _strtime(char
*_Buffer) ;
__attribute__((dllimport)) errno_t __attribute__((__cdecl__)) _strtime_s (char
*_Buf ,size_t _SizeInBytes);
extern "C++" { template <size_t __size> inline errno_t __attribute__((__cdecl__))
_strtime_s(char (&_Str)[__size]) { return _strtime_s(_Str,__size); } }
__attribute__ ((__dllimport__)) __time32_t __attribute__((__cdecl__))
_time32(__time32_t *_Time);

attribute ((dllimport)) __time32_t attribute((cdecl))

_mktime32(struct tm *_Tm);
__attribute__ ((__dllimport__)) __time32_t __attribute__((__cdecl__))
_mkgmtime32(struct tm *_Tm);

void attribute((cdecl)) tzset(void) ;

__attribute__ ((__dllimport__))

void attribute((cdecl)) _tzset(void);

__attribute__ ((__dllimport__)) double __attribute__((__cdecl__))
_difftime64(__time64_t _Time1,__time64_t _Time2);
__attribute__ ((__dllimport__)) char *__attribute__((__cdecl__)) _ctime64(const
__time64_t *_Time) ;
__attribute__((dllimport)) errno_t __attribute__((__cdecl__)) _ctime64_s (char
*_Buf,size_t _SizeInBytes,const __time64_t *_Time);
__attribute__ ((__dllimport__)) struct tm *__attribute__((__cdecl__))
_gmtime64(const __time64_t *_Time) ;
__attribute__((dllimport)) errno_t __attribute__((__cdecl__)) _gmtime64_s (struct
tm *_Tm,const __time64_t *_Time);
__attribute__ ((__dllimport__)) struct tm *__attribute__((__cdecl__))
_localtime64(const __time64_t *_Time) ;
__attribute__((dllimport)) errno_t __attribute__((__cdecl__)) _localtime64_s
(struct tm *_Tm,const __time64_t *_Time);
__attribute__ ((__dllimport__)) __time64_t __attribute__((__cdecl__))
_mktime64(struct tm *_Tm);
__attribute__ ((__dllimport__)) __time64_t __attribute__((__cdecl__))
_mkgmtime64(struct tm *_Tm);
__attribute__ ((__dllimport__)) __time64_t __attribute__((__cdecl__))
_time64(__time64_t *_Time);

unsigned attribute((cdecl)) _getsystime(struct tm *_Tm);

unsigned __attribute__((__cdecl__)) _setsystime(struct tm *_Tm,unsigned
_MilliSec);
# 252 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/time.h" 3
time_t __attribute__((__cdecl__)) time(time_t *_Time) __asm__("_time64");

double attribute((cdecl)) difftime(time_t _Time1,time_t _Time2)

__asm__("_difftime64");
struct tm *__attribute__((__cdecl__)) localtime(const time_t *_Time)
__asm__("_localtime64");
errno_t __attribute__((__cdecl__)) localtime_s(struct tm *_Tm,const time_t *_Time)
__asm__("_localtime64_s");
struct tm *__attribute__((__cdecl__)) gmtime(const time_t *_Time)
__asm__("_gmtime64");
errno_t __attribute__((__cdecl__)) gmtime_s(struct tm *_Tm, const time_t *_Time)
__asm__("_gmtime64_s");
char *__attribute__((__cdecl__)) ctime(const time_t *_Time) __asm__("_ctime64");
errno_t __attribute__((__cdecl__)) ctime_s(char *_Buf,size_t _SizeInBytes,const
time_t *_Time) __asm__("_ctime64_s");
time_t __attribute__((__cdecl__)) mktime(struct tm *_Tm) __asm__("_mktime64");
time_t __attribute__((__cdecl__)) _mkgmtime(struct tm *_Tm) __asm__("_mkgmtime64");
# 281 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/time.h" 3
__attribute__ ((__dllimport__)) extern int daylight ;
__attribute__ ((__dllimport__)) extern long timezone ;
__attribute__ ((__dllimport__)) extern char *tzname[2] ;
void __attribute__((__cdecl__)) tzset(void) ;

# 1 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/_timeval.h" 1 3
# 10 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/_timeval.h" 3
struct timeval
{
long tv_sec;
long tv_usec;
};
# 288 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/time.h" 2 3

struct timezone {
int tz_minuteswest;
int tz_dsttime;
};

extern int attribute((cdecl)) mingw_gettimeofday (struct timeval *p,

struct timezone *z);

#pragma pack(pop)
# 321 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/time.h" 3
}
# 330 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/time.h" 3
# 1 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/pthread_time.h" 1 3
# 49 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/pthread_time.h" 3
typedef int clockid_t;
# 78 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/pthread_time.h" 3
extern "C" {

int attribute((cdecl)) nanosleep(const struct timespec *request, struct

timespec *remain);

int attribute((cdecl)) clock_nanosleep(clockid_t clock_id, int flags,

const struct timespec *request, struct timespec *remain);
int __attribute__((__cdecl__)) clock_getres(clockid_t clock_id, struct timespec
*res);
int __attribute__((__cdecl__)) clock_gettime(clockid_t clock_id, struct timespec
*tp);
int __attribute__((__cdecl__)) clock_settime(clockid_t clock_id, const struct
timespec *tp);

}
# 331 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/time.h" 2 3
# 70 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/pthread.h" 2 3

# 1 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/pthread_compat.h" 1 3
# 74 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/pthread.h" 2 3

extern "C" {
# 165 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/pthread.h" 3
void * pthread_timechange_handler_np(void * dummy);
int pthread_delay_np (const struct timespec *interval);
int pthread_num_processors_np(void);
int pthread_set_num_processors_np(int n);
# 185 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/pthread.h" 3
typedef long pthread_once_t;
typedef unsigned pthread_mutexattr_t;
typedef unsigned pthread_key_t;
typedef void *pthread_barrierattr_t;
typedef int pthread_condattr_t;
typedef int pthread_rwlockattr_t;
# 201 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/pthread.h" 3
typedef uintptr_t pthread_t;

typedef struct _pthread_cleanup _pthread_cleanup;

struct _pthread_cleanup
{
void (*func)(void *);
void *arg;
_pthread_cleanup *next;
};
# 245 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/pthread.h" 3
struct sched_param {
int sched_priority;
};

int sched_yield(void);
int sched_get_priority_min(int pol);
int sched_get_priority_max(int pol);
int sched_getscheduler(pid_t pid);
int sched_setscheduler(pid_t pid, int pol, const struct sched_param *param);

typedef struct pthread_attr_t pthread_attr_t;

struct pthread_attr_t
{
unsigned p_state;
void *stack;
size_t s_size;
struct sched_param param;
};

int pthread_attr_setschedparam(pthread_attr_t *attr, const struct sched_param

*param);
int pthread_attr_getschedparam(const pthread_attr_t *attr, struct sched_param
*param);
int pthread_getschedparam(pthread_t thread, int *pol, struct sched_param *param);
int pthread_setschedparam(pthread_t thread, int pol, const struct sched_param
*param);
int pthread_attr_setschedpolicy (pthread_attr_t *attr, int pol);
int pthread_attr_getschedpolicy (const pthread_attr_t *attr, int *pol);

typedef intptr_t pthread_spinlock_t;

typedef intptr_t pthread_mutex_t;
typedef intptr_t pthread_cond_t;
typedef intptr_t pthread_rwlock_t;
typedef void *pthread_barrier_t;
# 297 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/pthread.h" 3
extern void (**_pthread_key_dest)(void *);
int pthread_key_create(pthread_key_t *key, void (* dest)(void *));
int pthread_key_delete(pthread_key_t key);
void * pthread_getspecific(pthread_key_t key);
int pthread_setspecific(pthread_key_t key, const void *value);

__attribute__((__always_inline__))
inline bool
__is_single_threaded() noexcept
{

return !__gthread_active_p();

inline _Atomic_word
__attribute__((__always_inline__))
__exchange_and_add(volatile _Atomic_word* __mem, int __val)
{ return __atomic_fetch_add(__mem, __val, 4); }

inline void
__attribute__((__always_inline__))
__atomic_add(volatile _Atomic_word* __mem, int __val)
{ __atomic_fetch_add(__mem, __val, 4); }
# 80 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/ext/atomicity.h" 3
inline _Atomic_word
__attribute__((__always_inline__))
__exchange_and_add_single(_Atomic_word* __mem, int __val)
{
_Atomic_word __result = *__mem;
*__mem += __val;
return __result;
}

inline void
__attribute__((__always_inline__))
__atomic_add_single(_Atomic_word* __mem, int __val)
{ *__mem += __val; }

inline _Atomic_word
__attribute__ ((__always_inline__))
__exchange_and_add_dispatch(_Atomic_word* __mem, int __val)
{
if (__is_single_threaded())
return __exchange_and_add_single(__mem, __val);
else
return __exchange_and_add(__mem, __val);
}

inline void
__attribute__ ((__always_inline__))
__atomic_add_dispatch(_Atomic_word* __mem, int __val)
{
if (__is_single_threaded())
__atomic_add_single(__mem, __val);
else
__atomic_add(__mem, __val);
}

}
# 42 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_classes.h" 2 3

namespace std
{

# 66 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_classes.h" 3
class locale
{
public:

typedef int category;

class facet;
class id;
class _Impl;

friend class facet;

friend class _Impl;

template<typename _Facet>
friend bool
has_facet(const locale&) throw();

template<typename _Facet>
friend const _Facet&
use_facet(const locale&);

template<typename _Facet>
friend const _Facet*
__try_use_facet(const locale&) noexcept;

template<typename _Cache>
friend struct __use_cache;
# 106 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_classes.h" 3
static const category none = 0;
static const category ctype = 1L << 0;
static const category numeric = 1L << 1;
static const category collate = 1L << 2;
static const category time = 1L << 3;
static const category monetary = 1L << 4;
static const category messages = 1L << 5;
static const category all = (ctype | numeric | collate |
time | monetary | messages);
# 125 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_classes.h" 3
locale() throw();
# 134 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_classes.h" 3
locale(const locale& __other) throw();
# 144 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_classes.h" 3
explicit
locale(const char* __s);
# 159 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_classes.h" 3
locale(const locale& __base, const char* __s, category __cat);
# 170 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_classes.h" 3
explicit
locale(const std::string& __s) : locale(__s.c_str()) { }
# 185 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_classes.h" 3
locale(const locale& __base, const std::string& __s, category __cat)
: locale(__base, __s.c_str(), __cat) { }
# 200 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_classes.h" 3
locale(const locale& __base, const locale& __add, category __cat);
# 213 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_classes.h" 3
template<typename _Facet>
locale(const locale& __other, _Facet* __f);

~locale() throw();
# 227 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_classes.h" 3
const locale&
operator=(const locale& __other) throw();
# 242 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_classes.h" 3
template<typename _Facet>
locale
combine(const locale& __other) const;
__attribute ((__abi_tag__ ("cxx11")))
string
name() const;
# 272 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_classes.h" 3
bool
operator==(const locale& __other) const throw();
# 302 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_classes.h" 3
template<typename _Char, typename _Traits, typename _Alloc>
bool
operator()(const basic_string<_Char, _Traits, _Alloc>& __s1,
const basic_string<_Char, _Traits, _Alloc>& __s2) const;
# 318 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_classes.h" 3
static locale
global(const locale& __loc);

static const locale&

classic();

private:

_Impl* _M_impl;

static _Impl* _S_classic;

static _Impl* _S_global;

static const char* const* const _S_categories;

# 353 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_classes.h" 3
enum { _S_categories_size = 6 + 0 };

static __gthread_once_t _S_once;

explicit
locale(_Impl*) throw();

static void
_S_initialize();

static void
_S_initialize_once() throw();

static category
_S_normalize_category(category);

void
_M_coalesce(const locale& __base, const locale& __add, category __cat);
static const id* const _S_twinned_facets[];

};
# 391 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_classes.h" 3
class locale::facet
{
private:
friend class locale;
friend class locale::_Impl;

mutable _Atomic_word _M_refcount;

static __c_locale _S_c_locale;

static const char _S_c_name[2];

static __gthread_once_t _S_once;

static void
_S_initialize_once();

protected:
# 422 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_classes.h" 3
explicit
facet(size_t __refs = 0) throw() : _M_refcount(__refs ? 1 : 0)
{ }

virtual
~facet();

static void
_S_create_c_locale(__c_locale& __cloc, const char* __s,
__c_locale __old = 0);

static __c_locale
_S_clone_c_locale(__c_locale& __cloc) throw();

static void
_S_destroy_c_locale(__c_locale& __cloc);

static __c_locale
_S_lc_ctype_c_locale(__c_locale __cloc, const char* __s);

static __c_locale
_S_get_c_locale();

attribute ((const)) static const char*

_S_get_c_name() throw();
# 458 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_classes.h" 3
facet(const facet&) = delete;

facet&
operator=(const facet&) = delete;

private:
void
_M_add_reference() const throw()
{ __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }

void
_M_remove_reference() const throw()
{

;
if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1)
{
;
try
{ delete this; }
catch(...)
{ }
}
}

const facet* _M_sso_shim(const id*) const;

const facet* _M_cow_shim(const id*) const;

protected:
class __shim;
};
# 503 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_classes.h" 3
class locale::id
{
private:
friend class locale;
friend class locale::_Impl;

template<typename _Facet>
friend const _Facet&
use_facet(const locale&);

template<typename _Facet>
friend bool
has_facet(const locale&) throw();

template<typename _Facet>
friend const _Facet*
__try_use_facet(const locale&) noexcept;

mutable size_t _M_index;

static _Atomic_word _S_refcount;

void
operator=(const id&);
id(const id&);

public:

id() { }

size_t
_M_id() const throw();
};

class locale::_Impl
{
public:

friend class locale;

friend class locale::facet;

template<typename _Facet>
friend bool
has_facet(const locale&) throw();

template<typename _Facet>
friend const _Facet&
use_facet(const locale&);

template<typename _Facet>
friend const _Facet*
__try_use_facet(const locale&) noexcept;

template<typename _Cache>
friend struct __use_cache;

private:

_Atomic_word _M_refcount;
const facet** _M_facets;
size_t _M_facets_size;
const facet** _M_caches;
char** _M_names;
static const locale::id* const _S_id_ctype[];
static const locale::id* const _S_id_numeric[];
static const locale::id* const _S_id_collate[];
static const locale::id* const _S_id_time[];
static const locale::id* const _S_id_monetary[];
static const locale::id* const _S_id_messages[];
static const locale::id* const* const _S_facet_categories[];

void
_M_add_reference() throw()
{ __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }

void
_M_remove_reference() throw()
{
;
if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1)
{
;
try
{ delete this; }
catch(...)
{ }
}
}

_Impl(const _Impl&, size_t);

_Impl(const char*, size_t);
_Impl(size_t) throw();

~_Impl() throw();

_Impl(const _Impl&);

void
operator=(const _Impl&);

bool
_M_check_same_name()
{
bool __ret = true;
if (_M_names[1])

for (size_t i = 0; ret && __i < _S_categories_size - 1; ++__i)

__ret = __builtin_strcmp(_M_names[__i], _M_names[__i + 1]) == 0;
return __ret;
}

void
_M_replace_categories(const _Impl*, category);

void
_M_replace_category(const _Impl*, const locale::id* const*);

void
_M_replace_facet(const _Impl*, const locale::id*);

void
_M_install_facet(const locale::id*, const facet*);

template<typename _Facet>
void
_M_init_facet(_Facet* __facet)
{ _M_install_facet(&_Facet::id, __facet); }

template<typename _Facet>
void
_M_init_facet_unchecked(_Facet* __facet)
{
__facet->_M_add_reference();
_M_facets[_Facet::id._M_id()] = __facet;
}

void
_M_install_cache(const facet*, size_t);

void _M_init_extra(facet**);
void _M_init_extra(void*, void*, const char*, const char*);

};
# 673 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_classes.h" 3
template<typename _CharT>
class __cxx11:: collate : public locale::facet
{
public:

typedef _CharT char_type;

typedef basic_string<_CharT> string_type;

protected:

__c_locale _M_c_locale_collate;

public:

static locale::id id;

# 700 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_classes.h" 3
explicit
collate(size_t __refs = 0)
: facet(__refs), _M_c_locale_collate(_S_get_c_locale())
{ }
# 714 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_classes.h" 3
explicit
collate(__c_locale __cloc, size_t __refs = 0)
: facet(__refs), _M_c_locale_collate(_S_clone_c_locale(__cloc))
{ }
# 731 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_classes.h" 3
int
compare(const _CharT* __lo1, const _CharT* __hi1,
const _CharT* __lo2, const _CharT* __hi2) const
{ return this->do_compare(__lo1, __hi1, __lo2, __hi2); }
# 750 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_classes.h" 3
string_type
transform(const _CharT* __lo, const _CharT* __hi) const
{ return this->do_transform(__lo, __hi); }
# 764 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_classes.h" 3
long
hash(const _CharT* __lo, const _CharT* __hi) const
{ return this->do_hash(__lo, __hi); }

int
_M_compare(const _CharT*, const _CharT*) const throw();

size_t
_M_transform(_CharT*, const _CharT*, size_t) const throw();
protected:

virtual
~collate()
{ _S_destroy_c_locale(_M_c_locale_collate); }
# 793 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_classes.h" 3
virtual int
do_compare(const _CharT* __lo1, const _CharT* __hi1,
const _CharT* __lo2, const _CharT* __hi2) const;
# 807 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_classes.h" 3
virtual string_type
do_transform(const _CharT* __lo, const _CharT* __hi) const;
# 820 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_classes.h" 3
virtual long
do_hash(const _CharT* __lo, const _CharT* __hi) const;
};

template<typename _CharT>
locale::id collate<_CharT>::id;

template<>
int
collate<char>::_M_compare(const char*, const char*) const throw();

template<>
size_t
collate<char>::_M_transform(char*, const char*, size_t) const throw();

template<>
int
collate<wchar_t>::_M_compare(const wchar_t*, const wchar_t*) const throw();

template<>
size_t
collate<wchar_t>::_M_transform(wchar_t*, const wchar_t*, size_t) const throw();

template<typename _CharT>
class __cxx11:: collate_byname : public collate<_CharT>
{
public:

typedef _CharT char_type;

typedef basic_string<_CharT> string_type;

explicit
collate_byname(const char* __s, size_t __refs = 0)
: collate<_CharT>(__refs)
{
if (__builtin_strcmp(__s, "C") != 0
&& __builtin_strcmp(__s, "POSIX") != 0)
{
this->_S_destroy_c_locale(this->_M_c_locale_collate);
this->_S_create_c_locale(this->_M_c_locale_collate, __s);
}
}

explicit
collate_byname(const string& __s, size_t __refs = 0)
: collate_byname(__s.c_str(), __refs) { }

protected:
virtual
~collate_byname() { }
};

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_classes.tcc" 1 3
# 37 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_classes.tcc" 3

# 38 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_classes.tcc" 3

namespace std
{

template<typename _Facet>
locale::
locale(const locale& __other, _Facet* __f)
{
_M_impl = new _Impl(*__other._M_impl, 1);

try
{ _M_impl->_M_install_facet(&_Facet::id, __f); }
catch(...)
{
_M_impl->_M_remove_reference();
throw;
}
delete [] _M_impl->_M_names[0];
_M_impl->_M_names[0] = 0;
}

template<typename _Facet>
locale
locale::
combine(const locale& __other) const
{
_Impl* __tmp = new _Impl(*_M_impl, 1);
try
{
__tmp->_M_replace_facet(__other._M_impl, &_Facet::id);
}
catch(...)
{
__tmp->_M_remove_reference();
throw;
}
return locale(__tmp);
}

template<typename _CharT, typename _Traits, typename _Alloc>

bool
locale::
operator()(const basic_string<_CharT, _Traits, _Alloc>& __s1,
const basic_string<_CharT, _Traits, _Alloc>& __s2) const
{
typedef std::collate<_CharT> __collate_type;
const __collate_type& __collate = use_facet<__collate_type>(*this);
return (__collate.compare(__s1.data(), __s1.data() + __s1.length(),
__s2.data(), __s2.data() + __s2.length()) < 0);
}

#pragma GCC diagnostic push

#pragma GCC diagnostic ignored "-Wc++17-extensions"
template<typename _Facet>
inline const _Facet*
__try_use_facet(const locale& __loc) noexcept
{
const size_t __i = _Facet::id._M_id();
const locale::facet** __facets = __loc._M_impl->_M_facets;

if constexpr (__is_same(_Facet, ctype<char>)) return static_cast<const

_Facet*>(__facets[__i]);
if constexpr (__is_same(_Facet, num_get<char>)) return static_cast<const
_Facet*>(__facets[__i]);
if constexpr (__is_same(_Facet, num_put<char>)) return static_cast<const
_Facet*>(__facets[__i]);
if constexpr (__is_same(_Facet, codecvt<char, char, mbstate_t>)) return
static_cast<const _Facet*>(__facets[__i]);
if constexpr (__is_same(_Facet, collate<char>)) return static_cast<const
_Facet*>(__facets[__i]);
if constexpr (__is_same(_Facet, moneypunct<char>)) return static_cast<const
_Facet*>(__facets[__i]);
if constexpr (__is_same(_Facet, moneypunct<char, true>)) return
static_cast<const _Facet*>(__facets[__i]);
if constexpr (__is_same(_Facet, money_get<char>)) return static_cast<const
_Facet*>(__facets[__i]);
if constexpr (__is_same(_Facet, money_put<char>)) return static_cast<const
_Facet*>(__facets[__i]);
if constexpr (__is_same(_Facet, numpunct<char>)) return static_cast<const
_Facet*>(__facets[__i]);
if constexpr (__is_same(_Facet, time_get<char>)) return static_cast<const
_Facet*>(__facets[__i]);
if constexpr (__is_same(_Facet, time_put<char>)) return static_cast<const
_Facet*>(__facets[__i]);
if constexpr (__is_same(_Facet, messages<char>)) return static_cast<const
_Facet*>(__facets[__i]);

if constexpr (__is_same(_Facet, ctype<wchar_t>)) return static_cast<const

_Facet*>(__facets[__i]);
if constexpr (__is_same(_Facet, num_get<wchar_t>)) return static_cast<const
_Facet*>(__facets[__i]);
if constexpr (__is_same(_Facet, num_put<wchar_t>)) return static_cast<const
_Facet*>(__facets[__i]);
if constexpr (__is_same(_Facet, codecvt<wchar_t, char, mbstate_t>)) return
static_cast<const _Facet*>(__facets[__i]);
if constexpr (__is_same(_Facet, collate<wchar_t>)) return static_cast<const
_Facet*>(__facets[__i]);
if constexpr (__is_same(_Facet, moneypunct<wchar_t>)) return
static_cast<const _Facet*>(__facets[__i]);
if constexpr (__is_same(_Facet, moneypunct<wchar_t, true>)) return
static_cast<const _Facet*>(__facets[__i]);
if constexpr (__is_same(_Facet, money_get<wchar_t>)) return static_cast<const
_Facet*>(__facets[__i]);
if constexpr (__is_same(_Facet, money_put<wchar_t>)) return static_cast<const
_Facet*>(__facets[__i]);
if constexpr (__is_same(_Facet, numpunct<wchar_t>)) return static_cast<const
_Facet*>(__facets[__i]);
if constexpr (__is_same(_Facet, time_get<wchar_t>)) return static_cast<const
_Facet*>(__facets[__i]);
if constexpr (__is_same(_Facet, time_put<wchar_t>)) return static_cast<const
_Facet*>(__facets[__i]);
if constexpr (__is_same(_Facet, messages<wchar_t>)) return static_cast<const
_Facet*>(__facets[__i]);

if constexpr (__is_same(_Facet, codecvt<char16_t, char, mbstate_t>)) return

static_cast<const _Facet*>(__facets[__i]);
if constexpr (__is_same(_Facet, codecvt<char32_t, char, mbstate_t>)) return
static_cast<const _Facet*>(__facets[__i]);

if (i >= loc._M_impl->_M_facets_size || !facets[i])

return 0;

return dynamic_cast<const _Facet*>(facets[i]);

}
#pragma GCC diagnostic pop
# 164 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_classes.tcc" 3
template<typename _Facet>
inline bool
has_facet(const locale& __loc) throw()
{

static_assert(__is_base_of(locale::facet, _Facet),
"template argument must be derived from locale::facet");

return std::__try_use_facet<_Facet>(__loc) != 0;
}
# 191 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_classes.tcc" 3
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdangling-reference"
template<typename _Facet>
inline const _Facet&
use_facet(const locale& __loc)
{

static_assert(__is_base_of(locale::facet, _Facet),
"template argument must be derived from locale::facet");

if (const _Facet* f = std::try_use_facet<_Facet>(__loc))

return *__f;
__throw_bad_cast();
}
#pragma GCC diagnostic pop

template<typename _CharT>
int
collate<_CharT>::_M_compare(const _CharT*, const _CharT*) const throw ()
{ return 0; }

template<typename _CharT>
size_t
collate<_CharT>::_M_transform(_CharT*, const _CharT*, size_t) const throw ()
{ return 0; }

template<typename _CharT>
int
collate<_CharT>::
do_compare(const _CharT* __lo1, const _CharT* __hi1,
const _CharT* __lo2, const _CharT* __hi2) const
{

const string_type one(lo1, __hi1);

const string_type __two(__lo2, __hi2);

const _CharT* p = one.c_str();

const _CharT* __pend = __one.data() + __one.length();
const _CharT* __q = __two.c_str();
const _CharT* __qend = __two.data() + __two.length();

for (;;)
{
const int __res = _M_compare(__p, __q);
if (__res)
return __res;

__p += char_traits<_CharT>::length(__p);
__q += char_traits<_CharT>::length(__q);
if (__p == __pend && __q == __qend)
return 0;
else if (__p == __pend)
return -1;
else if (__q == __qend)
return 1;

__p++;
__q++;
}
}

template<typename _CharT>
typename collate<_CharT>::string_type
collate<_CharT>::
do_transform(const _CharT* __lo, const _CharT* __hi) const
{
string_type __ret;

const string_type str(lo, __hi);

const _CharT* p = str.c_str();

const _CharT* __pend = __str.data() + __str.length();

size_t len = (hi - __lo) * 2;

_CharT* __c = new _CharT[__len];

try
{

for (;;)
{

size_t __res = _M_transform(c, p, __len);

if (res >= len)

{
__len = __res + 1;
delete [] __c, __c = 0;
__c = new _CharT[__len];
__res = _M_transform(__c, __p, __len);
}

__ret.append(__c, __res);
__p += char_traits<_CharT>::length(__p);
if (__p == __pend)
break;

__p++;
__ret.push_back(_CharT());
}
}
catch(...)
{
delete [] __c;
throw;
}

delete [] __c;

return __ret;
}

template<typename _CharT>
long
collate<_CharT>::
do_hash(const _CharT* __lo, const _CharT* __hi) const
{
unsigned long __val = 0;
for (; __lo < __hi; ++__lo)
__val =
*__lo + ((__val << 7)
| (__val >> (__gnu_cxx::__numeric_traits<unsigned long>::
__digits - 7)));
return static_cast<long>(__val);
}

extern template class collate<char>;

extern template class collate_byname<char>;

extern template
const collate<char>*
__try_use_facet<collate<char> >(const locale&) noexcept;

extern template
const collate<char>&
use_facet<collate<char> >(const locale&);

extern template
bool
has_facet<collate<char> >(const locale&);

extern template class collate<wchar_t>;

extern template class collate_byname<wchar_t>;

extern template
const collate<wchar_t>*
__try_use_facet<collate<wchar_t> >(const locale&) noexcept;

extern template
const collate<wchar_t>&
use_facet<collate<wchar_t> >(const locale&);

extern template
bool
has_facet<collate<wchar_t> >(const locale&);
}
# 884 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_classes.h" 2 3
# 42 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/locale" 2 3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 1 3
# 37 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3

# 38 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cwctype" 1 3
# 39 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cwctype" 3

# 40 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cwctype" 3
# 50 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cwctype" 3
# 1 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/wctype.h" 1 3
# 15 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/wctype.h" 3
#pragma pack(push,_CRT_PACKING)

extern "C" {
# 176 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/wctype.h" 3
typedef wchar_t wctrans_t;
wint_t __attribute__((__cdecl__)) towctrans(wint_t,wctrans_t);
wctrans_t __attribute__((__cdecl__)) wctrans(const char *);
wctype_t __attribute__((__cdecl__)) wctype(const char *);

#pragma pack(pop)
# 51 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cwctype" 2 3
# 80 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cwctype" 3
namespace std
{
using ::wctrans_t;
using ::wctype_t;
using ::wint_t;

using ::iswalnum;
using ::iswalpha;

using ::iswblank;

using ::iswcntrl;
using ::iswctype;
using ::iswdigit;
using ::iswgraph;
using ::iswlower;
using ::iswprint;
using ::iswpunct;
using ::iswspace;
using ::iswupper;
using ::iswxdigit;
using ::towctrans;
using ::towlower;
using ::towupper;
using ::wctrans;
using ::wctype;
}
# 40 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 2 3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cctype" 1 3
# 39 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cctype" 3

# 40 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cctype" 3
# 41 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 2 3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/x86_64-w64-mingw32/bits/
ctype_base.h" 1 3
# 37 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/x86_64-w64-mingw32/bits/
ctype_base.h" 3
namespace std
{

struct ctype_base
{

typedef const int* __to_type;

typedef unsigned short mask;

static const mask upper = 1 << 0;
static const mask lower = 1 << 1;
static const mask alpha = 1 << 2;
static const mask digit = 1 << 3;
static const mask xdigit = 1 << 4;
static const mask space = 1 << 5;
static const mask print = 1 << 6;
static const mask graph = (1 << 2) | (1 << 3) | (1 << 9);
static const mask cntrl = 1 << 8;
static const mask punct = 1 << 9;
static const mask alnum = (1 << 2) | (1 << 3);

static const mask blank = 1 << 10;

};

}
# 42 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 2 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/ios_base.h" 1 3
# 37 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/ios_base.h" 3

# 38 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/ios_base.h" 3
# 46 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/ios_base.h" 3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/system_error" 1 3
# 32 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/system_error" 3

# 33 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/system_error" 3
# 43 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/system_error" 3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/stdexcept" 1 3
# 36 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/stdexcept" 3

# 37 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/stdexcept" 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/exception" 1 3
# 33 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/exception" 3

# 34 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/exception" 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 1 3
# 47 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 3

# 48 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 3
# 40 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/exception" 2 3

extern "C++" {

namespace std
{
# 54 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/exception" 3
class bad_exception : public exception
{
public:
bad_exception() noexcept { }

virtual ~bad_exception() noexcept;

virtual const char*

what() const noexcept;
};

typedef void (*terminate_handler) ();

terminate_handler set_terminate(terminate_handler) noexcept;

terminate_handler get_terminate() noexcept;

void terminate() noexcept attribute ((noreturn,cold));

# 124 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/exception" 3
__attribute__ ((__deprecated__ ("use '" "std::uncaught_exceptions()" "'
instead")))
bool uncaught_exception() noexcept __attribute__ ((__pure__));

int uncaught_exceptions() noexcept attribute ((pure));

}

namespace __gnu_cxx
{

# 158 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/exception" 3
void __verbose_terminate_handler();

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/exception_ptr.h" 1 3
# 36 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/exception_ptr.h" 3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/cxxabi_init_exception.h"
1 3
# 34
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/cxxabi_init_exception.h" 3

# 35
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/cxxabi_init_exception.h" 3

#pragma GCC visibility push(default)

# 1 "D:/Enviroments/mingw64_msvcrt/lib/gcc/x86_64-w64-mingw32/14.1.0/include/
stddef.h" 1 3 4
# 1 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/stddef.h" 1 3 4
# 2 "D:/Enviroments/mingw64_msvcrt/lib/gcc/x86_64-w64-mingw32/14.1.0/include/
stddef.h" 2 3 4
# 39
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/cxxabi_init_exception.h" 2 3
# 50
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/cxxabi_init_exception.h" 3
namespace std
{
class type_info;
}

namespace __cxxabiv1
{
struct __cxa_refcounted_exception;

extern "C"
{

void*
__cxa_allocate_exception(size_t) noexcept;

void
__cxa_free_exception(void*) noexcept;

__cxa_refcounted_exception*
__cxa_init_primary_exception(void *__object, std::type_info *__tinfo,
void ( *__dest) (void *))
noexcept;

}
}

#pragma GCC visibility pop

# 37 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/exception_ptr.h" 2 3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/typeinfo" 1 3
# 32 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/typeinfo" 3

# 33 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/typeinfo" 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 1 3
# 47 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 3

# 48 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 3
# 41 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/typeinfo" 2 3

#pragma GCC visibility push(default)

extern "C++" {

namespace __cxxabiv1
{
class __class_type_info;
}
# 83 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/typeinfo" 3
namespace std
{

class type_info
{
public:

virtual ~type_info();

const char* name() const noexcept

{ return __name[0] == '*' ? __name + 1 : __name; }
bool before(const type_info& __arg) const noexcept;

constexpr
bool operator==(const type_info& __arg) const noexcept;

size_t hash_code() const noexcept

{

return _Hash_bytes(name(), __builtin_strlen(name()),

static_cast<size_t>(0xc70f6907UL));

virtual bool __is_pointer_p() const;

virtual bool __is_function_p() const;

virtual bool __do_catch(const type_info *__thr_type, void **__thr_obj,

unsigned __outer) const;

virtual bool __do_upcast(const cxxabiv1::class_type_info *__target,

void **__obj_ptr) const;

protected:
const char *__name;

explicit type_info(const char *n): name(__n) { }

private:

type_info& operator=(const type_info&) = delete;

type_info(const type_info&) = delete;

bool __equal(const type_info&) const noexcept;

};
# 191 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/typeinfo" 3
constexpr inline bool
type_info::operator==(const type_info& __arg) const noexcept
{
if (std::__is_constant_evaluated())
return this == &__arg;

if (__name == __arg.__name)
return true;

return __equal(__arg);

}
# 219 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/typeinfo" 3
class bad_cast : public exception
{
public:
bad_cast() noexcept { }

virtual ~bad_cast() noexcept;

virtual const char* what() const noexcept;

};

class bad_typeid : public exception

{
public:
bad_typeid () noexcept { }

virtual ~bad_typeid() noexcept;

virtual const char* what() const noexcept;

};
}

#pragma GCC visibility pop

# 38 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/exception_ptr.h" 2 3
# 50 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/exception_ptr.h" 3
extern "C++" {
namespace std
{
class type_info;

namespace __exception_ptr
{
class exception_ptr;
}

using __exception_ptr::exception_ptr;
# 75 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/exception_ptr.h" 3
exception_ptr current_exception() noexcept;

template<typename _Ex>
exception_ptr make_exception_ptr(_Ex) noexcept;

void rethrow_exception(exception_ptr) attribute ((noreturn));

namespace __exception_ptr
{
using std::rethrow_exception;
# 97 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/exception_ptr.h" 3
class exception_ptr
{
void* _M_exception_object;

explicit exception_ptr(void* __e) noexcept;

void _M_addref() noexcept;

void _M_release() noexcept;

void *_M_get() const noexcept attribute ((pure));

friend exception_ptr std::current_exception() noexcept;

friend void std::rethrow_exception(exception_ptr);
template<typename _Ex>
friend exception_ptr std::make_exception_ptr(_Ex) noexcept;

public:
exception_ptr() noexcept;

exception_ptr(const exception_ptr&) noexcept;

exception_ptr(nullptr_t) noexcept
: _M_exception_object(nullptr)
{ }

exception_ptr(exception_ptr&& __o) noexcept

: _M_exception_object(__o._M_exception_object)
{ __o._M_exception_object = nullptr; }
# 135 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/exception_ptr.h" 3
exception_ptr&
operator=(const exception_ptr&) noexcept;

exception_ptr&
operator=(exception_ptr&& __o) noexcept
{
exception_ptr(static_cast<exception_ptr&&>(__o)).swap(*this);
return *this;
}

~exception_ptr() noexcept;

void
swap(exception_ptr&) noexcept;
# 162 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/exception_ptr.h" 3
explicit operator bool() const noexcept
{ return _M_exception_object; }

friend bool
operator==(const exception_ptr&, const exception_ptr&) noexcept = default;
# 182 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/exception_ptr.h" 3
const class std::type_info*
__cxa_exception_type() const noexcept
__attribute__ ((__pure__));
};

inline
exception_ptr::exception_ptr() noexcept
: _M_exception_object(0)
{ }

inline
exception_ptr::exception_ptr(const exception_ptr& __other)
noexcept
: _M_exception_object(__other._M_exception_object)
{
if (_M_exception_object)
_M_addref();
}

inline
exception_ptr::~exception_ptr() noexcept
{
if (_M_exception_object)
_M_release();
}

inline exception_ptr&
exception_ptr::operator=(const exception_ptr& __other) noexcept
{
exception_ptr(__other).swap(*this);
return *this;
}

inline void
exception_ptr::swap(exception_ptr &__other) noexcept
{
void *__tmp = _M_exception_object;
_M_exception_object = __other._M_exception_object;
__other._M_exception_object = __tmp;
}

inline void
swap(exception_ptr& __lhs, exception_ptr& __rhs)
{ __lhs.swap(__rhs); }

template<typename _Ex>

inline void
__dest_thunk(void* __x)
{ static_cast<_Ex*>(__x)->~_Ex(); }

using __exception_ptr::swap;

template<typename _Ex>
exception_ptr
make_exception_ptr(_Ex __ex) noexcept
{

using _Ex2 = typename decay<_Ex>::type;

void* __e = __cxxabiv1::__cxa_allocate_exception(sizeof(_Ex));
(void) __cxxabiv1::__cxa_init_primary_exception(
__e, const_cast<std::type_info*>(&typeid(_Ex)),
__exception_ptr::__dest_thunk<_Ex2>);
try
{
::new (__e) _Ex2(__ex);
return exception_ptr(__e);
}
catch(...)
{
__cxxabiv1::__cxa_free_exception(__e);
return current_exception();
}
# 277 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/exception_ptr.h" 3
}
# 291 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/exception_ptr.h" 3
}

}
# 167 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/exception" 2 3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/nested_exception.h" 1 3
# 40 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/nested_exception.h" 3
extern "C++" {

namespace std
{
# 59 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/nested_exception.h" 3
class nested_exception
{
exception_ptr _M_ptr;

public:

nested_exception() noexcept : _M_ptr(current_exception()) { }

nested_exception(const nested_exception&) noexcept = default;

nested_exception& operator=(const nested_exception&) noexcept = default;

virtual ~nested_exception() noexcept;

[[noreturn]]
void
rethrow_nested() const
{
if (_M_ptr)
rethrow_exception(_M_ptr);
std::terminate();
}

exception_ptr
nested_ptr() const noexcept
{ return _M_ptr; }
};

template<typename _Except>
struct _Nested_exception : public _Except, public nested_exception
{
explicit _Nested_exception(const _Except& __ex)
: _Except(__ex)
{ }

explicit _Nested_exception(_Except&& __ex)

: _Except(static_cast<_Except&&>(__ex))
{ }
};
# 145 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/nested_exception.h" 3
template<typename _Tp>
[[noreturn]]
inline void
throw_with_nested(_Tp&& __t)
{
using _Up = typename decay<_Tp>::type;
using _CopyConstructible
= __and_<is_copy_constructible<_Up>, is_move_constructible<_Up>>;
static_assert(_CopyConstructible::value,
"throw_with_nested argument must be CopyConstructible");

if constexpr (is_class_v<_Up>)
if constexpr (!is_final_v<_Up>)
if constexpr (!is_base_of_v<nested_exception, _Up>)
throw _Nested_exception<_Up>{std::forward<_Tp>(__t)};
throw std::forward<_Tp>(__t);

}
# 203 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/nested_exception.h" 3
template<typename _Ex>

inline void
rethrow_if_nested(const _Ex& __ex)
{
const _Ex* __ptr = __builtin_addressof(__ex);
# 223 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/nested_exception.h" 3
if constexpr (!is_polymorphic_v<_Ex>)
return;
else if constexpr (is_base_of_v<nested_exception, _Ex>
&& !is_convertible_v<_Ex*, nested_exception*>)
return;

else if (auto __ne_ptr = dynamic_cast<const nested_exception*>(__ptr))

__ne_ptr->rethrow_nested();

}
# 168 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/exception" 2 3
# 39 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/stdexcept" 2 3

namespace std
{

struct __cow_string
{
union {
const char* _M_p;
char _M_bytes[sizeof(const char*)];
};

__cow_string();
__cow_string(const std::string&);
__cow_string(const char*, size_t);
__cow_string(const __cow_string&) noexcept;
__cow_string& operator=(const __cow_string&) noexcept;
~__cow_string();

__cow_string(__cow_string&&) noexcept;
__cow_string& operator=(__cow_string&&) noexcept;

};

typedef basic_string<char> __sso_string;

# 113 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/stdexcept" 3
class logic_error : public exception
{
__cow_string _M_msg;

public:

explicit
logic_error(const string& __arg) ;

explicit
logic_error(const char*) ;

logic_error(logic_error&&) noexcept;
logic_error& operator=(logic_error&&) noexcept;

logic_error(const logic_error&) noexcept;

logic_error& operator=(const logic_error&) noexcept;

virtual ~logic_error() noexcept;

virtual const char*

virtual ~out_of_range() noexcept;

};
class runtime_error : public exception
{
__cow_string _M_msg;

public:

explicit
runtime_error(const string& __arg) ;

explicit
runtime_error(const char*) ;

runtime_error(runtime_error&&) noexcept;
runtime_error& operator=(runtime_error&&) noexcept;

runtime_error(const runtime_error&) noexcept;

runtime_error& operator=(const runtime_error&) noexcept;

virtual ~runtime_error() noexcept;

virtual const char*

what() const noexcept;

};

class range_error : public runtime_error

{
public:
explicit range_error(const string& __arg) ;

explicit range_error(const char*) ;

range_error(const range_error&) = default;
range_error& operator=(const range_error&) = default;
range_error(range_error&&) = default;
range_error& operator=(range_error&&) = default;

virtual ~range_error() noexcept;

};

class overflow_error : public runtime_error

{
public:
explicit overflow_error(const string& __arg) ;

explicit overflow_error(const char*) ;

overflow_error(const overflow_error&) = default;
overflow_error& operator=(const overflow_error&) = default;
overflow_error(overflow_error&&) = default;
overflow_error& operator=(overflow_error&&) = default;

virtual ~overflow_error() noexcept;

};

class underflow_error : public runtime_error

{
public:
explicit underflow_error(const string& __arg) ;

explicit underflow_error(const char*) ;

underflow_error(const underflow_error&) = default;
underflow_error& operator=(const underflow_error&) = default;
underflow_error(underflow_error&&) = default;
underflow_error& operator=(underflow_error&&) = default;

virtual ~underflow_error() noexcept;

};

}
# 44 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/system_error" 2 3

namespace std
{

class error_code;
class error_condition;
class system_error;

template<typename _Tp>
struct is_error_code_enum : public false_type { };

template<typename _Tp>
struct is_error_condition_enum : public false_type { };

template<>
struct is_error_condition_enum<errc>
: public true_type { };

template <typename _Tp>

inline constexpr bool is_error_code_enum_v =
is_error_code_enum<_Tp>::value;
template <typename _Tp>
inline constexpr bool is_error_condition_enum_v =
is_error_condition_enum<_Tp>::value;

inline namespace _V2 {

# 106 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/system_error" 3
class error_category
{
public:
constexpr error_category() noexcept = default;

virtual ~error_category();

error_category(const error_category&) = delete;

error_category& operator=(const error_category&) = delete;

virtual const char*

name() const noexcept = 0;

private:
__attribute ((__abi_tag__ ("cxx11")))
virtual __cow_string
_M_message(int) const;

public:

attribute ((abi_tag__ ("cxx11")))

virtual string
message(int) const = 0;
# 144 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/system_error" 3
public:

virtual error_condition
default_error_condition(int __i) const noexcept;

virtual bool
equivalent(int __i, const error_condition& __cond) const noexcept;

virtual bool
equivalent(const error_code& __code, int __i) const noexcept;

[[__nodiscard__]]
bool
operator==(const error_category& __other) const noexcept
{ return this == &__other; }

[[nodiscard]]
strong_ordering
operator<=>(const error_category& __rhs) const noexcept
{ return std::compare_three_way()(this, &__rhs); }
# 178 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/system_error" 3
};

[[__nodiscard__, __gnu__::__const__]]
const error_category&
generic_category() noexcept;

[[__nodiscard__, __gnu__::__const__]]
const error_category&
system_category() noexcept;

namespace __adl_only
{
void make_error_code() = delete;
void make_error_condition() = delete;
}
# 223 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/system_error" 3
class error_code
{
template<typename _ErrorCodeEnum>
using _Check
= __enable_if_t<is_error_code_enum<_ErrorCodeEnum>::value>;

public:
error_code() noexcept
: _M_value(0), _M_cat(&system_category()) { }

error_code(int __v, const error_category& __cat) noexcept

: _M_value(__v), _M_cat(&__cat) { }

template<typename _ErrorCodeEnum,
typename = _Check<_ErrorCodeEnum>>
error_code(_ErrorCodeEnum __e) noexcept
{
using __adl_only::make_error_code;
*this = make_error_code(__e);
}

error_code(const error_code&) = default;

error_code& operator=(const error_code&) = default;

void
assign(int __v, const error_category& __cat) noexcept
{
_M_value = __v;
_M_cat = &__cat;
}

void
clear() noexcept
{ assign(0, system_category()); }

[[__nodiscard__]]
int
value() const noexcept { return _M_value; }

[[__nodiscard__]]
const error_category&
category() const noexcept { return *_M_cat; }

error_condition
default_error_condition() const noexcept;

attribute ((abi_tag__ ("cxx11")))

string
message() const
{ return category().message(value()); }

[[__nodiscard__]]
explicit operator bool() const noexcept
{ return _M_value != 0; }

private:
int _M_value;
const error_category* _M_cat;
};
# 300 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/system_error" 3
[[__nodiscard__]]
inline error_code
make_error_code(errc __e) noexcept
{ return error_code(static_cast<int>(__e), generic_category()); }
# 314 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/system_error" 3
[[nodiscard]]
inline strong_ordering
operator<=>(const error_code& __lhs, const error_code& __rhs) noexcept
{
if (auto __c = __lhs.category() <=> __rhs.category(); __c != 0)
return __c;
return __lhs.value() <=> __rhs.value();
}
# 337 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/system_error" 3
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os, const error_code& __e)
{ return (__os << __e.category().name() << ':' << __e.value()); }
# 354 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/system_error" 3
class error_condition
{
template<typename _ErrorConditionEnum>
using _Check
= __enable_if_t<is_error_condition_enum<_ErrorConditionEnum>::value>;

public:

error_condition() noexcept
: _M_value(0), _M_cat(&generic_category()) { }

error_condition(int __v, const error_category& __cat) noexcept

: _M_value(__v), _M_cat(&__cat) { }

template<typename _ErrorConditionEnum,
typename = _Check<_ErrorConditionEnum>>
error_condition(_ErrorConditionEnum __e) noexcept
{
using __adl_only::make_error_condition;
*this = make_error_condition(__e);
}

error_condition(const error_condition&) = default;

error_condition& operator=(const error_condition&) = default;

void
assign(int __v, const error_category& __cat) noexcept
{
_M_value = __v;
_M_cat = &__cat;
}

void
clear() noexcept
{ assign(0, generic_category()); }

[[__nodiscard__]]
int
value() const noexcept { return _M_value; }

[[__nodiscard__]]
const error_category&
category() const noexcept { return *_M_cat; }
__attribute ((__abi_tag__ ("cxx11")))
string
message() const
{ return category().message(value()); }

[[__nodiscard__]]
explicit operator bool() const noexcept
{ return _M_value != 0; }

private:
int _M_value;
const error_category* _M_cat;
};
# 433 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/system_error" 3
[[__nodiscard__]]
inline error_condition
make_error_condition(errc __e) noexcept
{ return error_condition(static_cast<int>(__e), generic_category()); }
# 447 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/system_error" 3
[[__nodiscard__]]
inline bool
operator==(const error_code& __lhs, const error_code& __rhs) noexcept
{
return __lhs.category() == __rhs.category()
&& __lhs.value() == __rhs.value();
}
# 463 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/system_error" 3
[[__nodiscard__]]
inline bool
operator==(const error_code& __lhs, const error_condition& __rhs) noexcept
{
return __lhs.category().equivalent(__lhs.value(), __rhs)
|| __rhs.category().equivalent(__lhs, __rhs.value());
}
# 478 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/system_error" 3
[[__nodiscard__]]
inline bool
operator==(const error_condition& __lhs,
const error_condition& __rhs) noexcept
{
return __lhs.category() == __rhs.category()
&& __lhs.value() == __rhs.value();
}
# 496 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/system_error" 3
[[nodiscard]]
inline strong_ordering
operator<=>(const error_condition& __lhs,
const error_condition& __rhs) noexcept
{
if (auto __c = __lhs.category() <=> __rhs.category(); __c != 0)
return __c;
return __lhs.value() <=> __rhs.value();
}
# 556 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/system_error" 3
class system_error : public std::runtime_error
{
private:
error_code _M_code;

public:
system_error(error_code __ec = error_code())
: runtime_error(__ec.message()), _M_code(__ec) { }

system_error(error_code ec, const string& what)

: runtime_error(__what + (": " + __ec.message())), _M_code(__ec) { }

system_error(error_code ec, const char* what)

: runtime_error(__what + (": " + __ec.message())), _M_code(__ec) { }

system_error(int __v, const error_category& ecat, const char* what)

: system_error(error_code(__v, __ecat), __what) { }

system_error(int __v, const error_category& __ecat)

: runtime_error(error_code(__v, __ecat).message()),
_M_code(__v, __ecat) { }

system_error(int __v, const error_category& ecat, const string& what)

: runtime_error(__what + (": " + error_code(__v, __ecat).message())),
_M_code(__v, __ecat) { }

system_error (const system_error &) = default;

system_error &operator= (const system_error &) = default;

virtual ~system_error() noexcept;

const error_code&
code() const noexcept { return _M_code; }
};

namespace std
{

template<>
struct hash<error_code>
: public __hash_base<size_t, error_code>
{
size_t
operator()(const error_code& __e) const noexcept
{
const size_t __tmp = std::_Hash_impl::hash(__e.value());
return std::_Hash_impl::__hash_combine(&__e.category(), __tmp);
}
};
template<>
struct hash<error_condition>
: public __hash_base<size_t, error_condition>
{
size_t
operator()(const error_condition& __e) const noexcept
{
const size_t __tmp = std::_Hash_impl::hash(__e.value());
return std::_Hash_impl::__hash_combine(&__e.category(), __tmp);
}
};

}
# 47 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/ios_base.h" 2 3

namespace std
{

enum _Ios_Fmtflags
{
_S_boolalpha = 1L << 0,
_S_dec = 1L << 1,
_S_fixed = 1L << 2,
_S_hex = 1L << 3,
_S_internal = 1L << 4,
_S_left = 1L << 5,
_S_oct = 1L << 6,
_S_right = 1L << 7,
_S_scientific = 1L << 8,
_S_showbase = 1L << 9,
_S_showpoint = 1L << 10,
_S_showpos = 1L << 11,
_S_skipws = 1L << 12,
_S_unitbuf = 1L << 13,
_S_uppercase = 1L << 14,
_S_adjustfield = _S_left | _S_right | _S_internal,
_S_basefield = _S_dec | _S_oct | _S_hex,
_S_floatfield = _S_scientific | _S_fixed,
_S_ios_fmtflags_end = 1L << 16,
_S_ios_fmtflags_max = 0x7fffffff,
_S_ios_fmtflags_min = ~0x7fffffff
};

[[__nodiscard__]] constexpr
inline _Ios_Fmtflags
operator&(_Ios_Fmtflags __a, _Ios_Fmtflags __b) noexcept
{ return _Ios_Fmtflags(static_cast<int>(__a) & static_cast<int>(__b)); }

[[__nodiscard__]] constexpr
inline _Ios_Fmtflags
operator|(_Ios_Fmtflags __a, _Ios_Fmtflags __b) noexcept
{ return _Ios_Fmtflags(static_cast<int>(__a) | static_cast<int>(__b)); }

[[__nodiscard__]] constexpr
inline _Ios_Fmtflags
operator^(_Ios_Fmtflags __a, _Ios_Fmtflags __b) noexcept
{ return _Ios_Fmtflags(static_cast<int>(__a) ^ static_cast<int>(__b)); }

[[__nodiscard__]] constexpr
inline _Ios_Fmtflags
operator~(_Ios_Fmtflags __a) noexcept
{ return _Ios_Fmtflags(~static_cast<int>(__a)); }

constexpr
inline const _Ios_Fmtflags&
operator|=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b) noexcept
{ return __a = __a | __b; }

constexpr
inline const _Ios_Fmtflags&
operator&=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b) noexcept
{ return __a = __a & __b; }

constexpr
inline const _Ios_Fmtflags&
operator^=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b) noexcept
{ return __a = __a ^ __b; }

enum _Ios_Openmode
{
_S_app = 1L << 0,
_S_ate = 1L << 1,
_S_bin = 1L << 2,
_S_in = 1L << 3,
_S_out = 1L << 4,
_S_trunc = 1L << 5,
_S_noreplace = 1L << 6,
_S_ios_openmode_end = 1L << 16,
_S_ios_openmode_max = 0x7fffffff,
_S_ios_openmode_min = ~0x7fffffff
};

[[__nodiscard__]] constexpr
inline _Ios_Openmode
operator&(_Ios_Openmode __a, _Ios_Openmode __b) noexcept
{ return _Ios_Openmode(static_cast<int>(__a) & static_cast<int>(__b)); }

[[__nodiscard__]] constexpr
inline _Ios_Openmode
operator|(_Ios_Openmode __a, _Ios_Openmode __b) noexcept
{ return _Ios_Openmode(static_cast<int>(__a) | static_cast<int>(__b)); }

[[__nodiscard__]] constexpr
inline _Ios_Openmode
operator^(_Ios_Openmode __a, _Ios_Openmode __b) noexcept
{ return _Ios_Openmode(static_cast<int>(__a) ^ static_cast<int>(__b)); }

[[__nodiscard__]] constexpr
inline _Ios_Openmode
operator~(_Ios_Openmode __a) noexcept
{ return _Ios_Openmode(~static_cast<int>(__a)); }

constexpr
inline const _Ios_Openmode&
operator|=(_Ios_Openmode& __a, _Ios_Openmode __b) noexcept
{ return __a = __a | __b; }

constexpr
inline const _Ios_Openmode&
operator&=(_Ios_Openmode& __a, _Ios_Openmode __b) noexcept
{ return __a = __a & __b; }

constexpr
inline const _Ios_Openmode&
operator^=(_Ios_Openmode& __a, _Ios_Openmode __b) noexcept
{ return __a = __a ^ __b; }

enum _Ios_Iostate
{
_S_goodbit = 0,
_S_badbit = 1L << 0,
_S_eofbit = 1L << 1,
_S_failbit = 1L << 2,
_S_ios_iostate_end = 1L << 16,
_S_ios_iostate_max = 0x7fffffff,
_S_ios_iostate_min = ~0x7fffffff
};

[[__nodiscard__]] constexpr
inline _Ios_Iostate
operator&(_Ios_Iostate __a, _Ios_Iostate __b) noexcept
{ return _Ios_Iostate(static_cast<int>(__a) & static_cast<int>(__b)); }

[[__nodiscard__]] constexpr
inline _Ios_Iostate
operator|(_Ios_Iostate __a, _Ios_Iostate __b) noexcept
{ return _Ios_Iostate(static_cast<int>(__a) | static_cast<int>(__b)); }

[[__nodiscard__]] constexpr
inline _Ios_Iostate
operator^(_Ios_Iostate __a, _Ios_Iostate __b) noexcept
{ return _Ios_Iostate(static_cast<int>(__a) ^ static_cast<int>(__b)); }

[[__nodiscard__]] constexpr
inline _Ios_Iostate
operator~(_Ios_Iostate __a) noexcept
{ return _Ios_Iostate(~static_cast<int>(__a)); }

constexpr
inline const _Ios_Iostate&
operator|=(_Ios_Iostate& __a, _Ios_Iostate __b) noexcept
{ return __a = __a | __b; }

constexpr
inline const _Ios_Iostate&
operator&=(_Ios_Iostate& __a, _Ios_Iostate __b) noexcept
{ return __a = __a & __b; }

constexpr
inline const _Ios_Iostate&
operator^=(_Ios_Iostate& __a, _Ios_Iostate __b) noexcept
{ return __a = __a ^ __b; }

enum _Ios_Seekdir
{
_S_beg = 0,
_S_cur = 1,
_S_end = 2,
_S_ios_seekdir_end = 1L << 16
};

enum class io_errc { stream = 1 };

template <> struct is_error_code_enum<io_errc> : public true_type { };

[[__nodiscard__, __gnu__::__const__]]
const error_category&
iostream_category() noexcept;

[[__nodiscard__]]
inline error_code
make_error_code(io_errc __e) noexcept
{ return error_code(static_cast<int>(__e), iostream_category()); }

[[__nodiscard__]]
inline error_condition
make_error_condition(io_errc __e) noexcept
{ return error_condition(static_cast<int>(__e), iostream_category()); }
# 254 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/ios_base.h" 3
class ios_base
{
# 272 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/ios_base.h" 3
public:
# 281 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/ios_base.h" 3
class __attribute ((__abi_tag__ ("cxx11"))) failure : public system_error
{
public:
explicit
failure(const string& __str);

explicit
failure(const string&, const error_code&);

explicit
failure(const char*, const error_code& = io_errc::stream);
virtual
~failure() throw();

virtual const char*

what() const throw();
};
# 367 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/ios_base.h" 3
typedef _Ios_Fmtflags fmtflags;

static const fmtflags boolalpha = _S_boolalpha;

static const fmtflags dec = _S_dec;

static const fmtflags fixed = _S_fixed;

static const fmtflags hex = _S_hex;

static const fmtflags internal = _S_internal;

static const fmtflags left = _S_left;

static const fmtflags oct = _S_oct;

static const fmtflags right = _S_right;

static const fmtflags scientific = _S_scientific;

static const fmtflags showbase = _S_showbase;

static const fmtflags showpoint = _S_showpoint;

static const fmtflags showpos = _S_showpos;

static const fmtflags skipws = _S_skipws;

static const fmtflags unitbuf = _S_unitbuf;

static const fmtflags uppercase = _S_uppercase;

static const fmtflags adjustfield = _S_adjustfield;

static const fmtflags basefield = _S_basefield;

static const fmtflags floatfield = _S_floatfield;

# 442 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/ios_base.h" 3
typedef _Ios_Iostate iostate;

static const iostate badbit = _S_badbit;

static const iostate eofbit = _S_eofbit;

static const iostate failbit = _S_failbit;

static const iostate goodbit = _S_goodbit;

# 473 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/ios_base.h" 3
typedef _Ios_Openmode openmode;

static const openmode app = _S_app;

static const openmode ate = _S_ate;

static const openmode binary = _S_bin;

static const openmode in = _S_in;

static const openmode out = _S_out;

static const openmode trunc = _S_trunc;

static const openmode __noreplace = _S_noreplace;

static const openmode noreplace = _S_noreplace;

# 512 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/ios_base.h" 3
typedef _Ios_Seekdir seekdir;
static const seekdir beg = _S_beg;

static const seekdir cur = _S_cur;

static const seekdir end = _S_end;

# 545 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/ios_base.h" 3
enum event
{
erase_event,
imbue_event,
copyfmt_event
};
# 562 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/ios_base.h" 3
typedef void (*event_callback) (event __e, ios_base& __b, int __i);
# 574 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/ios_base.h" 3
void
register_callback(event_callback __fn, int __index);

protected:
streamsize _M_precision;
streamsize _M_width;
fmtflags _M_flags;
iostate _M_exception;
iostate _M_streambuf_state;

struct _Callback_list
{

_Callback_list* _M_next;
ios_base::event_callback _M_fn;
int _M_index;
_Atomic_word _M_refcount;

_Callback_list(ios_base::event_callback fn, int index,

_Callback_list* __cb)
: _M_next(__cb), _M_fn(__fn), _M_index(__index), _M_refcount(0) { }

void
_M_add_reference() { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }

int
_M_remove_reference()
{

;
int __res = __gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1);
if (__res == 0)
{
;
}
return __res;
}
};
_Callback_list* _M_callbacks;

void
_M_call_callbacks(event __ev) throw();

void
_M_dispose_callbacks(void) throw();

struct _Words
{
void* _M_pword;
long _M_iword;
_Words() : _M_pword(0), _M_iword(0) { }
};

_Words _M_word_zero;

enum { _S_local_word_size = 8 };
_Words _M_local_word[_S_local_word_size];

int _M_word_size;
_Words* _M_word;

_Words&
_M_grow_words(int __index, bool __iword);

locale _M_ios_locale;

void
_M_init() throw();

public:

class Init
{
friend class ios_base;
public:
Init();
~Init();

Init(const Init&) = default;

Init& operator=(const Init&) = default;

private:
static _Atomic_word _S_refcount;
static bool _S_synced_with_stdio;
};

fmtflags
flags() const
{ return _M_flags; }
# 692 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/ios_base.h" 3
fmtflags
flags(fmtflags __fmtfl)
{
fmtflags __old = _M_flags;
_M_flags = __fmtfl;
return __old;
}
# 708 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/ios_base.h" 3
fmtflags
setf(fmtflags __fmtfl)
{
fmtflags __old = _M_flags;
_M_flags |= __fmtfl;
return __old;
}
# 725 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/ios_base.h" 3
fmtflags
setf(fmtflags __fmtfl, fmtflags __mask)
{
fmtflags __old = _M_flags;
_M_flags &= ~__mask;
_M_flags |= (__fmtfl & __mask);
return __old;
}

void
unsetf(fmtflags __mask)
{ _M_flags &= ~__mask; }
# 751 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/ios_base.h" 3
streamsize
precision() const
{ return _M_precision; }

streamsize
precision(streamsize __prec)
{
streamsize __old = _M_precision;
_M_precision = __prec;
return __old;
}

streamsize
width() const
{ return _M_width; }

streamsize
width(streamsize __wide)
{
streamsize __old = _M_width;
_M_width = __wide;
return __old;
}
# 802 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/ios_base.h" 3
static bool
sync_with_stdio(bool __sync = true);
# 814 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/ios_base.h" 3
locale
imbue(const locale& __loc) throw();
# 825 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/ios_base.h" 3
locale
getloc() const
{ return _M_ios_locale; }
# 836 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/ios_base.h" 3
const locale&
_M_getloc() const
{ return _M_ios_locale; }
# 855 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/ios_base.h" 3
static int
xalloc() throw();
# 871 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/ios_base.h" 3
long&
iword(int __ix)
{
_Words& __word = ((unsigned)__ix < (unsigned)_M_word_size)
? _M_word[__ix] : _M_grow_words(__ix, true);
return __word._M_iword;
}
# 892 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/ios_base.h" 3
void*&
pword(int __ix)
{
_Words& __word = ((unsigned)__ix < (unsigned)_M_word_size)
? _M_word[__ix] : _M_grow_words(__ix, false);
return __word._M_pword;
}
# 909 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/ios_base.h" 3
virtual ~ios_base();

protected:
ios_base() throw ();
# 923 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/ios_base.h" 3
public:
ios_base(const ios_base&) = delete;

ios_base&
operator=(const ios_base&) = delete;

protected:
void
_M_move(ios_base&) noexcept;

void
_M_swap(ios_base& __rhs) noexcept;

};

inline ios_base&
boolalpha(ios_base& __base)
{
__base.setf(ios_base::boolalpha);
return __base;
}

inline ios_base&
noboolalpha(ios_base& __base)
{
__base.unsetf(ios_base::boolalpha);
return __base;
}

inline ios_base&
showbase(ios_base& __base)
{
__base.setf(ios_base::showbase);
return __base;
}

inline ios_base&
noshowbase(ios_base& __base)
{
__base.unsetf(ios_base::showbase);
return __base;
}

inline ios_base&
showpoint(ios_base& __base)
{
__base.setf(ios_base::showpoint);
return __base;
}

inline ios_base&
noshowpoint(ios_base& __base)
{
__base.unsetf(ios_base::showpoint);
return __base;
}

inline ios_base&
showpos(ios_base& __base)
{
__base.setf(ios_base::showpos);
return __base;
}

inline ios_base&
noshowpos(ios_base& __base)
{
__base.unsetf(ios_base::showpos);
return __base;
}

inline ios_base&
skipws(ios_base& __base)
{
__base.setf(ios_base::skipws);
return __base;
}

inline ios_base&
noskipws(ios_base& __base)
{
__base.unsetf(ios_base::skipws);
return __base;
}

inline ios_base&
uppercase(ios_base& __base)
{
__base.setf(ios_base::uppercase);
return __base;
}

inline ios_base&
nouppercase(ios_base& __base)
{
__base.unsetf(ios_base::uppercase);
return __base;
}
inline ios_base&
unitbuf(ios_base& __base)
{
__base.setf(ios_base::unitbuf);
return __base;
}

inline ios_base&
nounitbuf(ios_base& __base)
{
__base.unsetf(ios_base::unitbuf);
return __base;
}

inline ios_base&
internal(ios_base& __base)
{
__base.setf(ios_base::internal, ios_base::adjustfield);
return __base;
}

inline ios_base&
left(ios_base& __base)
{
__base.setf(ios_base::left, ios_base::adjustfield);
return __base;
}

inline ios_base&
right(ios_base& __base)
{
__base.setf(ios_base::right, ios_base::adjustfield);
return __base;
}

inline ios_base&
dec(ios_base& __base)
{
__base.setf(ios_base::dec, ios_base::basefield);
return __base;
}

inline ios_base&
hex(ios_base& __base)
{
__base.setf(ios_base::hex, ios_base::basefield);
return __base;
}
inline ios_base&
oct(ios_base& __base)
{
__base.setf(ios_base::oct, ios_base::basefield);
return __base;
}

inline ios_base&
fixed(ios_base& __base)
{
__base.setf(ios_base::fixed, ios_base::floatfield);
return __base;
}

inline ios_base&
scientific(ios_base& __base)
{
__base.setf(ios_base::scientific, ios_base::floatfield);
return __base;
}

inline ios_base&
hexfloat(ios_base& __base)
{
__base.setf(ios_base::fixed | ios_base::scientific, ios_base::floatfield);
return __base;
}

inline ios_base&
defaultfloat(ios_base& __base)
{
__base.unsetf(ios_base::floatfield);
return __base;
}

}
# 44 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 2 3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/streambuf" 1 3
# 36 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/streambuf" 3

# 37 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/streambuf" 3
# 47 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/streambuf" 3
namespace std
{
template<typename _CharT, typename _Traits>
streamsize
__copy_streambufs_eof(basic_streambuf<_CharT, _Traits>*,
basic_streambuf<_CharT, _Traits>*, bool&);
# 123 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/streambuf" 3
template<typename _CharT, typename _Traits>
class basic_streambuf
{
public:

typedef _CharT char_type;

typedef _Traits traits_type;
typedef typename traits_type::int_type int_type;
typedef typename traits_type::pos_type pos_type;
typedef typename traits_type::off_type off_type;

typedef basic_streambuf<char_type, traits_type> __streambuf_type;

friend class basic_ios<char_type, traits_type>;

friend class basic_istream<char_type, traits_type>;
friend class basic_ostream<char_type, traits_type>;
friend class istreambuf_iterator<char_type, traits_type>;
friend class ostreambuf_iterator<char_type, traits_type>;

friend streamsize
__copy_streambufs_eof<>(basic_streambuf*, basic_streambuf*, bool&);

template<bool _IsMove, typename _CharT2>

friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
_CharT2*>::__type
__copy_move_a2(istreambuf_iterator<_CharT2>,
istreambuf_iterator<_CharT2>, _CharT2*);

template<typename _CharT2>
friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
istreambuf_iterator<_CharT2> >::__type
find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
const _CharT2&);

template<typename _CharT2, typename _Distance>

friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
void>::__type
advance(istreambuf_iterator<_CharT2>&, _Distance);

friend void __istream_extract(istream&, char*, streamsize);

template<typename _CharT2, typename _Traits2, typename _Alloc>

friend basic_istream<_CharT2, _Traits2>&
operator>>(basic_istream<_CharT2, _Traits2>&,
basic_string<_CharT2, _Traits2, _Alloc>&);
template<typename _CharT2, typename _Traits2, typename _Alloc>
friend basic_istream<_CharT2, _Traits2>&
getline(basic_istream<_CharT2, _Traits2>&,
basic_string<_CharT2, _Traits2, _Alloc>&, _CharT2);

protected:

char_type* _M_in_beg;
char_type* _M_in_cur;
char_type* _M_in_end;
char_type* _M_out_beg;
char_type* _M_out_cur;
char_type* _M_out_end;

locale _M_buf_locale;

public:

virtual
~basic_streambuf()
{ }
# 215 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/streambuf" 3
locale
pubimbue(const locale& __loc)
{
locale __tmp(this->getloc());
this->imbue(__loc);
_M_buf_locale = __loc;
return __tmp;
}
# 232 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/streambuf" 3
locale
getloc() const
{ return _M_buf_locale; }
# 245 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/streambuf" 3
basic_streambuf*
pubsetbuf(char_type* __s, streamsize __n)
{ return this->setbuf(__s, __n); }
# 257 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/streambuf" 3
pos_type
pubseekoff(off_type __off, ios_base::seekdir __way,
ios_base::openmode __mode = ios_base::in | ios_base::out)
{ return this->seekoff(__off, __way, __mode); }
# 269 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/streambuf" 3
pos_type
pubseekpos(pos_type __sp,
ios_base::openmode __mode = ios_base::in | ios_base::out)
{ return this->seekpos(__sp, __mode); }
int
pubsync() { return this->sync(); }
# 290 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/streambuf" 3
streamsize
in_avail()
{
const streamsize __ret = this->egptr() - this->gptr();
return __ret ? __ret : this->showmanyc();
}
# 304 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/streambuf" 3
int_type
snextc()
{
int_type __ret = traits_type::eof();
if (__builtin_expect(!traits_type::eq_int_type(this->sbumpc(),
__ret), true))
__ret = this->sgetc();
return __ret;
}
# 322 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/streambuf" 3
int_type
sbumpc()
{
int_type __ret;
if (__builtin_expect(this->gptr() < this->egptr(), true))
{
__ret = traits_type::to_int_type(*this->gptr());
this->gbump(1);
}
else
__ret = this->uflow();
return __ret;
}
# 344 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/streambuf" 3
int_type
sgetc()
{
int_type __ret;
if (__builtin_expect(this->gptr() < this->egptr(), true))
__ret = traits_type::to_int_type(*this->gptr());
else
__ret = this->underflow();
return __ret;
}
# 363 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/streambuf" 3
streamsize
sgetn(char_type* __s, streamsize __n)
{ return this->xsgetn(__s, __n); }
# 378 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/streambuf" 3
int_type
sputbackc(char_type __c)
{
int_type __ret;
const bool __testpos = this->eback() < this->gptr();
if (__builtin_expect(!__testpos ||
!traits_type::eq(__c, this->gptr()[-1]), false))
__ret = this->pbackfail(traits_type::to_int_type(__c));
else
{
this->gbump(-1);
__ret = traits_type::to_int_type(*this->gptr());
}
return __ret;
}
# 403 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/streambuf" 3
int_type
sungetc()
{
int_type __ret;
if (__builtin_expect(this->eback() < this->gptr(), true))
{
this->gbump(-1);
__ret = traits_type::to_int_type(*this->gptr());
}
else
__ret = this->pbackfail();
return __ret;
}
# 430 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/streambuf" 3
int_type
sputc(char_type __c)
{
int_type __ret;
if (__builtin_expect(this->pptr() < this->epptr(), true))
{
*this->pptr() = __c;
this->pbump(1);
__ret = traits_type::to_int_type(__c);
}
else
__ret = this->overflow(traits_type::to_int_type(__c));
return __ret;
}
# 456 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/streambuf" 3
streamsize
sputn(const char_type* __s, streamsize __n)
{ return this->xsputn(__s, __n); }

protected:
# 470 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/streambuf" 3
basic_streambuf()
: _M_in_beg(0), _M_in_cur(0), _M_in_end(0),
_M_out_beg(0), _M_out_cur(0), _M_out_end(0),
_M_buf_locale(locale())
{ }
# 488 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/streambuf" 3
char_type*
eback() const { return _M_in_beg; }

char_type*
gptr() const { return _M_in_cur; }

char_type*
egptr() const { return _M_in_end; }
# 504 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/streambuf" 3
void
gbump(int __n) { _M_in_cur += __n; }
# 515 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/streambuf" 3
void
setg(char_type* __gbeg, char_type* __gnext, char_type* __gend)
{
_M_in_beg = __gbeg;
_M_in_cur = __gnext;
_M_in_end = __gend;
}
# 535 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/streambuf" 3
char_type*
pbase() const { return _M_out_beg; }

char_type*
pptr() const { return _M_out_cur; }

char_type*
epptr() const { return _M_out_end; }
# 551 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/streambuf" 3
void
pbump(int __n) { _M_out_cur += __n; }
# 561 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/streambuf" 3
void
setp(char_type* __pbeg, char_type* __pend)
{
_M_out_beg = _M_out_cur = __pbeg;
_M_out_end = __pend;
}
# 582 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/streambuf" 3
virtual void
imbue(const locale& __loc __attribute__ ((__unused__)))
{ }
# 597 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/streambuf" 3
virtual basic_streambuf<char_type,_Traits>*
setbuf(char_type*, streamsize)
{ return this; }
# 608 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/streambuf" 3
virtual pos_type
seekoff(off_type, ios_base::seekdir,
ios_base::openmode = ios_base::in | ios_base::out)
{ return pos_type(off_type(-1)); }
# 620 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/streambuf" 3
virtual pos_type
seekpos(pos_type,
ios_base::openmode = ios_base::in | ios_base::out)
{ return pos_type(off_type(-1)); }
# 633 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/streambuf" 3
virtual int
sync() { return 0; }
# 655 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/streambuf" 3
virtual streamsize
showmanyc() { return 0; }
# 671 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/streambuf" 3
virtual streamsize
xsgetn(char_type* __s, streamsize __n);
# 693 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/streambuf" 3
virtual int_type
underflow()
{ return traits_type::eof(); }
# 706 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/streambuf" 3
virtual int_type
uflow()
{
int_type __ret = traits_type::eof();
const bool __testeof = traits_type::eq_int_type(this->underflow(),
__ret);
if (!__testeof)
{
__ret = traits_type::to_int_type(*this->gptr());
this->gbump(1);
}
return __ret;
}
# 730 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/streambuf" 3
virtual int_type
pbackfail(int_type __c __attribute__ ((__unused__)) = traits_type::eof())
{ return traits_type::eof(); }
# 748 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/streambuf" 3
virtual streamsize
xsputn(const char_type* __s, streamsize __n);
# 774 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/streambuf" 3
virtual int_type
overflow(int_type __c __attribute__ ((__unused__)) = traits_type::eof())
{ return traits_type::eof(); }
# 801 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/streambuf" 3
void
__safe_gbump(streamsize __n) { _M_in_cur += __n; }

void
__safe_pbump(streamsize __n) { _M_out_cur += __n; }

protected:

basic_streambuf(const basic_streambuf&);

basic_streambuf&
operator=(const basic_streambuf&);

void
swap(basic_streambuf& __sb)
{
std::swap(_M_in_beg, __sb._M_in_beg);
std::swap(_M_in_cur, __sb._M_in_cur);
std::swap(_M_in_end, __sb._M_in_end);
std::swap(_M_out_beg, __sb._M_out_beg);
std::swap(_M_out_cur, __sb._M_out_cur);
std::swap(_M_out_end, __sb._M_out_end);
std::swap(_M_buf_locale, __sb._M_buf_locale);
}

};

template<typename _CharT, typename _Traits>

std::basic_streambuf<_CharT, _Traits>::
basic_streambuf(const basic_streambuf&) = default;

template<typename _CharT, typename _Traits>

std::basic_streambuf<_CharT, _Traits>&
std::basic_streambuf<_CharT, _Traits>::
operator=(const basic_streambuf&) = default;

template<>
streamsize
__copy_streambufs_eof(basic_streambuf<char>* __sbin,
basic_streambuf<char>* __sbout, bool& __ineof);

template<>
streamsize
__copy_streambufs_eof(basic_streambuf<wchar_t>* __sbin,
basic_streambuf<wchar_t>* __sbout, bool& __ineof);

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/streambuf.tcc" 1 3
# 37 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/streambuf.tcc" 3

# 38 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/streambuf.tcc" 3

namespace std
{

template<typename _CharT, typename _Traits>

streamsize
basic_streambuf<_CharT, _Traits>::
xsgetn(char_type* __s, streamsize __n)
{
streamsize __ret = 0;
while (__ret < __n)
{
const streamsize __buf_len = this->egptr() - this->gptr();
if (__buf_len)
{
const streamsize __remaining = __n - __ret;
const streamsize __len = std::min(__buf_len, __remaining);
traits_type::copy(__s, this->gptr(), __len);
__ret += __len;
__s += __len;
this->__safe_gbump(__len);
}

if (ret < n)

{
const int_type __c = this->uflow();
if (!traits_type::eq_int_type(__c, traits_type::eof()))
{
traits_type::assign(*__s++, traits_type::to_char_type(__c));
++__ret;
}
else
break;
}
}
return __ret;
}

template<typename _CharT, typename _Traits>

streamsize
basic_streambuf<_CharT, _Traits>::
xsputn(const char_type* __s, streamsize __n)
{
streamsize __ret = 0;
while (__ret < __n)
{
const streamsize __buf_len = this->epptr() - this->pptr();
if (__buf_len)
{
const streamsize __remaining = __n - __ret;
const streamsize __len = std::min(__buf_len, __remaining);
traits_type::copy(this->pptr(), __s, __len);
__ret += __len;
__s += __len;
this->__safe_pbump(__len);
}

if (ret < n)

{
int_type __c = this->overflow(traits_type::to_int_type(*__s));
if (!traits_type::eq_int_type(__c, traits_type::eof()))
{
++__ret;
++__s;
}
else
break;
}
}
return __ret;
}

template<typename _CharT, typename _Traits>

streamsize
__copy_streambufs_eof(basic_streambuf<_CharT, _Traits>* __sbin,
basic_streambuf<_CharT, _Traits>* __sbout,
bool& __ineof)
{
streamsize __ret = 0;
__ineof = true;
typename _Traits::int_type __c = __sbin->sgetc();
while (!_Traits::eq_int_type(__c, _Traits::eof()))
{
__c = __sbout->sputc(_Traits::to_char_type(__c));
if (_Traits::eq_int_type(__c, _Traits::eof()))
{
__ineof = false;
break;
}
++__ret;
__c = __sbin->snextc();
}
return __ret;
}

template<typename _CharT, typename _Traits>

inline streamsize
__copy_streambufs(basic_streambuf<_CharT, _Traits>* __sbin,
basic_streambuf<_CharT, _Traits>* __sbout)
{
bool __ineof;
return __copy_streambufs_eof(__sbin, __sbout, __ineof);
}

extern template class basic_streambuf<char>;

extern template
streamsize
__copy_streambufs(basic_streambuf<char>*,
basic_streambuf<char>*);

extern template class basic_streambuf<wchar_t>;

extern template
streamsize
__copy_streambufs(basic_streambuf<wchar_t>*,
basic_streambuf<wchar_t>*);

}
# 861 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/streambuf" 2 3
# 45 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 2 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/streambuf_iterator.h" 1
3
# 33 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/streambuf_iterator.h" 3

# 34 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/streambuf_iterator.h" 3

namespace std
{
# 49 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/streambuf_iterator.h" 3
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"

template<typename _CharT, typename _Traits>

class istreambuf_iterator
: public iterator<input_iterator_tag, _CharT, typename _Traits::off_type,
_CharT*, _CharT>
{
public:
# 67 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/streambuf_iterator.h" 3
using pointer = void;

typedef _CharT char_type;

typedef _Traits traits_type;
typedef typename _Traits::int_type int_type;
typedef basic_streambuf<_CharT, _Traits> streambuf_type;
typedef basic_istream<_CharT, _Traits> istream_type;

template<typename _CharT2>
friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
ostreambuf_iterator<_CharT2> >::__type
copy(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
ostreambuf_iterator<_CharT2>);

template<bool _IsMove, typename _CharT2>

friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
_CharT2*>::__type
__copy_move_a2(istreambuf_iterator<_CharT2>,
istreambuf_iterator<_CharT2>, _CharT2*);

template<typename _CharT2, typename _Size>

friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
_CharT2*>::__type
__copy_n_a(istreambuf_iterator<_CharT2>, _Size, _CharT2*, bool);

template<typename _CharT2, typename _Distance>

friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
void>::__type
advance(istreambuf_iterator<_CharT2>&, _Distance);

private:
mutable streambuf_type* _M_sbuf;
int_type _M_c;

public:

constexpr istreambuf_iterator() noexcept

: _M_sbuf(0), _M_c(traits_type::eof()) { }

constexpr istreambuf_iterator(default_sentinel_t) noexcept

: istreambuf_iterator() { }

istreambuf_iterator(const istreambuf_iterator&) noexcept = default;

~istreambuf_iterator() = default;

istreambuf_iterator(istream_type& __s) noexcept

: _M_sbuf(__s.rdbuf()), _M_c(traits_type::eof()) { }

istreambuf_iterator(streambuf_type* __s) noexcept

: _M_sbuf(__s), _M_c(traits_type::eof()) { }

istreambuf_iterator&
operator=(const istreambuf_iterator&) noexcept = default;

[[__nodiscard__]]
char_type
operator*() const
{
int_type __c = _M_get();
# 161 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/streambuf_iterator.h"
3
return traits_type::to_char_type(__c);
}

istreambuf_iterator&
operator++()
{
;

_M_sbuf->sbumpc();
_M_c = traits_type::eof();
return *this;
}

istreambuf_iterator
operator++(int)
{

istreambuf_iterator __old = *this;

__old._M_c = _M_sbuf->sbumpc();
_M_c = traits_type::eof();
return __old;
}

[[__nodiscard__]]
bool
equal(const istreambuf_iterator& __b) const
{ return _M_at_eof() == __b._M_at_eof(); }

private:
int_type
_M_get() const
{
int_type __ret = _M_c;
if (_M_sbuf && _S_is_eof(__ret) && _S_is_eof(__ret = _M_sbuf->sgetc()))
_M_sbuf = 0;
return __ret;
}

bool
_M_at_eof() const
{ return _S_is_eof(_M_get()); }

static bool
_S_is_eof(int_type __c)
{
const int_type __eof = traits_type::eof();
return traits_type::eq_int_type(__c, __eof);
}

[[nodiscard]]
friend bool
operator==(const istreambuf_iterator& __i, default_sentinel_t)
{ return __i._M_at_eof(); }

};
template<typename _CharT, typename _Traits>
[[__nodiscard__]]
inline bool
operator==(const istreambuf_iterator<_CharT, _Traits>& __a,
const istreambuf_iterator<_CharT, _Traits>& __b)
{ return __a.equal(__b); }
# 248 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/streambuf_iterator.h"
3
template<typename _CharT, typename _Traits>
class ostreambuf_iterator
: public iterator<output_iterator_tag, void, void, void, void>
{
public:

using difference_type = ptrdiff_t;

typedef _CharT char_type;

typedef _Traits traits_type;
typedef basic_streambuf<_CharT, _Traits> streambuf_type;
typedef basic_ostream<_CharT, _Traits> ostream_type;

private:
streambuf_type* _M_sbuf;
bool _M_failed;

public:

constexpr
ostreambuf_iterator() noexcept
: _M_sbuf(nullptr), _M_failed(true) { }

ostreambuf_iterator(ostream_type& __s) noexcept

: _M_sbuf(__s.rdbuf()), _M_failed(!_M_sbuf) { }

ostreambuf_iterator(streambuf_type* __s) noexcept

: _M_sbuf(__s), _M_failed(!_M_sbuf) { }

ostreambuf_iterator&
operator=(_CharT __c)
{
if (!_M_failed &&
_Traits::eq_int_type(_M_sbuf->sputc(__c), _Traits::eof()))
_M_failed = true;
return *this;
}

[[__nodiscard__]]
ostreambuf_iterator&
operator*()
{ return *this; }

ostreambuf_iterator&
operator++(int)
{ return *this; }

ostreambuf_iterator&
operator++()
{ return *this; }

[[__nodiscard__]]
bool
failed() const noexcept
{ return _M_failed; }

ostreambuf_iterator&
_M_put(const _CharT* __ws, streamsize __len)
{
if (__builtin_expect(!_M_failed, true)
&& __builtin_expect(this->_M_sbuf->sputn(__ws, __len) != __len,
false))
_M_failed = true;
return *this;
}
};
#pragma GCC diagnostic pop

template<typename _CharT>
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
ostreambuf_iterator<_CharT> >::__type
copy(istreambuf_iterator<_CharT> __first,
istreambuf_iterator<_CharT> __last,
ostreambuf_iterator<_CharT> __result)
{
if (__first._M_sbuf && !__last._M_sbuf && !__result._M_failed)
{
bool __ineof;
__copy_streambufs_eof(__first._M_sbuf, __result._M_sbuf, __ineof);
if (!__ineof)
__result._M_failed = true;
}
return __result;
}

template<bool _IsMove, typename _CharT>

typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
ostreambuf_iterator<_CharT> >::__type
__copy_move_a2(_CharT* __first, _CharT* __last,
ostreambuf_iterator<_CharT> __result)
{
const streamsize __num = __last - __first;
if (__num > 0)
__result._M_put(__first, __num);
return __result;
}

template<bool _IsMove, typename _CharT>

typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
ostreambuf_iterator<_CharT> >::__type
__copy_move_a2(const _CharT* __first, const _CharT* __last,
ostreambuf_iterator<_CharT> __result)
{
const streamsize __num = __last - __first;
if (__num > 0)
__result._M_put(__first, __num);
return __result;
}

template<bool _IsMove, typename _CharT>

typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
_CharT*>::__type
__copy_move_a2(istreambuf_iterator<_CharT> __first,
istreambuf_iterator<_CharT> __last, _CharT* __result)
{
typedef istreambuf_iterator<_CharT> __is_iterator_type;
typedef typename __is_iterator_type::traits_type traits_type;
typedef typename __is_iterator_type::streambuf_type streambuf_type;
typedef typename traits_type::int_type int_type;

if (__first._M_sbuf && !__last._M_sbuf)

{
streambuf_type* __sb = __first._M_sbuf;
int_type __c = __sb->sgetc();
while (!traits_type::eq_int_type(__c, traits_type::eof()))
{
const streamsize __n = __sb->egptr() - __sb->gptr();
if (__n > 1)
{
traits_type::copy(__result, __sb->gptr(), __n);
__sb->__safe_gbump(__n);
__result += __n;
__c = __sb->underflow();
}
else
{
*__result++ = traits_type::to_char_type(__c);
__c = __sb->snextc();
}
}
}
return __result;
}

template<typename _CharT, typename _Size>

typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
_CharT*>::__type
__copy_n_a(istreambuf_iterator<_CharT> __it, _Size __n, _CharT* __result,
bool __strict __attribute__((__unused__)))
{
if (__n == 0)
return __result;

;
_CharT* __beg = __result;
__result += __it._M_sbuf->sgetn(__beg, __n);

;
return __result;
}

template<typename _CharT>
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
istreambuf_iterator<_CharT> >::__type
find(istreambuf_iterator<_CharT> __first,
istreambuf_iterator<_CharT> __last, const _CharT& __val)
{
typedef istreambuf_iterator<_CharT> __is_iterator_type;
typedef typename __is_iterator_type::traits_type traits_type;
typedef typename __is_iterator_type::streambuf_type streambuf_type;
typedef typename traits_type::int_type int_type;
const int_type __eof = traits_type::eof();

if (__first._M_sbuf && !__last._M_sbuf)

{
const int_type __ival = traits_type::to_int_type(__val);
streambuf_type* __sb = __first._M_sbuf;
int_type __c = __sb->sgetc();
while (!traits_type::eq_int_type(__c, __eof)
&& !traits_type::eq_int_type(__c, __ival))
{
streamsize __n = __sb->egptr() - __sb->gptr();
if (__n > 1)
{
const _CharT* __p = traits_type::find(__sb->gptr(),
__n, __val);
if (__p)
__n = __p - __sb->gptr();
__sb->__safe_gbump(__n);
__c = __sb->sgetc();
}
else
__c = __sb->snextc();
}

__first._M_c = __eof;
}

return __first;
}

template<typename _CharT, typename _Distance>

typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
void>::__type
advance(istreambuf_iterator<_CharT>& __i, _Distance __n)
{
if (__n == 0)
return;

do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__n > 0),

false)) std::__glibcxx_assert_fail(); } while (false);

typedef istreambuf_iterator<_CharT> __is_iterator_type;

typedef typename __is_iterator_type::traits_type traits_type;
typedef typename __is_iterator_type::streambuf_type streambuf_type;
typedef typename traits_type::int_type int_type;
const int_type __eof = traits_type::eof();

streambuf_type* sb = i._M_sbuf;

while (__n > 0)
{
streamsize __size = __sb->egptr() - __sb->gptr();
if (__size > __n)
{
__sb->__safe_gbump(__n);
break;
}

__sb->__safe_gbump(__size);
__n -= __size;
if (traits_type::eq_int_type(__sb->underflow(), __eof))
{

;
break;
}
}

__i._M_c = __eof;
}

}
# 49 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 2 3

namespace std
{

# 74 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
template<typename _Tp>
void
__convert_to_v(const char*, _Tp&, ios_base::iostate&,
const __c_locale&) throw();

template<>
void
__convert_to_v(const char*, float&, ios_base::iostate&,
const __c_locale&) throw();

template<>
void
__convert_to_v(const char*, double&, ios_base::iostate&,
const __c_locale&) throw();

template<>
void
__convert_to_v(const char*, long double&, ios_base::iostate&,
const __c_locale&) throw();

template<typename _CharT, typename _Traits>

struct __pad
{
static void
_S_pad(ios_base& __io, _CharT __fill, _CharT* __news,
const _CharT* __olds, streamsize __newlen, streamsize __oldlen);
};

template<typename _CharT>
_CharT*
__add_grouping(_CharT* __s, _CharT __sep,
const char* __gbeg, size_t __gsize,
const _CharT* __first, const _CharT* __last);

template<typename _CharT>
inline
ostreambuf_iterator<_CharT>
__write(ostreambuf_iterator<_CharT> __s, const _CharT* __ws, int __len)
{
__s._M_put(__ws, __len);
return __s;
}

template<typename _CharT, typename _OutIter>

inline
_OutIter
__write(_OutIter __s, const _CharT* __ws, int __len)
{
for (int __j = 0; __j < __len; __j++, ++__s)
*__s = __ws[__j];
return __s;
}
# 152 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
template<typename _CharT>
class __ctype_abstract_base : public locale::facet, public ctype_base
{
public:

typedef _CharT char_type;

# 171 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
bool
is(mask __m, char_type __c) const
{ return this->do_is(__m, __c); }
# 188 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
const char_type*
is(const char_type *__lo, const char_type *__hi, mask *__vec) const
{ return this->do_is(__lo, __hi, __vec); }
# 204 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
const char_type*
scan_is(mask __m, const char_type* __lo, const char_type* __hi) const
{ return this->do_scan_is(__m, __lo, __hi); }
# 220 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
const char_type*
scan_not(mask __m, const char_type* __lo, const char_type* __hi) const
{ return this->do_scan_not(__m, __lo, __hi); }
# 234 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
char_type
toupper(char_type __c) const
{ return this->do_toupper(__c); }
# 249 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
const char_type*
toupper(char_type *__lo, const char_type* __hi) const
{ return this->do_toupper(__lo, __hi); }
# 263 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
char_type
tolower(char_type __c) const
{ return this->do_tolower(__c); }
# 278 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
const char_type*
tolower(char_type* __lo, const char_type* __hi) const
{ return this->do_tolower(__lo, __hi); }
# 295 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
char_type
widen(char __c) const
{ return this->do_widen(__c); }
# 314 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
const char*
widen(const char* __lo, const char* __hi, char_type* __to) const
{ return this->do_widen(__lo, __hi, __to); }
# 333 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
char
narrow(char_type __c, char __dfault) const
{ return this->do_narrow(__c, __dfault); }
# 355 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
const char_type*
narrow(const char_type* __lo, const char_type* __hi,
char __dfault, char* __to) const
{ return this->do_narrow(__lo, __hi, __dfault, __to); }

do_scan_not(mask __m, const char_type* __lo,
const char_type* __hi) const;

virtual char_type
do_toupper(char_type __c) const;

virtual const char_type*

do_toupper(char_type* __lo, const char_type* __hi) const;

virtual char_type
do_tolower(char_type __c) const;

virtual const char_type*

do_tolower(char_type* __lo, const char_type* __hi) const;

virtual char_type
do_widen(char __c) const;

virtual const char*

do_widen(const char* __lo, const char* __hi, char_type* __dest) const;

virtual char
do_narrow(char_type, char __dfault) const;

virtual const char_type*

do_narrow(const char_type* __lo, const char_type* __hi,
char __dfault, char* __to) const;
};

template<typename _CharT>
locale::id ctype<_CharT>::id;

template<typename _CharT, typename _Traits, typename _Alloc>

class ctype<basic_string<_CharT, _Traits, _Alloc> >;
# 688 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
template<>
class ctype<char> : public locale::facet, public ctype_base
{
public:

typedef char char_type;

protected:
__c_locale _M_c_locale_ctype;
bool _M_del;
__to_type _M_toupper;
__to_type _M_tolower;
const mask* _M_table;
mutable char _M_widen_ok;
mutable char _M_widen[1 + static_cast<unsigned char>(-1)];
mutable char _M_narrow[1 + static_cast<unsigned char>(-1)];
mutable char _M_narrow_ok;

public:

static locale::id id;

static const size_t table_size = 1 + static_cast<unsigned char>(-1);

# 725 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
explicit
ctype(const mask* __table = 0, bool __del = false, size_t __refs = 0);
# 738 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
explicit
ctype(__c_locale __cloc, const mask* __table = 0, bool __del = false,
size_t __refs = 0);
# 751 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
inline bool
is(mask __m, char __c) const;
# 766 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
inline const char*
is(const char* __lo, const char* __hi, mask* __vec) const;
# 780 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
inline const char*
scan_is(mask __m, const char* __lo, const char* __hi) const;
# 794 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
inline const char*
scan_not(mask __m, const char* __lo, const char* __hi) const;
# 809 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
char_type
toupper(char_type __c) const
{ return this->do_toupper(__c); }
# 826 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
const char_type*
toupper(char_type *__lo, const char_type* __hi) const
{ return this->do_toupper(__lo, __hi); }
# 842 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
char_type
tolower(char_type __c) const
{ return this->do_tolower(__c); }
# 859 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
const char_type*
tolower(char_type* __lo, const char_type* __hi) const
{ return this->do_tolower(__lo, __hi); }
# 879 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
char_type
widen(char __c) const
{
if (_M_widen_ok)
return _M_widen[static_cast<unsigned char>(__c)];
this->_M_widen_init();
return this->do_widen(__c);
}
# 906 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
const char*
widen(const char* __lo, const char* __hi, char_type* __to) const
{
if (_M_widen_ok == 1)
{
if (__builtin_expect(__hi != __lo, true))
__builtin_memcpy(__to, __lo, __hi - __lo);
return __hi;
}
if (!_M_widen_ok)
_M_widen_init();
return this->do_widen(__lo, __hi, __to);
}
# 938 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
char
narrow(char_type __c, char __dfault) const
{
if (_M_narrow[static_cast<unsigned char>(__c)])
return _M_narrow[static_cast<unsigned char>(__c)];
const char __t = do_narrow(__c, __dfault);
if (__t != __dfault)
_M_narrow[static_cast<unsigned char>(__c)] = __t;
return __t;
}
# 971 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
const char_type*
narrow(const char_type* __lo, const char_type* __hi,
char __dfault, char* __to) const
{
if (__builtin_expect(_M_narrow_ok == 1, true))
{
if (__builtin_expect(__hi != __lo, true))
__builtin_memcpy(__to, __lo, __hi - __lo);
return __hi;
}
if (!_M_narrow_ok)
_M_narrow_init();
return this->do_narrow(__lo, __hi, __dfault, __to);
}

const mask*
table() const throw()
{ return _M_table; }

static const mask*

classic_table() throw();
protected:
virtual
~ctype();
# 1021 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
virtual char_type
do_toupper(char_type __c) const;
# 1038 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
virtual const char_type*
do_toupper(char_type* __lo, const char_type* __hi) const;
# 1054 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
virtual char_type
do_tolower(char_type __c) const;
# 1071 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
virtual const char_type*
do_tolower(char_type* __lo, const char_type* __hi) const;
# 1091 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
virtual char_type
do_widen(char __c) const
{ return __c; }
# 1114 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
virtual const char*
do_widen(const char* __lo, const char* __hi, char_type* __to) const
{
if (__builtin_expect(__hi != __lo, true))
__builtin_memcpy(__to, __lo, __hi - __lo);
return __hi;
}
# 1141 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
virtual char
do_narrow(char_type __c, char __dfault __attribute__((__unused__))) const
{ return __c; }
# 1167 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
virtual const char_type*
do_narrow(const char_type* __lo, const char_type* __hi,
char __dfault __attribute__((__unused__)), char* __to) const
{
if (__builtin_expect(__hi != __lo, true))
__builtin_memcpy(__to, __lo, __hi - __lo);
return __hi;
}

private:
void _M_narrow_init() const;
void _M_widen_init() const;
};
# 1193 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
template<>
class ctype<wchar_t> : public __ctype_abstract_base<wchar_t>
{
public:

typedef wchar_t char_type;

typedef wctype_t __wmask_type;

protected:
__c_locale _M_c_locale_ctype;
bool _M_narrow_ok;
char _M_narrow[128];
wint_t _M_widen[1 + static_cast<unsigned char>(-1)];

mask _M_bit[16];
__wmask_type _M_wmask[16];

public:

static locale::id id;

# 1226 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
explicit
ctype(size_t __refs = 0);
# 1237 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
explicit
ctype(__c_locale __cloc, size_t __refs = 0);

protected:
__wmask_type
_M_convert_to_wmask(const mask __m) const throw();

virtual
~ctype();
# 1261 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
virtual bool
do_is(mask __m, char_type __c) const;
# 1280 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
virtual const char_type*
do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;
# 1298 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
virtual const char_type*
do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;
# 1316 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
virtual const char_type*
do_scan_not(mask __m, const char_type* __lo,
const char_type* __hi) const;
# 1333 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
virtual char_type
do_toupper(char_type __c) const;
# 1350 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
virtual const char_type*
do_toupper(char_type* __lo, const char_type* __hi) const;
# 1366 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
virtual char_type
do_tolower(char_type __c) const;
# 1383 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
virtual const char_type*
do_tolower(char_type* __lo, const char_type* __hi) const;
# 1403 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
virtual char_type
do_widen(char __c) const;
# 1425 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
virtual const char*
do_widen(const char* __lo, const char* __hi, char_type* __to) const;
# 1448 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
virtual char
do_narrow(char_type __c, char __dfault) const;
# 1474 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
virtual const char_type*
do_narrow(const char_type* __lo, const char_type* __hi,
char __dfault, char* __to) const;

void
_M_initialize_ctype() throw();
};

template<typename _CharT>
class ctype_byname : public ctype<_CharT>
{
public:
typedef typename ctype<_CharT>::mask mask;

explicit
ctype_byname(const char* __s, size_t __refs = 0);

explicit
ctype_byname(const string& __s, size_t __refs = 0)
: ctype_byname(__s.c_str(), __refs) { }

protected:
virtual
~ctype_byname() { }
};

template<>
class ctype_byname<char> : public ctype<char>
{
public:
explicit
ctype_byname(const char* __s, size_t __refs = 0);

explicit
ctype_byname(const string& __s, size_t __refs = 0);

protected:
virtual
~ctype_byname();
};

template<>
class ctype_byname<wchar_t> : public ctype<wchar_t>
{
public:
explicit
ctype_byname(const char* __s, size_t __refs = 0);

explicit
ctype_byname(const string& __s, size_t __refs = 0);

protected:
virtual
~ctype_byname();
};

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/x86_64-w64-mingw32/bits/
ctype_inline.h" 1 3
# 37 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/x86_64-w64-mingw32/bits/
ctype_inline.h" 3
namespace std
{

bool
ctype<char>::
is(mask __m, char __c) const
{ return (_M_table[static_cast<unsigned char>(__c) ] & __m); }

const char*
ctype<char>::
is(const char* __low, const char* __high, mask* __vec) const
{
while (__low < __high)
*__vec++ = _M_table[static_cast<unsigned char>(*__low++)];
return __high;
}

const char*
ctype<char>::
scan_is(mask __m, const char* __low, const char* __high) const
{
while (__low < __high && !this->is(__m, *__low))
++__low;
return __low;
}

const char*
ctype<char>::
scan_not(mask __m, const char* __low, const char* __high) const
{
while (__low < __high && this->is(__m, *__low) != 0)
++__low;
return __low;
}
}
# 1547 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 2 3

namespace std
{

class __num_base
{
public:

enum
{
_S_ominus,
_S_oplus,
_S_ox,
_S_oX,
_S_odigits,
_S_odigits_end = _S_odigits + 16,
_S_oudigits = _S_odigits_end,
_S_oudigits_end = _S_oudigits + 16,
_S_oe = _S_odigits + 14,
_S_oE = _S_oudigits + 14,
_S_oend = _S_oudigits_end
};

static const char* _S_atoms_out;

static const char* _S_atoms_in;

enum
{
_S_iminus,
_S_iplus,
_S_ix,
_S_iX,
_S_izero,
_S_ie = _S_izero + 14,
_S_iE = _S_izero + 20,
_S_iend = 26
};

static void
_S_format_float(const ios_base& __io, char* __fptr, char __mod) throw();
};

template<typename _CharT>
struct __numpunct_cache : public locale::facet
{
const char* _M_grouping;
size_t _M_grouping_size;
bool _M_use_grouping;
const _CharT* _M_truename;
size_t _M_truename_size;
const _CharT* _M_falsename;
size_t _M_falsename_size;
_CharT _M_decimal_point;
_CharT _M_thousands_sep;

_CharT _M_atoms_out[__num_base::_S_oend];

_CharT _M_atoms_in[__num_base::_S_iend];

bool _M_allocated;

__numpunct_cache(size_t __refs = 0)
: facet(__refs), _M_grouping(0), _M_grouping_size(0),
_M_use_grouping(false),
_M_truename(0), _M_truename_size(0), _M_falsename(0),
_M_falsename_size(0), _M_decimal_point(_CharT()),
_M_thousands_sep(_CharT()), _M_allocated(false)
{ }

~__numpunct_cache();

void
_M_cache(const locale& __loc);

private:
__numpunct_cache&
operator=(const __numpunct_cache&);

explicit
__numpunct_cache(const __numpunct_cache&);
};

template<typename _CharT>
__numpunct_cache<_CharT>::~__numpunct_cache()
{
if (_M_allocated)
{
delete [] _M_grouping;
delete [] _M_truename;
delete [] _M_falsename;
}
}

namespace __cxx11 {
# 1677 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
template<typename _CharT>
class numpunct : public locale::facet
{
public:

typedef _CharT char_type;

typedef basic_string<_CharT> string_type;

typedef __numpunct_cache<_CharT> __cache_type;

protected:
__cache_type* _M_data;

public:

static locale::id id;

explicit
numpunct(size_t __refs = 0)
: facet(__refs), _M_data(0)
{ _M_initialize_numpunct(); }
# 1715 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
explicit
numpunct(__cache_type* __cache, size_t __refs = 0)
: facet(__refs), _M_data(__cache)
{ _M_initialize_numpunct(); }
# 1729 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
explicit
numpunct(__c_locale __cloc, size_t __refs = 0)
: facet(__refs), _M_data(0)
{ _M_initialize_numpunct(__cloc); }
# 1743 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
char_type
decimal_point() const
{ return this->do_decimal_point(); }
# 1756 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
char_type
thousands_sep() const
{ return this->do_thousands_sep(); }
# 1787 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
string
grouping() const
{ return this->do_grouping(); }
# 1800 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
string_type
truename() const
{ return this->do_truename(); }
# 1813 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
string_type
falsename() const
{ return this->do_falsename(); }
protected:

virtual
~numpunct();
# 1830 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
virtual char_type
do_decimal_point() const
{ return _M_data->_M_decimal_point; }
# 1842 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
virtual char_type
do_thousands_sep() const
{ return _M_data->_M_thousands_sep; }
# 1855 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
virtual string
do_grouping() const
{ return _M_data->_M_grouping; }
# 1868 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
virtual string_type
do_truename() const
{ return _M_data->_M_truename; }
# 1881 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
virtual string_type
do_falsename() const
{ return _M_data->_M_falsename; }

void
_M_initialize_numpunct(__c_locale __cloc = 0);
};

template<typename _CharT>
locale::id numpunct<_CharT>::id;

template<>
numpunct<char>::~numpunct();

template<>
void
numpunct<char>::_M_initialize_numpunct(__c_locale __cloc);

template<>
numpunct<wchar_t>::~numpunct();

template<>
void
numpunct<wchar_t>::_M_initialize_numpunct(__c_locale __cloc);

template<typename _CharT>
class numpunct_byname : public numpunct<_CharT>
{
public:
typedef _CharT char_type;
typedef basic_string<_CharT> string_type;

explicit
numpunct_byname(const char* __s, size_t __refs = 0)
: numpunct<_CharT>(__refs)
{
if (__builtin_strcmp(__s, "C") != 0
&& __builtin_strcmp(__s, "POSIX") != 0)
{
__c_locale __tmp;
this->_S_create_c_locale(__tmp, __s);
this->_M_initialize_numpunct(__tmp);
this->_S_destroy_c_locale(__tmp);
}
}

explicit
numpunct_byname(const string& __s, size_t __refs = 0)
: numpunct_byname(__s.c_str(), __refs) { }

protected:
virtual
~numpunct_byname() { }
};

# 1959 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
template<typename _CharT, typename _InIter>
class num_get : public locale::facet
{
public:

typedef _CharT char_type;

typedef _InIter iter_type;

static locale::id id;

# 1980 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
explicit
num_get(size_t __refs = 0) : facet(__refs) { }
# 2006 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, bool& __v) const
{ return this->do_get(__in, __end, __io, __err, __v); }
# 2043 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, long& __v) const
{ return this->do_get(__in, __end, __io, __err, __v); }

iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned short& __v) const
{ return this->do_get(__in, __end, __io, __err, __v); }
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned int& __v) const
{ return this->do_get(__in, __end, __io, __err, __v); }

iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned long& __v) const
{ return this->do_get(__in, __end, __io, __err, __v); }

iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, long long& __v) const
{ return this->do_get(__in, __end, __io, __err, __v); }

iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned long long& __v) const
{ return this->do_get(__in, __end, __io, __err, __v); }
# 2103 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, float& __v) const
{ return this->do_get(__in, __end, __io, __err, __v); }

iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, double& __v) const
{ return this->do_get(__in, __end, __io, __err, __v); }

iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, long double& __v) const
{ return this->do_get(__in, __end, __io, __err, __v); }
# 2146 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
iter_type
get(iter_type __in, iter_type __end, ios_base& __io,
ios_base::iostate& __err, void*& __v) const
{ return this->do_get(__in, __end, __io, __err, __v); }

protected:

virtual ~num_get() { }

attribute ((abi_tag__ ("cxx11")))

iter_type
_M_extract_float(iter_type, iter_type, ios_base&, ios_base::iostate&,
string&) const;

template<typename _ValueT>
__attribute ((__abi_tag__ ("cxx11")))
iter_type
_M_extract_int(iter_type, iter_type, ios_base&, ios_base::iostate&,
_ValueT&) const;

template<typename _CharT2>
typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, int>::__type
_M_find(const _CharT2*, size_t __len, _CharT2 __c) const
{
int __ret = -1;
if (__len <= 10)
{
if (__c >= _CharT2('0') && __c < _CharT2(_CharT2('0') + __len))
__ret = __c - _CharT2('0');
}
else
{
if (__c >= _CharT2('0') && __c <= _CharT2('9'))
__ret = __c - _CharT2('0');
else if (__c >= _CharT2('a') && __c <= _CharT2('f'))
__ret = 10 + (__c - _CharT2('a'));
else if (__c >= _CharT2('A') && __c <= _CharT2('F'))
__ret = 10 + (__c - _CharT2('A'));
}
return __ret;
}

template<typename _CharT2>
typename __gnu_cxx::__enable_if<!__is_char<_CharT2>::__value,
int>::__type
_M_find(const _CharT2* __zero, size_t __len, _CharT2 __c) const
{
int __ret = -1;
const char_type* __q = char_traits<_CharT2>::find(__zero, __len, __c);
if (__q)
{
__ret = __q - __zero;
if (__ret > 15)
__ret -= 6;
}
return __ret;
}
# 2219 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
virtual iter_type
do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, bool&) const;

virtual iter_type
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, long& __v) const
{ return _M_extract_int(__beg, __end, __io, __err, __v); }

virtual iter_type
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned short& __v) const
{ return _M_extract_int(__beg, __end, __io, __err, __v); }

virtual iter_type
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned int& __v) const
{ return _M_extract_int(__beg, __end, __io, __err, __v); }

virtual iter_type
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned long& __v) const
{ return _M_extract_int(__beg, __end, __io, __err, __v); }
virtual iter_type
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, long long& __v) const
{ return _M_extract_int(__beg, __end, __io, __err, __v); }

virtual iter_type
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned long long& __v) const
{ return _M_extract_int(__beg, __end, __io, __err, __v); }

virtual iter_type
do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, float&) const;

virtual iter_type
do_get(iter_type, iter_type, ios_base&, ios_base::iostate&,
double&) const;
# 2271 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
virtual iter_type
do_get(iter_type, iter_type, ios_base&, ios_base::iostate&,
long double&) const;

virtual iter_type
do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, void*&) const;
# 2299 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
};

template<typename _CharT, typename _InIter>

locale::id num_get<_CharT, _InIter>::id;
# 2317 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
template<typename _CharT, typename _OutIter>
class num_put : public locale::facet
{
public:

typedef _CharT char_type;

typedef _OutIter iter_type;

static locale::id id;

# 2338 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
explicit
num_put(size_t __refs = 0) : facet(__refs) { }
# 2356 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
iter_type
put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const
{ return this->do_put(__s, __io, __fill, __v); }
# 2398 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
iter_type
put(iter_type __s, ios_base& __io, char_type __fill, long __v) const
{ return this->do_put(__s, __io, __fill, __v); }

iter_type
put(iter_type __s, ios_base& __io, char_type __fill,
unsigned long __v) const
{ return this->do_put(__s, __io, __fill, __v); }

iter_type
put(iter_type __s, ios_base& __io, char_type __fill, long long __v) const
{ return this->do_put(__s, __io, __fill, __v); }

iter_type
put(iter_type __s, ios_base& __io, char_type __fill,
unsigned long long __v) const
{ return this->do_put(__s, __io, __fill, __v); }
# 2461 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
iter_type
put(iter_type __s, ios_base& __io, char_type __fill, double __v) const
{ return this->do_put(__s, __io, __fill, __v); }

iter_type
put(iter_type __s, ios_base& __io, char_type __fill,
long double __v) const
{ return this->do_put(__s, __io, __fill, __v); }
# 2486 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
iter_type
put(iter_type __s, ios_base& __io, char_type __fill,
const void* __v) const
{ return this->do_put(__s, __io, __fill, __v); }

protected:
template<typename _ValueT>
iter_type
_M_insert_float(iter_type, ios_base& __io, char_type __fill,
char __mod, _ValueT __v) const;

void
_M_group_float(const char* __grouping, size_t __grouping_size,
char_type __sep, const char_type* __p, char_type* __new,
char_type* __cs, int& __len) const;

template<typename _ValueT>
iter_type
_M_insert_int(iter_type, ios_base& __io, char_type __fill,
_ValueT __v) const;

void
_M_group_int(const char* __grouping, size_t __grouping_size,
char_type __sep, ios_base& __io, char_type* __new,
char_type* __cs, int& __len) const;

void
_M_pad(char_type __fill, streamsize __w, ios_base& __io,
char_type* __new, const char_type* __cs, int& __len) const;

virtual
~num_put() { }
# 2534 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
virtual iter_type
do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const;

virtual iter_type
do_put(iter_type __s, ios_base& __io, char_type __fill, long __v) const
{ return _M_insert_int(__s, __io, __fill, __v); }

virtual iter_type
do_put(iter_type __s, ios_base& __io, char_type __fill,
unsigned long __v) const
{ return _M_insert_int(__s, __io, __fill, __v); }

virtual iter_type
do_put(iter_type __s, ios_base& __io, char_type __fill,
long long __v) const
{ return _M_insert_int(__s, __io, __fill, __v); }

virtual iter_type
do_put(iter_type __s, ios_base& __io, char_type __fill,
unsigned long long __v) const
{ return _M_insert_int(__s, __io, __fill, __v); }

virtual iter_type
do_put(iter_type, ios_base&, char_type, double) const;

virtual iter_type
do_put(iter_type, ios_base&, char_type, long double) const;

virtual iter_type
do_put(iter_type, ios_base&, char_type, const void*) const;
# 2586 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 3
};

template <typename _CharT, typename _OutIter>

locale::id num_put<_CharT, _OutIter>::id;

template<typename _CharT>
inline bool
isspace(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::space, __c); }

template<typename _CharT>
inline bool
isprint(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::print, __c); }
template<typename _CharT>
inline bool
iscntrl(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::cntrl, __c); }

template<typename _CharT>
inline bool
isupper(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::upper, __c); }

template<typename _CharT>
inline bool
islower(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::lower, __c); }

template<typename _CharT>
inline bool
isalpha(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alpha, __c); }

template<typename _CharT>
inline bool
isdigit(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::digit, __c); }

template<typename _CharT>
inline bool
ispunct(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::punct, __c); }

template<typename _CharT>
inline bool
isxdigit(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::xdigit, __c); }

template<typename _CharT>
inline bool
isalnum(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alnum, __c); }

template<typename _CharT>
inline bool
isgraph(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::graph, __c); }

template<typename _CharT>
inline bool
isblank(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).is(ctype_base::blank, __c); }

template<typename _CharT>
inline _CharT
toupper(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).toupper(__c); }

template<typename _CharT>
inline _CharT
tolower(_CharT __c, const locale& __loc)
{ return use_facet<ctype<_CharT> >(__loc).tolower(__c); }

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.tcc" 1 3
# 33 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.tcc" 3

# 34 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.tcc" 3

namespace std
{

template<typename _Facet>
struct __use_cache
{
const _Facet*
operator() (const locale& __loc) const;
};

template<typename _CharT>
struct __use_cache<__numpunct_cache<_CharT> >
{
const __numpunct_cache<_CharT>*
operator() (const locale& __loc) const
{
const size_t __i = numpunct<_CharT>::id._M_id();
const locale::facet** __caches = __loc._M_impl->_M_caches;
if (!__caches[__i])
{
__numpunct_cache<_CharT>* __tmp = 0;
try
{
__tmp = new __numpunct_cache<_CharT>;
__tmp->_M_cache(__loc);
}
catch(...)
{
delete __tmp;
throw;
}
__loc._M_impl->_M_install_cache(__tmp, __i);
}
return static_cast<const __numpunct_cache<_CharT>*>(__caches[__i]);
}
};

template<typename _CharT>
void
__numpunct_cache<_CharT>::_M_cache(const locale& __loc)
{
const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);

char* __grouping = 0;
_CharT* __truename = 0;
_CharT* __falsename = 0;
try
{
const string& __g = __np.grouping();
_M_grouping_size = __g.size();
__grouping = new char[_M_grouping_size];
__g.copy(__grouping, _M_grouping_size);
_M_use_grouping = (_M_grouping_size
&& static_cast<signed char>(__grouping[0]) > 0
&& (__grouping[0]
!= __gnu_cxx::__numeric_traits<char>::__max));

const basic_string<_CharT>& tn = np.truename();

_M_truename_size = __tn.size();
__truename = new _CharT[_M_truename_size];
__tn.copy(__truename, _M_truename_size);

const basic_string<_CharT>& fn = np.falsename();

_M_falsename_size = __fn.size();
__falsename = new _CharT[_M_falsename_size];
__fn.copy(__falsename, _M_falsename_size);

_M_decimal_point = __np.decimal_point();
_M_thousands_sep = __np.thousands_sep();

const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__loc);

__ct.widen(__num_base::_S_atoms_out,
__num_base::_S_atoms_out
+ __num_base::_S_oend, _M_atoms_out);
__ct.widen(__num_base::_S_atoms_in,
__num_base::_S_atoms_in
+ __num_base::_S_iend, _M_atoms_in);

_M_grouping = __grouping;
_M_truename = __truename;
_M_falsename = __falsename;
_M_allocated = true;
}
catch(...)
{
delete [] __grouping;
delete [] __truename;
delete [] __falsename;
throw;
}
}
# 139 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.tcc" 3
__attribute__ ((__pure__)) bool
__verify_grouping(const char* __grouping, size_t __grouping_size,
const string& __grouping_tmp) throw ();

template<typename _CharT, typename _InIter>

__attribute ((__abi_tag__ ("cxx11")))
_InIter
num_get<_CharT, _InIter>::
_M_extract_float(_InIter __beg, _InIter __end, ios_base& __io,
ios_base::iostate& __err, string& __xtrc) const
{
typedef char_traits<_CharT> __traits_type;
typedef __numpunct_cache<_CharT> __cache_type;
__use_cache<__cache_type> __uc;
const locale& __loc = __io._M_getloc();
const __cache_type* __lc = __uc(__loc);
const _CharT* __lit = __lc->_M_atoms_in;
char_type __c = char_type();

bool testeof = beg == __end;

if (!__testeof)
{
__c = *__beg;
const bool __plus = __c == __lit[__num_base::_S_iplus];
if ((__plus || __c == __lit[__num_base::_S_iminus])
&& !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
&& !(__c == __lc->_M_decimal_point))
{
__xtrc += __plus ? '+' : '-';
if (++__beg != __end)
__c = *__beg;
else
__testeof = true;
}
}

bool __found_mantissa = false;

int __sep_pos = 0;
while (!__testeof)
{
if ((__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
|| __c == __lc->_M_decimal_point)
break;
else if (__c == __lit[__num_base::_S_izero])
{
if (!__found_mantissa)
{
__xtrc += '0';
__found_mantissa = true;
}
++__sep_pos;
if (++__beg != __end)
__c = *__beg;
else
__testeof = true;
}
else
break;
}

bool __found_dec = false;

bool __found_sci = false;
string __found_grouping;
if (__lc->_M_use_grouping)
__found_grouping.reserve(32);
const char_type* __lit_zero = __lit + __num_base::_S_izero;

if (!__lc->_M_allocated)

while (!__testeof)
{
const int __digit = _M_find(__lit_zero, 10, __c);
if (__digit != -1)
{
__xtrc += '0' + __digit;
__found_mantissa = true;
}
else if (__c == __lc->_M_decimal_point
&& !__found_dec && !__found_sci)
{
__xtrc += '.';
__found_dec = true;
}
else if ((__c == __lit[__num_base::_S_ie]
|| __c == __lit[__num_base::_S_iE])
&& !__found_sci && __found_mantissa)
{

__xtrc += 'e';
__found_sci = true;

if (++__beg != __end)
{
__c = *__beg;
const bool __plus = __c == __lit[__num_base::_S_iplus];
if (__plus || __c == __lit[__num_base::_S_iminus])
__xtrc += __plus ? '+' : '-';
else
continue;
}
else
{
__testeof = true;
break;
}
}
else
break;
if (++__beg != __end)
__c = *__beg;
else
__testeof = true;
}
else
while (!__testeof)
{

if (__lc->_M_use_grouping && c == lc->_M_thousands_sep)

{
if (!__found_dec && !__found_sci)
{

if (__sep_pos)
{
__found_grouping += static_cast<char>(__sep_pos);
__sep_pos = 0;
}
else
{

__xtrc.clear();
break;
}
}
else
break;
}
else if (__c == __lc->_M_decimal_point)
{
if (!__found_dec && !__found_sci)
{

if (__found_grouping.size())
__found_grouping += static_cast<char>(__sep_pos);
__xtrc += '.';
__found_dec = true;
}
else
break;
}
else
{
const char_type* __q =
__traits_type::find(__lit_zero, 10, __c);
if (__q)
{
__xtrc += '0' + (__q - __lit_zero);
__found_mantissa = true;
++__sep_pos;
}
else if ((__c == __lit[__num_base::_S_ie]
|| __c == __lit[__num_base::_S_iE])
&& !__found_sci && __found_mantissa)
{

if (__found_grouping.size() && !__found_dec)

__found_grouping += static_cast<char>(__sep_pos);
__xtrc += 'e';
__found_sci = true;

if (++__beg != __end)
{
__c = *__beg;
const bool __plus = __c == __lit[__num_base::_S_iplus];
if ((__plus || __c == __lit[__num_base::_S_iminus])
&& !(__lc->_M_use_grouping
&& __c == __lc->_M_thousands_sep)
&& !(__c == __lc->_M_decimal_point))
__xtrc += __plus ? '+' : '-';
else
continue;
}
else
{
__testeof = true;
break;
}
}
else
break;
}

if (++__beg != __end)
__c = *__beg;
else
__testeof = true;
}

if (__found_grouping.size())
{

if (!__found_dec && !__found_sci)

__found_grouping += static_cast<char>(__sep_pos);

if (!std::__verify_grouping(__lc->_M_grouping,
__lc->_M_grouping_size,
__found_grouping))
__err = ios_base::failbit;
}

return __beg;
}

template<typename _CharT, typename _InIter>

template<typename _ValueT>
__attribute ((__abi_tag__ ("cxx11")))
_InIter
num_get<_CharT, _InIter>::
_M_extract_int(_InIter __beg, _InIter __end, ios_base& __io,
ios_base::iostate& __err, _ValueT& __v) const
{
typedef char_traits<_CharT> __traits_type;
using __gnu_cxx::__add_unsigned;
typedef typename __add_unsigned<_ValueT>::__type __unsigned_type;
typedef __numpunct_cache<_CharT> __cache_type;
__use_cache<__cache_type> __uc;
const locale& __loc = __io._M_getloc();
const __cache_type* __lc = __uc(__loc);
const _CharT* __lit = __lc->_M_atoms_in;
char_type __c = char_type();

const ios_base::fmtflags basefield = io.flags()

& ios_base::basefield;
const bool __oct = __basefield == ios_base::oct;
int __base = __oct ? 8 : (__basefield == ios_base::hex ? 16 : 10);

bool testeof = beg == __end;

bool __negative = false;

if (!__testeof)
{
__c = *__beg;
__negative = __c == __lit[__num_base::_S_iminus];
if ((__negative || __c == __lit[__num_base::_S_iplus])
&& !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
&& !(__c == __lc->_M_decimal_point))
{
if (++__beg != __end)
__c = *__beg;
else
__testeof = true;
}
}

bool __found_zero = false;

int __sep_pos = 0;
while (!__testeof)
{
if ((__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
|| __c == __lc->_M_decimal_point)
break;
else if (__c == __lit[__num_base::_S_izero]
&& (!__found_zero || __base == 10))
{
__found_zero = true;
++__sep_pos;
if (__basefield == 0)
__base = 8;
if (__base == 8)
__sep_pos = 0;
}
else if (__found_zero
&& (__c == __lit[__num_base::_S_ix]
|| __c == __lit[__num_base::_S_iX]))
{
if (__basefield == 0)
__base = 16;
if (__base == 16)
{
__found_zero = false;
__sep_pos = 0;
}
else
break;
}
else
break;

if (++__beg != __end)
{
__c = *__beg;
if (!__found_zero)
break;
}
else
__testeof = true;
}

const size_t len = (base == 16 ? __num_base::_S_iend

- __num_base::_S_izero : __base);

typedef __gnu_cxx::__numeric_traits<_ValueT> __num_traits;

string __found_grouping;
if (__lc->_M_use_grouping)
__found_grouping.reserve(32);
bool __testfail = false;
bool __testoverflow = false;
const __unsigned_type __max =
(__negative && __num_traits::__is_signed)
? -static_cast<__unsigned_type>(__num_traits::__min)
: __num_traits::__max;
const __unsigned_type __smax = __max / __base;
__unsigned_type __result = 0;
int __digit = 0;
const char_type* __lit_zero = __lit + __num_base::_S_izero;

if (!__lc->_M_allocated)

while (!__testeof)
{
__digit = _M_find(__lit_zero, __len, __c);
if (__digit == -1)
break;

if (result > smax)

__testoverflow = true;
else
{
__result *= __base;
__testoverflow |= __result > __max - __digit;
__result += __digit;
++__sep_pos;
}

if (++__beg != __end)
__c = *__beg;
else
__testeof = true;
}
else
while (!__testeof)
{

if (__lc->_M_use_grouping && c == lc->_M_thousands_sep)

{

if (__sep_pos)
{
__found_grouping += static_cast<char>(__sep_pos);
__sep_pos = 0;
}
else
{
__testfail = true;
break;
}
}
else if (__c == __lc->_M_decimal_point)
break;
else
{
const char_type* __q =
__traits_type::find(__lit_zero, __len, __c);
if (!__q)
break;

digit = q - __lit_zero;

if (__digit > 15)
__digit -= 6;
if (__result > __smax)
__testoverflow = true;
else
{
__result *= __base;
__testoverflow |= __result > __max - __digit;
__result += __digit;
++__sep_pos;
}
}

if (++__beg != __end)
__c = *__beg;
else
__testeof = true;
}

if (__found_grouping.size())
{

__found_grouping += static_cast<char>(__sep_pos);

if (!std::__verify_grouping(__lc->_M_grouping,
__lc->_M_grouping_size,
__found_grouping))
__err = ios_base::failbit;
}

if ((!__sep_pos && !__found_zero && !__found_grouping.size())

|| __testfail)
{
__v = 0;
__err = ios_base::failbit;
}
else if (__testoverflow)
{
if (__negative && __num_traits::__is_signed)
__v = __num_traits::__min;
else
__v = __num_traits::__max;
__err = ios_base::failbit;
}
else
__v = __negative ? -__result : __result;

if (__testeof)
__err |= ios_base::eofbit;
return __beg;
}

template<typename _CharT, typename _InIter>

_InIter
num_get<_CharT, _InIter>::
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, bool& __v) const
{
if (!(__io.flags() & ios_base::boolalpha))
{

long __l = -1;

__beg = _M_extract_int(__beg, __end, __io, __err, __l);
if (__l == 0 || __l == 1)
__v = bool(__l);
else
{
__v = true;
__err = ios_base::failbit;
if (__beg == __end)
__err |= ios_base::eofbit;
}
}
else
{

typedef __numpunct_cache<_CharT> __cache_type;

__use_cache<__cache_type> __uc;
const locale& __loc = __io._M_getloc();
const __cache_type* __lc = __uc(__loc);

bool __testf = true;

bool __testt = true;
bool __donef = __lc->_M_falsename_size == 0;
bool __donet = __lc->_M_truename_size == 0;
bool __testeof = false;
size_t __n = 0;
while (!__donef || !__donet)
{
if (__beg == __end)
{
__testeof = true;
break;
}

const char_type c = *beg;

if (!__donef)
__testf = __c == __lc->_M_falsename[__n];

if (!testf && donet)

_InIter
num_get<_CharT, _InIter>::
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, void*& __v) const
{

typedef ios_base::fmtflags fmtflags;

const fmtflags __fmt = __io.flags();
__io.flags((__fmt & ~ios_base::basefield) | ios_base::hex);

typedef __gnu_cxx::__conditional_type<(sizeof(void*)
<= sizeof(unsigned long)),
unsigned long, unsigned long long>::__type _UIntPtrType;

_UIntPtrType __ul;
__beg = _M_extract_int(__beg, __end, __io, __err, __ul);

__io.flags(__fmt);

__v = reinterpret_cast<void*>(__ul);
return __beg;
}
# 795 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.tcc" 3
template<typename _CharT, typename _OutIter>
void
num_put<_CharT, _OutIter>::
_M_pad(_CharT __fill, streamsize __w, ios_base& __io,
_CharT* __new, const _CharT* __cs, int& __len) const
{

__pad<_CharT, char_traits<_CharT> >::_S_pad(io, fill, __new,

__cs, __w, __len);
__len = static_cast<int>(__w);
}

template<typename _CharT, typename _ValueT>

int
__int_to_char(_CharT* __bufend, _ValueT __v, const _CharT* __lit,
ios_base::fmtflags __flags, bool __dec)
{
_CharT* __buf = __bufend;
if (__builtin_expect(__dec, true))
{

do
{
*--__buf = __lit[(__v % 10) + __num_base::_S_odigits];
__v /= 10;
}
while (__v != 0);
}
else if ((__flags & ios_base::basefield) == ios_base::oct)
{

do
{
*--__buf = __lit[(__v & 0x7) + __num_base::_S_odigits];
__v >>= 3;
}
while (__v != 0);
}
else
{

const bool uppercase = flags & ios_base::uppercase;

const int __case_offset = __uppercase ? __num_base::_S_oudigits
: __num_base::_S_odigits;
do
{
*--__buf = __lit[(__v & 0xf) + __case_offset];
__v >>= 4;
}
while (__v != 0);
}
return __bufend - __buf;
}

template<typename _CharT, typename _OutIter>

void
num_put<_CharT, _OutIter>::
_M_group_int(const char* __grouping, size_t __grouping_size, _CharT __sep,
ios_base&, _CharT* __new, _CharT* __cs, int& __len) const
{
_CharT* __p = std::__add_grouping(__new, __sep, __grouping,
__grouping_size, __cs, __cs + __len);
__len = __p - __new;
}

template<typename _CharT, typename _OutIter>

template<typename _ValueT>
_OutIter
num_put<_CharT, _OutIter>::
_M_insert_int(_OutIter __s, ios_base& __io, _CharT __fill,
_ValueT __v) const
{
using __gnu_cxx::__add_unsigned;
typedef typename __add_unsigned<_ValueT>::__type __unsigned_type;
typedef __numpunct_cache<_CharT> __cache_type;
__use_cache<__cache_type> __uc;
const locale& __loc = __io._M_getloc();
const __cache_type* __lc = __uc(__loc);
const _CharT* __lit = __lc->_M_atoms_out;
const ios_base::fmtflags __flags = __io.flags();

const int __ilen = 5 * sizeof(_ValueT);

_CharT* __cs = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
* __ilen));

const ios_base::fmtflags basefield = flags & ios_base::basefield;

const bool __dec = (__basefield != ios_base::oct
&& __basefield != ios_base::hex);
const __unsigned_type __u = ((__v > 0 || !__dec)
? __unsigned_type(__v)
: -__unsigned_type(__v));
int __len = __int_to_char(__cs + __ilen, __u, __lit, __flags, __dec);
__cs += __ilen - __len;

if (__lc->_M_use_grouping)
{

_CharT* __cs2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)

* (__len + 1)
* 2));
_M_group_int(__lc->_M_grouping, __lc->_M_grouping_size,
__lc->_M_thousands_sep, __io, __cs2 + 2, __cs, __len);
__cs = __cs2 + 2;
}

if (__builtin_expect(__dec, true))
{

if (__v >= 0)
{
if (bool(__flags & ios_base::showpos)
&& __gnu_cxx::__numeric_traits<_ValueT>::__is_signed)
*--__cs = __lit[__num_base::_S_oplus], ++__len;
}
else
*--__cs = __lit[__num_base::_S_ominus], ++__len;
}
else if (bool(__flags & ios_base::showbase) && __v)
{
if (__basefield == ios_base::oct)
*--__cs = __lit[__num_base::_S_odigits], ++__len;
else
{

const bool uppercase = flags & ios_base::uppercase;

*--__cs = __lit[__num_base::_S_ox + __uppercase];

*--__cs = __lit[__num_base::_S_odigits];
__len += 2;
}
}

const streamsize w = io.width();

if (__w > static_cast<streamsize>(__len))
{
_CharT* __cs3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
* __w));
_M_pad(__fill, __w, __io, __cs3, __cs, __len);
__cs = __cs3;
}
__io.width(0);

return std::write(s, cs, len);

}

template<typename _CharT, typename _OutIter>

void
num_put<_CharT, _OutIter>::
_M_group_float(const char* __grouping, size_t __grouping_size,
_CharT __sep, const _CharT* __p, _CharT* __new,
_CharT* __cs, int& __len) const
{

const int declen = p ? p - cs : __len;

_CharT* __p2 = std::__add_grouping(__new, __sep, __grouping,
__grouping_size,
__cs, __cs + __declen);

int newlen = p2 - __new;

if (__p)
{
char_traits<_CharT>::copy(__p2, __p, __len - __declen);
__newlen += __len - __declen;
}
__len = __newlen;
}
# 989 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.tcc" 3
template<typename _CharT, typename _OutIter>
template<typename _ValueT>
_OutIter
num_put<_CharT, _OutIter>::
_M_insert_float(_OutIter __s, ios_base& __io, _CharT __fill, char __mod,
_ValueT __v) const
{
typedef __numpunct_cache<_CharT> __cache_type;
__use_cache<__cache_type> __uc;
const locale& __loc = __io._M_getloc();
const __cache_type* __lc = __uc(__loc);

const streamsize prec = io.precision() < 0 ? 6 : __io.precision();

const int __max_digits =

__gnu_cxx::__numeric_traits<_ValueT>::__digits10;

int __len;

char __fbuf[16];
__num_base::_S_format_float(__io, __fbuf, __mod);

const bool __use_prec =

(__io.flags() & ios_base::floatfield) != ios_base::floatfield;

int __cs_size = __max_digits * 3;

char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
if (__use_prec)
__len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
__fbuf, __prec, __v);
else
__len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
__fbuf, __v);

if (len >= cs_size)

{
__cs_size = __len + 1;
__cs = static_cast<char*>(__builtin_alloca(__cs_size));
if (__use_prec)
__len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
__fbuf, __prec, __v);
else
__len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
__fbuf, __v);
}
# 1062 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.tcc" 3
const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);

_CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)

* __len));
__ctype.widen(__cs, __cs + __len, __ws);

_CharT* __wp = 0;
const char* __p = char_traits<char>::find(__cs, __len, '.');
if (__p)
{
__wp = __ws + (__p - __cs);
*__wp = __lc->_M_decimal_point;
}

if (__lc->_M_use_grouping
&& (__wp || __len < 3 || (__cs[1] <= '9' && __cs[2] <= '9'
&& __cs[1] >= '0' && __cs[2] >= '0')))
{

_CharT* __ws2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)

* __len * 2));

streamsize __off = 0;
if (__cs[0] == '-' || __cs[0] == '+')
{
__off = 1;
__ws2[0] = __ws[0];
__len -= 1;
}

_M_group_float(__lc->_M_grouping, __lc->_M_grouping_size,
__lc->_M_thousands_sep, __wp, __ws2 + __off,
__ws + __off, __len);
__len += __off;

__ws = __ws2;
}

const streamsize w = io.width();

if (__w > static_cast<streamsize>(__len))
{
_CharT* __ws3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
* __w));
_M_pad(__fill, __w, __io, __ws3, __ws, __len);
__ws = __ws3;
}
__io.width(0);

return std::write(s, ws, len);

}

template<typename _CharT, typename _OutIter>

_OutIter
num_put<_CharT, _OutIter>::
do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const
{
const ios_base::fmtflags __flags = __io.flags();
if ((__flags & ios_base::boolalpha) == 0)
{
const long __l = __v;
__s = _M_insert_int(__s, __io, __fill, __l);
}
else
{
typedef __numpunct_cache<_CharT> __cache_type;
__use_cache<__cache_type> __uc;
const locale& __loc = __io._M_getloc();
const __cache_type* __lc = __uc(__loc);

const _CharT* name = v ? __lc->_M_truename

: __lc->_M_falsename;
int __len = __v ? __lc->_M_truename_size
: __lc->_M_falsename_size;

const streamsize w = io.width();

if (__w > static_cast<streamsize>(__len))
{
const streamsize __plen = __w - __len;
_CharT* __ps
= static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
* __plen));

char_traits<_CharT>::assign(ps, plen, __fill);

__io.width(0);

if ((__flags & ios_base::adjustfield) == ios_base::left)

{
__s = std::__write(__s, __name, __len);
__s = std::__write(__s, __ps, __plen);
}
else
{
__s = std::__write(__s, __ps, __plen);
__s = std::__write(__s, __name, __len);
}
return __s;
}
__io.width(0);
__s = std::__write(__s, __name, __len);
}
return __s;
}

template<typename _CharT, typename _OutIter>

_OutIter
num_put<_CharT, _OutIter>::
do_put(iter_type __s, ios_base& __io, char_type __fill, double __v) const
{ return _M_insert_float(__s, __io, __fill, char(), __v); }
# 1187 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.tcc" 3
template<typename _CharT, typename _OutIter>
_OutIter
num_put<_CharT, _OutIter>::
do_put(iter_type __s, ios_base& __io, char_type __fill,
long double __v) const
{ return _M_insert_float(__s, __io, __fill, 'L', __v); }

template<typename _CharT, typename _OutIter>

_OutIter
num_put<_CharT, _OutIter>::
do_put(iter_type __s, ios_base& __io, char_type __fill,
const void* __v) const
{
const ios_base::fmtflags __flags = __io.flags();
const ios_base::fmtflags __fmt = ~(ios_base::basefield
| ios_base::uppercase);
__io.flags((__flags & __fmt) | (ios_base::hex | ios_base::showbase));

typedef __gnu_cxx::__conditional_type<(sizeof(const void*)

<= sizeof(unsigned long)),
unsigned long, unsigned long long>::__type _UIntPtrType;

__s = _M_insert_int(s, io, __fill,

reinterpret_cast<_UIntPtrType>(__v));
__io.flags(__flags);
return __s;
}
# 1224 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.tcc" 3
# 1233 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.tcc" 3
template<typename _CharT, typename _Traits>
void
__pad<_CharT, _Traits>::_S_pad(ios_base& __io, _CharT __fill,
_CharT* __news, const _CharT* __olds,
streamsize __newlen, streamsize __oldlen)
{
const size_t __plen = static_cast<size_t>(__newlen - __oldlen);
const ios_base::fmtflags __adjust = __io.flags() & ios_base::adjustfield;

if (__adjust == ios_base::left)
{
_Traits::copy(__news, __olds, __oldlen);
_Traits::assign(__news + __oldlen, __plen, __fill);
return;
}

size_t __mod = 0;
if (__adjust == ios_base::internal)
{

const locale& loc = io._M_getloc();

const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);

if (__ctype.widen('-') == __olds[0]
|| __ctype.widen('+') == __olds[0])
{
__news[0] = __olds[0];
__mod = 1;
++__news;
}
else if (__ctype.widen('0') == __olds[0]
&& __oldlen > 1
&& (__ctype.widen('x') == __olds[1]
|| __ctype.widen('X') == __olds[1]))
{
__news[0] = __olds[0];
__news[1] = __olds[1];
__mod = 2;
__news += 2;
}

}
_Traits::assign(__news, __plen, __fill);
_Traits::copy(__news + __plen, __olds + __mod, __oldlen - __mod);
}

template<typename _CharT>
_CharT*
__add_grouping(_CharT* __s, _CharT __sep,
const char* __gbeg, size_t __gsize,
const _CharT* __first, const _CharT* __last)
{
size_t __idx = 0;
size_t __ctr = 0;
while (__last - __first > __gbeg[__idx]
&& static_cast<signed char>(__gbeg[__idx]) > 0
&& __gbeg[__idx] != __gnu_cxx::__numeric_traits<char>::__max)
{
__last -= __gbeg[__idx];
__idx < __gsize - 1 ? ++__idx : ++__ctr;
}

while (first != last)

*__s++ = *__first++;

while (__ctr--)
{
*__s++ = __sep;
for (char __i = __gbeg[__idx]; __i > 0; --__i)
*__s++ = *__first++;
}

while (__idx--)
{
*__s++ = __sep;
for (char __i = __gbeg[__idx]; __i > 0; --__i)
*__s++ = *__first++;
}

return __s;
}

extern template class __cxx11:: numpunct<char>;

extern template class __cxx11:: numpunct_byname<char>;
extern template class num_get<char>;
extern template class num_put<char>;
extern template class ctype_byname<char>;

extern template
const ctype<char>*
__try_use_facet<ctype<char> >(const locale&) noexcept;

extern template
const numpunct<char>*
__try_use_facet<numpunct<char> >(const locale&) noexcept;

extern template
const num_put<char>*
__try_use_facet<num_put<char> >(const locale&) noexcept;

extern template
const num_get<char>*
__try_use_facet<num_get<char> >(const locale&) noexcept;

extern template
const ctype<char>&
use_facet<ctype<char> >(const locale&);

extern template
const numpunct<char>&
use_facet<numpunct<char> >(const locale&);

extern template
const num_put<char>&
use_facet<num_put<char> >(const locale&);

extern template
const num_get<char>&
use_facet<num_get<char> >(const locale&);

extern template
bool
has_facet<ctype<char> >(const locale&);

extern template
bool
has_facet<numpunct<char> >(const locale&);

extern template
bool
has_facet<num_put<char> >(const locale&);

extern template
bool
has_facet<num_get<char> >(const locale&);

extern template class __cxx11:: numpunct<wchar_t>;

extern template class __cxx11:: numpunct_byname<wchar_t>;
extern template class num_get<wchar_t>;
extern template class num_put<wchar_t>;
extern template class ctype_byname<wchar_t>;

extern template
const ctype<wchar_t>*
__try_use_facet<ctype<wchar_t> >(const locale&) noexcept;

extern template
const numpunct<wchar_t>*
__try_use_facet<numpunct<wchar_t> >(const locale&) noexcept;

extern template
const num_put<wchar_t>*
__try_use_facet<num_put<wchar_t> >(const locale&) noexcept;

extern template
const num_get<wchar_t>*
__try_use_facet<num_get<wchar_t> >(const locale&) noexcept;

extern template
const ctype<wchar_t>&
use_facet<ctype<wchar_t> >(const locale&);

extern template
const numpunct<wchar_t>&
use_facet<numpunct<wchar_t> >(const locale&);

extern template
const num_put<wchar_t>&
use_facet<num_put<wchar_t> >(const locale&);

extern template
const num_get<wchar_t>&
use_facet<num_get<wchar_t> >(const locale&);

extern template
bool
has_facet<ctype<wchar_t> >(const locale&);

extern template
bool
has_facet<numpunct<wchar_t> >(const locale&);

extern template
bool
has_facet<num_put<wchar_t> >(const locale&);

extern template
bool
has_facet<num_get<wchar_t> >(const locale&);

}
# 2688 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets.h" 2 3
# 43 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/locale" 2 3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h" 1
3
# 37 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h"
3

# 38 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h"
3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/ctime" 1 3
# 39 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/ctime" 3

# 40 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/ctime" 3
# 58 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/ctime" 3
namespace std
{
using ::clock_t;
using ::time_t;
using ::tm;

using ::clock;
using ::difftime;
using ::mktime;
using ::time;
using ::asctime;
using ::ctime;
using ::gmtime;
using ::localtime;
using ::strftime;
}
# 40 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h"
2 3
namespace std
{

# 52 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h"
3
class time_base
{
public:
enum dateorder { no_order, dmy, mdy, ymd, ydm };
};

template<typename _CharT>
struct __timepunct_cache : public locale::facet
{

static const _CharT* _S_timezones[14];

const _CharT* _M_date_format;

const _CharT* _M_date_era_format;
const _CharT* _M_time_format;
const _CharT* _M_time_era_format;
const _CharT* _M_date_time_format;
const _CharT* _M_date_time_era_format;
const _CharT* _M_am;
const _CharT* _M_pm;
const _CharT* _M_am_pm_format;

const _CharT* _M_day1;

const _CharT* _M_day2;
const _CharT* _M_day3;
const _CharT* _M_day4;
const _CharT* _M_day5;
const _CharT* _M_day6;
const _CharT* _M_day7;

const _CharT* _M_aday1;

const _CharT* _M_aday2;
const _CharT* _M_aday3;
const _CharT* _M_aday4;
const _CharT* _M_aday5;
const _CharT* _M_aday6;
const _CharT* _M_aday7;

const _CharT* _M_month01;

const _CharT* _M_month02;
const _CharT* _M_month03;
const _CharT* _M_month04;
const _CharT* _M_month05;
const _CharT* _M_month06;
const _CharT* _M_month07;
const _CharT* _M_month08;
const _CharT* _M_month09;
const _CharT* _M_month10;
const _CharT* _M_month11;
const _CharT* _M_month12;
const _CharT* _M_amonth01;
const _CharT* _M_amonth02;
const _CharT* _M_amonth03;
const _CharT* _M_amonth04;
const _CharT* _M_amonth05;
const _CharT* _M_amonth06;
const _CharT* _M_amonth07;
const _CharT* _M_amonth08;
const _CharT* _M_amonth09;
const _CharT* _M_amonth10;
const _CharT* _M_amonth11;
const _CharT* _M_amonth12;

bool _M_allocated;

__timepunct_cache(size_t refs = 0) : facet(refs),

_M_date_format(0), _M_date_era_format(0), _M_time_format(0),
_M_time_era_format(0), _M_date_time_format(0),
_M_date_time_era_format(0), _M_am(0), _M_pm(0),
_M_am_pm_format(0), _M_day1(0), _M_day2(0), _M_day3(0),
_M_day4(0), _M_day5(0), _M_day6(0), _M_day7(0),
_M_aday1(0), _M_aday2(0), _M_aday3(0), _M_aday4(0),
_M_aday5(0), _M_aday6(0), _M_aday7(0), _M_month01(0),
_M_month02(0), _M_month03(0), _M_month04(0), _M_month05(0),
_M_month06(0), _M_month07(0), _M_month08(0), _M_month09(0),
_M_month10(0), _M_month11(0), _M_month12(0), _M_amonth01(0),
_M_amonth02(0), _M_amonth03(0), _M_amonth04(0),
_M_amonth05(0), _M_amonth06(0), _M_amonth07(0),
_M_amonth08(0), _M_amonth09(0), _M_amonth10(0),
_M_amonth11(0), _M_amonth12(0), _M_allocated(false)
{ }

~__timepunct_cache();

private:
__timepunct_cache&
operator=(const __timepunct_cache&);

explicit
__timepunct_cache(const __timepunct_cache&);
};

template<typename _CharT>
__timepunct_cache<_CharT>::~__timepunct_cache()
{
if (_M_allocated)
{

}
}

template<>
const char*
__timepunct_cache<char>::_S_timezones[14];
template<>
const wchar_t*
__timepunct_cache<wchar_t>::_S_timezones[14];

template<typename _CharT>
const _CharT* __timepunct_cache<_CharT>::_S_timezones[14];

template<typename _CharT>
class __timepunct : public locale::facet
{
public:

typedef _CharT __char_type;

typedef __timepunct_cache<_CharT> __cache_type;

protected:
__cache_type* _M_data;
__c_locale _M_c_locale_timepunct;
const char* _M_name_timepunct;

public:

static locale::id id;

explicit
__timepunct(size_t __refs = 0);

explicit
__timepunct(__cache_type* __cache, size_t __refs = 0);
# 206 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h"
3
explicit
__timepunct(__c_locale __cloc, const char* __s, size_t __refs = 0);

void
_M_put(_CharT* __s, size_t __maxlen, const _CharT* __format,
const tm* __tm) const throw ();

void
_M_date_formats(const _CharT** __date) const
{

__date[0] = _M_data->_M_date_format;
__date[1] = _M_data->_M_date_era_format;
}

void
_M_time_formats(const _CharT** __time) const
{

__time[0] = _M_data->_M_time_format;
__time[1] = _M_data->_M_time_era_format;
}

void
_M_date_time_formats(const _CharT** __dt) const
{

__dt[0] = _M_data->_M_date_time_format;
__dt[1] = _M_data->_M_date_time_era_format;
}

void
_M_am_pm_format(const _CharT*) const
{ }

void
_M_am_pm_format(const _CharT** __ampm_format) const
{
__ampm_format[0] = _M_data->_M_am_pm_format;
}

void
_M_am_pm(const _CharT** __ampm) const
{
__ampm[0] = _M_data->_M_am;
__ampm[1] = _M_data->_M_pm;
}

void
_M_days(const _CharT** __days) const
{
__days[0] = _M_data->_M_day1;
__days[1] = _M_data->_M_day2;
__days[2] = _M_data->_M_day3;
__days[3] = _M_data->_M_day4;
__days[4] = _M_data->_M_day5;
__days[5] = _M_data->_M_day6;
__days[6] = _M_data->_M_day7;
}

void
_M_days_abbreviated(const _CharT** __days) const
{
__days[0] = _M_data->_M_aday1;
__days[1] = _M_data->_M_aday2;
__days[2] = _M_data->_M_aday3;
__days[3] = _M_data->_M_aday4;
__days[4] = _M_data->_M_aday5;
__days[5] = _M_data->_M_aday6;
__days[6] = _M_data->_M_aday7;
}

void
_M_months(const _CharT** __months) const
{
__months[0] = _M_data->_M_month01;
__months[1] = _M_data->_M_month02;
__months[2] = _M_data->_M_month03;
__months[3] = _M_data->_M_month04;
__months[4] = _M_data->_M_month05;
__months[5] = _M_data->_M_month06;
__months[6] = _M_data->_M_month07;
__months[7] = _M_data->_M_month08;
__months[8] = _M_data->_M_month09;
__months[9] = _M_data->_M_month10;
__months[10] = _M_data->_M_month11;
__months[11] = _M_data->_M_month12;
}

void
_M_months_abbreviated(const _CharT** __months) const
{
__months[0] = _M_data->_M_amonth01;
__months[1] = _M_data->_M_amonth02;
__months[2] = _M_data->_M_amonth03;
__months[3] = _M_data->_M_amonth04;
__months[4] = _M_data->_M_amonth05;
__months[5] = _M_data->_M_amonth06;
__months[6] = _M_data->_M_amonth07;
__months[7] = _M_data->_M_amonth08;
__months[8] = _M_data->_M_amonth09;
__months[9] = _M_data->_M_amonth10;
__months[10] = _M_data->_M_amonth11;
__months[11] = _M_data->_M_amonth12;
}

protected:
virtual
~__timepunct();

void
_M_initialize_timepunct(__c_locale __cloc = 0);
};

template<typename _CharT>
locale::id __timepunct<_CharT>::id;

template<>
void
__timepunct<char>::_M_initialize_timepunct(__c_locale __cloc);

template<>
void
__timepunct<char>::_M_put(char*, size_t, const char*, const tm*) const throw
();

template<>
void
__timepunct<wchar_t>::_M_initialize_timepunct(__c_locale __cloc);

template<>
void
__timepunct<wchar_t>::_M_put(wchar_t*, size_t, const wchar_t*,
const tm*) const throw ();
}

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/x86_64-w64-mingw32/bits/
time_members.h" 1 3
# 37 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/x86_64-w64-mingw32/bits/
time_members.h" 3
namespace std
{

template<typename _CharT>
__timepunct<_CharT>::__timepunct(size_t __refs)
: facet(__refs), _M_data(0)
{
_M_name_timepunct = _S_get_c_name();
_M_initialize_timepunct();
}

template<typename _CharT>
__timepunct<_CharT>::__timepunct(__cache_type* __cache, size_t __refs)
: facet(__refs), _M_data(__cache)
{
_M_name_timepunct = _S_get_c_name();
_M_initialize_timepunct();
}

template<typename _CharT>
__timepunct<_CharT>::__timepunct(__c_locale __cloc, const char* __s,
size_t __refs)
: facet(__refs), _M_data(0)
{
if (__builtin_strcmp(__s, _S_get_c_name()) != 0)
{
const size_t __len = __builtin_strlen(__s) + 1;
char* __tmp = new char[__len];
__builtin_memcpy(__tmp, __s, __len);
_M_name_timepunct = __tmp;
}
else
_M_name_timepunct = _S_get_c_name();

try
{ _M_initialize_timepunct(__cloc); }
catch(...)
{
if (_M_name_timepunct != _S_get_c_name())
delete [] _M_name_timepunct;
throw;
}
}

template<typename _CharT>
__timepunct<_CharT>::~__timepunct()
{
if (_M_name_timepunct != _S_get_c_name())
delete [] _M_name_timepunct;
delete _M_data;
_S_destroy_c_locale(_M_c_locale_timepunct);
}

}
# 353 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h"
2 3

namespace std
{

struct __time_get_state
{

void
_M_finalize_state(tm* __tm);

unsigned int _M_have_I : 1;

unsigned int _M_have_wday : 1;
unsigned int _M_have_yday : 1;
unsigned int _M_have_mon : 1;
unsigned int _M_have_mday : 1;
unsigned int _M_have_uweek : 1;
unsigned int _M_have_wweek : 1;
unsigned int _M_have_century : 1;
unsigned int _M_is_pm : 1;
unsigned int _M_want_century : 1;
unsigned int _M_want_xday : 1;
unsigned int _M_pad1 : 5;
unsigned int _M_week_no : 6;
unsigned int _M_pad2 : 10;
int _M_century;
int _M_pad3;
};

namespace __cxx11 {
# 397 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h"
3
template<typename _CharT, typename _InIter>
class time_get : public locale::facet, public time_base
{
public:

typedef _CharT char_type;

typedef _InIter iter_type;

static locale::id id;

# 418 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h"
3
explicit
time_get(size_t __refs = 0)
: facet (__refs) { }
# 435 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h"
3
dateorder
date_order() const
{ return this->do_date_order(); }
# 459 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h"
3
iter_type
get_time(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, tm* __tm) const
{ return this->do_get_time(__beg, __end, __io, __err, __tm); }
# 484 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h"
3
iter_type
get_date(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, tm* __tm) const
{ return this->do_get_date(__beg, __end, __io, __err, __tm); }
# 512 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h"
3
iter_type
get_weekday(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, tm* __tm) const
{ return this->do_get_weekday(__beg, __end, __io, __err, __tm); }
# 541 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h"
3
iter_type
get_monthname(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, tm* __tm) const
{ return this->do_get_monthname(__beg, __end, __io, __err, __tm); }
# 567 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h"
3
iter_type
get_year(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, tm* __tm) const
{ return this->do_get_year(__beg, __end, __io, __err, __tm); }
# 588 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h"
3
inline
iter_type get(iter_type __s, iter_type __end, ios_base& __io,
ios_base::iostate& __err, tm* __tm, char __format,
char __modifier = 0) const
{
return this->do_get(__s, __end, __io, __err, __tm, __format,
__modifier);
}
# 615 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h"
3
iter_type get(iter_type __s, iter_type __end, ios_base& __io,
ios_base::iostate& __err, tm* __tm, const char_type* __fmt,
const char_type* __fmtend) const;

protected:

virtual
~time_get() { }
# 635 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h"
3
virtual dateorder
do_date_order() const;
# 653 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h"
3
virtual iter_type
do_get_time(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, tm* __tm) const;
# 672 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h"
3
virtual iter_type
do_get_date(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, tm* __tm) const;
# 691 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h"
3
virtual iter_type
do_get_weekday(iter_type __beg, iter_type __end, ios_base&,
ios_base::iostate& __err, tm* __tm) const;
# 710 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h"
3
virtual iter_type
do_get_monthname(iter_type __beg, iter_type __end, ios_base&,
ios_base::iostate& __err, tm* __tm) const;
# 729 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h"
3
virtual iter_type
do_get_year(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, tm* __tm) const;
# 752 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h"
3
virtual

iter_type
do_get(iter_type __s, iter_type __end, ios_base& __f,
ios_base::iostate& __err, tm* __tm,
char __format, char __modifier) const;

iter_type
_M_extract_num(iter_type __beg, iter_type __end, int& __member,
int __min, int __max, size_t __len,
ios_base& __io, ios_base::iostate& __err) const;

typedef _OutIter iter_type;

explicit
time_put_byname(const char*, size_t __refs = 0)
: time_put<_CharT, _OutIter>(__refs)
{ }

explicit
time_put_byname(const string& __s, size_t __refs = 0)
: time_put_byname(__s.c_str(), __refs) { }

protected:
virtual
~time_put_byname() { }
};
# 966 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h"
3
class money_base
{
public:
enum part { none, space, symbol, sign, value };
struct pattern { char field[4]; };

static const pattern _S_default_pattern;

enum
{
_S_minus,
_S_zero,
_S_end = 11
};

static const char* _S_atoms;

attribute ((const)) static pattern

_S_construct_pattern(char __precedes, char __space, char __posn) throw ();
};

template<typename _CharT, bool _Intl>

struct __moneypunct_cache : public locale::facet
{
const char* _M_grouping;
size_t _M_grouping_size;
bool _M_use_grouping;
_CharT _M_decimal_point;
_CharT _M_thousands_sep;
const _CharT* _M_curr_symbol;
size_t _M_curr_symbol_size;
const _CharT* _M_positive_sign;
size_t _M_positive_sign_size;
const _CharT* _M_negative_sign;
size_t _M_negative_sign_size;
int _M_frac_digits;
money_base::pattern _M_pos_format;
money_base::pattern _M_neg_format;

_CharT _M_atoms[money_base::_S_end];

bool _M_allocated;

__moneypunct_cache(size_t refs = 0) : facet(refs),

_M_grouping(0), _M_grouping_size(0), _M_use_grouping(false),
_M_decimal_point(_CharT()), _M_thousands_sep(_CharT()),
_M_curr_symbol(0), _M_curr_symbol_size(0),
_M_positive_sign(0), _M_positive_sign_size(0),
_M_negative_sign(0), _M_negative_sign_size(0),
_M_frac_digits(0),
_M_pos_format(money_base::pattern()),
_M_neg_format(money_base::pattern()), _M_allocated(false)
{ }

~__moneypunct_cache();

void
_M_cache(const locale& __loc);

private:
__moneypunct_cache&
operator=(const __moneypunct_cache&);
explicit
__moneypunct_cache(const __moneypunct_cache&);
};

template<typename _CharT, bool _Intl>

__moneypunct_cache<_CharT, _Intl>::~__moneypunct_cache()
{
if (_M_allocated)
{
delete [] _M_grouping;
delete [] _M_curr_symbol;
delete [] _M_positive_sign;
delete [] _M_negative_sign;
}
}

namespace __cxx11 {
# 1061
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h" 3
template<typename _CharT, bool _Intl>
class moneypunct : public locale::facet, public money_base
{
public:

typedef _CharT char_type;

typedef basic_string<_CharT> string_type;

typedef __moneypunct_cache<_CharT, _Intl> __cache_type;

private:
__cache_type* _M_data;

public:

static const bool intl = _Intl;

static locale::id id;

# 1090
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h" 3
explicit
moneypunct(size_t __refs = 0)
: facet(__refs), _M_data(0)
{ _M_initialize_moneypunct(); }
# 1103
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h" 3
explicit
moneypunct(__cache_type* __cache, size_t __refs = 0)
: facet(__refs), _M_data(__cache)
{ _M_initialize_moneypunct(); }
# 1118
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h" 3
explicit
moneypunct(__c_locale __cloc, const char* __s, size_t __refs = 0)
: facet(__refs), _M_data(0)
{ _M_initialize_moneypunct(__cloc, __s); }
# 1132
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h" 3
char_type
decimal_point() const
{ return this->do_decimal_point(); }
# 1145
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h" 3
char_type
thousands_sep() const
{ return this->do_thousands_sep(); }
# 1175
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h" 3
string
grouping() const
{ return this->do_grouping(); }
# 1188
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h" 3
string_type
curr_symbol() const
{ return this->do_curr_symbol(); }
# 1205
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h" 3
string_type
positive_sign() const
{ return this->do_positive_sign(); }
# 1222
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h" 3
string_type
negative_sign() const
{ return this->do_negative_sign(); }
# 1238
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h" 3
int
frac_digits() const
{ return this->do_frac_digits(); }
# 1274
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h" 3
pattern
pos_format() const
{ return this->do_pos_format(); }

pattern
neg_format() const
{ return this->do_neg_format(); }

protected:

virtual
~moneypunct();
# 1296
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h" 3
virtual char_type
do_decimal_point() const
{ return _M_data->_M_decimal_point; }
# 1308
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h" 3
virtual char_type
do_thousands_sep() const
{ return _M_data->_M_thousands_sep; }
# 1321
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h" 3
virtual string
do_grouping() const
{ return _M_data->_M_grouping; }
# 1334
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h" 3
virtual string_type
do_curr_symbol() const
{ return _M_data->_M_curr_symbol; }
# 1347
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h" 3
virtual string_type
do_positive_sign() const
{ return _M_data->_M_positive_sign; }
# 1360
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h" 3
virtual string_type
do_negative_sign() const
{ return _M_data->_M_negative_sign; }
# 1374
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h" 3
virtual int
do_frac_digits() const
{ return _M_data->_M_frac_digits; }
# 1388
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h" 3
virtual pattern
do_pos_format() const
{ return _M_data->_M_pos_format; }
# 1402
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h" 3
virtual pattern
do_neg_format() const
{ return _M_data->_M_neg_format; }

void
_M_initialize_moneypunct(__c_locale __cloc = 0,
const char* __name = 0);
};

template<typename _CharT, bool _Intl>

locale::id moneypunct<_CharT, _Intl>::id;

template<typename _CharT, bool _Intl>

const bool moneypunct<_CharT, _Intl>::intl;

template<>
moneypunct<char, true>::~moneypunct();

template<>
moneypunct<char, false>::~moneypunct();

template<>
void
moneypunct<char, true>::_M_initialize_moneypunct(__c_locale, const char*);
template<>
void
moneypunct<char, false>::_M_initialize_moneypunct(__c_locale, const char*);

template<>
moneypunct<wchar_t, true>::~moneypunct();

template<>
moneypunct<wchar_t, false>::~moneypunct();

template<>
void
moneypunct<wchar_t, true>::_M_initialize_moneypunct(__c_locale,
const char*);

template<>
void
moneypunct<wchar_t, false>::_M_initialize_moneypunct(__c_locale,
const char*);

template<typename _CharT, bool _Intl>

class moneypunct_byname : public moneypunct<_CharT, _Intl>
{
public:
typedef _CharT char_type;
typedef basic_string<_CharT> string_type;

static const bool intl = _Intl;

explicit
moneypunct_byname(const char* __s, size_t __refs = 0)
: moneypunct<_CharT, _Intl>(__refs)
{
if (__builtin_strcmp(__s, "C") != 0
&& __builtin_strcmp(__s, "POSIX") != 0)
{
__c_locale __tmp;
this->_S_create_c_locale(__tmp, __s);
this->_M_initialize_moneypunct(__tmp);
this->_S_destroy_c_locale(__tmp);
}
}

explicit
moneypunct_byname(const string& __s, size_t __refs = 0)
: moneypunct_byname(__s.c_str(), __refs) { }

protected:
virtual
~moneypunct_byname() { }
};

template<typename _CharT, bool _Intl>

const bool moneypunct_byname<_CharT, _Intl>::intl;
}

namespace __cxx11 {
# 1505
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h" 3
template<typename _CharT, typename _InIter>
class money_get : public locale::facet
{
public:

typedef _CharT char_type;

typedef _InIter iter_type;
typedef basic_string<_CharT> string_type;

static locale::id id;

# 1527
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h" 3
explicit
money_get(size_t __refs = 0) : facet(__refs) { }
# 1557
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h" 3
iter_type
get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
ios_base::iostate& __err, long double& __units) const
{ return this->do_get(__s, __end, __intl, __io, __err, __units); }
# 1588
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h" 3
iter_type
get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
ios_base::iostate& __err, string_type& __digits) const
{ return this->do_get(__s, __end, __intl, __io, __err, __digits); }

protected:

virtual
~money_get() { }
# 1612
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h" 3
virtual iter_type
do_get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
ios_base::iostate& __err, long double& __units) const;
# 1624
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h" 3
virtual iter_type
do_get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
ios_base::iostate& __err, string_type& __digits) const;
# 1644
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h" 3
template<bool _Intl>
iter_type
_M_extract(iter_type __s, iter_type __end, ios_base& __io,
ios_base::iostate& __err, string& __digits) const;
};
template<typename _CharT, typename _InIter>
locale::id money_get<_CharT, _InIter>::id;
# 1666
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h" 3
template<typename _CharT, typename _OutIter>
class money_put : public locale::facet
{
public:

typedef _CharT char_type;

typedef _OutIter iter_type;
typedef basic_string<_CharT> string_type;

static locale::id id;

# 1687
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h" 3
explicit
money_put(size_t __refs = 0) : facet(__refs) { }
# 1707
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h" 3
iter_type
put(iter_type __s, bool __intl, ios_base& __io,
char_type __fill, long double __units) const
{ return this->do_put(__s, __intl, __io, __fill, __units); }
# 1730
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h" 3
iter_type
put(iter_type __s, bool __intl, ios_base& __io,
char_type __fill, const string_type& __digits) const
{ return this->do_put(__s, __intl, __io, __fill, __digits); }

protected:

virtual
~money_put() { }
# 1765
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h" 3
virtual iter_type
do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
long double __units) const;
# 1789
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h" 3
virtual iter_type
do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
const string_type& __digits) const;
# 1809
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h" 3
template<bool _Intl>
iter_type
_M_insert(iter_type __s, ios_base& __io, char_type __fill,
const string_type& __digits) const;
};

template<typename _CharT, typename _OutIter>

locale::id money_put<_CharT, _OutIter>::id;
}

struct messages_base
{
typedef int catalog;
};

namespace __cxx11 {
# 1852
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h" 3
template<typename _CharT>
class messages : public locale::facet, public messages_base
{
public:

typedef _CharT char_type;

typedef basic_string<_CharT> string_type;

protected:

__c_locale _M_c_locale_messages;
const char* _M_name_messages;

public:

static locale::id id;

# 1880
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h" 3
explicit
messages(size_t __refs = 0);
# 1894
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h" 3
explicit
messages(__c_locale __cloc, const char* __s, size_t __refs = 0);
# 1907
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h" 3
catalog
open(const basic_string<char>& __s, const locale& __loc) const
{ return this->do_open(__s, __loc); }
# 1925
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h" 3
catalog
open(const basic_string<char>&, const locale&, const char*) const;
# 1943
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h" 3
string_type
get(catalog __c, int __set, int __msgid, const string_type& __s) const
{ return this->do_get(__c, __set, __msgid, __s); }
# 1954
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h" 3
void
close(catalog __c) const
{ return this->do_close(__c); }

protected:

virtual
~messages();
# 1974
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h" 3
virtual catalog
do_open(const basic_string<char>&, const locale&) const;
# 1993
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h" 3
virtual string_type
do_get(catalog, int, int, const string_type& __dfault) const;

virtual void
do_close(catalog) const;

char*
_M_convert_to_char(const string_type& __msg) const
{

return reinterpret_cast<char*>(const_cast<_CharT*>(__msg.c_str()));
}

string_type
_M_convert_from_char(char*) const
{

return string_type();
}
};

template<typename _CharT>
locale::id messages<_CharT>::id;

template<>
string
messages<char>::do_get(catalog, int, int, const string&) const;

template<>
wstring
messages<wchar_t>::do_get(catalog, int, int, const wstring&) const;

template<typename _CharT>
class messages_byname : public messages<_CharT>
{
public:
typedef _CharT char_type;
typedef basic_string<_CharT> string_type;

explicit
messages_byname(const char* __s, size_t __refs = 0);

explicit
messages_byname(const string& __s, size_t __refs = 0)
: messages_byname(__s.c_str(), __refs) { }

protected:
virtual
~messages_byname()
{ }
};

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/x86_64-w64-mingw32/bits/
messages_members.h" 1 3
# 36 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/x86_64-w64-mingw32/bits/
messages_members.h" 3
namespace std
{

template<typename _CharT>
messages<_CharT>::messages(size_t __refs)
: facet(__refs)
{ _M_c_locale_messages = _S_get_c_locale(); }

template<typename _CharT>
messages<_CharT>::messages(__c_locale, const char*, size_t __refs)
: facet(__refs)
{ _M_c_locale_messages = _S_get_c_locale(); }

template<typename _CharT>
typename messages<_CharT>::catalog
messages<_CharT>::open(const basic_string<char>& __s, const locale& __loc,
const char*) const
{ return this->do_open(__s, __loc); }

template<typename _CharT>
messages<_CharT>::~messages()
{ _S_destroy_c_locale(_M_c_locale_messages); }

template<typename _CharT>
typename messages<_CharT>::catalog
messages<_CharT>::do_open(const basic_string<char>&, const locale&) const
{ return 0; }
template<typename _CharT>
typename messages<_CharT>::string_type
messages<_CharT>::do_get(catalog, int, int,
const string_type& __dfault) const
{ return __dfault; }

template<typename _CharT>
void
messages<_CharT>::do_close(catalog) const
{ }

template<typename _CharT>
messages_byname<_CharT>::messages_byname(const char* __s, size_t __refs)
: messages<_CharT>(__refs)
{
if (__builtin_strcmp(__s, "C") != 0
&& __builtin_strcmp(__s, "POSIX") != 0)
{
this->_S_destroy_c_locale(this->_M_c_locale_messages);
this->_S_create_c_locale(this->_M_c_locale_messages, __s);
}
}

}
# 2065
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h" 2 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/codecvt.h" 1 3
# 39 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/codecvt.h" 3

# 40 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/codecvt.h" 3

namespace std
{

class codecvt_base
{
public:
enum result
{
ok,
partial,
error,
noconv
};
};
# 70 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/codecvt.h" 3
template<typename _InternT, typename _ExternT, typename _StateT>
class __codecvt_abstract_base
: public locale::facet, public codecvt_base
{
public:

typedef codecvt_base::result result;

typedef _InternT intern_type;
typedef _ExternT extern_type;
typedef _StateT state_type;
# 118 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/codecvt.h" 3
result
out(state_type& __state, const intern_type* __from,
const intern_type* __from_end, const intern_type*& __from_next,
extern_type* __to, extern_type* __to_end,
extern_type*& __to_next) const
{
return this->do_out(__state, __from, __from_end, __from_next,
__to, __to_end, __to_next);
}
# 157 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/codecvt.h" 3
result
unshift(state_type& __state, extern_type* __to, extern_type* __to_end,
extern_type*& __to_next) const
{ return this->do_unshift(__state, __to,__to_end,__to_next); }
# 198 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/codecvt.h" 3
result
in(state_type& __state, const extern_type* __from,
const extern_type* __from_end, const extern_type*& __from_next,
intern_type* __to, intern_type* __to_end,
intern_type*& __to_next) const
{
return this->do_in(__state, __from, __from_end, __from_next,
__to, __to_end, __to_next);
}

int
encoding() const throw()
{ return this->do_encoding(); }

bool
always_noconv() const throw()
{ return this->do_always_noconv(); }

int
length(state_type& __state, const extern_type* __from,
const extern_type* __end, size_t __max) const
{ return this->do_length(__state, __from, __end, __max); }

int
max_length() const throw()
{ return this->do_max_length(); }

protected:
explicit
__codecvt_abstract_base(size_t __refs = 0) : locale::facet(__refs) { }

virtual
~__codecvt_abstract_base() { }
# 239 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/codecvt.h" 3
virtual result
do_out(state_type& __state, const intern_type* __from,
const intern_type* __from_end, const intern_type*& __from_next,
extern_type* __to, extern_type* __to_end,
extern_type*& __to_next) const = 0;

virtual result
do_unshift(state_type& __state, extern_type* __to,
extern_type* __to_end, extern_type*& __to_next) const = 0;

virtual result
do_in(state_type& __state, const extern_type* __from,
const extern_type* __from_end, const extern_type*& __from_next,
intern_type* __to, intern_type* __to_end,
intern_type*& __to_next) const = 0;

virtual int
do_encoding() const throw() = 0;

virtual bool
do_always_noconv() const throw() = 0;

virtual int
do_length(state_type&, const extern_type* __from,
const extern_type* __end, size_t __max) const = 0;

virtual int
do_max_length() const throw() = 0;
};
# 276 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/codecvt.h" 3
template<typename _InternT, typename _ExternT, typename _StateT>
class codecvt
: public __codecvt_abstract_base<_InternT, _ExternT, _StateT>
{
public:

typedef codecvt_base::result result;

typedef _InternT intern_type;
typedef _ExternT extern_type;
typedef _StateT state_type;

protected:
__c_locale _M_c_locale_codecvt;

public:
static locale::id id;

explicit
codecvt(size_t __refs = 0)
: __codecvt_abstract_base<_InternT, _ExternT, _StateT> (__refs),
_M_c_locale_codecvt(0)
{ }

explicit
codecvt(__c_locale __cloc, size_t __refs = 0);

protected:
virtual
~codecvt() { }

virtual result
do_out(state_type& __state, const intern_type* __from,
const intern_type* __from_end, const intern_type*& __from_next,
extern_type* __to, extern_type* __to_end,
extern_type*& __to_next) const;

virtual result
do_unshift(state_type& __state, extern_type* __to,
extern_type* __to_end, extern_type*& __to_next) const;

virtual int
do_encoding() const throw();

virtual bool
do_always_noconv() const throw();

virtual int
do_length(state_type&, const extern_type* __from,
const extern_type* __end, size_t __max) const;

virtual int
do_max_length() const throw();
};

template<typename _InternT, typename _ExternT, typename _StateT>

locale::id codecvt<_InternT, _ExternT, _StateT>::id;

template<>
class codecvt<char, char, mbstate_t>
: public __codecvt_abstract_base<char, char, mbstate_t>
{
friend class messages<char>;

public:

typedef char intern_type;

typedef char extern_type;
typedef mbstate_t state_type;

protected:
__c_locale _M_c_locale_codecvt;

public:
static locale::id id;

explicit
codecvt(size_t __refs = 0);

explicit
codecvt(__c_locale __cloc, size_t __refs = 0);

protected:
virtual
~codecvt();

virtual result
do_unshift(state_type& __state, extern_type* __to,
extern_type* __to_end, extern_type*& __to_next) const;

virtual int
do_encoding() const throw();

virtual bool
do_always_noconv() const throw();

virtual int
do_length(state_type&, const extern_type* __from,
const extern_type* __end, size_t __max) const;

virtual int
do_max_length() const throw();
};

template<>
class codecvt<wchar_t, char, mbstate_t>
: public __codecvt_abstract_base<wchar_t, char, mbstate_t>
{
friend class messages<wchar_t>;

public:

typedef wchar_t intern_type;

typedef char extern_type;
typedef mbstate_t state_type;

protected:
__c_locale _M_c_locale_codecvt;

public:
static locale::id id;

explicit
codecvt(size_t __refs = 0);

explicit
codecvt(__c_locale __cloc, size_t __refs = 0);

protected:
virtual
~codecvt();

virtual result
do_unshift(state_type& __state,
extern_type* __to, extern_type* __to_end,
extern_type*& __to_next) const;

virtual result
do_in(state_type& __state,
const extern_type* __from, const extern_type* __from_end,
const extern_type*& __from_next,
intern_type* __to, intern_type* __to_end,
intern_type*& __to_next) const;

virtual
int do_encoding() const throw();

virtual
bool do_always_noconv() const throw();

virtual
int do_length(state_type&, const extern_type* __from,
const extern_type* __end, size_t __max) const;

virtual int
do_max_length() const throw();
};

template<>
class codecvt<char16_t, char, mbstate_t>
: public __codecvt_abstract_base<char16_t, char, mbstate_t>
{
public:

typedef char16_t intern_type;

typedef char extern_type;
typedef mbstate_t state_type;

public:
static locale::id id;

explicit
codecvt(size_t __refs = 0)
: __codecvt_abstract_base<char16_t, char, mbstate_t>(__refs) { }

protected:
virtual
~codecvt();

virtual result
do_unshift(state_type& __state,
extern_type* __to, extern_type* __to_end,
extern_type*& __to_next) const;

virtual result
do_in(state_type& __state,
const extern_type* __from, const extern_type* __from_end,
const extern_type*& __from_next,
intern_type* __to, intern_type* __to_end,
intern_type*& __to_next) const;

virtual
int do_encoding() const throw();

virtual
bool do_always_noconv() const throw();

virtual
int do_length(state_type&, const extern_type* __from,
const extern_type* __end, size_t __max) const;

virtual int
do_max_length() const throw();
};

template<>
class codecvt<char32_t, char, mbstate_t>
: public __codecvt_abstract_base<char32_t, char, mbstate_t>
{
public:

typedef char32_t intern_type;

typedef char extern_type;
typedef mbstate_t state_type;

public:
static locale::id id;

explicit
codecvt(size_t __refs = 0)
: __codecvt_abstract_base<char32_t, char, mbstate_t>(__refs) { }
protected:
virtual
~codecvt();

virtual result
do_unshift(state_type& __state,
extern_type* __to, extern_type* __to_end,
extern_type*& __to_next) const;

virtual result
do_in(state_type& __state,
const extern_type* __from, const extern_type* __from_end,
const extern_type*& __from_next,
intern_type* __to, intern_type* __to_end,
intern_type*& __to_next) const;

virtual
int do_encoding() const throw();

virtual
bool do_always_noconv() const throw();

virtual
int do_length(state_type&, const extern_type* __from,
const extern_type* __end, size_t __max) const;

virtual int
do_max_length() const throw();
};

template<>
class codecvt<char16_t, char8_t, mbstate_t>
: public __codecvt_abstract_base<char16_t, char8_t, mbstate_t>
{
public:

typedef char16_t intern_type;

typedef char8_t extern_type;
typedef mbstate_t state_type;

public:
static locale::id id;

explicit
codecvt(size_t __refs = 0)
: __codecvt_abstract_base<char16_t, char8_t, mbstate_t>(__refs) { }

protected:
virtual
~codecvt();

virtual result
do_unshift(state_type& __state,
extern_type* __to, extern_type* __to_end,
extern_type*& __to_next) const;

virtual result
do_in(state_type& __state,
const extern_type* __from, const extern_type* __from_end,
const extern_type*& __from_next,
intern_type* __to, intern_type* __to_end,
intern_type*& __to_next) const;

virtual
int do_encoding() const throw();

virtual
bool do_always_noconv() const throw();

virtual
int do_length(state_type&, const extern_type* __from,
const extern_type* __end, size_t __max) const;

virtual int
do_max_length() const throw();
};

template<>
class codecvt<char32_t, char8_t, mbstate_t>
: public __codecvt_abstract_base<char32_t, char8_t, mbstate_t>
{
public:

typedef char32_t intern_type;

typedef char8_t extern_type;
typedef mbstate_t state_type;

public:
static locale::id id;

explicit
codecvt(size_t __refs = 0)
: __codecvt_abstract_base<char32_t, char8_t, mbstate_t>(__refs) { }

protected:
virtual
~codecvt();
virtual result
do_out(state_type& __state, const intern_type* __from,
const intern_type* __from_end, const intern_type*& __from_next,
extern_type* __to, extern_type* __to_end,
extern_type*& __to_next) const;

virtual result
do_unshift(state_type& __state,
extern_type* __to, extern_type* __to_end,
extern_type*& __to_next) const;

virtual result
do_in(state_type& __state,
const extern_type* __from, const extern_type* __from_end,
const extern_type*& __from_next,
intern_type* __to, intern_type* __to_end,
intern_type*& __to_next) const;

virtual
int do_encoding() const throw();

virtual
bool do_always_noconv() const throw();

virtual
int do_length(state_type&, const extern_type* __from,
const extern_type* __end, size_t __max) const;

virtual int
do_max_length() const throw();
};

template<typename _InternT, typename _ExternT, typename _StateT>

class codecvt_byname : public codecvt<_InternT, _ExternT, _StateT>
{
public:
explicit
codecvt_byname(const char* __s, size_t __refs = 0)
: codecvt<_InternT, _ExternT, _StateT>(__refs)
{
if (__builtin_strcmp(__s, "C") != 0
&& __builtin_strcmp(__s, "POSIX") != 0)
{
this->_S_destroy_c_locale(this->_M_c_locale_codecvt);
this->_S_create_c_locale(this->_M_c_locale_codecvt, __s);
}
}

explicit
codecvt_byname(const string& __s, size_t __refs = 0)
: codecvt_byname(__s.c_str(), __refs) { }
protected:
virtual
~codecvt_byname() { }
};

template<>
class codecvt_byname<char16_t, char, mbstate_t>
: public codecvt<char16_t, char, mbstate_t>
{
public:
explicit
codecvt_byname(const char*, size_t __refs = 0)
: codecvt<char16_t, char, mbstate_t>(__refs) { }

explicit
codecvt_byname(const string& __s, size_t __refs = 0)
: codecvt_byname(__s.c_str(), __refs) { }

protected:
virtual
~codecvt_byname() { }
};

template<>
class codecvt_byname<char32_t, char, mbstate_t>
: public codecvt<char32_t, char, mbstate_t>
{
public:
explicit
codecvt_byname(const char*, size_t __refs = 0)
: codecvt<char32_t, char, mbstate_t>(__refs) { }

explicit
codecvt_byname(const string& __s, size_t __refs = 0)
: codecvt_byname(__s.c_str(), __refs) { }

protected:
virtual
~codecvt_byname() { }
};

template<>
class codecvt_byname<char16_t, char8_t, mbstate_t>
: public codecvt<char16_t, char8_t, mbstate_t>
{
public:
explicit
codecvt_byname(const char*, size_t __refs = 0)
: codecvt<char16_t, char8_t, mbstate_t>(__refs) { }

explicit
codecvt_byname(const string& __s, size_t __refs = 0)
: codecvt_byname(__s.c_str(), __refs) { }

protected:
virtual
~codecvt_byname() { }
};

template<>
class codecvt_byname<char32_t, char8_t, mbstate_t>
: public codecvt<char32_t, char8_t, mbstate_t>
{
public:
explicit
codecvt_byname(const char*, size_t __refs = 0)
: codecvt<char32_t, char8_t, mbstate_t>(__refs) { }

explicit
codecvt_byname(const string& __s, size_t __refs = 0)
: codecvt_byname(__s.c_str(), __refs) { }

protected:
virtual
~codecvt_byname() { }
};

extern template class codecvt_byname<char, char, mbstate_t>;

extern template
const codecvt<char, char, mbstate_t>&
use_facet<codecvt<char, char, mbstate_t> >(const locale&);

extern template
bool
has_facet<codecvt<char, char, mbstate_t> >(const locale&);

extern template class codecvt_byname<wchar_t, char, mbstate_t>;

extern template
const codecvt<wchar_t, char, mbstate_t>&
use_facet<codecvt<wchar_t, char, mbstate_t> >(const locale&);

extern template
bool
has_facet<codecvt<wchar_t, char, mbstate_t> >(const locale&);

extern template class codecvt_byname<char16_t, char, mbstate_t>;

extern template class codecvt_byname<char32_t, char, mbstate_t>;

extern template class codecvt_byname<char16_t, char8_t, mbstate_t>;

extern template class codecvt_byname<char32_t, char8_t, mbstate_t>;
}
# 2068
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h" 2 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.tcc"
1 3
# 33
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.tcc" 3

# 34
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.tcc" 3

namespace std
{

template<typename _CharT, bool _Intl>

struct __use_cache<__moneypunct_cache<_CharT, _Intl> >
{
const __moneypunct_cache<_CharT, _Intl>*
operator() (const locale& __loc) const
{
const size_t __i = moneypunct<_CharT, _Intl>::id._M_id();
const locale::facet** __caches = __loc._M_impl->_M_caches;
if (!__caches[__i])
{
__moneypunct_cache<_CharT, _Intl>* __tmp = 0;
try
{
__tmp = new __moneypunct_cache<_CharT, _Intl>;
__tmp->_M_cache(__loc);
}
catch(...)
{
delete __tmp;
throw;
}
__loc._M_impl->_M_install_cache(__tmp, __i);
}
return static_cast<
const __moneypunct_cache<_CharT, _Intl>*>(__caches[__i]);
}
};

template<typename _CharT, bool _Intl>

void
__moneypunct_cache<_CharT, _Intl>::_M_cache(const locale& __loc)
{
const moneypunct<_CharT, _Intl>& __mp =
use_facet<moneypunct<_CharT, _Intl> >(__loc);

struct _Scoped_str
{
size_t _M_len;
_CharT* _M_str;
explicit
_Scoped_str(const basic_string<_CharT>& __str)
: _M_len(__str.size()), _M_str(new _CharT[_M_len])
{ __str.copy(_M_str, _M_len); }

~_Scoped_str() { delete[] _M_str; }

void
_M_release(const _CharT*& __p, size_t& __n)
{
__p = _M_str;
__n = _M_len;
_M_str = 0;
}
};

_Scoped_str __curr_symbol(__mp.curr_symbol());
_Scoped_str __positive_sign(__mp.positive_sign());
_Scoped_str __negative_sign(__mp.negative_sign());

const string& g = mp.grouping();

const size_t __g_size = __g.size();
char* const __grouping = new char[__g_size];
__g.copy(__grouping, __g_size);

_M_grouping = __grouping;
_M_grouping_size = __g_size;
_M_use_grouping = (__g_size
&& static_cast<signed char>(__grouping[0]) > 0
&& (__grouping[0]
!= __gnu_cxx::__numeric_traits<char>::__max));

_M_decimal_point = __mp.decimal_point();
_M_thousands_sep = __mp.thousands_sep();

__curr_symbol._M_release(_M_curr_symbol, _M_curr_symbol_size);
__positive_sign._M_release(_M_positive_sign, _M_positive_sign_size);
__negative_sign._M_release(_M_negative_sign, _M_negative_sign_size);

_M_frac_digits = __mp.frac_digits();
_M_pos_format = __mp.pos_format();
_M_neg_format = __mp.neg_format();

const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__loc);

__ct.widen(money_base::_S_atoms,
money_base::_S_atoms + money_base::_S_end, _M_atoms);

_M_allocated = true;
}

namespace __cxx11 {

template<typename _CharT, typename _InIter>

template<bool _Intl>
_InIter
money_get<_CharT, _InIter>::
_M_extract(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, string& __units) const
{
typedef char_traits<_CharT> __traits_type;
typedef typename string_type::size_type size_type;
typedef money_base::part part;
typedef __moneypunct_cache<_CharT, _Intl> __cache_type;

const locale& loc = io._M_getloc();

const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);

__use_cache<__cache_type> __uc;
const __cache_type* __lc = __uc(__loc);
const char_type* __lit = __lc->_M_atoms;

bool __negative = false;

size_type __sign_size = 0;

const bool __mandatory_sign = (__lc->_M_positive_sign_size

&& __lc->_M_negative_sign_size);

string __grouping_tmp;
if (__lc->_M_use_grouping)
__grouping_tmp.reserve(32);

int __last_pos = 0;

int __n = 0;

bool __testvalid = true;

bool __testdecfound = false;

string __res;
__res.reserve(32);

const char_type* __lit_zero = __lit + money_base::_S_zero;

const money_base::pattern __p = __lc->_M_neg_format;
for (int __i = 0; __i < 4 && __testvalid; ++__i)
{
const part __which = static_cast<part>(__p.field[__i]);
switch (__which)
{
case money_base::symbol:

if (__io.flags() & ios_base::showbase || __sign_size > 1

|| __i == 0
|| (__i == 1 && (__mandatory_sign
|| (static_cast<part>(__p.field[0])
== money_base::sign)
|| (static_cast<part>(__p.field[2])
== money_base::space)))
|| (__i == 2 && ((static_cast<part>(__p.field[3])
== money_base::value)
|| (__mandatory_sign
&& (static_cast<part>(__p.field[3])
== money_base::sign)))))
{
const size_type __len = __lc->_M_curr_symbol_size;
size_type __j = 0;
for (; __beg != __end && __j < __len
&& *__beg == __lc->_M_curr_symbol[__j];
++__beg, (void)++__j);
if (__j != __len
&& (__j || __io.flags() & ios_base::showbase))
__testvalid = false;
}
break;
case money_base::sign:

if (__lc->_M_positive_sign_size && beg != end

&& *__beg == __lc->_M_positive_sign[0])
{
__sign_size = __lc->_M_positive_sign_size;
++__beg;
}
else if (__lc->_M_negative_sign_size && __beg != __end
&& *__beg == __lc->_M_negative_sign[0])
{
__negative = true;
__sign_size = __lc->_M_negative_sign_size;
++__beg;
}
else if (__lc->_M_positive_sign_size
&& !__lc->_M_negative_sign_size)

__negative = true;
else if (__mandatory_sign)
__testvalid = false;
break;
case money_base::value:

for (; beg != end; ++__beg)

{
const char_type __c = *__beg;
const char_type* __q = __traits_type::find(__lit_zero,
10, __c);
if (__q != 0)
{
__res += money_base::_S_atoms[__q - __lit];
++__n;
}
else if (__c == __lc->_M_decimal_point
&& !__testdecfound)
{
if (__lc->_M_frac_digits <= 0)
break;

__last_pos = __n;
__n = 0;
__testdecfound = true;
}
else if (__lc->_M_use_grouping
&& __c == __lc->_M_thousands_sep
&& !__testdecfound)
{
if (__n)
{

__grouping_tmp += static_cast<char>(__n);
__n = 0;
}
else
{
__testvalid = false;
break;
}
}
else
break;
}
if (__res.empty())
__testvalid = false;
break;
case money_base::space:

if (beg != end && __ctype.is(ctype_base::space, *__beg))

++__beg;
else
__testvalid = false;

case money_base::none:

if (__i != 3)
for (; __beg != __end
&& __ctype.is(ctype_base::space, *__beg); ++__beg);
break;
}
}

if (__sign_size > 1 && __testvalid)

{
const char_type* __sign = __negative ? __lc->_M_negative_sign
: __lc->_M_positive_sign;
size_type __i = 1;
for (; __beg != __end && __i < __sign_size
&& *__beg == __sign[__i]; ++__beg, (void)++__i);

if (__i != __sign_size)
__testvalid = false;
}

if (__testvalid)
{

if (__res.size() > 1)
{
const size_type __first = __res.find_first_not_of('0');
const bool __only_zeros = __first == string::npos;
if (__first)
__res.erase(0, __only_zeros ? __res.size() - 1 : __first);
}

if (negative && res[0] != '0')

__res.insert(__res.begin(), '-');

if (__grouping_tmp.size())
{

__grouping_tmp += static_cast<char>(testdecfound ? last_pos

: __n);
if (!std::__verify_grouping(__lc->_M_grouping,
__lc->_M_grouping_size,
__grouping_tmp))
__err |= ios_base::failbit;
}

if (testdecfound && n != __lc->_M_frac_digits)

__testvalid = false;
}

if (!__testvalid)
__err |= ios_base::failbit;
else
__units.swap(__res);

if (__beg == __end)
__err |= ios_base::eofbit;
return __beg;
}
# 368
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.tcc" 3
template<typename _CharT, typename _InIter>
_InIter
money_get<_CharT, _InIter>::
do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io,
ios_base::iostate& __err, long double& __units) const
{
string __str;
__beg = __intl ? _M_extract<true>(__beg, __end, __io, __err, __str)
: _M_extract<false>(__beg, __end, __io, __err, __str);
std::__convert_to_v(__str.c_str(), __units, __err, _S_get_c_locale());
return __beg;
}

template<typename _CharT, typename _InIter>

_InIter
money_get<_CharT, _InIter>::
do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io,
ios_base::iostate& __err, string_type& __digits) const
{
typedef typename string::size_type size_type;
const locale& __loc = __io._M_getloc();
const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);

string __str;
__beg = __intl ? _M_extract<true>(__beg, __end, __io, __err, __str)
: _M_extract<false>(__beg, __end, __io, __err, __str);
const size_type __len = __str.size();
if (__len)
{
__digits.resize(__len);
__ctype.widen(__str.data(), __str.data() + __len, &__digits[0]);
}
return __beg;
}
# 420
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.tcc" 3
template<typename _CharT, typename _OutIter>
template<bool _Intl>
_OutIter
money_put<_CharT, _OutIter>::
_M_insert(iter_type __s, ios_base& __io, char_type __fill,
const string_type& __digits) const
{
typedef typename string_type::size_type size_type;
typedef money_base::part part;
typedef __moneypunct_cache<_CharT, _Intl> __cache_type;

const locale& loc = io._M_getloc();

const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);

__use_cache<__cache_type> __uc;
const __cache_type* __lc = __uc(__loc);
const char_type* __lit = __lc->_M_atoms;

const char_type* beg = digits.data();

money_base::pattern __p;
const char_type* __sign;
size_type __sign_size;
if (!(*__beg == __lit[money_base::_S_minus]))
{
__p = __lc->_M_pos_format;
__sign = __lc->_M_positive_sign;
__sign_size = __lc->_M_positive_sign_size;
}
else
{
__p = __lc->_M_neg_format;
__sign = __lc->_M_negative_sign;
__sign_size = __lc->_M_negative_sign_size;
if (__digits.size())
++__beg;
}

size_type len = ctype.scan_not(ctype_base::digit, __beg,

__beg + __digits.size()) - __beg;
if (__len)
{

string_type __value;
__value.reserve(2 * __len);

long paddec = len - __lc->_M_frac_digits;

if (__paddec > 0)
{
if (__lc->_M_frac_digits < 0)
__paddec = __len;
if (__lc->_M_grouping_size)
{
__value.assign(2 * __paddec, char_type());
_CharT* __vend =
std::__add_grouping(&__value[0], __lc->_M_thousands_sep,
__lc->_M_grouping,
__lc->_M_grouping_size,
__beg, __beg + __paddec);
__value.erase(__vend - &__value[0]);
}
else
__value.assign(__beg, __paddec);
}

if (__lc->_M_frac_digits > 0)
{
__value += __lc->_M_decimal_point;
if (__paddec >= 0)
__value.append(__beg + __paddec, __lc->_M_frac_digits);
else
{

__value.append(-__paddec, __lit[money_base::_S_zero]);
__value.append(__beg, __len);
}
}

const ios_base::fmtflags f = io.flags()

& ios_base::adjustfield;
__len = __value.size() + __sign_size;
__len += ((__io.flags() & ios_base::showbase)
? __lc->_M_curr_symbol_size : 0);

string_type __res;
__res.reserve(2 * __len);

const size_type __width = static_cast<size_type>(__io.width());

const bool __testipad = (__f == ios_base::internal
&& __len < __width);

for (int i = 0; i < 4; ++__i)

{
const part __which = static_cast<part>(__p.field[__i]);
switch (__which)
{
case money_base::symbol:
if (__io.flags() & ios_base::showbase)
__res.append(__lc->_M_curr_symbol,
__lc->_M_curr_symbol_size);
break;
case money_base::sign:

if (__sign_size)
__res += __sign[0];
break;
case money_base::value:
__res += __value;
break;
case money_base::space:

if (__testipad)
__res.append(__width - __len, __fill);
else
__res += __fill;
break;
case money_base::none:
if (__testipad)
__res.append(__width - __len, __fill);
break;
}
}

if (__sign_size > 1)
__res.append(__sign + 1, __sign_size - 1);

__len = __res.size();
if (__width > __len)
{
if (__f == ios_base::left)

res.append(width - len, fill);

else

res.insert(0, width - len, fill);

__len = __width;
}

s = std::write(s, res.data(), __len);

}
__io.width(0);
return __s;
}
# 590
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.tcc" 3
template<typename _CharT, typename _OutIter>
_OutIter
money_put<_CharT, _OutIter>::
do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
long double __units) const
{
const locale __loc = __io.getloc();
const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);

int __cs_size = 64;

char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));

int len = std::convert_from_v(_S_get_c_locale(), cs, cs_size,

"%.*Lf", 0, __units);

if (len >= cs_size)

{
__cs_size = __len + 1;
__cs = static_cast<char*>(__builtin_alloca(__cs_size));
__len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
"%.*Lf", 0, __units);
}
# 622
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.tcc" 3
string_type __digits(__len, char_type());
__ctype.widen(__cs, __cs + __len, &__digits[0]);
return __intl ? _M_insert<true>(__s, __io, __fill, __digits)
: _M_insert<false>(__s, __io, __fill, __digits);
}

template<typename _CharT, typename _OutIter>

_OutIter
money_put<_CharT, _OutIter>::
do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
const string_type& __digits) const
{ return __intl ? _M_insert<true>(__s, __io, __fill, __digits)
: _M_insert<false>(__s, __io, __fill, __digits); }
# 674
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.tcc" 3
}

template<typename _CharT, typename _InIter>

time_base::dateorder
time_get<_CharT, _InIter>::do_date_order() const
{ return time_base::no_order; }

template<typename _CharT, typename _InIter>

_InIter
time_get<_CharT, _InIter>::
_M_extract_via_format(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, tm* __tm,
const _CharT* __format,
__time_get_state &__state) const
{
const locale& __loc = __io._M_getloc();
const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
const size_t __len = char_traits<_CharT>::length(__format);

ios_base::iostate __tmperr = ios_base::goodbit;

size_t __i = 0;
for (; __beg != __end && __i < __len && !__tmperr; ++__i)
{
if (__ctype.narrow(__format[__i], 0) == '%')
{

char c = ctype.narrow(format[++i], 0);

int __mem = 0;
if (__c == 'E' || __c == 'O')
__c = __ctype.narrow(__format[++__i], 0);
switch (__c)
{
const char* __cs;
_CharT __wcs[10];
case 'a':
case 'A':

const char_type* __days[14];

__tp._M_days(&__days[0]);
__tp._M_days_abbreviated(&__days[7]);
__beg = _M_extract_name(__beg, __end, __mem, __days,
14, __io, __tmperr);
if (!__tmperr)
{
__tm->tm_wday = __mem % 7;
__state._M_have_wday = 1;
}
break;
case 'h':
case 'b':
case 'B':

const char_type* __months[24];

__tp._M_months(&__months[0]);
__tp._M_months_abbreviated(&__months[12]);
__beg = _M_extract_name(__beg, __end, __mem,
__months, 24, __io, __tmperr);
if (!__tmperr)
{
__tm->tm_mon = __mem % 12;
__state._M_have_mon = 1;
__state._M_want_xday = 1;
}
break;
case 'c':

const char_type* __dt[2];

__tp._M_date_time_formats(__dt);
__beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
__tm, __dt[0], __state);
if (!__tmperr)
__state._M_want_xday = 1;
break;
case 'C':

__beg = _M_extract_num(beg, end, __mem, 0, 99, 2,

__io, __tmperr);
if (!__tmperr)
{
__state._M_century = __mem;
__state._M_have_century = 1;
__state._M_want_xday = 1;
}
break;
case 'd':
case 'e':

if (__ctype.is(ctype_base::space, *__beg))
++__beg;
__beg = _M_extract_num(__beg, __end, __mem, 1, 31, 2,
__io, __tmperr);
if (!__tmperr)
{
__tm->tm_mday = __mem;
__state._M_have_mday = 1;
__state._M_want_xday = 1;
}
break;
case 'D':

__cs = "%m/%d/%y";
__ctype.widen(__cs, __cs + 9, __wcs);
__beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
__tm, __wcs, __state);
if (!__tmperr)
__state._M_want_xday = 1;
break;
case 'H':

__beg = _M_extract_num(beg, end, __mem, 0, 23, 2,

__io, __tmperr);
if (!__tmperr)
{
__tm->tm_hour = __mem;
__state._M_have_I = 0;
}
break;
case 'I':

__beg = _M_extract_num(beg, end, __mem, 1, 12, 2,

__io, __tmperr);
if (!__tmperr)
{
__tm->tm_hour = __mem % 12;
__state._M_have_I = 1;
}
break;
case 'j':

__beg = _M_extract_num(beg, end, __mem, 1, 366, 3,

__io, __tmperr);
if (!__tmperr)
{
__tm->tm_yday = __mem - 1;
__state._M_have_yday = 1;
}
break;
case 'm':

__beg = _M_extract_num(beg, end, __mem, 1, 12, 2,

__io, __tmperr);
if (!__tmperr)
{
__tm->tm_mon = __mem - 1;
__state._M_have_mon = 1;
}
break;
case 'M':

__beg = _M_extract_num(beg, end, __mem, 0, 59, 2,

__io, __tmperr);
if (!__tmperr)
__tm->tm_min = __mem;
break;
case 'n':
case 't':
while (__beg != __end
&& __ctype.is(ctype_base::space, *__beg))
++__beg;
break;
case 'p':

const char_type* __ampm[2];

__tp._M_am_pm(&__ampm[0]);
if (!__ampm[0][0] || !__ampm[1][0])
break;
__beg = _M_extract_name(__beg, __end, __mem, __ampm,
2, __io, __tmperr);
if (!__tmperr && __mem)
__state._M_is_pm = 1;
break;
case 'r':

const char_type* __ampm_format;

__tp._M_am_pm_format(&__ampm_format);
__beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
__tm, __ampm_format, __state);
break;
case 'R':

__cs = "%H:%M";
__ctype.widen(__cs, __cs + 6, __wcs);
__beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
__tm, __wcs, __state);
break;
case 'S':
__beg = _M_extract_num(__beg, __end, __mem, 0, 60, 2,

__io, __tmperr);
if (!__tmperr)
__tm->tm_sec = __mem;
break;
case 'T':

__cs = "%H:%M:%S";
__ctype.widen(__cs, __cs + 9, __wcs);
__beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
__tm, __wcs, __state);
break;
case 'U':

__beg = _M_extract_num(beg, end, __mem, 0, 53, 2,

__io, __tmperr);
if (!__tmperr)
{
__state._M_week_no = __mem;
__state._M_have_uweek = 1;
}
break;
case 'w':

__beg = _M_extract_num(beg, end, __mem, 0, 6, 1,

__io, __tmperr);
if (!__tmperr)
{
__tm->tm_wday = __mem;
__state._M_have_wday = 1;
}
break;
case 'W':

__beg = _M_extract_num(beg, end, __mem, 0, 53, 2,

__io, __tmperr);
if (!__tmperr)
{
__state._M_week_no = __mem;
__state._M_have_wweek = 1;
}
break;
case 'x':

const char_type* __dates[2];

__tp._M_date_formats(__dates);
__beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
__tm, __dates[0], __state);
break;
case 'X':

const char_type* __times[2];

__tp._M_time_formats(__times);
__beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
__tm, __times[0], __state);
break;
case 'y':

__beg = _M_extract_num(beg, end, __mem, 0, 99, 2,

__io, __tmperr);
if (!__tmperr)
{
__state._M_want_century = 1;
__state._M_want_xday = 1;

__c = 0;
if (__beg != __end)
__c = __ctype.narrow(*__beg, '*');
if (__c >= '0' && __c <= '9')
{
++__beg;
__mem = __mem * 10 + (__c - '0');
if (__beg != __end)
{
__c = __ctype.narrow(*__beg, '*');
if (__c >= '0' && __c <= '9')
{
++__beg;
__mem = __mem * 10 + (__c - '0');
}
}
__mem -= 1900;
__state._M_want_century = 0;
}

else if (__mem < 69)

__mem += 100;
__tm->tm_year = __mem;
}
break;
case 'Y':

__beg = _M_extract_num(beg, end, __mem, 0, 9999, 4,

__io, __tmperr);
if (!__tmperr)
{
__tm->tm_year = __mem - 1900;
__state._M_want_century = 0;
__state._M_want_xday = 1;
}
break;
case 'Z':

if (__ctype.is(ctype_base::upper, *__beg))
{
int __tmp;
__beg = _M_extract_name(__beg, __end, __tmp,
__timepunct_cache<_CharT>::_S_timezones,
14, __io, __tmperr);

if (beg != end && !tmperr && tmp == 0

&& (*__beg == __ctype.widen('-')
|| *__beg == __ctype.widen('+')))
{
__beg = _M_extract_num(__beg, __end, __tmp, 0, 23, 2,
__io, __tmperr);
__beg = _M_extract_num(__beg, __end, __tmp, 0, 59, 2,
__io, __tmperr);
}
}
else
__tmperr |= ios_base::failbit;
break;
case '%':
if (*__beg == __ctype.widen('%'))
++__beg;
else
__tmperr |= ios_base::failbit;
break;
default:

__tmperr |= ios_base::failbit;
}
}
else if (__ctype.is(ctype_base::space, __format[__i]))
{

while (beg != end

&& __ctype.is(ctype_base::space, *__beg))
++__beg;
}
else
{

if (__ctype.tolower(__format[__i]) == __ctype.tolower(*__beg)
|| __ctype.toupper(__format[__i]) == __ctype.toupper(*__beg))
++__beg;
else
__tmperr |= ios_base::failbit;
}
}

if (tmperr || i != __len)

__err |= ios_base::failbit;

return __beg;
}

template<typename _CharT, typename _InIter>

_InIter
time_get<_CharT, _InIter>::
_M_extract_via_format(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, tm* __tm,
const _CharT* __format) const
{
__time_get_state __state = __time_get_state();
return _M_extract_via_format(__beg, __end, __io, __err, __tm,
__format, __state);
}
template<typename _CharT, typename _InIter>
_InIter
time_get<_CharT, _InIter>::
_M_extract_num(iter_type __beg, iter_type __end, int& __member,
int __min, int __max, size_t __len,
ios_base& __io, ios_base::iostate& __err) const
{
const locale& __loc = __io._M_getloc();
const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);

size_t __i = 0;
int __value = 0;
for (; __beg != __end && __i < __len; ++__beg, (void)++__i)
{
const char __c = __ctype.narrow(*__beg, '*');
if (__c >= '0' && __c <= '9')
{
__value = __value * 10 + (__c - '0');
if (__value > __max)
break;
}
else
break;
}
if (__i && __value >= __min && __value <= __max)
__member = __value;
else
__err |= ios_base::failbit;

return __beg;
}

template<typename _CharT, typename _InIter>

_InIter
time_get<_CharT, _InIter>::
_M_extract_name(iter_type __beg, iter_type __end, int& __member,
const _CharT** __names, size_t __indexlen,
ios_base& __io, ios_base::iostate& __err) const
{
typedef char_traits<_CharT> __traits_type;
const locale& __loc = __io._M_getloc();
const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);

size_t* __matches
= static_cast<size_t*>(__builtin_alloca(2 * sizeof(size_t)
* __indexlen));
size_t* __lengths = __matches + __indexlen;
size_t __nmatches = 0;
size_t __pos = 0;
bool __testvalid = true;
const char_type* __name;
bool __begupdated = false;
if (__beg != __end)
{
const char_type __c = *__beg;

const char_type cl = ctype.tolower(__c);

const char_type __cu = __ctype.toupper(__c);
for (size_t __i1 = 0; __i1 < __indexlen; ++__i1)
if (__cl == __ctype.tolower(__names[__i1][0])
|| __cu == __ctype.toupper(__names[__i1][0]))
{
__lengths[__nmatches]
= __traits_type::length(__names[__i1]);
__matches[__nmatches++] = __i1;
}
}

while (__nmatches > 1)

{

size_t minlen = lengths[0];

for (size_t __i2 = 1; __i2 < __nmatches; ++__i2)
__minlen = std::min(__minlen, __lengths[__i2]);
++__pos;
++__beg;
if (__pos == __minlen)
{

bool __match_longer = false;

if (__beg != __end)
{

const char_type cl = ctype.tolower(*__beg);

const char_type __cu = __ctype.toupper(*__beg);
for (size_t __i3 = 0; __i3 < __nmatches; ++__i3)
{
__name = __names[__matches[__i3]];
if (__lengths[__i3] > __pos
&& (__ctype.tolower(__name[__pos]) == __cl
|| __ctype.toupper(__name[__pos]) == __cu))
{
__match_longer = true;
break;
}
}
}
for (size_t __i4 = 0; __i4 < __nmatches;)
if (__match_longer == (__lengths[__i4] == __pos))
{
__matches[__i4] = __matches[--__nmatches];
__lengths[__i4] = __lengths[__nmatches];
}
else
++__i4;
if (__match_longer)
{
__minlen = __lengths[0];
for (size_t __i5 = 1; __i5 < __nmatches; ++__i5)
__minlen = std::min(__minlen, __lengths[__i5]);
}
else
{

if (nmatches == 2 && (indexlen & 1) == 0)

{
if (__matches[0] < __indexlen / 2)
{
if (__matches[1] == __matches[0] + __indexlen / 2)
__nmatches = 1;
}
else if (__matches[1] == __matches[0] - __indexlen / 2)
{
__matches[0] = __matches[1];
__lengths[0] = __lengths[1];
__nmatches = 1;
}
}
__begupdated = true;
break;
}
}
if (__pos < __minlen && __beg != __end)
{

const char_type cl = ctype.tolower(*__beg);

const char_type __cu = __ctype.toupper(*__beg);
for (size_t __i6 = 0; __i6 < __nmatches;)
{
__name = __names[__matches[__i6]];
if (__ctype.tolower(__name[__pos]) != __cl
&& __ctype.toupper(__name[__pos]) != __cu)
{
__matches[__i6] = __matches[--__nmatches];
__lengths[__i6] = __lengths[__nmatches];
}
else
++__i6;
}
}
else
break;
}

if (__nmatches == 1)
{

if (!__begupdated)
{
++__beg;
++__pos;
}
__name = __names[__matches[0]];
const size_t __len = __lengths[0];
while (__pos < __len
&& __beg != __end

&& (ctype.tolower(name[pos]) == ctype.tolower(*__beg)

|| (__ctype.toupper(__name[__pos])
== __ctype.toupper(*__beg))))
++__beg, (void)++__pos;

if (__len == __pos)
__member = __matches[0];
else
__testvalid = false;
}
else
__testvalid = false;
if (!__testvalid)
__err |= ios_base::failbit;

return __beg;
}

template<typename _CharT, typename _InIter>

_InIter
time_get<_CharT, _InIter>::
_M_extract_wday_or_month(iter_type __beg, iter_type __end, int& __member,
const _CharT** __names, size_t __indexlen,
ios_base& __io, ios_base::iostate& __err) const
{
typedef char_traits<_CharT> __traits_type;
const locale& __loc = __io._M_getloc();
const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);

int* __matches = static_cast<int>(__builtin_alloca(2 sizeof(int)

* __indexlen));
size_t __nmatches = 0;
size_t* __matches_lengths = 0;
size_t __pos = 0;

if (__beg != __end)
{
const char_type __c = *__beg;
for (size_t __i = 0; __i < 2 * __indexlen; ++__i)
if (__c == __names[__i][0]
|| __c == __ctype.toupper(__names[__i][0]))
__matches[__nmatches++] = __i;
}

if (__nmatches)
{
++__beg;
++__pos;

__matches_lengths
= static_cast<size_t*>(__builtin_alloca(sizeof(size_t)
* __nmatches));
for (size_t __i = 0; __i < __nmatches; ++__i)
__matches_lengths[__i]
= __traits_type::length(__names[__matches[__i]]);
}

for (; beg != end; ++beg, (void)++pos)

{
size_t __nskipped = 0;
const char_type __c = *__beg;
for (size_t __i = 0; __i < __nmatches;)
{
const char_type* __name = __names[__matches[__i]];
if (__pos >= __matches_lengths[__i])
++__nskipped, ++__i;
else if (!(__name[__pos] == __c))
{
--__nmatches;
__matches[__i] = __matches[__nmatches];
__matches_lengths[__i] = __matches_lengths[__nmatches];
}
else
++__i;
}
if (__nskipped == __nmatches)
break;
}

if ((nmatches == 1 && matches_lengths[0] == __pos)

|| (__nmatches == 2 && (__matches_lengths[0] == __pos
|| __matches_lengths[1] == __pos)))
__member = (__matches[0] >= (int)__indexlen
? __matches[0] - (int)__indexlen : __matches[0]);
else
__err |= ios_base::failbit;

return __beg;
}

template<typename _CharT, typename _InIter>

_InIter
time_get<_CharT, _InIter>::
do_get_time(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, tm* __tm) const
{
const locale& __loc = __io._M_getloc();
const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
const char_type* __times[2];
__tp._M_time_formats(__times);
__time_get_state __state = __time_get_state();
__beg = _M_extract_via_format(__beg, __end, __io, __err,
__tm, __times[0], __state);
__state._M_finalize_state(__tm);
if (__beg == __end)
__err |= ios_base::eofbit;
return __beg;
}

template<typename _CharT, typename _InIter>

_InIter
time_get<_CharT, _InIter>::
do_get_date(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, tm* __tm) const
{
const locale& __loc = __io._M_getloc();
const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
const char_type* __dates[2];
__tp._M_date_formats(__dates);
__time_get_state __state = __time_get_state();
__beg = _M_extract_via_format(__beg, __end, __io, __err,
__tm, __dates[0], __state);
__state._M_finalize_state(__tm);
if (__beg == __end)
__err |= ios_base::eofbit;
return __beg;
}

template<typename _CharT, typename _InIter>

_InIter
time_get<_CharT, _InIter>::
do_get_weekday(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, tm* __tm) const
{
const locale& __loc = __io._M_getloc();
const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
const char_type* __days[14];
__tp._M_days_abbreviated(__days);
__tp._M_days(__days + 7);
int __tmpwday;
ios_base::iostate __tmperr = ios_base::goodbit;

__beg = _M_extract_wday_or_month(beg, end, tmpwday, days, 7,

__io, __tmperr);
if (!__tmperr)
__tm->tm_wday = __tmpwday;
else
__err |= ios_base::failbit;

if (__beg == __end)
__err |= ios_base::eofbit;
return __beg;
}

template<typename _CharT, typename _InIter>

_InIter
time_get<_CharT, _InIter>::
do_get_monthname(iter_type __beg, iter_type __end,
ios_base& __io, ios_base::iostate& __err, tm* __tm) const
{
const locale& __loc = __io._M_getloc();
const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
const char_type* __months[24];
__tp._M_months_abbreviated(__months);
__tp._M_months(__months + 12);
int __tmpmon;
ios_base::iostate __tmperr = ios_base::goodbit;

__beg = _M_extract_wday_or_month(beg, end, tmpmon, months, 12,

__io, __tmperr);
if (!__tmperr)
__tm->tm_mon = __tmpmon;
else
__err |= ios_base::failbit;

if (__beg == __end)
__err |= ios_base::eofbit;
return __beg;
}

template<typename _CharT, typename _InIter>

_InIter
time_get<_CharT, _InIter>::
do_get_year(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, tm* __tm) const
{
int __tmpyear;
ios_base::iostate __tmperr = ios_base::goodbit;
const locale& __loc = __io._M_getloc();
const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);

__beg = _M_extract_num(beg, end, __tmpyear, 0, 99, 2,

__io, __tmperr);
if (!__tmperr)
{
char __c = 0;
if (__beg != __end)
__c = __ctype.narrow(*__beg, '*');

if (c >= '0' && c <= '9')

{
++__beg;
__tmpyear = __tmpyear * 10 + (__c - '0');
if (__beg != __end)
{
__c = __ctype.narrow(*__beg, '*');
if (__c >= '0' && __c <= '9')
{
++__beg;
__tmpyear = __tmpyear * 10 + (__c - '0');
}
}
__tmpyear -= 1900;
}
else if (__tmpyear < 69)
__tmpyear += 100;
__tm->tm_year = __tmpyear;
}
else
__err |= ios_base::failbit;

if (__beg == __end)
__err |= ios_base::eofbit;
return __beg;
}

template<typename _CharT, typename _InIter>

inline
_InIter
time_get<_CharT, _InIter>::
get(iter_type __s, iter_type __end, ios_base& __io,
ios_base::iostate& __err, tm* __tm, const char_type* __fmt,
const char_type* __fmtend) const
{
const locale& __loc = __io._M_getloc();
ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
__err = ios_base::goodbit;
bool __use_state = false;

#pragma GCC diagnostic push

#pragma GCC diagnostic ignored "-Wpmf-conversions"

if ((void*)(this->*(&time_get::do_get)) == (void*)(&time_get::do_get))
__use_state = true;
#pragma GCC diagnostic pop

__time_get_state state = time_get_state();

while (__fmt != __fmtend &&
__err == ios_base::goodbit)
{
if (__s == __end)
{
__err = ios_base::eofbit | ios_base::failbit;
break;
}
else if (__ctype.narrow(*__fmt, 0) == '%')
{
const char_type* __fmt_start = __fmt;
char __format;
char __mod = 0;
if (++__fmt == __fmtend)
{
__err = ios_base::failbit;
break;
}
const char __c = __ctype.narrow(*__fmt, 0);
if (__c != 'E' && __c != 'O')
__format = __c;
else if (++__fmt != __fmtend)
{
__mod = __c;
__format = __ctype.narrow(*__fmt, 0);
}
else
{
__err = ios_base::failbit;
break;
}
if (__use_state)
{
char_type __new_fmt[4];
__new_fmt[0] = __fmt_start[0];
__new_fmt[1] = __fmt_start[1];
if (__mod)
{
__new_fmt[2] = __fmt_start[2];
__new_fmt[3] = char_type();
}
else
__new_fmt[2] = char_type();
__s = _M_extract_via_format(__s, __end, __io, __err, __tm,
__new_fmt, __state);
if (__s == __end)
__err |= ios_base::eofbit;
}
else
__s = this->do_get(__s, __end, __io, __err, __tm, __format,
__mod);
++__fmt;
}
else if (__ctype.is(ctype_base::space, *__fmt))
{
++__fmt;
while (__fmt != __fmtend &&
__ctype.is(ctype_base::space, *__fmt))
++__fmt;

while (s != end &&

__ctype.is(ctype_base::space, *__s))
++__s;
}

else if (ctype.tolower(s) == ctype.tolower(fmt) ||

__ctype.toupper(*__s) == __ctype.toupper(*__fmt))
{
++__s;
++__fmt;
}
else
{
__err = ios_base::failbit;
break;
}
}
if (__use_state)
__state._M_finalize_state(__tm);
return __s;
}

template<typename _CharT, typename _InIter>

inline
_InIter
time_get<_CharT, _InIter>::
do_get(iter_type __beg, iter_type __end, ios_base& __io,
ios_base::iostate& __err, tm* __tm,
char __format, char __mod) const
{
const locale& __loc = __io._M_getloc();
ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
__err = ios_base::goodbit;

char_type __fmt[4];
__fmt[0] = __ctype.widen('%');
if (!__mod)
{
__fmt[1] = __format;
__fmt[2] = char_type();
}
else
{
__fmt[1] = __mod;
__fmt[2] = __format;
__fmt[3] = char_type();
}

__time_get_state state = time_get_state();

__beg = _M_extract_via_format(__beg, __end, __io, __err, __tm, __fmt,
__state);
__state._M_finalize_state(__tm);
if (__beg == __end)
__err |= ios_base::eofbit;
return __beg;
}

template<typename _CharT, typename _OutIter>

_OutIter
time_put<_CharT, _OutIter>::
put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm,
const _CharT* __beg, const _CharT* __end) const
{
const locale& __loc = __io._M_getloc();
ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
for (; __beg != __end; ++__beg)
if (__ctype.narrow(*__beg, 0) != '%')
{
*__s = *__beg;
++__s;
}
else if (++__beg != __end)
{
char __format;
char __mod = 0;
const char __c = __ctype.narrow(*__beg, 0);
if (__c != 'E' && __c != 'O')
__format = __c;
else if (++__beg != __end)
{
__mod = __c;
__format = __ctype.narrow(*__beg, 0);
}
else
break;
__s = this->do_put(__s, __io, __fill, __tm, __format, __mod);
}
else
break;
return __s;
}
template<typename _CharT, typename _OutIter>
_OutIter
time_put<_CharT, _OutIter>::
do_put(iter_type __s, ios_base& __io, char_type, const tm* __tm,
char __format, char __mod) const
{
const locale& __loc = __io._M_getloc();
ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
__timepunct<_CharT> const& __tp = use_facet<__timepunct<_CharT> >(__loc);

const size_t __maxlen = 128;

char_type __res[__maxlen];

char_type __fmt[4];
__fmt[0] = __ctype.widen('%');
if (!__mod)
{
__fmt[1] = __format;
__fmt[2] = char_type();
}
else
{
__fmt[1] = __mod;
__fmt[2] = __format;
__fmt[3] = char_type();
}

__tp._M_put(res, maxlen, fmt, tm);

return std::write(s, __res, char_traits<char_type>::length(__res));

}

extern template class moneypunct<char, false>;

extern template class moneypunct<char, true>;
extern template class moneypunct_byname<char, false>;
extern template class moneypunct_byname<char, true>;
extern template class __cxx11:: money_get<char>;
extern template class __cxx11:: money_put<char>;
extern template class __timepunct<char>;
extern template class time_put<char>;
extern template class time_put_byname<char>;
extern template class time_get<char>;
extern template class time_get_byname<char>;
extern template class messages<char>;
extern template class messages_byname<char>;

extern template
const moneypunct<char, true>*
__try_use_facet<moneypunct<char, true> >(const locale&) noexcept;

extern template
const moneypunct<char, false>*
__try_use_facet<moneypunct<char, false> >(const locale&) noexcept;

extern template
const money_put<char>*
__try_use_facet<money_put<char> >(const locale&) noexcept;

extern template
const money_get<char>*
__try_use_facet<money_get<char> >(const locale&) noexcept;

extern template
const __timepunct<char>*
__try_use_facet<__timepunct<char> >(const locale&) noexcept;

extern template
const time_put<char>*
__try_use_facet<time_put<char> >(const locale&) noexcept;

extern template
const time_get<char>*
__try_use_facet<time_get<char> >(const locale&) noexcept;

extern template
const messages<char>*
__try_use_facet<messages<char> >(const locale&) noexcept;

extern template
const moneypunct<char, true>&
use_facet<moneypunct<char, true> >(const locale&);

extern template
const moneypunct<char, false>&
use_facet<moneypunct<char, false> >(const locale&);

extern template
const money_put<char>&
use_facet<money_put<char> >(const locale&);

extern template
const money_get<char>&
use_facet<money_get<char> >(const locale&);

extern template
const __timepunct<char>&
use_facet<__timepunct<char> >(const locale&);

extern template
const time_put<char>&
use_facet<time_put<char> >(const locale&);

extern template
const time_get<char>&
use_facet<time_get<char> >(const locale&);
extern template
const messages<char>&
use_facet<messages<char> >(const locale&);

extern template
bool
has_facet<moneypunct<char> >(const locale&);

extern template
bool
has_facet<money_put<char> >(const locale&);

extern template
bool
has_facet<money_get<char> >(const locale&);

extern template
bool
has_facet<__timepunct<char> >(const locale&);

extern template
bool
has_facet<time_put<char> >(const locale&);

extern template
bool
has_facet<time_get<char> >(const locale&);

extern template
bool
has_facet<messages<char> >(const locale&);

extern template class moneypunct<wchar_t, false>;

extern template class moneypunct<wchar_t, true>;
extern template class moneypunct_byname<wchar_t, false>;
extern template class moneypunct_byname<wchar_t, true>;
extern template class __cxx11:: money_get<wchar_t>;
extern template class __cxx11:: money_put<wchar_t>;
extern template class __timepunct<wchar_t>;
extern template class time_put<wchar_t>;
extern template class time_put_byname<wchar_t>;
extern template class time_get<wchar_t>;
extern template class time_get_byname<wchar_t>;
extern template class messages<wchar_t>;
extern template class messages_byname<wchar_t>;

extern template
const moneypunct<wchar_t, true>*
__try_use_facet<moneypunct<wchar_t, true> >(const locale&) noexcept;

extern template
const moneypunct<wchar_t, false>*
__try_use_facet<moneypunct<wchar_t, false> >(const locale&) noexcept;

extern template
const money_put<wchar_t>*
__try_use_facet<money_put<wchar_t> >(const locale&) noexcept;
extern template
const money_get<wchar_t>*
__try_use_facet<money_get<wchar_t> >(const locale&) noexcept;

extern template
const __timepunct<wchar_t>*
__try_use_facet<__timepunct<wchar_t> >(const locale&) noexcept;

extern template
const time_put<wchar_t>*
__try_use_facet<time_put<wchar_t> >(const locale&) noexcept;

extern template
const time_get<wchar_t>*
__try_use_facet<time_get<wchar_t> >(const locale&) noexcept;

extern template
const messages<wchar_t>*
__try_use_facet<messages<wchar_t> >(const locale&) noexcept;

extern template
const moneypunct<wchar_t, true>&
use_facet<moneypunct<wchar_t, true> >(const locale&);

extern template
const moneypunct<wchar_t, false>&
use_facet<moneypunct<wchar_t, false> >(const locale&);

extern template
const money_put<wchar_t>&
use_facet<money_put<wchar_t> >(const locale&);

extern template
const money_get<wchar_t>&
use_facet<money_get<wchar_t> >(const locale&);

extern template
const __timepunct<wchar_t>&
use_facet<__timepunct<wchar_t> >(const locale&);

extern template
const time_put<wchar_t>&
use_facet<time_put<wchar_t> >(const locale&);

extern template
const time_get<wchar_t>&
use_facet<time_get<wchar_t> >(const locale&);

extern template
const messages<wchar_t>&
use_facet<messages<wchar_t> >(const locale&);

extern template
bool
has_facet<moneypunct<wchar_t> >(const locale&);

extern template
bool
has_facet<money_put<wchar_t> >(const locale&);
extern template
bool
has_facet<money_get<wchar_t> >(const locale&);

extern template
bool
has_facet<__timepunct<wchar_t> >(const locale&);

extern template
bool
has_facet<time_put<wchar_t> >(const locale&);

extern template
bool
has_facet<time_get<wchar_t> >(const locale&);

extern template
bool
has_facet<messages<wchar_t> >(const locale&);

}
# 2070
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_facets_nonio.h" 2 3
# 44 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/locale" 2 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_conv.h" 1 3
# 42 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_conv.h" 3
namespace std
{

template<typename _OutStr, typename _InChar, typename _Codecvt,

typename _State, typename _Fn>
bool
__do_str_codecvt(const _InChar* __first, const _InChar* __last,
_OutStr& __outstr, const _Codecvt& __cvt, _State& __state,
size_t& __count, _Fn __fn)
{
if (__first == __last)
{
__outstr.clear();
__count = 0;
return true;
}

size_t __outchars = 0;
auto __next = __first;
const auto __maxlen = __cvt.max_length() + 1;

codecvt_base::result __result;
do
{
__outstr.resize(__outstr.size() + (__last - __next) * __maxlen);
auto __outnext = &__outstr.front() + __outchars;
auto const __outlast = &__outstr.back() + 1;
__result = (__cvt.*__fn)(__state, __next, __last, __next,
__outnext, __outlast, __outnext);
__outchars = __outnext - &__outstr.front();
}
while (__result == codecvt_base::partial && __next != __last
&& ptrdiff_t(__outstr.size() - __outchars) < __maxlen);

if (__result == codecvt_base::error)
{
__count = __next - __first;
return false;
}

if constexpr (is_same<typename _Codecvt::intern_type,

typename _Codecvt::extern_type>())
if (__result == codecvt_base::noconv)
{
__outstr.assign(__first, __last);
__count = __last - __first;
return true;
}

__outstr.resize(__outchars);
__count = __next - __first;
return true;
}

template<typename _CharT, typename _Traits, typename _Alloc, typename _State>

inline bool
__str_codecvt_in(const char* __first, const char* __last,
basic_string<_CharT, _Traits, _Alloc>& __outstr,
const codecvt<_CharT, char, _State>& __cvt,
_State& __state, size_t& __count)
{
using _Codecvt = codecvt<_CharT, char, _State>;
using _ConvFn
= codecvt_base::result
(_Codecvt::*)(_State&, const char*, const char*, const char*&,
_CharT*, _CharT*, _CharT*&) const;
_ConvFn __fn = &codecvt<_CharT, char, _State>::in;
return __do_str_codecvt(__first, __last, __outstr, __cvt, __state,
__count, __fn);
}

template<typename _CharT, typename _Traits, typename _Alloc, typename _State>

inline bool
__str_codecvt_in(const char* __first, const char* __last,
basic_string<_CharT, _Traits, _Alloc>& __outstr,
const codecvt<_CharT, char, _State>& __cvt)
{
_State __state = {};
size_t __n;
return __str_codecvt_in(__first, __last, __outstr, __cvt, __state, __n);
}

template<typename _CharT, typename _Traits, typename _Alloc, typename _State>

inline bool
__str_codecvt_in_all(const char* __first, const char* __last,
basic_string<_CharT, _Traits, _Alloc>& __outstr,
const codecvt<_CharT, char, _State>& __cvt)
{
_State __state = {};
size_t __n;
return __str_codecvt_in(__first, __last, __outstr, __cvt, __state, __n)
&& (__n == size_t(__last - __first));
}

template<typename _CharT, typename _Traits, typename _Alloc, typename _State>

inline bool
__str_codecvt_out(const _CharT* __first, const _CharT* __last,
basic_string<char, _Traits, _Alloc>& __outstr,
const codecvt<_CharT, char, _State>& __cvt,
_State& __state, size_t& __count)
{
using _Codecvt = codecvt<_CharT, char, _State>;
using _ConvFn
= codecvt_base::result
(_Codecvt::*)(_State&, const _CharT*, const _CharT*, const _CharT*&,
char*, char*, char*&) const;
_ConvFn __fn = &codecvt<_CharT, char, _State>::out;
return __do_str_codecvt(__first, __last, __outstr, __cvt, __state,
__count, __fn);
}

template<typename _CharT, typename _Traits, typename _Alloc, typename _State>

inline bool
__str_codecvt_out(const _CharT* __first, const _CharT* __last,
basic_string<char, _Traits, _Alloc>& __outstr,
const codecvt<_CharT, char, _State>& __cvt)
{
_State __state = {};
size_t __n;
return __str_codecvt_out(__first, __last, __outstr, __cvt, __state, __n);
}

template<typename _CharT, typename _Traits, typename _Alloc, typename _State>

inline bool
__str_codecvt_out_all(const _CharT* __first, const _CharT* __last,
basic_string<char, _Traits, _Alloc>& __outstr,
const codecvt<_CharT, char, _State>& __cvt)
{
_State __state = {};
size_t __n;
return __str_codecvt_out(__first, __last, __outstr, __cvt, __state, __n)
&& (__n == size_t(__last - __first));
}

template<typename _CharT, typename _Traits, typename _Alloc, typename _State>

inline bool
__str_codecvt_out(const _CharT* __first, const _CharT* __last,
basic_string<char8_t, _Traits, _Alloc>& __outstr,
const codecvt<_CharT, char8_t, _State>& __cvt,
_State& __state, size_t& __count)
{
using _Codecvt = codecvt<_CharT, char8_t, _State>;
using _ConvFn
= codecvt_base::result
(_Codecvt::*)(_State&, const _CharT*, const _CharT*, const _CharT*&,
char8_t*, char8_t*, char8_t*&) const;
_ConvFn __fn = &codecvt<_CharT, char8_t, _State>::out;
return __do_str_codecvt(__first, __last, __outstr, __cvt, __state,
__count, __fn);
}

template<typename _CharT, typename _Traits, typename _Alloc, typename _State>

namespace __detail
{
template<typename _Tp>
struct _Scoped_ptr
{
__attribute__((__nonnull__(2)))
explicit
_Scoped_ptr(_Tp* __ptr) noexcept
: _M_ptr(__ptr)
{ }

_Scoped_ptr(_Tp* ptr, const char* msg)

: _M_ptr(__ptr)
{
if (!__ptr)
__throw_logic_error(__msg);
}

~_Scoped_ptr() { delete _M_ptr; }

_Scoped_ptr(const _Scoped_ptr&) = delete;

_Scoped_ptr& operator=(const _Scoped_ptr&) = delete;

__attribute__((__returns_nonnull__))
_Tp* operator->() const noexcept { return _M_ptr; }

_Tp& operator() const noexcept { return _M_ptr; }

private:
_Tp* _M_ptr;
};
}

namespace __cxx11 {

template<typename _Codecvt, typename _Elem = wchar_t,

typename _Wide_alloc = allocator<_Elem>,
typename _Byte_alloc = allocator<char>>
class wstring_convert
{
public:
typedef basic_string<char, char_traits<char>, _Byte_alloc> byte_string;
typedef basic_string<_Elem, char_traits<_Elem>, _Wide_alloc> wide_string;
typedef typename _Codecvt::state_type state_type;
typedef typename wide_string::traits_type::int_type int_type;

wstring_convert() : _M_cvt(new _Codecvt()) { }

explicit
wstring_convert(_Codecvt* __pcvt) : _M_cvt(__pcvt, "wstring_convert")
{ }
# 291 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_conv.h" 3
wstring_convert(_Codecvt* __pcvt, state_type __state)
: _M_cvt(__pcvt, "wstring_convert"),
_M_state(__state), _M_with_cvtstate(true)
{ }

explicit
wstring_convert(const byte_string& __byte_err,
const wide_string& __wide_err = wide_string())
: _M_cvt(new _Codecvt),
_M_byte_err_string(__byte_err), _M_wide_err_string(__wide_err),
_M_with_strings(true)
{ }

~wstring_convert() = default;

wstring_convert(const wstring_convert&) = delete;

wstring_convert& operator=(const wstring_convert&) = delete;

wide_string
from_bytes(char __byte)
{
char __bytes[2] = { __byte };
return from_bytes(__bytes, __bytes+1);
}

wide_string
from_bytes(const char* __ptr)
{ return from_bytes(__ptr, __ptr+char_traits<char>::length(__ptr)); }

wide_string
from_bytes(const byte_string& __str)
{
auto __ptr = __str.data();
return from_bytes(__ptr, __ptr + __str.size());
}

wide_string
from_bytes(const char* __first, const char* __last)
{
if (!_M_with_cvtstate)
_M_state = state_type();
wide_string __out{ _M_wide_err_string.get_allocator() };
if (__str_codecvt_in(__first, __last, __out, *_M_cvt, _M_state,
_M_count))
return __out;
if (_M_with_strings)
return _M_wide_err_string;
__throw_range_error("wstring_convert::from_bytes");
}

byte_string
to_bytes(_Elem __wchar)
{
_Elem __wchars[2] = { __wchar };
return to_bytes(__wchars, __wchars+1);
}

byte_string
to_bytes(const _Elem* __ptr)
{
return to_bytes(__ptr, __ptr+wide_string::traits_type::length(__ptr));
}

byte_string
to_bytes(const wide_string& __wstr)
{
auto __ptr = __wstr.data();
return to_bytes(__ptr, __ptr + __wstr.size());
}

byte_string
to_bytes(const _Elem* __first, const _Elem* __last)
{
if (!_M_with_cvtstate)
_M_state = state_type();
byte_string __out{ _M_byte_err_string.get_allocator() };
if (__str_codecvt_out(__first, __last, __out, *_M_cvt, _M_state,
_M_count))
return __out;
if (_M_with_strings)
return _M_byte_err_string;
__throw_range_error("wstring_convert::to_bytes");
}

size_t converted() const noexcept { return _M_count; }

state_type state() const { return _M_state; }

private:
__detail::_Scoped_ptr<_Codecvt> _M_cvt;
byte_string _M_byte_err_string;
wide_string _M_wide_err_string;
state_type _M_state = state_type();
size_t _M_count = 0;
bool _M_with_cvtstate = false;
bool _M_with_strings = false;
};

template<typename _Codecvt, typename _Elem = wchar_t,

typename _Tr = char_traits<_Elem>>
class wbuffer_convert : public basic_streambuf<_Elem, _Tr>
{
typedef basic_streambuf<_Elem, _Tr> _Wide_streambuf;

public:
typedef typename _Codecvt::state_type state_type;

wbuffer_convert() : wbuffer_convert(nullptr) { }
# 427 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/locale_conv.h" 3
explicit
wbuffer_convert(streambuf* __bytebuf, _Codecvt* __pcvt = new _Codecvt,
state_type __state = state_type())
: _M_buf(__bytebuf), _M_cvt(__pcvt, "wbuffer_convert"),
_M_state(__state), _M_always_noconv(_M_cvt->always_noconv())
{
if (_M_buf)
{
this->setp(_M_put_area, _M_put_area + _S_buffer_length);
this->setg(_M_get_area + _S_putback_length,
_M_get_area + _S_putback_length,
_M_get_area + _S_putback_length);
}
}

~wbuffer_convert() = default;

wbuffer_convert(const wbuffer_convert&) = delete;

wbuffer_convert& operator=(const wbuffer_convert&) = delete;

streambuf* rdbuf() const noexcept { return _M_buf; }

streambuf*
rdbuf(streambuf *__bytebuf) noexcept
{
auto __prev = _M_buf;
_M_buf = __bytebuf;
return __prev;
}

state_type state() const noexcept { return _M_state; }

protected:
int
sync()
{ return _M_buf && _M_conv_put() && !_M_buf->pubsync() ? 0 : -1; }

typename _Wide_streambuf::int_type
overflow(typename _Wide_streambuf::int_type __out)
{
if (!_M_buf || !_M_conv_put())
return _Tr::eof();
else if (!_Tr::eq_int_type(__out, _Tr::eof()))
return this->sputc(__out);
return _Tr::not_eof(__out);
}

typename _Wide_streambuf::int_type
underflow()
{
if (!_M_buf)
return _Tr::eof();

if (this->gptr() < this->egptr() || (_M_buf && _M_conv_get()))

return _Tr::to_int_type(*this->gptr());
else
return _Tr::eof();
}

streamsize
xsputn(const typename _Wide_streambuf::char_type* __s, streamsize __n)
{
if (!_M_buf || __n == 0)
return 0;
streamsize __done = 0;
do
{
auto __nn = std::min<streamsize>(this->epptr() - this->pptr(),
__n - __done);
_Tr::copy(this->pptr(), __s + __done, __nn);
this->pbump(__nn);
__done += __nn;
} while (__done < __n && _M_conv_put());
return __done;
}

private:

bool
_M_conv_get()
{
const streamsize __pb1 = this->gptr() - this->eback();
const streamsize __pb2 = _S_putback_length;
const streamsize __npb = std::min(__pb1, __pb2);

_Tr::move(_M_get_area + _S_putback_length - __npb,

this->gptr() - __npb, __npb);

streamsize __nbytes = sizeof(_M_get_buf) - _M_unconv;

__nbytes = std::min(__nbytes, _M_buf->in_avail());
if (__nbytes < 1)
__nbytes = 1;
__nbytes = _M_buf->sgetn(_M_get_buf + _M_unconv, __nbytes);
if (__nbytes < 1)
return false;
__nbytes += _M_unconv;

_Elem* __outbuf = _M_get_area + _S_putback_length;

_Elem* __outnext = __outbuf;
const char* __bnext = _M_get_buf;

codecvt_base::result __result;
if (_M_always_noconv)
__result = codecvt_base::noconv;
else
{
_Elem* __outend = _M_get_area + _S_buffer_length;

__result = _M_cvt->in(_M_state,
__bnext, __bnext + __nbytes, __bnext,
__outbuf, __outend, __outnext);
}

if (__result == codecvt_base::noconv)
{

auto __get_buf = reinterpret_cast<const _Elem*>(_M_get_buf);

_Tr::copy(__outbuf, __get_buf, __nbytes);
_M_unconv = 0;
return true;
}

if ((_M_unconv = _M_get_buf + nbytes - bnext))

char_traits<char>::move(_M_get_buf, __bnext, _M_unconv);

this->setg(outbuf, outbuf, __outnext);

return __result != codecvt_base::error;
}

bool
_M_put(...)
{ return false; }

bool
_M_put(const char* __p, streamsize __n)
{
if (_M_buf->sputn(__p, __n) < __n)
return false;
return true;
}

bool
_M_conv_put()
{
_Elem* const __first = this->pbase();
const _Elem* const __last = this->pptr();
const streamsize __pending = __last - __first;

if (_M_always_noconv)
return _M_put(__first, __pending);

char __outbuf[2 * _S_buffer_length];

const _Elem* next = first;

const _Elem* __start;
do
{
__start = __next;
char* __outnext = __outbuf;
char* const __outlast = __outbuf + sizeof(__outbuf);
auto __result = _M_cvt->out(_M_state, __next, __last, __next,
__outnext, __outlast, __outnext);
if (__result == codecvt_base::error)
return false;
else if (__result == codecvt_base::noconv)
return _M_put(__next, __pending);

if (!_M_put(outbuf, outnext - __outbuf))

return false;
}
while (__next != __last && __next != __start);

if (__next != __last)
_Tr::move(__first, __next, __last - __next);

this->pbump(__first - __next);
return __next != __first;
}

streambuf* _M_buf;
__detail::_Scoped_ptr<_Codecvt> _M_cvt;
state_type _M_state;
static const streamsize _S_buffer_length = 32;
static const streamsize _S_putback_length = 3;
_Elem _M_put_area[_S_buffer_length];
_Elem _M_get_area[_S_buffer_length];
streamsize _M_unconv = 0;
char _M_get_buf[_S_buffer_length-_S_putback_length];
bool _M_always_noconv;
};

}
# 46 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/locale" 2 3
# 48 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/format" 2 3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/optional" 1 3
# 33 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/optional" 3

# 34 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/optional" 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 1 3
# 47 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 3

# 48 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 3
# 38 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/optional" 2 3

# 1
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/enable_special_members.h" 1
3
# 33
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/enable_special_members.h" 3

# 34
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/enable_special_members.h" 3

namespace std
{

struct _Enable_default_constructor_tag
{
explicit constexpr _Enable_default_constructor_tag() = default;
};
template<bool _Switch, typename _Tag = void>
struct _Enable_default_constructor
{
constexpr _Enable_default_constructor() noexcept = default;
constexpr _Enable_default_constructor(_Enable_default_constructor const&)
noexcept = default;
constexpr _Enable_default_constructor(_Enable_default_constructor&&)
noexcept = default;
_Enable_default_constructor&
operator=(_Enable_default_constructor const&) noexcept = default;
_Enable_default_constructor&
operator=(_Enable_default_constructor&&) noexcept = default;

constexpr explicit
_Enable_default_constructor(_Enable_default_constructor_tag) { }
};

template<bool _Switch, typename _Tag = void>

struct _Enable_destructor { };

template<bool _Copy, bool _CopyAssignment,

bool _Move, bool _MoveAssignment,
typename _Tag = void>
struct _Enable_copy_move { };
# 96
"D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/enable_special_members.h" 3
template<bool _Default, bool _Destructor,
bool _Copy, bool _CopyAssignment,
bool _Move, bool _MoveAssignment,
typename _Tag = void>
struct _Enable_special_members
: private _Enable_default_constructor<_Default, _Tag>,
private _Enable_destructor<_Destructor, _Tag>,
private _Enable_copy_move<_Copy, _CopyAssignment,
_Move, _MoveAssignment,
_Tag>
{ };

template<typename _Tag>
struct _Enable_default_constructor<false, _Tag>
{
constexpr _Enable_default_constructor() noexcept = delete;
constexpr _Enable_default_constructor(_Enable_default_constructor const&)
noexcept = default;
constexpr _Enable_default_constructor(_Enable_default_constructor&&)
noexcept = default;
_Enable_default_constructor&
operator=(_Enable_default_constructor const&) noexcept = default;
_Enable_default_constructor&
operator=(_Enable_default_constructor&&) noexcept = default;

constexpr explicit
_Enable_default_constructor(_Enable_default_constructor_tag) { }
};

template<typename _Tag>
struct _Enable_destructor<false, _Tag>
{ ~_Enable_destructor() noexcept = delete; };

template<typename _Tag>
struct _Enable_copy_move<false, true, true, true, _Tag>
{
constexpr _Enable_copy_move() noexcept = default;
constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete;
constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default;
_Enable_copy_move&
operator=(_Enable_copy_move const&) noexcept = default;
_Enable_copy_move&
operator=(_Enable_copy_move&&) noexcept = default;
};

template<typename _Tag>
struct _Enable_copy_move<true, false, true, true, _Tag>
{
constexpr _Enable_copy_move() noexcept = default;
constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default;
constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default;
_Enable_copy_move&
operator=(_Enable_copy_move const&) noexcept = delete;
_Enable_copy_move&
operator=(_Enable_copy_move&&) noexcept = default;
};

template<typename _Tag>
struct _Enable_copy_move<false, false, true, true, _Tag>
{
constexpr _Enable_copy_move() noexcept = default;
constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete;
constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default;
_Enable_copy_move&
operator=(_Enable_copy_move const&) noexcept = delete;
_Enable_copy_move&
operator=(_Enable_copy_move&&) noexcept = default;
};

template<typename _Tag>
struct _Enable_copy_move<true, true, false, true, _Tag>
{
constexpr _Enable_copy_move() noexcept = default;
constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default;
constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete;
_Enable_copy_move&
operator=(_Enable_copy_move const&) noexcept = default;
_Enable_copy_move&
operator=(_Enable_copy_move&&) noexcept = default;
};

template<typename _Tag>
struct _Enable_copy_move<false, true, false, true, _Tag>
{
constexpr _Enable_copy_move() noexcept = default;
constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete;
constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete;
_Enable_copy_move&
operator=(_Enable_copy_move const&) noexcept = default;
_Enable_copy_move&
operator=(_Enable_copy_move&&) noexcept = default;
};

template<typename _Tag>
struct _Enable_copy_move<true, false, false, true, _Tag>
{
constexpr _Enable_copy_move() noexcept = default;
constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default;
constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete;
_Enable_copy_move&
operator=(_Enable_copy_move const&) noexcept = delete;
_Enable_copy_move&
operator=(_Enable_copy_move&&) noexcept = default;
};

template<typename _Tag>
struct _Enable_copy_move<false, false, false, true, _Tag>
{
constexpr _Enable_copy_move() noexcept = default;
constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete;
constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete;
_Enable_copy_move&
operator=(_Enable_copy_move const&) noexcept = delete;
_Enable_copy_move&
operator=(_Enable_copy_move&&) noexcept = default;
};

template<typename _Tag>
struct _Enable_copy_move<true, true, true, false, _Tag>
{
constexpr _Enable_copy_move() noexcept = default;
constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default;
constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default;
_Enable_copy_move&
operator=(_Enable_copy_move const&) noexcept = default;
_Enable_copy_move&
operator=(_Enable_copy_move&&) noexcept = delete;
};

template<typename _Tag>
struct _Enable_copy_move<false, true, true, false, _Tag>
{
constexpr _Enable_copy_move() noexcept = default;
constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete;
constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default;
_Enable_copy_move&
operator=(_Enable_copy_move const&) noexcept = default;
_Enable_copy_move&
operator=(_Enable_copy_move&&) noexcept = delete;
};

template<typename _Tag>
struct _Enable_copy_move<true, false, true, false, _Tag>
{
constexpr _Enable_copy_move() noexcept = default;
constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default;
constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default;
_Enable_copy_move&
operator=(_Enable_copy_move const&) noexcept = delete;
_Enable_copy_move&
operator=(_Enable_copy_move&&) noexcept = delete;
};

template<typename _Tag>
struct _Enable_copy_move<false, false, true, false, _Tag>
{
constexpr _Enable_copy_move() noexcept = default;
constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete;
constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default;
_Enable_copy_move&
operator=(_Enable_copy_move const&) noexcept = delete;
_Enable_copy_move&
operator=(_Enable_copy_move&&) noexcept = delete;
};

template<typename _Tag>
struct _Enable_copy_move<true, true, false, false, _Tag>
{
constexpr _Enable_copy_move() noexcept = default;
constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default;
constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete;
_Enable_copy_move&
operator=(_Enable_copy_move const&) noexcept = default;
_Enable_copy_move&
operator=(_Enable_copy_move&&) noexcept = delete;
};

template<typename _Tag>
struct _Enable_copy_move<false, true, false, false, _Tag>
{
constexpr _Enable_copy_move() noexcept = default;
constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete;
constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete;
_Enable_copy_move&
operator=(_Enable_copy_move const&) noexcept = default;
_Enable_copy_move&
operator=(_Enable_copy_move&&) noexcept = delete;
};

template<typename _Tag>
struct _Enable_copy_move<true, false, false, false, _Tag>
{
constexpr _Enable_copy_move() noexcept = default;
constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default;
constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete;
_Enable_copy_move&
operator=(_Enable_copy_move const&) noexcept = delete;
_Enable_copy_move&
operator=(_Enable_copy_move&&) noexcept = delete;
};

template<typename _Tag>
struct _Enable_copy_move<false, false, false, false, _Tag>
{
constexpr _Enable_copy_move() noexcept = default;
constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete;
constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete;
_Enable_copy_move&
operator=(_Enable_copy_move const&) noexcept = delete;
_Enable_copy_move&
operator=(_Enable_copy_move&&) noexcept = delete;
};

}
# 46 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/optional" 2 3
# 58 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/optional" 3
namespace std
{

template<typename _Tp>
class optional;

struct nullopt_t
{

enum class _Construct { _Token };

explicit constexpr nullopt_t(_Construct) noexcept { }

};

inline constexpr nullopt_t nullopt { nullopt_t::_Construct::_Token };

template<typename _Fn> struct _Optional_func { _Fn& _M_f; };

class bad_optional_access : public exception
{
public:
bad_optional_access() = default;
virtual ~bad_optional_access() = default;

const char* what() const noexcept override

{ return "bad optional access"; }
};

[[noreturn]] inline void

__throw_bad_optional_access()
{ (throw (bad_optional_access())); }

template <typename _Tp>

struct _Optional_payload_base
{
using _Stored_type = remove_const_t<_Tp>;

_Optional_payload_base() = default;
~_Optional_payload_base() = default;

template<typename... _Args>
constexpr
_Optional_payload_base(in_place_t __tag, _Args&&... __args)
: _M_payload(__tag, std::forward<_Args>(__args)...),
_M_engaged(true)
{ }

template<typename _Up, typename... _Args>

constexpr
_Optional_payload_base(std::initializer_list<_Up> __il,
_Args&&... __args)
: _M_payload(__il, std::forward<_Args>(__args)...),
_M_engaged(true)
{ }

constexpr
_Optional_payload_base(bool ,
const _Optional_payload_base& __other)
{
if (__other._M_engaged)
this->_M_construct(__other._M_get());
}

constexpr
_Optional_payload_base(bool ,
_Optional_payload_base&& __other)
{
if (__other._M_engaged)
this->_M_construct(std::move(__other._M_get()));
}

_Optional_payload_base(const _Optional_payload_base&) = default;

_Optional_payload_base(_Optional_payload_base&&) = default;

_Optional_payload_base&
operator=(const _Optional_payload_base&) = default;

_Optional_payload_base&
operator=(_Optional_payload_base&&) = default;

constexpr void
_M_copy_assign(const _Optional_payload_base& __other)
{
if (this->_M_engaged && __other._M_engaged)
this->_M_get() = __other._M_get();
else
{
if (__other._M_engaged)
this->_M_construct(__other._M_get());
else
this->_M_reset();
}
}

constexpr void
_M_move_assign(_Optional_payload_base&& __other)
noexcept(__and_v<is_nothrow_move_constructible<_Tp>,
is_nothrow_move_assignable<_Tp>>)
{
if (this->_M_engaged && __other._M_engaged)
this->_M_get() = std::move(__other._M_get());
else
{
if (__other._M_engaged)
this->_M_construct(std::move(__other._M_get()));
else
this->_M_reset();
}
}

struct _Empty_byte { };

template<typename _Up, bool = is_trivially_destructible_v<_Up>>

union _Storage
{
constexpr _Storage() noexcept : _M_empty() { }

template<typename... _Args>
constexpr
_Storage(in_place_t, _Args&&... __args)
: _M_value(std::forward<_Args>(__args)...)
{ }

template<typename _Vp, typename... _Args>

constexpr
_Storage(std::initializer_list<_Vp> __il, _Args&&... __args)
: _M_value(__il, std::forward<_Args>(__args)...)
{ }

template<typename _Fn, typename _Arg>

constexpr
_Storage(_Optional_func<_Fn> __f, _Arg&& __arg)
: _M_value(std::__invoke(std::forward<_Fn>(__f._M_f),
std::forward<_Arg>(__arg)))
{ }

_Empty_byte _M_empty;
_Up _M_value;
};

template<typename _Up>
union _Storage<_Up, false>
{
constexpr _Storage() noexcept : _M_empty() { }

template<typename... _Args>
constexpr
_Storage(in_place_t, _Args&&... __args)
: _M_value(std::forward<_Args>(__args)...)
{ }

template<typename _Vp, typename... _Args>

constexpr
_Storage(std::initializer_list<_Vp> __il, _Args&&... __args)
: _M_value(__il, std::forward<_Args>(__args)...)
{ }

template<typename _Fn, typename _Arg>

constexpr
_Storage(_Optional_func<_Fn> __f, _Arg&& __arg)
: _M_value(std::__invoke(std::forward<_Fn>(__f._M_f),
std::forward<_Arg>(__arg)))
{ }

constexpr ~_Storage() { }

_Empty_byte _M_empty;
_Up _M_value;
};

_Storage<_Stored_type> _M_payload;

bool _M_engaged = false;

template<typename... _Args>
constexpr void
_M_construct(_Args&&... __args)
noexcept(is_nothrow_constructible_v<_Stored_type, _Args...>)
{
std::_Construct(std::__addressof(this->_M_payload._M_value),
std::forward<_Args>(__args)...);
this->_M_engaged = true;
}

constexpr void
_M_destroy() noexcept
{
_M_engaged = false;
_M_payload._M_value.~_Stored_type();
}

template<typename _Fn, typename _Up>

constexpr void
_M_apply(_Optional_func<_Fn> __f, _Up&& __x)
{
std::construct_at(std::__addressof(this->_M_payload),
__f, std::forward<_Up>(__x));
_M_engaged = true;
}

constexpr _Tp&
_M_get() noexcept
{ return this->_M_payload._M_value; }

constexpr const _Tp&

_M_get() const noexcept
{ return this->_M_payload._M_value; }

constexpr void
_M_reset() noexcept
{
if (this->_M_engaged)
_M_destroy();
else
this->_M_engaged = false;
}
};

template <typename _Tp,

bool =
is_trivially_destructible_v<_Tp>,
bool =
is_trivially_copy_assignable_v<_Tp>
&& is_trivially_copy_constructible_v<_Tp>,
bool =
is_trivially_move_assignable_v<_Tp>
&& is_trivially_move_constructible_v<_Tp>>
struct _Optional_payload;

template <typename _Tp>

struct _Optional_payload<_Tp, true, true, true>
: _Optional_payload_base<_Tp>
{
using _Optional_payload_base<_Tp>::_Optional_payload_base;

_Optional_payload() = default;
};

template <typename _Tp>

struct _Optional_payload<_Tp, true, false, true>
: _Optional_payload_base<_Tp>
{
using _Optional_payload_base<_Tp>::_Optional_payload_base;

_Optional_payload() = default;
~_Optional_payload() = default;
_Optional_payload(const _Optional_payload&) = default;
_Optional_payload(_Optional_payload&&) = default;
_Optional_payload& operator=(_Optional_payload&&) = default;

constexpr
_Optional_payload&
operator=(const _Optional_payload& __other)
{
this->_M_copy_assign(__other);
return *this;
}
};

template <typename _Tp>

struct _Optional_payload<_Tp, true, true, false>
: _Optional_payload_base<_Tp>
{
using _Optional_payload_base<_Tp>::_Optional_payload_base;

constexpr
_Optional_payload&
operator=(_Optional_payload&& __other)
noexcept(__and_v<is_nothrow_move_constructible<_Tp>,
is_nothrow_move_assignable<_Tp>>)
{
this->_M_move_assign(std::move(__other));
return *this;
}
};

template <typename _Tp>

struct _Optional_payload<_Tp, true, false, false>
: _Optional_payload_base<_Tp>
{
using _Optional_payload_base<_Tp>::_Optional_payload_base;

_Optional_payload() = default;
~_Optional_payload() = default;
_Optional_payload(const _Optional_payload&) = default;
_Optional_payload(_Optional_payload&&) = default;

constexpr
_Optional_payload&
operator=(const _Optional_payload& __other)
{
this->_M_copy_assign(__other);
return *this;
}

template <typename _Tp, bool _Copy, bool _Move>

struct _Optional_payload<_Tp, false, _Copy, _Move>
: _Optional_payload<_Tp, true, false, false>
{

using _Optional_payload<_Tp, true, false, false>::_Optional_payload;

_Optional_payload() = default;
_Optional_payload(const _Optional_payload&) = default;
_Optional_payload(_Optional_payload&&) = default;
_Optional_payload& operator=(const _Optional_payload&) = default;
_Optional_payload& operator=(_Optional_payload&&) = default;

constexpr ~_Optional_payload() { this->_M_reset(); }

};

template<typename _Tp, typename _Dp>

class _Optional_base_impl
{
protected:
using _Stored_type = remove_const_t<_Tp>;

template<typename... _Args>
constexpr void
_M_construct(_Args&&... __args)
noexcept(is_nothrow_constructible_v<_Stored_type, _Args...>)
{
static_cast<_Dp*>(this)->_M_payload._M_construct(
std::forward<_Args>(__args)...);
}

constexpr void
_M_destruct() noexcept
{ static_cast<_Dp*>(this)->_M_payload._M_destroy(); }

constexpr void
_M_reset() noexcept
{ static_cast<_Dp*>(this)->_M_payload._M_reset(); }

constexpr bool _M_is_engaged() const noexcept

{ return static_cast<const _Dp*>(this)->_M_payload._M_engaged; }

constexpr _Tp&
_M_get() noexcept
{
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(this-
>_M_is_engaged()), false)) std::__glibcxx_assert_fail(); } while (false);
return static_cast<_Dp*>(this)->_M_payload._M_get();
}

constexpr const _Tp&

_M_get() const noexcept
{
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(this-
>_M_is_engaged()), false)) std::__glibcxx_assert_fail(); } while (false);
return static_cast<const _Dp*>(this)->_M_payload._M_get();
}
};
# 505 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/optional" 3
template<typename _Tp,
bool = is_trivially_copy_constructible_v<_Tp>,
bool = is_trivially_move_constructible_v<_Tp>>
struct _Optional_base
: _Optional_base_impl<_Tp, _Optional_base<_Tp>>
{

constexpr _Optional_base() = default;

template<typename... _Args,
enable_if_t<is_constructible_v<_Tp, _Args...>, bool> = false>
constexpr explicit
_Optional_base(in_place_t, _Args&&... __args)
: _M_payload(in_place, std::forward<_Args>(__args)...)
{ }
template<typename _Up, typename... _Args,
enable_if_t<is_constructible_v<_Tp,
initializer_list<_Up>&,
_Args...>, bool> = false>
constexpr explicit
_Optional_base(in_place_t,
initializer_list<_Up> __il,
_Args&&... __args)
: _M_payload(in_place, __il, std::forward<_Args>(__args)...)
{ }

constexpr
_Optional_base(const _Optional_base& __other)
: _M_payload(__other._M_payload._M_engaged, __other._M_payload)
{ }

constexpr
_Optional_base(_Optional_base&& __other)
noexcept(is_nothrow_move_constructible_v<_Tp>)
: _M_payload(__other._M_payload._M_engaged,
std::move(__other._M_payload))
{ }

_Optional_base& operator=(const _Optional_base&) = default;

_Optional_base& operator=(_Optional_base&&) = default;

_Optional_payload<_Tp> _M_payload;
};

template<typename _Tp>
struct _Optional_base<_Tp, false, true>
: _Optional_base_impl<_Tp, _Optional_base<_Tp>>
{

constexpr _Optional_base() = default;

template<typename _Up, typename... _Args,

enable_if_t<is_constructible_v<_Tp,
initializer_list<_Up>&,
_Args...>, bool> = false>
constexpr explicit
_Optional_base(in_place_t,
initializer_list<_Up> __il,
_Args... __args)
: _M_payload(in_place, __il, std::forward<_Args>(__args)...)
{ }
constexpr _Optional_base(const _Optional_base& __other)
: _M_payload(__other._M_payload._M_engaged, __other._M_payload)
{ }

constexpr _Optional_base(_Optional_base&& __other) = default;

_Optional_base& operator=(const _Optional_base&) = default;

_Optional_base& operator=(_Optional_base&&) = default;

_Optional_payload<_Tp> _M_payload;
};

template<typename _Tp>
struct _Optional_base<_Tp, true, false>
: _Optional_base_impl<_Tp, _Optional_base<_Tp>>
{

constexpr _Optional_base() = default;

template<typename _Up, typename... _Args,

constexpr _Optional_base(const _Optional_base& __other) = default;

constexpr
_Optional_base(_Optional_base&& __other)
noexcept(is_nothrow_move_constructible_v<_Tp>)
: _M_payload(__other._M_payload._M_engaged,
std::move(__other._M_payload))
{ }

_Optional_base& operator=(const _Optional_base&) = default;

_Optional_base& operator=(_Optional_base&&) = default;

_Optional_payload<_Tp> _M_payload;
};

template<typename _Tp>
struct _Optional_base<_Tp, true, true>
: _Optional_base_impl<_Tp, _Optional_base<_Tp>>
{

constexpr _Optional_base() = default;

template<typename _Up, typename... _Args,

constexpr _Optional_base(const _Optional_base& __other) = default;

constexpr _Optional_base(_Optional_base&& __other) = default;

_Optional_base& operator=(const _Optional_base&) = default;

_Optional_base& operator=(_Optional_base&&) = default;

_Optional_payload<_Tp> _M_payload;
};

template<typename _Tp>
class optional;

template<typename _Tp>
inline constexpr bool __is_optional_v = false;
template<typename _Tp>
inline constexpr bool __is_optional_v<optional<_Tp>> = true;

template<typename _Tp, typename _Up>

using __converts_from_optional =
__or_<is_constructible<_Tp, const optional<_Up>&>,
is_constructible<_Tp, optional<_Up>&>,
is_constructible<_Tp, const optional<_Up>&&>,
is_constructible<_Tp, optional<_Up>&&>,
is_convertible<const optional<_Up>&, _Tp>,
is_convertible<optional<_Up>&, _Tp>,
is_convertible<const optional<_Up>&&, _Tp>,
is_convertible<optional<_Up>&&, _Tp>>;

template<typename _Tp, typename _Up>

using __assigns_from_optional =
__or_<is_assignable<_Tp&, const optional<_Up>&>,
is_assignable<_Tp&, optional<_Up>&>,
is_assignable<_Tp&, const optional<_Up>&&>,
is_assignable<_Tp&, optional<_Up>&&>>;
template<typename _Tp>
class optional
: private _Optional_base<_Tp>,
private _Enable_copy_move<

is_copy_constructible_v<_Tp>,

__and_v<is_copy_constructible<_Tp>, is_copy_assignable<_Tp>>,

is_move_constructible_v<_Tp>,

__and_v<is_move_constructible<_Tp>, is_move_assignable<_Tp>>,

optional<_Tp>>
{
static_assert(!is_same_v<remove_cv_t<_Tp>, nullopt_t>);
static_assert(!is_same_v<remove_cv_t<_Tp>, in_place_t>);
static_assert(is_object_v<_Tp> && !is_array_v<_Tp>);

private:
using _Base = _Optional_base<_Tp>;

template<typename _Up>
using __not_self = __not_<is_same<optional, __remove_cvref_t<_Up>>>;
template<typename _Up>
using __not_tag = __not_<is_same<in_place_t, __remove_cvref_t<_Up>>>;
template<typename... _Cond>
using _Requires = enable_if_t<__and_v<_Cond...>, bool>;

public:
using value_type = _Tp;

constexpr optional() noexcept { }

constexpr optional(nullopt_t) noexcept { }

template<typename _Up = _Tp,

_Requires<__not_self<_Up>, __not_tag<_Up>,
is_constructible<_Tp, _Up>,
is_convertible<_Up, _Tp>> = true>
constexpr
optional(_Up&& __t)
noexcept(is_nothrow_constructible_v<_Tp, _Up>)
: _Base(std::in_place, std::forward<_Up>(__t)) { }

template<typename _Up = _Tp,

_Requires<__not_self<_Up>, __not_tag<_Up>,
is_constructible<_Tp, _Up>,
__not_<is_convertible<_Up, _Tp>>> = false>
explicit constexpr
optional(_Up&& __t)
noexcept(is_nothrow_constructible_v<_Tp, _Up>)
: _Base(std::in_place, std::forward<_Up>(__t)) { }
template<typename _Up,
_Requires<__not_<is_same<_Tp, _Up>>,
is_constructible<_Tp, const _Up&>,
is_convertible<const _Up&, _Tp>,
__not_<__converts_from_optional<_Tp, _Up>>> = true>
constexpr
optional(const optional<_Up>& __t)
noexcept(is_nothrow_constructible_v<_Tp, const _Up&>)
{
if (__t)
emplace(*__t);
}

template<typename _Up,
_Requires<__not_<is_same<_Tp, _Up>>,
is_constructible<_Tp, const _Up&>,
__not_<is_convertible<const _Up&, _Tp>>,
__not_<__converts_from_optional<_Tp, _Up>>> = false>
explicit constexpr
optional(const optional<_Up>& __t)
noexcept(is_nothrow_constructible_v<_Tp, const _Up&>)
{
if (__t)
emplace(*__t);
}

template<typename _Up,
_Requires<__not_<is_same<_Tp, _Up>>,
is_constructible<_Tp, _Up>,
is_convertible<_Up, _Tp>,
__not_<__converts_from_optional<_Tp, _Up>>> = true>
constexpr
optional(optional<_Up>&& __t)
noexcept(is_nothrow_constructible_v<_Tp, _Up>)
{
if (__t)
emplace(std::move(*__t));
}

template<typename _Up,
_Requires<__not_<is_same<_Tp, _Up>>,
is_constructible<_Tp, _Up>,
__not_<is_convertible<_Up, _Tp>>,
__not_<__converts_from_optional<_Tp, _Up>>> = false>
explicit constexpr
optional(optional<_Up>&& __t)
noexcept(is_nothrow_constructible_v<_Tp, _Up>)
{
if (__t)
emplace(std::move(*__t));
}

template<typename... _Args,
_Requires<is_constructible<_Tp, _Args...>> = false>
explicit constexpr
optional(in_place_t, _Args&&... __args)
noexcept(is_nothrow_constructible_v<_Tp, _Args...>)
: _Base(std::in_place, std::forward<_Args>(__args)...) { }
template<typename _Up, typename... _Args,
_Requires<is_constructible<_Tp,
initializer_list<_Up>&,
_Args...>> = false>
explicit constexpr
optional(in_place_t, initializer_list<_Up> __il, _Args&&... __args)
noexcept(is_nothrow_constructible_v<_Tp, initializer_list<_Up>&,
_Args...>)
: _Base(std::in_place, __il, std::forward<_Args>(__args)...) { }

constexpr optional&
operator=(nullopt_t) noexcept
{
this->_M_reset();
return *this;
}

template<typename _Up = _Tp>

constexpr
enable_if_t<__and_v<__not_self<_Up>,
__not_<__and_<is_scalar<_Tp>,
is_same<_Tp, decay_t<_Up>>>>,
is_constructible<_Tp, _Up>,
is_assignable<_Tp&, _Up>>,
optional&>
operator=(_Up&& __u)
noexcept(__and_v<is_nothrow_constructible<_Tp, _Up>,
is_nothrow_assignable<_Tp&, _Up>>)
{
if (this->_M_is_engaged())
this->_M_get() = std::forward<_Up>(__u);
else
this->_M_construct(std::forward<_Up>(__u));

return *this;
}

template<typename _Up>
constexpr
enable_if_t<__and_v<__not_<is_same<_Tp, _Up>>,
is_constructible<_Tp, const _Up&>,
is_assignable<_Tp&, const _Up&>,
__not_<__converts_from_optional<_Tp, _Up>>,
__not_<__assigns_from_optional<_Tp, _Up>>>,
optional&>
operator=(const optional<_Up>& __u)
noexcept(__and_v<is_nothrow_constructible<_Tp, const _Up&>,
is_nothrow_assignable<_Tp&, const _Up&>>)
{
if (__u)
{
if (this->_M_is_engaged())
this->_M_get() = *__u;
else
this->_M_construct(*__u);
}
else
{
this->_M_reset();
}
return *this;
}

template<typename _Up>
constexpr
enable_if_t<__and_v<__not_<is_same<_Tp, _Up>>,
is_constructible<_Tp, _Up>,
is_assignable<_Tp&, _Up>,
__not_<__converts_from_optional<_Tp, _Up>>,
__not_<__assigns_from_optional<_Tp, _Up>>>,
optional&>
operator=(optional<_Up>&& __u)
noexcept(__and_v<is_nothrow_constructible<_Tp, _Up>,
is_nothrow_assignable<_Tp&, _Up>>)
{
if (__u)
{
if (this->_M_is_engaged())
this->_M_get() = std::move(*__u);
else
this->_M_construct(std::move(*__u));
}
else
{
this->_M_reset();
}

return *this;
}

template<typename... _Args>
constexpr
enable_if_t<is_constructible_v<_Tp, _Args...>, _Tp&>
emplace(_Args&&... __args)
noexcept(is_nothrow_constructible_v<_Tp, _Args...>)
{
this->_M_reset();
this->_M_construct(std::forward<_Args>(__args)...);
return this->_M_get();
}

template<typename _Up, typename... _Args>

constexpr
enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>,
_Tp&>
emplace(initializer_list<_Up> __il, _Args&&... __args)
noexcept(is_nothrow_constructible_v<_Tp, initializer_list<_Up>&,
_Args...>)
{
this->_M_reset();
this->_M_construct(__il, std::forward<_Args>(__args)...);
return this->_M_get();
}
constexpr void
swap(optional& __other)
noexcept(is_nothrow_move_constructible_v<_Tp>
&& is_nothrow_swappable_v<_Tp>)
{
using std::swap;

if (this->_M_is_engaged() && __other._M_is_engaged())

swap(this->_M_get(), __other._M_get());
else if (this->_M_is_engaged())
{
__other._M_construct(std::move(this->_M_get()));
this->_M_destruct();
}
else if (__other._M_is_engaged())
{
this->_M_construct(std::move(__other._M_get()));
__other._M_destruct();
}
}

constexpr const _Tp*

operator->() const noexcept
{ return std::__addressof(this->_M_get()); }

constexpr _Tp*
operator->() noexcept
{ return std::__addressof(this->_M_get()); }

constexpr const _Tp&

operator*() const& noexcept
{ return this->_M_get(); }

constexpr _Tp&
operator*()& noexcept
{ return this->_M_get(); }

constexpr _Tp&&
operator*()&& noexcept
{ return std::move(this->_M_get()); }

constexpr const _Tp&&

operator*() const&& noexcept
{ return std::move(this->_M_get()); }

constexpr explicit operator bool() const noexcept

{ return this->_M_is_engaged(); }

constexpr bool has_value() const noexcept

{ return this->_M_is_engaged(); }

constexpr const _Tp&

value() const&
{
if (this->_M_is_engaged())
return this->_M_get();
__throw_bad_optional_access();
}

constexpr _Tp&
value()&
{
if (this->_M_is_engaged())
return this->_M_get();
__throw_bad_optional_access();
}

constexpr _Tp&&
value()&&
{
if (this->_M_is_engaged())
return std::move(this->_M_get());
__throw_bad_optional_access();
}

constexpr const _Tp&&

value() const&&
{
if (this->_M_is_engaged())
return std::move(this->_M_get());
__throw_bad_optional_access();
}

template<typename _Up>
constexpr _Tp
value_or(_Up&& __u) const&
{
static_assert(is_copy_constructible_v<_Tp>);
static_assert(is_convertible_v<_Up&&, _Tp>);

if (this->_M_is_engaged())
return this->_M_get();
else
return static_cast<_Tp>(std::forward<_Up>(__u));
}

template<typename _Up>
constexpr _Tp
value_or(_Up&& __u) &&
{
static_assert(is_move_constructible_v<_Tp>);
static_assert(is_convertible_v<_Up&&, _Tp>);

if (this->_M_is_engaged())
return std::move(this->_M_get());
else
return static_cast<_Tp>(std::forward<_Up>(__u));
}

template<typename _Fn>
constexpr auto
and_then(_Fn&& __f) &
{
using _Up = remove_cvref_t<invoke_result_t<_Fn, _Tp&>>;
static_assert(__is_optional_v<remove_cvref_t<_Up>>,
"the function passed to std::optional<T>::and_then "
"must return a std::optional");
if (has_value())
return std::__invoke(std::forward<_Fn>(__f), **this);
else
return _Up();
}

template<typename _Fn>
constexpr auto
and_then(_Fn&& __f) const &
{
using _Up = remove_cvref_t<invoke_result_t<_Fn, const _Tp&>>;
static_assert(__is_optional_v<_Up>,
"the function passed to std::optional<T>::and_then "
"must return a std::optional");
if (has_value())
return std::__invoke(std::forward<_Fn>(__f), **this);
else
return _Up();
}

template<typename _Fn>
constexpr auto
and_then(_Fn&& __f) &&
{
using _Up = remove_cvref_t<invoke_result_t<_Fn, _Tp>>;
static_assert(__is_optional_v<remove_cvref_t<_Up>>,
"the function passed to std::optional<T>::and_then "
"must return a std::optional");
if (has_value())
return std::__invoke(std::forward<_Fn>(__f), std::move(**this));
else
return _Up();
}

template<typename _Fn>
constexpr auto
and_then(_Fn&& __f) const &&
{
using _Up = remove_cvref_t<invoke_result_t<_Fn, const _Tp>>;
static_assert(__is_optional_v<remove_cvref_t<_Up>>,
"the function passed to std::optional<T>::and_then "
"must return a std::optional");
if (has_value())
return std::__invoke(std::forward<_Fn>(__f), std::move(**this));
else
return _Up();
}

template<typename _Fn>
constexpr auto
transform(_Fn&& __f) &
{
using _Up = remove_cv_t<invoke_result_t<_Fn, _Tp&>>;
if (has_value())
return optional<_Up>(_Optional_func<_Fn>{__f}, **this);
else
return optional<_Up>();
}

template<typename _Fn>
constexpr auto
transform(_Fn&& __f) const &
{
using _Up = remove_cv_t<invoke_result_t<_Fn, const _Tp&>>;
if (has_value())
return optional<_Up>(_Optional_func<_Fn>{__f}, **this);
else
return optional<_Up>();
}

template<typename _Fn>
constexpr auto
transform(_Fn&& __f) &&
{
using _Up = remove_cv_t<invoke_result_t<_Fn, _Tp>>;
if (has_value())
return optional<_Up>(_Optional_func<_Fn>{__f}, std::move(**this));
else
return optional<_Up>();
}

template<typename _Fn>
constexpr auto
transform(_Fn&& __f) const &&
{
using _Up = remove_cv_t<invoke_result_t<_Fn, const _Tp>>;
if (has_value())
return optional<_Up>(_Optional_func<_Fn>{__f}, std::move(**this));
else
return optional<_Up>();
}

template<typename _Fn> requires invocable<_Fn> && copy_constructible<_Tp>

constexpr optional
or_else(_Fn&& __f) const&
{
using _Up = invoke_result_t<_Fn>;
static_assert(is_same_v<remove_cvref_t<_Up>, optional>,
"the function passed to std::optional<T>::or_else "
"must return a std::optional<T>");

if (has_value())
return *this;
else
return std::forward<_Fn>(__f)();
}

template<typename _Fn> requires invocable<_Fn> && move_constructible<_Tp>

constexpr optional
or_else(_Fn&& __f) &&
{
using _Up = invoke_result_t<_Fn>;
static_assert(is_same_v<remove_cvref_t<_Up>, optional>,
"the function passed to std::optional<T>::or_else "
"must return a std::optional<T>");

if (has_value())
return std::move(*this);
else
return std::forward<_Fn>(__f)();
}

constexpr void reset() noexcept { this->_M_reset(); }

private:

template<typename _Up> friend class optional;

template<typename _Fn, typename _Value>

explicit constexpr
optional(_Optional_func<_Fn> __f, _Value&& __v)
{
this->_M_payload._M_apply(__f, std::forward<_Value>(__v));
}

};

template<typename _Tp>
using __optional_relop_t =
enable_if_t<is_convertible<_Tp, bool>::value, bool>;

template<typename _Tp, typename _Up>

using __optional_eq_t = __optional_relop_t<
decltype(std::declval<const _Tp&>() == std::declval<const _Up&>())
>;

template<typename _Tp, typename _Up>

using __optional_ne_t = __optional_relop_t<
decltype(std::declval<const _Tp&>() != std::declval<const _Up&>())
>;

template<typename _Tp, typename _Up>

using __optional_lt_t = __optional_relop_t<
decltype(std::declval<const _Tp&>() < std::declval<const _Up&>())
>;

template<typename _Tp, typename _Up>

using __optional_gt_t = __optional_relop_t<
decltype(std::declval<const _Tp&>() > std::declval<const _Up&>())
>;

template<typename _Tp, typename _Up>

using __optional_le_t = __optional_relop_t<
decltype(std::declval<const _Tp&>() <= std::declval<const _Up&>())
>;

template<typename _Tp, typename _Up>

using __optional_ge_t = __optional_relop_t<
decltype(std::declval<const _Tp&>() >= std::declval<const _Up&>())
>;
template<typename _Tp, typename _Up>
constexpr auto
operator==(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
-> __optional_eq_t<_Tp, _Up>
{
return static_cast<bool>(__lhs) == static_cast<bool>(__rhs)
&& (!__lhs || *__lhs == *__rhs);
}

template<typename _Tp, typename _Up>

constexpr auto
operator!=(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
-> __optional_ne_t<_Tp, _Up>
{
return static_cast<bool>(__lhs) != static_cast<bool>(__rhs)
|| (static_cast<bool>(__lhs) && *__lhs != *__rhs);
}

template<typename _Tp, typename _Up>

constexpr auto
operator<(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
-> __optional_lt_t<_Tp, _Up>
{
return static_cast<bool>(__rhs) && (!__lhs || *__lhs < *__rhs);
}

template<typename _Tp, typename _Up>

constexpr auto
operator>(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
-> __optional_gt_t<_Tp, _Up>
{
return static_cast<bool>(__lhs) && (!__rhs || *__lhs > *__rhs);
}

template<typename _Tp, typename _Up>

constexpr auto
operator<=(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
-> __optional_le_t<_Tp, _Up>
{
return !__lhs || (static_cast<bool>(__rhs) && *__lhs <= *__rhs);
}

template<typename _Tp, typename _Up>

constexpr auto
operator>=(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
-> __optional_ge_t<_Tp, _Up>
{
return !__rhs || (static_cast<bool>(__lhs) && *__lhs >= *__rhs);
}

template<typename _Tp, three_way_comparable_with<_Tp> _Up>

constexpr compare_three_way_result_t<_Tp, _Up>
operator<=>(const optional<_Tp>& __x, const optional<_Up>& __y)
{
return __x && __y ? *__x <=> *__y : bool(__x) <=> bool(__y);
}
template<typename _Tp>
constexpr bool
operator==(const optional<_Tp>& __lhs, nullopt_t) noexcept
{ return !__lhs; }

template<typename _Tp>
constexpr strong_ordering
operator<=>(const optional<_Tp>& __x, nullopt_t) noexcept
{ return bool(__x) <=> false; }
# 1358 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/optional" 3
template<typename _Tp, typename _Up>
constexpr auto
operator==(const optional<_Tp>& __lhs, const _Up& __rhs)
-> __optional_eq_t<_Tp, _Up>
{ return __lhs && *__lhs == __rhs; }

template<typename _Tp, typename _Up>

constexpr auto
operator==(const _Up& __lhs, const optional<_Tp>& __rhs)
-> __optional_eq_t<_Up, _Tp>
{ return __rhs && __lhs == *__rhs; }

template<typename _Tp, typename _Up>

constexpr auto
operator!=(const optional<_Tp>& __lhs, const _Up& __rhs)
-> __optional_ne_t<_Tp, _Up>
{ return !__lhs || *__lhs != __rhs; }

template<typename _Tp, typename _Up>

constexpr auto
operator!=(const _Up& __lhs, const optional<_Tp>& __rhs)
-> __optional_ne_t<_Up, _Tp>
{ return !__rhs || __lhs != *__rhs; }

template<typename _Tp, typename _Up>

constexpr auto
operator<(const optional<_Tp>& __lhs, const _Up& __rhs)
-> __optional_lt_t<_Tp, _Up>
{ return !__lhs || *__lhs < __rhs; }

template<typename _Tp, typename _Up>

constexpr auto
operator<(const _Up& __lhs, const optional<_Tp>& __rhs)
-> __optional_lt_t<_Up, _Tp>
{ return __rhs && __lhs < *__rhs; }

template<typename _Tp, typename _Up>

constexpr auto
operator>(const optional<_Tp>& __lhs, const _Up& __rhs)
-> __optional_gt_t<_Tp, _Up>
{ return __lhs && *__lhs > __rhs; }

template<typename _Tp, typename _Up>

constexpr auto
operator>(const _Up& __lhs, const optional<_Tp>& __rhs)
-> __optional_gt_t<_Up, _Tp>
{ return !__rhs || __lhs > *__rhs; }

template<typename _Tp, typename _Up>

constexpr auto
operator<=(const optional<_Tp>& __lhs, const _Up& __rhs)
-> __optional_le_t<_Tp, _Up>
{ return !__lhs || *__lhs <= __rhs; }

template<typename _Tp, typename _Up>

constexpr auto
operator<=(const _Up& __lhs, const optional<_Tp>& __rhs)
-> __optional_le_t<_Up, _Tp>
{ return __rhs && __lhs <= *__rhs; }

template<typename _Tp, typename _Up>

constexpr auto
operator>=(const optional<_Tp>& __lhs, const _Up& __rhs)
-> __optional_ge_t<_Tp, _Up>
{ return __lhs && *__lhs >= __rhs; }

template<typename _Tp, typename _Up>

constexpr auto
operator>=(const _Up& __lhs, const optional<_Tp>& __rhs)
-> __optional_ge_t<_Up, _Tp>
{ return !__rhs || __lhs >= *__rhs; }

template<typename _Tp, typename _Up>

requires (!__is_optional_v<_Up>)
&& three_way_comparable_with<_Up, _Tp>
constexpr compare_three_way_result_t<_Tp, _Up>
operator<=>(const optional<_Tp>& __x, const _Up& __v)
{ return bool(__x) ? *__x <=> __v : strong_ordering::less; }

template<typename _Tp>
constexpr
inline enable_if_t<is_move_constructible_v<_Tp> && is_swappable_v<_Tp>>
swap(optional<_Tp>& __lhs, optional<_Tp>& __rhs)
noexcept(noexcept(__lhs.swap(__rhs)))
{ __lhs.swap(__rhs); }

template<typename _Tp>
enable_if_t<!(is_move_constructible_v<_Tp> && is_swappable_v<_Tp>)>
swap(optional<_Tp>&, optional<_Tp>&) = delete;

template<typename _Tp>
constexpr
enable_if_t<is_constructible_v<decay_t<_Tp>, _Tp>,
optional<decay_t<_Tp>>>
make_optional(_Tp&& __t)
noexcept(is_nothrow_constructible_v<optional<decay_t<_Tp>>, _Tp>)
{ return optional<decay_t<_Tp>>{ std::forward<_Tp>(__t) }; }

template<typename _Tp, typename... _Args>

constexpr
enable_if_t<is_constructible_v<_Tp, _Args...>,
optional<_Tp>>
make_optional(_Args&&... __args)
noexcept(is_nothrow_constructible_v<_Tp, _Args...>)
{ return optional<_Tp>{ in_place, std::forward<_Args>(__args)... }; }

template<typename _Tp, typename _Up, typename... _Args>

constexpr
enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>,
optional<_Tp>>
make_optional(initializer_list<_Up> __il, _Args&&... __args)
noexcept(is_nothrow_constructible_v<_Tp, initializer_list<_Up>&, _Args...>)
{ return optional<_Tp>{ in_place, __il, std::forward<_Args>(__args)... }; }

template<typename _Tp, typename _Up = remove_const_t<_Tp>,

bool = __poison_hash<_Up>::__enable_hash_call>
struct __optional_hash_call_base
{
size_t
operator()(const optional<_Tp>& __t) const
noexcept(noexcept(hash<_Up>{}(*__t)))
{

constexpr size_t __magic_disengaged_hash = static_cast<size_t>(-3333);

return __t ? hash<_Up>{}(*__t) : __magic_disengaged_hash;
}
};

template<typename _Tp, typename _Up>

struct __optional_hash_call_base<_Tp, _Up, false> {};

template<typename _Tp>
struct hash<optional<_Tp>>
: private __poison_hash<remove_const_t<_Tp>>,
public __optional_hash_call_base<_Tp>
{
using result_type [[__deprecated__]] = size_t;
using argument_type [[__deprecated__]] = optional<_Tp>;
};

template<typename _Tp>
struct __is_fast_hash<hash<optional<_Tp>>> : __is_fast_hash<hash<_Tp>>
{ };

template <typename _Tp> optional(_Tp) -> optional<_Tp>;

}
# 49 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/format" 2 3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/span" 1 3
# 37 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/span" 3
# 38 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/span" 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 1 3
# 47 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 3

# 48 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 3
# 41 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/span" 2 3

namespace std
{

inline constexpr size_t dynamic_extent = static_cast<size_t>(-1);

template<typename _Type, size_t _Extent>

class span;

namespace __detail
{
template<typename _Tp>
inline constexpr bool __is_span = false;

template<typename _Tp, size_t _Num>

inline constexpr bool __is_span<span<_Tp, _Num>> = true;

template<typename _Tp>
inline constexpr bool __is_std_array = false;

template<typename _Tp, size_t _Num>

inline constexpr bool __is_std_array<std::array<_Tp, _Num>> = true;

template<size_t _Extent>
class __extent_storage
{
public:
constexpr
__extent_storage(size_t) noexcept
{ }

static constexpr size_t

_M_extent() noexcept
{ return _Extent; }
};

template<>
class __extent_storage<dynamic_extent>
{
public:
constexpr
__extent_storage(size_t __extent) noexcept
: _M_extent_value(__extent)
{ }
constexpr size_t
_M_extent() const noexcept
{ return this->_M_extent_value; }

private:
size_t _M_extent_value;
};
}

template<typename _Type, size_t _Extent = dynamic_extent>

class span
{
template<size_t _Offset, size_t _Count>
static constexpr size_t
_S_subspan_extent()
{
if constexpr (_Count != dynamic_extent)
return _Count;
else if constexpr (extent != dynamic_extent)
return _Extent - _Offset;
else
return dynamic_extent;
}

template<typename _Tp, size_t _ArrayExtent>

requires (_Extent == dynamic_extent || _ArrayExtent == _Extent)
using __is_compatible_array = __is_array_convertible<_Type, _Tp>;

template<typename _Ref>
using __is_compatible_ref
= __is_array_convertible<_Type, remove_reference_t<_Ref>>;

public:

using element_type = _Type;

using value_type = remove_cv_t<_Type>;
using size_type = size_t;
using difference_type = ptrdiff_t;
using pointer = _Type*;
using const_pointer = const _Type*;
using reference = element_type&;
using const_reference = const element_type&;
using iterator = __gnu_cxx::__normal_iterator<pointer, span>;
using reverse_iterator = std::reverse_iterator<iterator>;

using const_iterator = std::const_iterator<iterator>;

using const_reverse_iterator = std::const_iterator<reverse_iterator>;

static constexpr size_t extent = _Extent;

constexpr
span() noexcept
requires (_Extent == dynamic_extent || _Extent == 0)
: _M_ptr(nullptr), _M_extent(0)
{ }

template<contiguous_iterator _It>
requires __is_compatible_ref<iter_reference_t<_It>>::value
constexpr explicit(extent != dynamic_extent)
span(_It __first, size_type __count)
noexcept
: _M_ptr(std::to_address(__first)), _M_extent(__count)
{
if constexpr (_Extent != dynamic_extent)
{
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__count
== _Extent), false)) std::__glibcxx_assert_fail(); } while (false);
}
;
}

template<contiguous_iterator _It, sized_sentinel_for<_It> _End>

requires __is_compatible_ref<iter_reference_t<_It>>::value
&& (!is_convertible_v<_End, size_type>)
constexpr explicit(extent != dynamic_extent)
span(_It __first, _End __last)
noexcept(noexcept(__last - __first))
: _M_ptr(std::to_address(__first)),
_M_extent(static_cast<size_type>(__last - __first))
{
if constexpr (_Extent != dynamic_extent)
{
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool((__last
- __first) == _Extent), false)) std::__glibcxx_assert_fail(); } while (false);
}
;
}

template<size_t _ArrayExtent>
requires (_Extent == dynamic_extent || _ArrayExtent == _Extent)
constexpr
span(type_identity_t<element_type> (&__arr)[_ArrayExtent]) noexcept
: span(static_cast<pointer>(__arr), _ArrayExtent)
{ }

template<typename _Tp, size_t _ArrayExtent>

requires __is_compatible_array<_Tp, _ArrayExtent>::value
constexpr
span(array<_Tp, _ArrayExtent>& __arr) noexcept
: span(static_cast<pointer>(__arr.data()), _ArrayExtent)
{ }

template<typename _Tp, size_t _ArrayExtent>

requires __is_compatible_array<const _Tp, _ArrayExtent>::value
constexpr
span(const array<_Tp, _ArrayExtent>& __arr) noexcept
: span(static_cast<pointer>(__arr.data()), _ArrayExtent)
{ }

template<typename _Range>
requires (!__detail::__is_span<remove_cvref_t<_Range>>)
&& (!__detail::__is_std_array<remove_cvref_t<_Range>>)
&& (!is_array_v<remove_cvref_t<_Range>>)
&& ranges::contiguous_range<_Range> && ranges::sized_range<_Range>
&& (ranges::borrowed_range<_Range> || is_const_v<element_type>)
&& __is_compatible_ref<ranges::range_reference_t<_Range>>::value
constexpr explicit(extent != dynamic_extent)
span(_Range&& __range)
noexcept(noexcept(ranges::data(__range))
&& noexcept(ranges::size(__range)))
: span(ranges::data(__range), ranges::size(__range))
{
if constexpr (extent != dynamic_extent)
{
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!
bool(ranges::size(__range) == extent), false)) std::__glibcxx_assert_fail(); }
while (false);
}
}

constexpr
span(const span&) noexcept = default;

template<typename _OType, size_t _OExtent>

requires (_Extent == dynamic_extent || _OExtent == dynamic_extent
|| _Extent == _OExtent)
&& (__is_array_convertible<_Type, _OType>::value)
constexpr
explicit(extent != dynamic_extent && _OExtent == dynamic_extent)
span(const span<_OType, _OExtent>& __s) noexcept
: _M_extent(__s.size()), _M_ptr(__s.data())
{
if constexpr (extent != dynamic_extent)
{
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!
bool(__s.size() == extent), false)) std::__glibcxx_assert_fail(); } while (false);
}
}

~span() noexcept = default;

constexpr span&
operator=(const span&) noexcept = default;

[[nodiscard]]
constexpr size_type
size() const noexcept
{ return this->_M_extent._M_extent(); }

[[nodiscard]]
constexpr size_type
size_bytes() const noexcept
{ return this->_M_extent._M_extent() * sizeof(element_type); }

[[nodiscard]]
constexpr bool
empty() const noexcept
{ return size() == 0; }
[[nodiscard]]
constexpr reference
front() const noexcept
{
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(!empty()),
false)) std::__glibcxx_assert_fail(); } while (false);
return *this->_M_ptr;
}

[[nodiscard]]
constexpr reference
back() const noexcept
{
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(!empty()),
false)) std::__glibcxx_assert_fail(); } while (false);
return *(this->_M_ptr + (size() - 1));
}

[[nodiscard]]
constexpr reference
operator[](size_type __idx) const noexcept
{
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__idx <
size()), false)) std::__glibcxx_assert_fail(); } while (false);
return *(this->_M_ptr + __idx);
}

[[nodiscard]]
constexpr reference
at(size_type __idx) const
{
if (__idx >= size())
__throw_out_of_range_fmt(("span::at(%zu) out-of-range for span " "of size %zu")
, __idx, this->size());
return *(this->_M_ptr + __idx);
}

[[nodiscard]]
constexpr pointer
data() const noexcept
{ return this->_M_ptr; }

[[nodiscard]]
constexpr iterator
begin() const noexcept
{ return iterator(this->_M_ptr); }

[[nodiscard]]
constexpr iterator
end() const noexcept
{ return iterator(this->_M_ptr + this->size()); }

[[nodiscard]]
constexpr reverse_iterator
rbegin() const noexcept
{ return reverse_iterator(this->end()); }

[[nodiscard]]
constexpr reverse_iterator
rend() const noexcept
{ return reverse_iterator(this->begin()); }

[[nodiscard]]
constexpr const_iterator
cbegin() const noexcept
{ return begin(); }

[[nodiscard]]
constexpr const_iterator
cend() const noexcept
{ return end(); }

[[nodiscard]]
constexpr const_reverse_iterator
crbegin() const noexcept
{ return rbegin(); }

[[nodiscard]]
constexpr const_reverse_iterator
crend() const noexcept
{ return rend(); }

template<size_t _Count>
[[nodiscard]]
constexpr span<element_type, _Count>
first() const noexcept
{
if constexpr (_Extent == dynamic_extent)
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(_Count <=
size()), false)) std::__glibcxx_assert_fail(); } while (false);
else
static_assert(_Count <= extent);
using _Sp = span<element_type, _Count>;
return _Sp{ this->data(), _Count };
}

[[nodiscard]]
constexpr span<element_type, dynamic_extent>
first(size_type __count) const noexcept
{
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__count <=
size()), false)) std::__glibcxx_assert_fail(); } while (false);
return { this->data(), __count };
}

template<size_t _Count>
[[nodiscard]]
constexpr span<element_type, _Count>
last() const noexcept
{
if constexpr (_Extent == dynamic_extent)
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(_Count <=
size()), false)) std::__glibcxx_assert_fail(); } while (false);
else
static_assert(_Count <= extent);
using _Sp = span<element_type, _Count>;
return _Sp{ this->data() + (this->size() - _Count), _Count };
}

[[nodiscard]]
constexpr span<element_type, dynamic_extent>
last(size_type __count) const noexcept
{
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__count <=
size()), false)) std::__glibcxx_assert_fail(); } while (false);
return { this->data() + (this->size() - __count), __count };
}

template<size_t _Offset, size_t _Count = dynamic_extent>

[[nodiscard]]
constexpr auto
subspan() const noexcept
-> span<element_type, _S_subspan_extent<_Offset, _Count>()>
{
if constexpr (_Extent == dynamic_extent)
{
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(_Offset
<= size()), false)) std::__glibcxx_assert_fail(); } while (false);
}
else
static_assert(_Offset <= extent);

using _Sp = span<element_type, _S_subspan_extent<_Offset, _Count>()>;

if constexpr (_Count == dynamic_extent)

return _Sp{ this->data() + _Offset, this->size() - _Offset };
else
{
if constexpr (_Extent == dynamic_extent)
{
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(_Count <=
size()), false)) std::__glibcxx_assert_fail(); } while (false);
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(_Count <=
(size() - _Offset)), false)) std::__glibcxx_assert_fail(); } while (false);
}
else
{
static_assert(_Count <= extent);
static_assert(_Count <= (extent - _Offset));
}
return _Sp{ this->data() + _Offset, _Count };
}
}

[[nodiscard]]
constexpr span<element_type, dynamic_extent>
subspan(size_type __offset, size_type __count = dynamic_extent) const
noexcept
{
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__offset <=
size()), false)) std::__glibcxx_assert_fail(); } while (false);
if (__count == dynamic_extent)
__count = this->size() - __offset;
else
{
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__count <=
size()), false)) std::__glibcxx_assert_fail(); } while (false);
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__offset +
__count <= size()), false)) std::__glibcxx_assert_fail(); } while (false);
}
return {this->data() + __offset, __count};
}

private:
pointer _M_ptr;
[[no_unique_address]] __detail::__extent_storage<extent> _M_extent;
};

template<typename _Type, size_t _ArrayExtent>

span(_Type(&)[_ArrayExtent]) -> span<_Type, _ArrayExtent>;

template<typename _Type, size_t _ArrayExtent>

span(array<_Type, _ArrayExtent>&) -> span<_Type, _ArrayExtent>;

template<typename _Type, size_t _ArrayExtent>

span(const array<_Type, _ArrayExtent>&)
-> span<const _Type, _ArrayExtent>;

template<contiguous_iterator _Iter, typename _End>

span(_Iter, _End)
-> span<remove_reference_t<iter_reference_t<_Iter>>>;

template<ranges::contiguous_range _Range>
span(_Range &&)
-> span<remove_reference_t<ranges::range_reference_t<_Range&>>>;

template<typename _Type, size_t _Extent>

[[nodiscard]]
inline
span<const byte, _Extent == dynamic_extent
? dynamic_extent : _Extent * sizeof(_Type)>
as_bytes(span<_Type, _Extent> __sp) noexcept
{
auto data = reinterpret_cast<const byte*>(__sp.data());
auto size = __sp.size_bytes();
constexpr auto extent = _Extent == dynamic_extent
? dynamic_extent : _Extent * sizeof(_Type);
return span<const byte, extent>{data, size};
}

template<typename _Type, size_t _Extent>

requires (!is_const_v<_Type>)
inline
span<byte, _Extent == dynamic_extent
? dynamic_extent : _Extent * sizeof(_Type)>
as_writable_bytes [[nodiscard]] (span<_Type, _Extent> __sp) noexcept
{
auto data = reinterpret_cast<byte*>(__sp.data());
auto size = __sp.size_bytes();
constexpr auto extent = _Extent == dynamic_extent
? dynamic_extent : _Extent * sizeof(_Type);
return span<byte, extent>{data, size};
}

namespace ranges
{

template<typename _ElementType, size_t _Extent>

inline constexpr bool
enable_borrowed_range<span<_ElementType, _Extent>> = true;

template<typename _ElementType, size_t _Extent>

inline constexpr bool
enable_view<span<_ElementType, _Extent>> = true;
}

}
# 50 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/format" 2 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/variant" 1 3
# 32 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/variant" 3

# 33 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/variant" 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 1 3
# 47 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 3

# 48 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/version.h" 3
# 37 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/variant" 2 3
# 45 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/variant" 3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/parse_numbers.h" 1 3
# 33 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/parse_numbers.h" 3

# 34 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/parse_numbers.h" 3
# 42 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/parse_numbers.h" 3
namespace std
{

namespace __parse_int
{
template<unsigned _Base, char _Dig>
struct _Digit;

template<unsigned _Base>
struct _Digit<_Base, '0'> : integral_constant<unsigned, 0>
{
using __valid = true_type;
};
template<unsigned _Base>
struct _Digit<_Base, '1'> : integral_constant<unsigned, 1>
{
using __valid = true_type;
};

template<unsigned _Base, unsigned _Val>

struct _Digit_impl : integral_constant<unsigned, _Val>
{
static_assert(_Base > _Val, "invalid digit");
using __valid = true_type;
};

template<unsigned _Base>
struct _Digit<_Base, '2'> : _Digit_impl<_Base, 2>
{ };

template<unsigned _Base>
struct _Digit<_Base, '3'> : _Digit_impl<_Base, 3>
{ };

template<unsigned _Base>
struct _Digit<_Base, '4'> : _Digit_impl<_Base, 4>
{ };

template<unsigned _Base>
struct _Digit<_Base, '5'> : _Digit_impl<_Base, 5>
{ };

template<unsigned _Base>
struct _Digit<_Base, '6'> : _Digit_impl<_Base, 6>
{ };

template<unsigned _Base>
struct _Digit<_Base, '7'> : _Digit_impl<_Base, 7>
{ };

template<unsigned _Base>
struct _Digit<_Base, '8'> : _Digit_impl<_Base, 8>
{ };

template<unsigned _Base>
struct _Digit<_Base, '9'> : _Digit_impl<_Base, 9>
{ };

template<unsigned _Base>
struct _Digit<_Base, 'a'> : _Digit_impl<_Base, 0xa>
{ };

template<unsigned _Base>
struct _Digit<_Base, 'A'> : _Digit_impl<_Base, 0xa>
{ };

template<unsigned _Base>
struct _Digit<_Base, 'b'> : _Digit_impl<_Base, 0xb>
{ };

template<unsigned _Base>
struct _Digit<_Base, 'B'> : _Digit_impl<_Base, 0xb>
{ };

template<unsigned _Base>
struct _Digit<_Base, 'c'> : _Digit_impl<_Base, 0xc>
{ };

template<unsigned _Base>
struct _Digit<_Base, 'C'> : _Digit_impl<_Base, 0xc>
{ };

template<unsigned _Base>
struct _Digit<_Base, 'd'> : _Digit_impl<_Base, 0xd>
{ };

template<unsigned _Base>
struct _Digit<_Base, 'D'> : _Digit_impl<_Base, 0xd>
{ };

template<unsigned _Base>
struct _Digit<_Base, 'e'> : _Digit_impl<_Base, 0xe>
{ };

template<unsigned _Base>
struct _Digit<_Base, 'E'> : _Digit_impl<_Base, 0xe>
{ };

template<unsigned _Base>
struct _Digit<_Base, 'f'> : _Digit_impl<_Base, 0xf>
{ };

template<unsigned _Base>
struct _Digit<_Base, 'F'> : _Digit_impl<_Base, 0xf>
{ };

template<unsigned _Base>
struct _Digit<_Base, '\''> : integral_constant<unsigned, 0>
{
using __valid = false_type;
};

template<unsigned long long _Val>

using __ull_constant = integral_constant<unsigned long long, _Val>;

template<unsigned _Base, char _Dig, char... _Digs>

struct _Power_help
{
using __next = typename _Power_help<_Base, _Digs...>::type;
using __valid_digit = typename _Digit<_Base, _Dig>::__valid;
using type
= __ull_constant<__next::value * (__valid_digit{} ? _Base : 1ULL)>;
};

template<unsigned _Base, char _Dig>

struct _Power_help<_Base, _Dig>
{
using __valid_digit = typename _Digit<_Base, _Dig>::__valid;
using type = __ull_constant<__valid_digit::value>;
};

template<unsigned _Base, char... _Digs>

struct _Power : _Power_help<_Base, _Digs...>::type
{ };

template<unsigned _Base>
struct _Power<_Base> : __ull_constant<0>
{ };

template<unsigned _Base, unsigned long long _Pow, char _Dig, char... _Digs>
struct _Number_help
{
using __digit = _Digit<_Base, _Dig>;
using __valid_digit = typename __digit::__valid;
using __next = _Number_help<_Base,
__valid_digit::value ? _Pow / _Base : _Pow,
_Digs...>;
using type = __ull_constant<_Pow * __digit::value + __next::type::value>;
static_assert((type::value / _Pow) == __digit::value,
"integer literal does not fit in unsigned long long");
};

template<unsigned _Base, unsigned long long _Pow, char _Dig, char..._Digs>

struct _Number_help<_Base, _Pow, '\'', _Dig, _Digs...>
: _Number_help<_Base, _Pow, _Dig, _Digs...>
{ };

template<unsigned _Base, char _Dig>

struct _Number_help<_Base, 1ULL, _Dig>
{
using type = __ull_constant<_Digit<_Base, _Dig>::value>;
};

template<unsigned _Base, char... _Digs>

struct _Number
: _Number_help<_Base, _Power<_Base, _Digs...>::value, _Digs...>::type
{ };

template<unsigned _Base>
struct _Number<_Base>
: __ull_constant<0>
{ };

template<char... _Digs>
struct _Parse_int;

template<char... _Digs>
struct _Parse_int<'0', 'b', _Digs...>
: _Number<2U, _Digs...>::type
{ };
template<char... _Digs>
struct _Parse_int<'0', 'B', _Digs...>
: _Number<2U, _Digs...>::type
{ };

template<char... _Digs>
struct _Parse_int<'0', 'x', _Digs...>
: _Number<16U, _Digs...>::type
{ };

template<char... _Digs>
struct _Parse_int<'0', 'X', _Digs...>
: _Number<16U, _Digs...>::type
{ };

template<char... _Digs>
struct _Parse_int<'0', _Digs...>
: _Number<8U, _Digs...>::type
{ };

template<char... _Digs>
struct _Parse_int
: _Number<10U, _Digs...>::type
{ };

namespace __select_int
{
template<unsigned long long _Val, typename... _Ints>
struct _Select_int_base;

template<unsigned long long _Val, typename _IntType, typename... _Ints>

struct _Select_int_base<_Val, _IntType, _Ints...>
: __conditional_t<(_Val <= __gnu_cxx::__int_traits<_IntType>::__max),
integral_constant<_IntType, (_IntType)_Val>,
_Select_int_base<_Val, _Ints...>>
{ };

template<unsigned long long _Val>

struct _Select_int_base<_Val>
{ };

template<char... _Digs>
using _Select_int = typename _Select_int_base<
__parse_int::_Parse_int<_Digs...>::value,
unsigned char,
unsigned short,
unsigned int,
unsigned long,
unsigned long long
>::type;

}
# 46 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/variant" 2 3
# 59 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/variant" 3
namespace std
{

template<typename... _Types> class tuple;

template<typename... _Types> class variant;
template <typename> struct hash;

template<typename _Variant>
struct variant_size;

template<typename _Variant>
struct variant_size<const _Variant> : variant_size<_Variant> {};

template<typename _Variant>
struct variant_size<volatile _Variant> : variant_size<_Variant> {};

template<typename _Variant>
struct variant_size<const volatile _Variant> : variant_size<_Variant> {};

template<typename... _Types>
struct variant_size<variant<_Types...>>
: std::integral_constant<size_t, sizeof...(_Types)> {};

template<typename _Variant>
inline constexpr size_t variant_size_v = variant_size<_Variant>::value;

template<typename... _Types>
inline constexpr size_t
variant_size_v<variant<_Types...>> = sizeof...(_Types);

template<typename... _Types>
inline constexpr size_t
variant_size_v<const variant<_Types...>> = sizeof...(_Types);

template<size_t _Np, typename _Variant>

struct variant_alternative;

template<size_t _Np, typename... _Types>

struct variant_alternative<_Np, variant<_Types...>>
{
static_assert(_Np < sizeof...(_Types));

using type = typename _Nth_type<_Np, _Types...>::type;

};

template<size_t _Np, typename _Variant>

using variant_alternative_t =
typename variant_alternative<_Np, _Variant>::type;

template<size_t _Np, typename _Variant>

struct variant_alternative<_Np, const _Variant>
{ using type = const variant_alternative_t<_Np, _Variant>; };

template<size_t _Np, typename _Variant>

struct variant_alternative<_Np, volatile _Variant>
{ using type = volatile variant_alternative_t<_Np, _Variant>; };
template<size_t _Np, typename _Variant>
struct variant_alternative<_Np, const volatile _Variant>
{ using type = const volatile variant_alternative_t<_Np, _Variant>; };

inline constexpr size_t variant_npos = -1;

template<size_t _Np, typename... _Types>

constexpr variant_alternative_t<_Np, variant<_Types...>>&
get(variant<_Types...>&);

template<size_t _Np, typename... _Types>

constexpr variant_alternative_t<_Np, variant<_Types...>>&&
get(variant<_Types...>&&);

template<size_t _Np, typename... _Types>

constexpr variant_alternative_t<_Np, variant<_Types...>> const&
get(const variant<_Types...>&);

template<size_t _Np, typename... _Types>

constexpr variant_alternative_t<_Np, variant<_Types...>> const&&
get(const variant<_Types...>&&);

template<typename _Result_type, typename _Visitor, typename... _Variants>

constexpr decltype(auto)
__do_visit(_Visitor&& __visitor, _Variants&&... __variants);

template <typename... _Types, typename _Tp>

constexpr
decltype(auto)
__variant_cast(_Tp&& __rhs)
{
if constexpr (is_lvalue_reference_v<_Tp>)
{
if constexpr (is_const_v<remove_reference_t<_Tp>>)
return static_cast<const variant<_Types...>&>(__rhs);
else
return static_cast<variant<_Types...>&>(__rhs);
}
else
return static_cast<variant<_Types...>&&>(__rhs);
}

namespace __detail
{
namespace __variant
{

struct __variant_cookie {};

struct __variant_idx_cookie { using type = __variant_idx_cookie; };

template<typename _Tp> struct __deduce_visit_result { using type = _Tp; };

template<typename _Visitor, typename... _Variants>

constexpr void
__raw_visit(_Visitor&& __visitor, _Variants&&... __variants)
{
std::__do_visit<__variant_cookie>(std::forward<_Visitor>(__visitor),
std::forward<_Variants>(__variants)...);
}

template<typename _Visitor, typename... _Variants>

constexpr void
__raw_idx_visit(_Visitor&& __visitor, _Variants&&... __variants)
{
std::__do_visit<__variant_idx_cookie>(std::forward<_Visitor>(__visitor),
std::forward<_Variants>(__variants)...);
}

template<typename... _Types>
constexpr std::variant<_Types...>&
__as(std::variant<_Types...>& __v) noexcept
{ return __v; }

template<typename... _Types>
constexpr const std::variant<_Types...>&
__as(const std::variant<_Types...>& __v) noexcept
{ return __v; }

template<typename... _Types>
constexpr std::variant<_Types...>&&
__as(std::variant<_Types...>&& __v) noexcept
{ return std::move(__v); }

template<typename... _Types>
constexpr const std::variant<_Types...>&&
__as(const std::variant<_Types...>&& __v) noexcept
{ return std::move(__v); }

template<typename _Type, bool = std::is_trivially_destructible_v<_Type>>

struct _Uninitialized;

template<typename _Type>
struct _Uninitialized<_Type, true>
{
template<typename... _Args>
constexpr
_Uninitialized(in_place_index_t<0>, _Args&&... __args)
: _M_storage(std::forward<_Args>(__args)...)
{ }

constexpr const _Type& _M_get() const & noexcept

{ return _M_storage; }

constexpr _Type& _M_get() & noexcept

{ return _M_storage; }

constexpr const _Type&& _M_get() const && noexcept

{ return std::move(_M_storage); }

constexpr _Type&& _M_get() && noexcept

{ return std::move(_M_storage); }

_Type _M_storage;
};

template<typename _Type>
struct _Uninitialized<_Type, false>
{

template<typename... _Args>
constexpr
_Uninitialized(in_place_index_t<0>, _Args&&... __args)
: _M_storage(std::forward<_Args>(__args)...)
{ }

constexpr ~_Uninitialized() { }

_Uninitialized(const _Uninitialized&) = default;

_Uninitialized(_Uninitialized&&) = default;
_Uninitialized& operator=(const _Uninitialized&) = default;
_Uninitialized& operator=(_Uninitialized&&) = default;

constexpr const _Type& _M_get() const & noexcept

{ return _M_storage; }

constexpr _Type& _M_get() & noexcept

{ return _M_storage; }

constexpr const _Type&& _M_get() const && noexcept

{ return std::move(_M_storage); }

constexpr _Type&& _M_get() && noexcept

{ return std::move(_M_storage); }

struct _Empty_byte { };

union {
_Empty_byte _M_empty;
_Type _M_storage;
};
# 301 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/variant" 3
};

template<size_t _Np, typename _Union>

constexpr decltype(auto)
__get_n(_Union&& __u) noexcept
{
if constexpr (_Np == 0)
return std::forward<_Union>(__u)._M_first._M_get();
else if constexpr (_Np == 1)
return std::forward<_Union>(__u)._M_rest._M_first._M_get();
else if constexpr (_Np == 2)
return std::forward<_Union>(__u)._M_rest._M_rest._M_first._M_get();
else
return __variant::__get_n<_Np - 3>(
std::forward<_Union>(__u)._M_rest._M_rest._M_rest);
}

template<size_t _Np, typename _Variant>

constexpr decltype(auto)
__get(_Variant&& __v) noexcept
{ return __variant::__get_n<_Np>(std::forward<_Variant>(__v)._M_u); }

template<size_t _Np, typename _Union>

constexpr decltype(auto)
__construct_n(_Union& __u) noexcept
{
if constexpr (_Np == 0)
return &__u._M_first;
else if constexpr (_Np == 1)
{
std::_Construct(&__u._M_rest);
return &__u._M_rest._M_first;
}
else if constexpr (_Np == 2)
{
std::_Construct(&__u._M_rest);
std::_Construct(&__u._M_rest._M_rest);
return &__u._M_rest._M_rest._M_first;
}
else
{
std::_Construct(&__u._M_rest);
std::_Construct(&__u._M_rest._M_rest);
std::_Construct(&__u._M_rest._M_rest._M_rest);
return __variant::__construct_n<_Np - 3>(__u._M_rest._M_rest._M_rest);
}
}

template<typename... _Types>
struct _Traits
{
static constexpr bool _S_default_ctor =
is_default_constructible_v<typename _Nth_type<0, _Types...>::type>;
static constexpr bool _S_copy_ctor =
(is_copy_constructible_v<_Types> && ...);
static constexpr bool _S_move_ctor =
(is_move_constructible_v<_Types> && ...);
static constexpr bool _S_copy_assign =
_S_copy_ctor
&& (is_copy_assignable_v<_Types> && ...);
static constexpr bool _S_move_assign =
_S_move_ctor
&& (is_move_assignable_v<_Types> && ...);

static constexpr bool _S_trivial_dtor =

(is_trivially_destructible_v<_Types> && ...);
static constexpr bool _S_trivial_copy_ctor =
(is_trivially_copy_constructible_v<_Types> && ...);
static constexpr bool _S_trivial_move_ctor =
(is_trivially_move_constructible_v<_Types> && ...);
static constexpr bool _S_trivial_copy_assign =
_S_trivial_dtor && _S_trivial_copy_ctor
&& (is_trivially_copy_assignable_v<_Types> && ...);
static constexpr bool _S_trivial_move_assign =
_S_trivial_dtor && _S_trivial_move_ctor
&& (is_trivially_move_assignable_v<_Types> && ...);

static constexpr bool _S_nothrow_default_ctor =

is_nothrow_default_constructible_v<
typename _Nth_type<0, _Types...>::type>;
static constexpr bool _S_nothrow_copy_ctor = false;
static constexpr bool _S_nothrow_move_ctor =
(is_nothrow_move_constructible_v<_Types> && ...);
static constexpr bool _S_nothrow_copy_assign = false;
static constexpr bool _S_nothrow_move_assign =
_S_nothrow_move_ctor
&& (is_nothrow_move_assignable_v<_Types> && ...);
};

template<bool __trivially_destructible, typename... _Types>

union _Variadic_union
{
_Variadic_union() = default;

template<size_t _Np, typename... _Args>

_Variadic_union(in_place_index_t<_Np>, _Args&&...) = delete;
};

template<bool __trivially_destructible, typename _First, typename... _Rest>

union _Variadic_union<__trivially_destructible, _First, _Rest...>
{
constexpr _Variadic_union() : _M_rest() { }

template<typename... _Args>
constexpr
_Variadic_union(in_place_index_t<0>, _Args&&... __args)
: _M_first(in_place_index<0>, std::forward<_Args>(__args)...)
{ }

template<size_t _Np, typename... _Args>

constexpr
_Variadic_union(in_place_index_t<_Np>, _Args&&... __args)
: _M_rest(in_place_index<_Np-1>, std::forward<_Args>(__args)...)
{ }

_Variadic_union(const _Variadic_union&) = default;

_Variadic_union(_Variadic_union&&) = default;
_Variadic_union& operator=(const _Variadic_union&) = default;
_Variadic_union& operator=(_Variadic_union&&) = default;

~_Variadic_union() = default;

constexpr ~_Variadic_union()
requires (!__trivially_destructible)
{ }
_Uninitialized<_First> _M_first;
_Variadic_union<__trivially_destructible, _Rest...> _M_rest;
};

template<typename _Tp>
struct _Never_valueless_alt
: __and_<bool_constant<sizeof(_Tp) <= 256>, is_trivially_copyable<_Tp>>
{ };
# 458 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/variant" 3
template <typename... _Types>
constexpr bool __never_valueless()
{
return _Traits<_Types...>::_S_move_assign
&& (_Never_valueless_alt<_Types>::value && ...);
}

template<bool __trivially_destructible, typename... _Types>

struct _Variant_storage;

template <typename... _Types>

using __select_index =
typename __select_int::_Select_int_base<sizeof...(_Types),
unsigned char,
unsigned short>::type::value_type;

template<typename... _Types>
struct _Variant_storage<false, _Types...>
{
constexpr
_Variant_storage()
: _M_index(static_cast<__index_type>(variant_npos))
{ }

template<size_t _Np, typename... _Args>

constexpr
_Variant_storage(in_place_index_t<_Np>, _Args&&... __args)
: _M_u(in_place_index<_Np>, std::forward<_Args>(__args)...),
_M_index{_Np}
{ }

constexpr void
_M_reset()
{
if (!_M_valid()) [[unlikely]]
return;

std::__do_visit<void>([](auto&& __this_mem) mutable

{
std::_Destroy(std::__addressof(__this_mem));
}, __variant_cast<_Types...>(*this));

_M_index = static_cast<__index_type>(variant_npos);
}
constexpr
~_Variant_storage()
{ _M_reset(); }

constexpr bool
_M_valid() const noexcept
{
if constexpr (__variant::__never_valueless<_Types...>())
return true;
return this->_M_index != __index_type(variant_npos);
}

_Variadic_union<false, _Types...> _M_u;

using __index_type = __select_index<_Types...>;
__index_type _M_index;
};

template<typename... _Types>
struct _Variant_storage<true, _Types...>
{
constexpr
_Variant_storage()
: _M_index(static_cast<__index_type>(variant_npos))
{ }

template<size_t _Np, typename... _Args>

constexpr
_Variant_storage(in_place_index_t<_Np>, _Args&&... __args)
: _M_u(in_place_index<_Np>, std::forward<_Args>(__args)...),
_M_index{_Np}
{ }

constexpr void
_M_reset() noexcept
{ _M_index = static_cast<__index_type>(variant_npos); }

constexpr bool
_M_valid() const noexcept
{
if constexpr (__variant::__never_valueless<_Types...>())
return true;

return this->_M_index != static_cast<__index_type>(variant_npos);

}

_Variadic_union<true, _Types...> _M_u;

using __index_type = __select_index<_Types...>;
__index_type _M_index;
};

template<size_t _Np, bool _Triv, typename... _Types, typename... _Args>

constexpr
inline void
__emplace(_Variant_storage<_Triv, _Types...>& __v, _Args&&... __args)
{
__v._M_reset();
auto* __addr = __variant::__construct_n<_Np>(__v._M_u);
std::_Construct(__addr, in_place_index<0>,
std::forward<_Args>(__args)...);

__v._M_index = _Np;
}

template<typename... _Types>
using _Variant_storage_alias =
_Variant_storage<_Traits<_Types...>::_S_trivial_dtor, _Types...>;

template<bool, typename... _Types>

struct _Copy_ctor_base : _Variant_storage_alias<_Types...>
{
using _Base = _Variant_storage_alias<_Types...>;
using _Base::_Base;

constexpr
_Copy_ctor_base(const _Copy_ctor_base& __rhs)
noexcept(_Traits<_Types...>::_S_nothrow_copy_ctor)
{
__variant::__raw_idx_visit(
[this](auto&& __rhs_mem, auto __rhs_index) mutable
{
constexpr size_t __j = __rhs_index;
if constexpr (__j != variant_npos)
std::_Construct(std::__addressof(this->_M_u),
in_place_index<__j>, __rhs_mem);
}, __variant_cast<_Types...>(__rhs));
this->_M_index = __rhs._M_index;
}

_Copy_ctor_base(_Copy_ctor_base&&) = default;
_Copy_ctor_base& operator=(const _Copy_ctor_base&) = default;
_Copy_ctor_base& operator=(_Copy_ctor_base&&) = default;
};

template<typename... _Types>
struct _Copy_ctor_base<true, _Types...> : _Variant_storage_alias<_Types...>
{
using _Base = _Variant_storage_alias<_Types...>;
using _Base::_Base;
};

template<typename... _Types>
using _Copy_ctor_alias =
_Copy_ctor_base<_Traits<_Types...>::_S_trivial_copy_ctor, _Types...>;

template<bool, typename... _Types>

struct _Move_ctor_base : _Copy_ctor_alias<_Types...>
{
using _Base = _Copy_ctor_alias<_Types...>;
using _Base::_Base;

constexpr
_Move_ctor_base(_Move_ctor_base&& __rhs)
noexcept(_Traits<_Types...>::_S_nothrow_move_ctor)
{
__variant::__raw_idx_visit(
[this](auto&& __rhs_mem, auto __rhs_index) mutable
{
constexpr size_t __j = __rhs_index;
if constexpr (__j != variant_npos)
std::_Construct(std::__addressof(this->_M_u),
in_place_index<__j>,
std::forward<decltype(__rhs_mem)>(__rhs_mem));
}, __variant_cast<_Types...>(std::move(__rhs)));
this->_M_index = __rhs._M_index;
}

_Move_ctor_base(const _Move_ctor_base&) = default;

_Move_ctor_base& operator=(const _Move_ctor_base&) = default;
_Move_ctor_base& operator=(_Move_ctor_base&&) = default;
};

template<typename... _Types>
struct _Move_ctor_base<true, _Types...> : _Copy_ctor_alias<_Types...>
{
using _Base = _Copy_ctor_alias<_Types...>;
using _Base::_Base;
};

template<typename... _Types>
using _Move_ctor_alias =
_Move_ctor_base<_Traits<_Types...>::_S_trivial_move_ctor, _Types...>;

template<bool, typename... _Types>

struct _Copy_assign_base : _Move_ctor_alias<_Types...>
{
using _Base = _Move_ctor_alias<_Types...>;
using _Base::_Base;

constexpr
_Copy_assign_base&
operator=(const _Copy_assign_base& __rhs)
noexcept(_Traits<_Types...>::_S_nothrow_copy_assign)
{
__variant::__raw_idx_visit(
[this](auto&& __rhs_mem, auto __rhs_index) mutable
{
constexpr size_t __j = __rhs_index;
if constexpr (__j == variant_npos)
this->_M_reset();
else if (this->_M_index == __j)
__variant::__get<__j>(*this) = __rhs_mem;
else
{
using _Tj = typename _Nth_type<__j, _Types...>::type;
if constexpr (is_nothrow_copy_constructible_v<_Tj>
|| !is_nothrow_move_constructible_v<_Tj>)
__variant::__emplace<__j>(*this, __rhs_mem);
else
{
using _Variant = variant<_Types...>;
_Variant& __self = __variant_cast<_Types...>(*this);
__self = _Variant(in_place_index<__j>, __rhs_mem);
}
}
}, __variant_cast<_Types...>(__rhs));
return *this;
}

_Copy_assign_base(const _Copy_assign_base&) = default;

_Copy_assign_base(_Copy_assign_base&&) = default;
_Copy_assign_base& operator=(_Copy_assign_base&&) = default;
};

template<typename... _Types>
struct _Copy_assign_base<true, _Types...> : _Move_ctor_alias<_Types...>
{
using _Base = _Move_ctor_alias<_Types...>;
using _Base::_Base;
};

template<typename... _Types>
using _Copy_assign_alias =
_Copy_assign_base<_Traits<_Types...>::_S_trivial_copy_assign, _Types...>;

template<bool, typename... _Types>

struct _Move_assign_base : _Copy_assign_alias<_Types...>
{
using _Base = _Copy_assign_alias<_Types...>;
using _Base::_Base;

constexpr
_Move_assign_base&
operator=(_Move_assign_base&& __rhs)
noexcept(_Traits<_Types...>::_S_nothrow_move_assign)
{
__variant::__raw_idx_visit(
[this](auto&& __rhs_mem, auto __rhs_index) mutable
{
constexpr size_t __j = __rhs_index;
if constexpr (__j != variant_npos)
{
if (this->_M_index == __j)
__variant::__get<__j>(*this) = std::move(__rhs_mem);
else
{
using _Tj = typename _Nth_type<__j, _Types...>::type;
if constexpr (is_nothrow_move_constructible_v<_Tj>)
__variant::__emplace<__j>(*this, std::move(__rhs_mem));
else
{
using _Variant = variant<_Types...>;
_Variant& __self = __variant_cast<_Types...>(*this);
__self.template emplace<__j>(std::move(__rhs_mem));
}
}
}
else
this->_M_reset();
}, __variant_cast<_Types...>(__rhs));
return *this;
}

_Move_assign_base(const _Move_assign_base&) = default;

_Move_assign_base(_Move_assign_base&&) = default;
_Move_assign_base& operator=(const _Move_assign_base&) = default;
};

template<typename... _Types>
struct _Move_assign_base<true, _Types...> : _Copy_assign_alias<_Types...>
{
using _Base = _Copy_assign_alias<_Types...>;
using _Base::_Base;
};

template<typename... _Types>
using _Move_assign_alias =
_Move_assign_base<_Traits<_Types...>::_S_trivial_move_assign, _Types...>;

template<typename... _Types>
struct _Variant_base : _Move_assign_alias<_Types...>
{
using _Base = _Move_assign_alias<_Types...>;

constexpr
_Variant_base() noexcept(_Traits<_Types...>::_S_nothrow_default_ctor)
: _Variant_base(in_place_index<0>) { }

template<size_t _Np, typename... _Args>

constexpr explicit
_Variant_base(in_place_index_t<_Np> __i, _Args&&... __args)
: _Base(__i, std::forward<_Args>(__args)...)
{ }

_Variant_base(const _Variant_base&) = default;

_Variant_base(_Variant_base&&) = default;
_Variant_base& operator=(const _Variant_base&) = default;
_Variant_base& operator=(_Variant_base&&) = default;
};

template<typename _Tp, typename... _Types>

inline constexpr bool __exactly_once
= std::__find_uniq_type_in_pack<_Tp, _Types...>() < sizeof...(_Types);

template<typename _Ti> struct _Arr { _Ti _M_x[1]; };

template<size_t _Ind, typename _Tp, typename _Ti, typename = void>

struct _Build_FUN
{

void _S_fun() = delete;

};
template<size_t _Ind, typename _Tp, typename _Ti>
struct _Build_FUN<_Ind, _Tp, _Ti,
void_t<decltype(_Arr<_Ti>{{std::declval<_Tp>()}})>>
{

static integral_constant<size_t, _Ind> _S_fun(_Ti);

};

template<typename _Tp, typename _Variant,

typename = make_index_sequence<variant_size_v<_Variant>>>
struct _Build_FUNs;

template<typename _Tp, typename... _Ti, size_t... _Ind>

struct _Build_FUNs<_Tp, variant<_Ti...>, index_sequence<_Ind...>>
: _Build_FUN<_Ind, _Tp, _Ti>...
{
using _Build_FUN<_Ind, _Tp, _Ti>::_S_fun...;
};

template<typename _Tp, typename _Variant>

using _FUN_type
= decltype(_Build_FUNs<_Tp, _Variant>::_S_fun(std::declval<_Tp>()));

template<typename _Tp, typename _Variant, typename = void>

inline constexpr size_t
__accepted_index = variant_npos;

template<typename _Tp, typename _Variant>

inline constexpr size_t
__accepted_index<_Tp, _Variant, void_t<_FUN_type<_Tp, _Variant>>>
= _FUN_type<_Tp, _Variant>::value;

template<typename _Maybe_variant_cookie, typename _Variant,

typename = __remove_cvref_t<_Variant>>
inline constexpr bool
__extra_visit_slot_needed = false;

template<typename _Var, typename... _Types>

inline constexpr bool
__extra_visit_slot_needed<__variant_cookie, _Var, variant<_Types...>>
= !__variant::__never_valueless<_Types...>();

template<typename _Var, typename... _Types>

inline constexpr bool
__extra_visit_slot_needed<__variant_idx_cookie, _Var, variant<_Types...>>
= !__variant::__never_valueless<_Types...>();

template<typename _Tp, size_t... _Dimensions>

struct _Multi_array;

template<typename _Tp>
struct _Multi_array<_Tp>
{
template<typename>
struct __untag_result
: false_type
{ using element_type = _Tp; };

#pragma GCC diagnostic push

#pragma GCC diagnostic ignored "-Wignored-qualifiers"
template <typename... _Args>
struct __untag_result<const void(*)(_Args...)>
: false_type
{ using element_type = void(*)(_Args...); };
#pragma GCC diagnostic pop

template <typename... _Args>

struct __untag_result<__variant_cookie(*)(_Args...)>
: false_type
{ using element_type = void(*)(_Args...); };

template <typename... _Args>

struct __untag_result<__variant_idx_cookie(*)(_Args...)>
: false_type
{ using element_type = void(*)(_Args...); };

template <typename _Res, typename... _Args>

struct __untag_result<__deduce_visit_result<_Res>(*)(_Args...)>
: true_type
{ using element_type = _Res(*)(_Args...); };

using __result_is_deduced = __untag_result<_Tp>;

constexpr const typename __untag_result<_Tp>::element_type&

_M_access() const
{ return _M_data; }

typename __untag_result<_Tp>::element_type _M_data;

};

template<typename _Ret,
typename _Visitor,
typename... _Variants,
size_t __first, size_t... __rest>
struct _Multi_array<_Ret(*)(_Visitor, _Variants...), __first, __rest...>
{
static constexpr size_t __index =
sizeof...(_Variants) - sizeof...(__rest) - 1;

using _Variant = typename _Nth_type<__index, _Variants...>::type;

static constexpr int __do_cookie =

__extra_visit_slot_needed<_Ret, _Variant> ? 1 : 0;

using _Tp = _Ret(*)(_Visitor, _Variants...);

template<typename... _Args>
constexpr decltype(auto)
_M_access(size_t __first_index, _Args... __rest_indices) const
{
return _M_arr[__first_index + __do_cookie]
._M_access(__rest_indices...);
}

_Multi_array<_Tp, __rest...> _M_arr[first + do_cookie];

};
# 949 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/variant" 3
template<typename _Array_type, typename _Index_seq>
struct __gen_vtable_impl;
# 959 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/variant" 3
template<typename _Result_type, typename _Visitor, size_t... __dimensions,
typename... _Variants, size_t... __indices>
struct __gen_vtable_impl<
_Multi_array<_Result_type (*)(_Visitor, _Variants...), __dimensions...>,
std::index_sequence<__indices...>>
{
using _Next =
remove_reference_t<typename _Nth_type<sizeof...(__indices),
_Variants...>::type>;
using _Array_type =
_Multi_array<_Result_type (*)(_Visitor, _Variants...),
__dimensions...>;

static constexpr _Array_type

_S_apply()
{
_Array_type __vtable{};
_S_apply_all_alts(
__vtable, make_index_sequence<variant_size_v<_Next>>());
return __vtable;
}

template<size_t... __var_indices>
static constexpr void
_S_apply_all_alts(_Array_type& __vtable,
std::index_sequence<__var_indices...>)
{
if constexpr (__extra_visit_slot_needed<_Result_type, _Next>)
(_S_apply_single_alt<true, __var_indices>(
__vtable._M_arr[__var_indices + 1],
&(__vtable._M_arr[0])), ...);
else
(_S_apply_single_alt<false, __var_indices>(
__vtable._M_arr[__var_indices]), ...);
}

template<bool __do_cookie, size_t __index, typename _Tp>

static constexpr void
_S_apply_single_alt(_Tp& __element, _Tp* __cookie_element = nullptr)
{
if constexpr (__do_cookie)
{
__element = __gen_vtable_impl<
_Tp,
std::index_sequence<__indices..., __index>>::_S_apply();
*__cookie_element = __gen_vtable_impl<
_Tp,
std::index_sequence<__indices..., variant_npos>>::_S_apply();
}
else
{
auto __tmp_element = __gen_vtable_impl<
remove_reference_t<decltype(__element)>,
std::index_sequence<__indices..., __index>>::_S_apply();
static_assert(is_same_v<_Tp, decltype(__tmp_element)>,
"std::visit requires the visitor to have the same "
"return type for all alternatives of a variant");
__element = __tmp_element;
}
}
};

template<typename _Result_type, typename _Visitor, typename... _Variants,

size_t... __indices>
struct __gen_vtable_impl<
_Multi_array<_Result_type (*)(_Visitor, _Variants...)>,
std::index_sequence<__indices...>>
{
using _Array_type =
_Multi_array<_Result_type (*)(_Visitor, _Variants...)>;

template<size_t __index, typename _Variant>

static constexpr decltype(auto)
__element_by_index_or_cookie(_Variant&& __var) noexcept
{
if constexpr (__index != variant_npos)
return __variant::__get<__index>(std::forward<_Variant>(__var));
else
return __variant_cookie{};
}

static constexpr decltype(auto)

__visit_invoke(_Visitor&& __visitor, _Variants... __vars)
{
if constexpr (is_same_v<_Result_type, __variant_idx_cookie>)

std::__invoke(std::forward<_Visitor>(__visitor),
__element_by_index_or_cookie<__indices>(
std::forward<_Variants>(__vars))...,
integral_constant<size_t, __indices>()...);
else if constexpr (is_same_v<_Result_type, __variant_cookie>)

std::__invoke(std::forward<_Visitor>(__visitor),
__element_by_index_or_cookie<__indices>(
std::forward<_Variants>(__vars))...);
else if constexpr (_Array_type::__result_is_deduced::value)

return std::__invoke(std::forward<_Visitor>(__visitor),
__element_by_index_or_cookie<__indices>(
std::forward<_Variants>(__vars))...);
else
return std::__invoke_r<_Result_type>(
std::forward<_Visitor>(__visitor),
__variant::__get<__indices>(std::forward<_Variants>(__vars))...);
}
static constexpr auto
_S_apply()
{
if constexpr (_Array_type::__result_is_deduced::value)
{
constexpr bool __visit_ret_type_mismatch =
!is_same_v<typename _Result_type::type,
decltype(__visit_invoke(std::declval<_Visitor>(),
std::declval<_Variants>()...))>;
if constexpr (__visit_ret_type_mismatch)
{
struct __cannot_match {};
return __cannot_match{};
}
else
return _Array_type{&__visit_invoke};
}
else
return _Array_type{&__visit_invoke};
}
};

template<typename _Result_type, typename _Visitor, typename... _Variants>

struct __gen_vtable
{
using _Array_type =
_Multi_array<_Result_type (*)(_Visitor, _Variants...),
variant_size_v<remove_reference_t<_Variants>>...>;

static constexpr _Array_type _S_vtable

= __gen_vtable_impl<_Array_type, std::index_sequence<>>::_S_apply();
};

template<size_t _Np, typename _Tp>

struct _Base_dedup : public _Tp { };

template<typename _Variant, typename __indices>

struct _Variant_hash_base;

template<typename... _Types, size_t... __indices>

struct _Variant_hash_base<variant<_Types...>,
std::index_sequence<__indices...>>
: _Base_dedup<__indices, __poison_hash<remove_const_t<_Types>>>... { };

template<size_t _Np, typename _Variant,

typename _AsV = decltype(__variant::__as(std::declval<_Variant>())),
typename _Tp = variant_alternative_t<_Np, remove_reference_t<_AsV>>>
using __get_t
= __conditional_t<is_lvalue_reference_v<_Variant>, _Tp&, _Tp&&>;

template<typename _Visitor, typename... _Variants>

using __visit_result_t
= invoke_result_t<_Visitor, __get_t<0, _Variants>...>;

template<typename _Tp, typename... _Types>

constexpr inline bool __same_types = (is_same_v<_Tp, _Types> && ...);
template <typename _Visitor, typename _Variant, size_t... _Idxs>
constexpr bool __check_visitor_results(std::index_sequence<_Idxs...>)
{
return __same_types<
invoke_result_t<_Visitor, __get_t<_Idxs, _Variant>>...
>;
}

}
}

template<typename _Tp, typename... _Types>

constexpr bool
holds_alternative(const variant<_Types...>& __v) noexcept
{
static_assert(__detail::__variant::__exactly_once<_Tp, _Types...>,
"T must occur exactly once in alternatives");
return __v.index() == std::__find_uniq_type_in_pack<_Tp, _Types...>();
}

template<typename _Tp, typename... _Types>

constexpr _Tp&
get(variant<_Types...>& __v)
{
static_assert(__detail::__variant::__exactly_once<_Tp, _Types...>,
"T must occur exactly once in alternatives");
constexpr size_t __n = std::__find_uniq_type_in_pack<_Tp, _Types...>();
return std::get<__n>(__v);
}

template<typename _Tp, typename... _Types>

constexpr _Tp&&
get(variant<_Types...>&& __v)
{
static_assert(__detail::__variant::__exactly_once<_Tp, _Types...>,
"T must occur exactly once in alternatives");
constexpr size_t __n = std::__find_uniq_type_in_pack<_Tp, _Types...>();
return std::get<__n>(std::move(__v));
}

template<typename _Tp, typename... _Types>

constexpr const _Tp&
get(const variant<_Types...>& __v)
{
static_assert(__detail::__variant::__exactly_once<_Tp, _Types...>,
"T must occur exactly once in alternatives");
constexpr size_t __n = std::__find_uniq_type_in_pack<_Tp, _Types...>();
return std::get<__n>(__v);
}

template<typename _Tp, typename... _Types>

constexpr const _Tp&&
get(const variant<_Types...>&& __v)
{
static_assert(__detail::__variant::__exactly_once<_Tp, _Types...>,
"T must occur exactly once in alternatives");
constexpr size_t __n = std::__find_uniq_type_in_pack<_Tp, _Types...>();
return std::get<__n>(std::move(__v));
}

template<size_t _Np, typename... _Types>

constexpr add_pointer_t<variant_alternative_t<_Np, variant<_Types...>>>
get_if(variant<_Types...>* __ptr) noexcept
{
using _Alternative_type = variant_alternative_t<_Np, variant<_Types...>>;
static_assert(_Np < sizeof...(_Types),
"The index must be in [0, number of alternatives)");
static_assert(!is_void_v<_Alternative_type>, "_Tp must not be void");
if (__ptr && __ptr->index() == _Np)
return std::addressof(__detail::__variant::__get<_Np>(*__ptr));
return nullptr;
}

template<size_t _Np, typename... _Types>

constexpr
add_pointer_t<const variant_alternative_t<_Np, variant<_Types...>>>
get_if(const variant<_Types...>* __ptr) noexcept
{
using _Alternative_type = variant_alternative_t<_Np, variant<_Types...>>;
static_assert(_Np < sizeof...(_Types),
"The index must be in [0, number of alternatives)");
static_assert(!is_void_v<_Alternative_type>, "_Tp must not be void");
if (__ptr && __ptr->index() == _Np)
return std::addressof(__detail::__variant::__get<_Np>(*__ptr));
return nullptr;
}

template<typename _Tp, typename... _Types>

constexpr add_pointer_t<_Tp>
get_if(variant<_Types...>* __ptr) noexcept
{
static_assert(__detail::__variant::__exactly_once<_Tp, _Types...>,
"T must occur exactly once in alternatives");
static_assert(!is_void_v<_Tp>, "_Tp must not be void");
constexpr size_t __n = std::__find_uniq_type_in_pack<_Tp, _Types...>();
return std::get_if<__n>(__ptr);
}

template<typename _Tp, typename... _Types>

constexpr add_pointer_t<const _Tp>
get_if(const variant<_Types...>* __ptr) noexcept
{
static_assert(__detail::__variant::__exactly_once<_Tp, _Types...>,
"T must occur exactly once in alternatives");
static_assert(!is_void_v<_Tp>, "_Tp must not be void");
constexpr size_t __n = std::__find_uniq_type_in_pack<_Tp, _Types...>();
return std::get_if<__n>(__ptr);
}

struct monostate { };
# 1264 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/variant" 3
template<typename... _Types> constexpr bool operator <(const variant<_Types...>&
__lhs, const variant<_Types...>& __rhs) { bool __ret = true;
__detail::__variant::__raw_idx_visit( [&__ret, &__lhs] (auto&& __rhs_mem, auto
__rhs_index) mutable { if constexpr (__rhs_index != variant_npos) { if
(__lhs.index() == __rhs_index) { auto& __this_mem = std::get<__rhs_index>(__lhs);
__ret = __this_mem < __rhs_mem; } else __ret = (__lhs.index() + 1) < (__rhs_index +
1); } else __ret = (__lhs.index() + 1) < (__rhs_index + 1); }, __rhs); return
__ret; }
template<typename... _Types> constexpr bool operator <=(const variant<_Types...>&
__lhs, const variant<_Types...>& __rhs) { bool __ret = true;
__detail::__variant::__raw_idx_visit( [&__ret, &__lhs] (auto&& __rhs_mem, auto
__rhs_index) mutable { if constexpr (__rhs_index != variant_npos) { if
(__lhs.index() == __rhs_index) { auto& __this_mem = std::get<__rhs_index>(__lhs);
__ret = __this_mem <= __rhs_mem; } else __ret = (__lhs.index() + 1) <= (__rhs_index
+ 1); } else __ret = (__lhs.index() + 1) <= (__rhs_index + 1); }, __rhs); return
__ret; }
template<typename... _Types> constexpr bool operator ==(const variant<_Types...>&
__lhs, const variant<_Types...>& __rhs) { bool __ret = true;
__detail::__variant::__raw_idx_visit( [&__ret, &__lhs] (auto&& __rhs_mem, auto
__rhs_index) mutable { if constexpr (__rhs_index != variant_npos) { if
(__lhs.index() == __rhs_index) { auto& __this_mem = std::get<__rhs_index>(__lhs);
__ret = __this_mem == __rhs_mem; } else __ret = (__lhs.index() + 1) == (__rhs_index
+ 1); } else __ret = (__lhs.index() + 1) == (__rhs_index + 1); }, __rhs); return
__ret; }
template<typename... _Types> constexpr bool operator !=(const variant<_Types...>&
__lhs, const variant<_Types...>& __rhs) { bool __ret = true;
__detail::__variant::__raw_idx_visit( [&__ret, &__lhs] (auto&& __rhs_mem, auto
__rhs_index) mutable { if constexpr (__rhs_index != variant_npos) { if
(__lhs.index() == __rhs_index) { auto& __this_mem = std::get<__rhs_index>(__lhs);
__ret = __this_mem != __rhs_mem; } else __ret = (__lhs.index() + 1) != (__rhs_index
+ 1); } else __ret = (__lhs.index() + 1) != (__rhs_index + 1); }, __rhs); return
__ret; }
template<typename... _Types> constexpr bool operator >=(const variant<_Types...>&
__lhs, const variant<_Types...>& __rhs) { bool __ret = true;
__detail::__variant::__raw_idx_visit( [&__ret, &__lhs] (auto&& __rhs_mem, auto
__rhs_index) mutable { if constexpr (__rhs_index != variant_npos) { if
(__lhs.index() == __rhs_index) { auto& __this_mem = std::get<__rhs_index>(__lhs);
__ret = __this_mem >= __rhs_mem; } else __ret = (__lhs.index() + 1) >= (__rhs_index
+ 1); } else __ret = (__lhs.index() + 1) >= (__rhs_index + 1); }, __rhs); return
__ret; }
template<typename... _Types> constexpr bool operator >(const variant<_Types...>&
__lhs, const variant<_Types...>& __rhs) { bool __ret = true;
__detail::__variant::__raw_idx_visit( [&__ret, &__lhs] (auto&& __rhs_mem, auto
__rhs_index) mutable { if constexpr (__rhs_index != variant_npos) { if
(__lhs.index() == __rhs_index) { auto& __this_mem = std::get<__rhs_index>(__lhs);
__ret = __this_mem > __rhs_mem; } else __ret = (__lhs.index() + 1) > (__rhs_index +
1); } else __ret = (__lhs.index() + 1) > (__rhs_index + 1); }, __rhs); return
__ret; }

constexpr bool operator==(monostate, monostate) noexcept { return true; }

template<typename... _Types>
requires (three_way_comparable<_Types> && ...)
constexpr
common_comparison_category_t<compare_three_way_result_t<_Types>...>
operator<=>(const variant<_Types...>& __v, const variant<_Types...>& __w)
{
common_comparison_category_t<compare_three_way_result_t<_Types>...> __ret
= strong_ordering::equal;

__detail::__variant::__raw_idx_visit(
[&__ret, &__v] (auto&& __w_mem, auto __w_index) mutable
{
if constexpr (__w_index != variant_npos)
{
if (__v.index() == __w_index)
{
auto& __this_mem = std::get<__w_index>(__v);
__ret = __this_mem <=> __w_mem;
return;
}
}
__ret = (__v.index() + 1) <=> (__w_index + 1);
}, __w);
return __ret;
}

constexpr strong_ordering
operator<=>(monostate, monostate) noexcept { return strong_ordering::equal; }
# 1312 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/variant" 3
template<typename _Visitor, typename... _Variants>
constexpr __detail::__variant::__visit_result_t<_Visitor, _Variants...>
visit(_Visitor&&, _Variants&&...);

template<typename... _Types>
constexpr
inline enable_if_t<(is_move_constructible_v<_Types> && ...)
&& (is_swappable_v<_Types> && ...)>
swap(variant<_Types...>& __lhs, variant<_Types...>& __rhs)
noexcept(noexcept(__lhs.swap(__rhs)))
{ __lhs.swap(__rhs); }

template<typename... _Types>
enable_if_t<!((is_move_constructible_v<_Types> && ...)
&& (is_swappable_v<_Types> && ...))>
swap(variant<_Types...>&, variant<_Types...>&) = delete;

class bad_variant_access : public exception

{
public:
bad_variant_access() noexcept { }

const char* what() const noexcept override

{ return _M_reason; }

private:
bad_variant_access(const char* __reason) noexcept : _M_reason(__reason) { }

const char* _M_reason = "bad variant access";

friend void __throw_bad_variant_access(const char* __what);

};

inline void
__throw_bad_variant_access(const char* __what)
{ (throw (bad_variant_access(__what))); }

inline void
__throw_bad_variant_access(bool __valueless)
{
if (__valueless) [[__unlikely__]]
__throw_bad_variant_access("std::get: variant is valueless");
else
__throw_bad_variant_access("std::get: wrong index for variant");
}

template<typename... _Types>
class variant
: private __detail::__variant::_Variant_base<_Types...>,
private _Enable_copy_move<
__detail::__variant::_Traits<_Types...>::_S_copy_ctor,
__detail::__variant::_Traits<_Types...>::_S_copy_assign,
__detail::__variant::_Traits<_Types...>::_S_move_ctor,
__detail::__variant::_Traits<_Types...>::_S_move_assign,
variant<_Types...>>
{
private:
template <typename... _UTypes, typename _Tp>
friend constexpr decltype(auto)
__variant_cast(_Tp&&);

static_assert(sizeof...(_Types) > 0,
"variant must have at least one alternative");
static_assert(!(std::is_reference_v<_Types> || ...),
"variant must have no reference alternative");
static_assert(!(std::is_void_v<_Types> || ...),
"variant must have no void alternative");

using _Base = detail::variant::_Variant_base<_Types...>;

template<typename _Tp>
static constexpr bool __not_self
= !is_same_v<__remove_cvref_t<_Tp>, variant>;

template<typename _Tp>
static constexpr bool
__exactly_once = __detail::__variant::__exactly_once<_Tp, _Types...>;

template<typename _Tp>
static constexpr size_t __accepted_index
= __detail::__variant::__accepted_index<_Tp, variant>;

template<size_t _Np, typename = enable_if_t<(_Np < sizeof...(_Types))>>

using __to_type = typename _Nth_type<_Np, _Types...>::type;

template<typename _Tp, typename = enable_if_t<__not_self<_Tp>>>

using __accepted_type = __to_type<__accepted_index<_Tp>>;

template<typename _Tp>
static constexpr size_t __index_of
= std::__find_uniq_type_in_pack<_Tp, _Types...>();

using _Traits = detail::variant::_Traits<_Types...>;

template<typename _Tp>
struct __is_in_place_tag : false_type { };
template<typename _Tp>
struct __is_in_place_tag<in_place_type_t<_Tp>> : true_type { };
template<size_t _Np>
struct __is_in_place_tag<in_place_index_t<_Np>> : true_type { };

template<typename _Tp>
static constexpr bool __not_in_place_tag
= !__is_in_place_type_v<__remove_cvref_t<_Tp>>
&& !__is_in_place_index_v<__remove_cvref_t<_Tp>>;

public:

variant() requires is_default_constructible_v<__to_type<0>> = default;

# 1431 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/variant" 3
variant(const variant& __rhs) = default;
variant(variant&&) = default;
variant& operator=(const variant&) = default;
variant& operator=(variant&&) = default;
constexpr ~variant() = default;

template<typename _Tp,
typename = enable_if_t<sizeof...(_Types) != 0>,
typename = enable_if_t<__not_in_place_tag<_Tp>>,
typename _Tj = __accepted_type<_Tp&&>,
typename = enable_if_t<__exactly_once<_Tj>
&& is_constructible_v<_Tj, _Tp>>>
constexpr
variant(_Tp&& __t)
noexcept(is_nothrow_constructible_v<_Tj, _Tp>)
: variant(in_place_index<__accepted_index<_Tp>>,
std::forward<_Tp>(__t))
{ }

template<typename _Tp, typename... _Args,

typename = enable_if_t<__exactly_once<_Tp>
&& is_constructible_v<_Tp, _Args...>>>
constexpr explicit
variant(in_place_type_t<_Tp>, _Args&&... __args)
: variant(in_place_index<__index_of<_Tp>>,
std::forward<_Args>(__args)...)
{ }

template<typename _Tp, typename _Up, typename... _Args,

typename = enable_if_t<__exactly_once<_Tp>
&& is_constructible_v<_Tp,
initializer_list<_Up>&, _Args...>>>
constexpr explicit
variant(in_place_type_t<_Tp>, initializer_list<_Up> __il,
_Args&&... __args)
: variant(in_place_index<__index_of<_Tp>>, __il,
std::forward<_Args>(__args)...)
{ }

template<size_t _Np, typename... _Args,

typename _Tp = __to_type<_Np>,
typename = enable_if_t<is_constructible_v<_Tp, _Args...>>>
constexpr explicit
variant(in_place_index_t<_Np>, _Args&&... __args)
: _Base(in_place_index<_Np>, std::forward<_Args>(__args)...)
{ }
template<size_t _Np, typename _Up, typename... _Args,
typename _Tp = __to_type<_Np>,
typename = enable_if_t<is_constructible_v<_Tp,
initializer_list<_Up>&,
_Args...>>>
constexpr explicit
variant(in_place_index_t<_Np>, initializer_list<_Up> __il,
_Args&&... __args)
: _Base(in_place_index<_Np>, __il, std::forward<_Args>(__args)...)
{ }

template<typename _Tp>
constexpr
enable_if_t<__exactly_once<__accepted_type<_Tp&&>>
&& is_constructible_v<__accepted_type<_Tp&&>, _Tp>
&& is_assignable_v<__accepted_type<_Tp&&>&, _Tp>,
variant&>
operator=(_Tp&& __rhs)
noexcept(is_nothrow_assignable_v<__accepted_type<_Tp&&>&, _Tp>
&& is_nothrow_constructible_v<__accepted_type<_Tp&&>, _Tp>)
{
constexpr auto __index = __accepted_index<_Tp>;
if (index() == __index)
std::get<__index>(*this) = std::forward<_Tp>(__rhs);
else
{
using _Tj = __accepted_type<_Tp&&>;
if constexpr (is_nothrow_constructible_v<_Tj, _Tp>
|| !is_nothrow_move_constructible_v<_Tj>)
this->emplace<__index>(std::forward<_Tp>(__rhs));
else

this->emplace<__index>(_Tj(std::forward<_Tp>(__rhs)));
}
return *this;
}

template<typename _Tp, typename... _Args>

constexpr
enable_if_t<is_constructible_v<_Tp, _Args...> && __exactly_once<_Tp>,
_Tp&>
emplace(_Args&&... __args)
{
constexpr size_t __index = __index_of<_Tp>;
return this->emplace<__index>(std::forward<_Args>(__args)...);
}

template<typename _Tp, typename _Up, typename... _Args>

constexpr
enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>
&& __exactly_once<_Tp>,
_Tp&>
emplace(initializer_list<_Up> __il, _Args&&... __args)
{
constexpr size_t __index = __index_of<_Tp>;
return this->emplace<__index>(__il, std::forward<_Args>(__args)...);
}
template<size_t _Np, typename... _Args>
constexpr
enable_if_t<is_constructible_v<__to_type<_Np>, _Args...>,
__to_type<_Np>&>
emplace(_Args&&... __args)
{
namespace __variant = std::__detail::__variant;
using type = typename _Nth_type<_Np, _Types...>::type;

if constexpr (is_nothrow_constructible_v<type, _Args...>)

{
__variant::__emplace<_Np>(*this, std::forward<_Args>(__args)...);
}
else if constexpr (is_scalar_v<type>)
{

const type __tmp(std::forward<_Args>(__args)...);

__variant::__emplace<_Np>(*this, __tmp);
}
else if constexpr (__variant::_Never_valueless_alt<type>()
&& _Traits::_S_move_assign)
{

variant __tmp(in_place_index<_Np>,
std::forward<_Args>(__args)...);

*this = std::move(__tmp);
}
else
{

__variant::__emplace<_Np>(*this, std::forward<_Args>(__args)...);
}
return std::get<_Np>(*this);
}

template<size_t _Np, typename _Up, typename... _Args>

constexpr
enable_if_t<is_constructible_v<__to_type<_Np>,
initializer_list<_Up>&, _Args...>,
__to_type<_Np>&>
emplace(initializer_list<_Up> __il, _Args&&... __args)
{
namespace __variant = std::__detail::__variant;
using type = typename _Nth_type<_Np, _Types...>::type;

if constexpr (is_nothrow_constructible_v<type,
initializer_list<_Up>&,
_Args...>)
{
__variant::__emplace<_Np>(*this, __il,
std::forward<_Args>(__args)...);
}
else if constexpr (__variant::_Never_valueless_alt<type>()
&& _Traits::_S_move_assign)
{

variant __tmp(in_place_index<_Np>, __il,

std::forward<_Args>(__args)...);

*this = std::move(__tmp);
}
else
{

__variant::__emplace<_Np>(*this, __il,
std::forward<_Args>(__args)...);
}
return std::get<_Np>(*this);
}

template<size_t _Np, typename... _Args>

enable_if_t<!(_Np < sizeof...(_Types))> emplace(_Args&&...) = delete;

template<typename _Tp, typename... _Args>

enable_if_t<!__exactly_once<_Tp>> emplace(_Args&&...) = delete;

constexpr bool valueless_by_exception() const noexcept

{ return !this->_M_valid(); }

constexpr size_t index() const noexcept

{
using __index_type = typename _Base::__index_type;
if constexpr (__detail::__variant::__never_valueless<_Types...>())
return this->_M_index;
else if constexpr (sizeof...(_Types) <= __index_type(-1) / 2)
return make_signed_t<__index_type>(this->_M_index);
else
return size_t(__index_type(this->_M_index + 1)) - 1;
}

constexpr
void
swap(variant& __rhs)
noexcept((__is_nothrow_swappable<_Types>::value && ...)
&& is_nothrow_move_constructible_v<variant>)
{
static_assert((is_move_constructible_v<_Types> && ...));

if (__rhs.valueless_by_exception()) [[__unlikely__]]
{
if (!this->valueless_by_exception()) [[__likely__]]
__rhs.swap(*this);
return;
}

namespace variant = detail::__variant;

__variant::__raw_idx_visit(
[this, &__rhs](auto&& __rhs_mem, auto __rhs_index) mutable
{
constexpr size_t __j = __rhs_index;
if constexpr (__j != variant_npos)
{
if (this->index() == __j)
{
using std::swap;
swap(std::get<__j>(*this), __rhs_mem);
}
else
{
auto __tmp(std::move(__rhs_mem));

if constexpr (_Traits::_S_trivial_move_assign)
__rhs = std::move(*this);
else
__variant::__raw_idx_visit(
[&__rhs](auto&& __this_mem, auto __this_index) mutable
{
constexpr size_t __k = __this_index;
if constexpr (__k != variant_npos)
__variant::__emplace<__k>(__rhs,
std::move(__this_mem));
}, *this);

__variant::__emplace<__j>(*this, std::move(__tmp));
}
}
}, __rhs);
}

private:
template<size_t _Np, typename _Vp>
friend constexpr decltype(auto)
__detail::__variant::__get(_Vp&& __v) noexcept;

template<typename... _Tp> friend constexpr bool operator <(const

variant<_Tp...>& __lhs, const variant<_Tp...>& __rhs);
template<typename... _Tp> friend constexpr bool operator <=(const
variant<_Tp...>& __lhs, const variant<_Tp...>& __rhs);
template<typename... _Tp> friend constexpr bool operator ==(const
variant<_Tp...>& __lhs, const variant<_Tp...>& __rhs);
template<typename... _Tp> friend constexpr bool operator !=(const
variant<_Tp...>& __lhs, const variant<_Tp...>& __rhs);
template<typename... _Tp> friend constexpr bool operator >=(const
variant<_Tp...>& __lhs, const variant<_Tp...>& __rhs);
template<typename... _Tp> friend constexpr bool operator >(const
variant<_Tp...>& __lhs, const variant<_Tp...>& __rhs);
};

template<size_t _Np, typename... _Types>

constexpr variant_alternative_t<_Np, variant<_Types...>>&
get(variant<_Types...>& __v)
{
static_assert(_Np < sizeof...(_Types),
"The index must be in [0, number of alternatives)");
if (__v.index() != _Np)
__throw_bad_variant_access(__v.valueless_by_exception());
return __detail::__variant::__get<_Np>(__v);
}

template<size_t _Np, typename... _Types>

constexpr variant_alternative_t<_Np, variant<_Types...>>&&
get(variant<_Types...>&& __v)
{
static_assert(_Np < sizeof...(_Types),
"The index must be in [0, number of alternatives)");
if (__v.index() != _Np)
__throw_bad_variant_access(__v.valueless_by_exception());
return __detail::__variant::__get<_Np>(std::move(__v));
}

template<size_t _Np, typename... _Types>

constexpr const variant_alternative_t<_Np, variant<_Types...>>&
get(const variant<_Types...>& __v)
{
static_assert(_Np < sizeof...(_Types),
"The index must be in [0, number of alternatives)");
if (__v.index() != _Np)
__throw_bad_variant_access(__v.valueless_by_exception());
return __detail::__variant::__get<_Np>(__v);
}

template<size_t _Np, typename... _Types>

constexpr const variant_alternative_t<_Np, variant<_Types...>>&&
get(const variant<_Types...>&& __v)
{
static_assert(_Np < sizeof...(_Types),
"The index must be in [0, number of alternatives)");
if (__v.index() != _Np)
__throw_bad_variant_access(__v.valueless_by_exception());
return __detail::__variant::__get<_Np>(std::move(__v));
}

template<typename _Result_type, typename _Visitor, typename... _Variants>

constexpr decltype(auto)
__do_visit(_Visitor&& __visitor, _Variants&&... __variants)
{

if constexpr (sizeof...(_Variants) == 0)
{
if constexpr (is_void_v<_Result_type>)
return (void) std::forward<_Visitor>(__visitor)();
else
return std::forward<_Visitor>(__visitor)();
}
else
{
constexpr size_t __max = 11;

using _V0 = typename _Nth_type<0, _Variants...>::type;

constexpr auto __n = variant_size_v<remove_reference_t<_V0>>;

if constexpr (sizeof...(_Variants) > 1 || n > max)

{

constexpr auto& vtable = detail::variant::gen_vtable<

_Result_type, _Visitor&&, _Variants&&...>::_S_vtable;

auto __func_ptr = __vtable._M_access(__variants.index()...);

return (*__func_ptr)(std::forward<_Visitor>(__visitor),
std::forward<_Variants>(__variants)...);
}
else
{

_V0& __v0
= [](_V0& __v, ...) -> _V0& { return __v; }(__variants...);

using __detail::__variant::_Multi_array;
using __detail::__variant::__gen_vtable_impl;
using _Ma = _Multi_array<_Result_type (*)(_Visitor&&, _V0&&)>;
# 1814 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/variant" 3
switch (__v0.index())
{
case 0: { if constexpr (0 < __n) { return __gen_vtable_impl<_Ma,
index_sequence<0>>:: __visit_invoke(std::forward<_Visitor>(__visitor),
std::forward<_V0>(__v0)); } else __builtin_unreachable(); }
case 1: { if constexpr (1 < __n) { return __gen_vtable_impl<_Ma,
index_sequence<1>>:: __visit_invoke(std::forward<_Visitor>(__visitor),
std::forward<_V0>(__v0)); } else __builtin_unreachable(); }
case 2: { if constexpr (2 < __n) { return __gen_vtable_impl<_Ma,
index_sequence<2>>:: __visit_invoke(std::forward<_Visitor>(__visitor),
std::forward<_V0>(__v0)); } else __builtin_unreachable(); }
case 3: { if constexpr (3 < __n) { return __gen_vtable_impl<_Ma,
index_sequence<3>>:: __visit_invoke(std::forward<_Visitor>(__visitor),
std::forward<_V0>(__v0)); } else __builtin_unreachable(); }
case 4: { if constexpr (4 < __n) { return __gen_vtable_impl<_Ma,
index_sequence<4>>:: __visit_invoke(std::forward<_Visitor>(__visitor),
std::forward<_V0>(__v0)); } else __builtin_unreachable(); }
case 5: { if constexpr (5 < __n) { return __gen_vtable_impl<_Ma,
index_sequence<5>>:: __visit_invoke(std::forward<_Visitor>(__visitor),
std::forward<_V0>(__v0)); } else __builtin_unreachable(); }
case 6: { if constexpr (6 < __n) { return __gen_vtable_impl<_Ma,
index_sequence<6>>:: __visit_invoke(std::forward<_Visitor>(__visitor),
std::forward<_V0>(__v0)); } else __builtin_unreachable(); }
case 7: { if constexpr (7 < __n) { return __gen_vtable_impl<_Ma,
index_sequence<7>>:: __visit_invoke(std::forward<_Visitor>(__visitor),
std::forward<_V0>(__v0)); } else __builtin_unreachable(); }
case 8: { if constexpr (8 < __n) { return __gen_vtable_impl<_Ma,
index_sequence<8>>:: __visit_invoke(std::forward<_Visitor>(__visitor),
std::forward<_V0>(__v0)); } else __builtin_unreachable(); }
case 9: { if constexpr (9 < __n) { return __gen_vtable_impl<_Ma,
index_sequence<9>>:: __visit_invoke(std::forward<_Visitor>(__visitor),
std::forward<_V0>(__v0)); } else __builtin_unreachable(); }
case 10: { if constexpr (10 < __n) { return __gen_vtable_impl<_Ma,
index_sequence<10>>:: __visit_invoke(std::forward<_Visitor>(__visitor),
std::forward<_V0>(__v0)); } else __builtin_unreachable(); }
case variant_npos:
using __detail::__variant::__variant_idx_cookie;
using __detail::__variant::__variant_cookie;
if constexpr (is_same_v<_Result_type, __variant_idx_cookie>
|| is_same_v<_Result_type, __variant_cookie>)
{
using _Npos = index_sequence<variant_npos>;
return __gen_vtable_impl<_Ma, _Npos>::
__visit_invoke(std::forward<_Visitor>(__visitor),
std::forward<_V0>(__v0));
}
else
__builtin_unreachable();
default:
__builtin_unreachable();
}

}
}
}

template<typename _Visitor, typename... _Variants>

constexpr __detail::__variant::__visit_result_t<_Visitor, _Variants...>
visit(_Visitor&& __visitor, _Variants&&... __variants)
{
namespace __variant = std::__detail::__variant;

if ((__variant::__as(__variants).valueless_by_exception() || ...))
__throw_bad_variant_access("std::visit: variant is valueless");

using _Result_type
= __detail::__variant::__visit_result_t<_Visitor, _Variants...>;

using _Tag = detail::variant::__deduce_visit_result<_Result_type>;

if constexpr (sizeof...(_Variants) == 1)
{
using _Vp = decltype(__variant::__as(std::declval<_Variants>()...));

constexpr bool __visit_rettypes_match = detail::variant::

__check_visitor_results<_Visitor, _Vp>(
make_index_sequence<variant_size_v<remove_reference_t<_Vp>>>());
if constexpr (!__visit_rettypes_match)
{
static_assert(__visit_rettypes_match,
"std::visit requires the visitor to have the same "
"return type for all alternatives of a variant");
return;
}
else
return std::__do_visit<_Tag>(
std::forward<_Visitor>(__visitor),
static_cast<_Vp>(__variants)...);
}
else
return std::__do_visit<_Tag>(
std::forward<_Visitor>(__visitor),
__variant::__as(std::forward<_Variants>(__variants))...);
}

template<typename _Res, typename _Visitor, typename... _Variants>

constexpr _Res
visit(_Visitor&& __visitor, _Variants&&... __variants)
{
namespace __variant = std::__detail::__variant;

if ((__variant::__as(__variants).valueless_by_exception() || ...))
__throw_bad_variant_access("std::visit<R>: variant is valueless");

return std::__do_visit<_Res>(std::forward<_Visitor>(__visitor),
__variant::__as(std::forward<_Variants>(__variants))...);
}

template<bool, typename... _Types>

struct __variant_hash_call_base_impl
{
size_t
operator()(const variant<_Types...>& __t) const
noexcept((is_nothrow_invocable_v<hash<decay_t<_Types>>, _Types> && ...))
{
size_t __ret;
__detail::__variant::__raw_visit(
[&__t, &__ret](auto&& __t_mem) mutable
{
using _Type = __remove_cvref_t<decltype(__t_mem)>;
if constexpr (!is_same_v<_Type,
__detail::__variant::__variant_cookie>)
__ret = std::hash<size_t>{}(__t.index())
+ std::hash<_Type>{}(__t_mem);
else
__ret = std::hash<size_t>{}(__t.index());
}, __t);
return __ret;
}
};

template<typename... _Types>
struct __variant_hash_call_base_impl<false, _Types...> {};

template<typename... _Types>
using __variant_hash_call_base =
__variant_hash_call_base_impl<(__poison_hash<remove_const_t<_Types>>::
__enable_hash_call &&...), _Types...>;

template<typename... _Types>
struct hash<variant<_Types...>>
: private __detail::__variant::_Variant_hash_base<
variant<_Types...>, std::index_sequence_for<_Types...>>,
public __variant_hash_call_base<_Types...>
{
using result_type [[__deprecated__]] = size_t;
using argument_type [[__deprecated__]] = variant<_Types...>;
};

template<>
struct hash<monostate>
{
using result_type [[__deprecated__]] = size_t;
using argument_type [[__deprecated__]] = monostate;

size_t
operator()(const monostate&) const noexcept
{
constexpr size_t __magic_monostate_hash = -7777;
return __magic_monostate_hash;
}
};

template<typename... _Types>
struct __is_fast_hash<hash<variant<_Types...>>>
: bool_constant<(__is_fast_hash<_Types>::value && ...)>
{ };

}
# 53 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/format" 2 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/ranges_algobase.h" 1 3
# 43 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/ranges_algobase.h" 3
namespace std
{

namespace ranges
{
namespace __detail
{
template<typename _Tp>
constexpr inline bool __is_normal_iterator = false;

template<typename _Iterator, typename _Container>

constexpr inline bool
__is_normal_iterator<__gnu_cxx::__normal_iterator<_Iterator,
_Container>> = true;

template<typename _Tp>
constexpr inline bool __is_reverse_iterator = false;

template<typename _Iterator>
constexpr inline bool
__is_reverse_iterator<reverse_iterator<_Iterator>> = true;

template<typename _Tp>
constexpr inline bool __is_move_iterator = false;

template<typename _Iterator>
constexpr inline bool
__is_move_iterator<move_iterator<_Iterator>> = true;
}

struct __equal_fn
{
template<input_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
input_iterator _Iter2, sentinel_for<_Iter2> _Sent2,
typename _Pred = ranges::equal_to,
typename _Proj1 = identity, typename _Proj2 = identity>
requires indirectly_comparable<_Iter1, _Iter2, _Pred, _Proj1, _Proj2>
constexpr bool
operator()(_Iter1 __first1, _Sent1 __last1,
_Iter2 __first2, _Sent2 __last2, _Pred __pred = {},
_Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const
{

if constexpr (__detail::__is_normal_iterator<_Iter1>
&& same_as<_Iter1, _Sent1>)
return (*this)(__first1.base(), __last1.base(),
std::move(__first2), std::move(__last2),
std::move(__pred),
std::move(__proj1), std::move(__proj2));
else if constexpr (__detail::__is_normal_iterator<_Iter2>
&& same_as<_Iter2, _Sent2>)
return (*this)(std::move(__first1), std::move(__last1),
__first2.base(), __last2.base(),
std::move(__pred),
std::move(__proj1), std::move(__proj2));
else if constexpr (sized_sentinel_for<_Sent1, _Iter1>
&& sized_sentinel_for<_Sent2, _Iter2>)
{
auto __d1 = ranges::distance(__first1, __last1);
auto __d2 = ranges::distance(__first2, __last2);
if (__d1 != __d2)
return false;

using _ValueType1 = iter_value_t<_Iter1>;

constexpr bool __use_memcmp
= ((is_integral_v<_ValueType1> || is_pointer_v<_ValueType1>)
&& __memcmpable<_Iter1, _Iter2>::__value
&& is_same_v<_Pred, ranges::equal_to>
&& is_same_v<_Proj1, identity>
&& is_same_v<_Proj2, identity>);
if constexpr (__use_memcmp)
{
if (const size_t __len = (__last1 - __first1))
return !std::__memcmp(__first1, __first2, __len);
return true;
}
else
{
for (; __first1 != __last1; ++__first1, (void)++__first2)
if (!(bool)std::__invoke(__pred,
std::__invoke(__proj1, *__first1),
std::__invoke(__proj2, *__first2)))
return false;
return true;
}
}
else
{
for (; __first1 != __last1 && __first2 != __last2;
++__first1, (void)++__first2)
if (!(bool)std::__invoke(__pred,
std::__invoke(__proj1, *__first1),
std::__invoke(__proj2, *__first2)))
return false;
return __first1 == __last1 && __first2 == __last2;
}
}

template<input_range _Range1, input_range _Range2,

typename _Pred = ranges::equal_to,
typename _Proj1 = identity, typename _Proj2 = identity>
requires indirectly_comparable<iterator_t<_Range1>, iterator_t<_Range2>,
_Pred, _Proj1, _Proj2>
constexpr bool
operator()(_Range1&& __r1, _Range2&& __r2, _Pred __pred = {},
_Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const
{
return (*this)(ranges::begin(__r1), ranges::end(__r1),
ranges::begin(__r2), ranges::end(__r2),
std::move(__pred),
std::move(__proj1), std::move(__proj2));
}
};

inline constexpr __equal_fn equal{};

template<typename _Iter, typename _Out>

struct in_out_result
{
[[no_unique_address]] _Iter in;
[[no_unique_address]] _Out out;

template<typename _Iter2, typename _Out2>

requires convertible_to<const _Iter&, _Iter2>
&& convertible_to<const _Out&, _Out2>
constexpr
operator in_out_result<_Iter2, _Out2>() const &
{ return {in, out}; }

template<typename _Iter2, typename _Out2>

requires convertible_to<_Iter, _Iter2>
&& convertible_to<_Out, _Out2>
constexpr
operator in_out_result<_Iter2, _Out2>() &&
{ return {std::move(in), std::move(out)}; }
};

template<typename _Iter, typename _Out>

using copy_result = in_out_result<_Iter, _Out>;

template<typename _Iter, typename _Out>

using move_result = in_out_result<_Iter, _Out>;
template<typename _Iter1, typename _Iter2>
using move_backward_result = in_out_result<_Iter1, _Iter2>;

template<typename _Iter1, typename _Iter2>

using copy_backward_result = in_out_result<_Iter1, _Iter2>;

template<bool _IsMove,
bidirectional_iterator _Iter, sentinel_for<_Iter> _Sent,
bidirectional_iterator _Out>
requires (_IsMove
? indirectly_movable<_Iter, _Out>
: indirectly_copyable<_Iter, _Out>)
constexpr __conditional_t<_IsMove,
move_backward_result<_Iter, _Out>,
copy_backward_result<_Iter, _Out>>
__copy_or_move_backward(_Iter __first, _Sent __last, _Out __result);

template<bool _IsMove,
input_iterator _Iter, sentinel_for<_Iter> _Sent,
weakly_incrementable _Out>
requires (_IsMove
? indirectly_movable<_Iter, _Out>
: indirectly_copyable<_Iter, _Out>)
constexpr __conditional_t<_IsMove,
move_result<_Iter, _Out>,
copy_result<_Iter, _Out>>
__copy_or_move(_Iter __first, _Sent __last, _Out __result)
{

using __detail::__is_move_iterator;
using __detail::__is_reverse_iterator;
using __detail::__is_normal_iterator;
if constexpr (__is_move_iterator<_Iter> && same_as<_Iter, _Sent>)
{
auto [__in, __out]
= ranges::__copy_or_move<true>(std::move(__first).base(),
std::move(__last).base(),
std::move(__result));
return {move_iterator{std::move(__in)}, std::move(__out)};
}
else if constexpr (__is_reverse_iterator<_Iter> && same_as<_Iter, _Sent>
&& __is_reverse_iterator<_Out>)
{
auto [__in,__out]
= ranges::__copy_or_move_backward<_IsMove>(std::move(__last).base(),
std::move(__first).base(),
std::move(__result).base());
return {reverse_iterator{std::move(__in)},
reverse_iterator{std::move(__out)}};
}
else if constexpr (__is_normal_iterator<_Iter> && same_as<_Iter, _Sent>)
{
auto [__in,__out]
= ranges::__copy_or_move<_IsMove>(__first.base(), __last.base(),
std::move(__result));
return {decltype(__first){__in}, std::move(__out)};
}
else if constexpr (__is_normal_iterator<_Out>)
{
auto [__in,__out]
= ranges::__copy_or_move<_IsMove>(std::move(__first), __last,
__result.base());
return {std::move(__in), decltype(__result){__out}};
}
else if constexpr (sized_sentinel_for<_Sent, _Iter>)
{
if (!std::__is_constant_evaluated())
{
if constexpr (__memcpyable<_Iter, _Out>::__value)
{
using _ValueTypeI = iter_value_t<_Iter>;
static_assert(_IsMove
? is_move_assignable_v<_ValueTypeI>
: is_copy_assignable_v<_ValueTypeI>);
auto __num = __last - __first;
if (__num)
__builtin_memmove(__result, __first,
sizeof(_ValueTypeI) * __num);
return {__first + __num, __result + __num};
}
}

for (auto n = last - first; n > 0; --__n)

{
if constexpr (_IsMove)
*__result = std::move(*__first);
else
*__result = *__first;
++__first;
++__result;
}
return {std::move(__first), std::move(__result)};
}
else
{
while (__first != __last)
{
if constexpr (_IsMove)
*__result = std::move(*__first);
else
*__result = *__first;
++__first;
++__result;
}
return {std::move(__first), std::move(__result)};
}
}

struct __copy_fn
{
template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
weakly_incrementable _Out>
requires indirectly_copyable<_Iter, _Out>
constexpr copy_result<_Iter, _Out>
operator()(_Iter __first, _Sent __last, _Out __result) const
{
return ranges::__copy_or_move<false>(std::move(__first),
std::move(__last),
std::move(__result));
}

template<input_range _Range, weakly_incrementable _Out>

requires indirectly_copyable<iterator_t<_Range>, _Out>
constexpr copy_result<borrowed_iterator_t<_Range>, _Out>
operator()(_Range&& __r, _Out __result) const
{
return (*this)(ranges::begin(__r), ranges::end(__r),
std::move(__result));
}
};

inline constexpr __copy_fn copy{};

struct __move_fn
{
template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
weakly_incrementable _Out>
requires indirectly_movable<_Iter, _Out>
constexpr move_result<_Iter, _Out>
operator()(_Iter __first, _Sent __last, _Out __result) const
{
return ranges::__copy_or_move<true>(std::move(__first),
std::move(__last),
std::move(__result));
}

template<input_range _Range, weakly_incrementable _Out>

requires indirectly_movable<iterator_t<_Range>, _Out>
constexpr move_result<borrowed_iterator_t<_Range>, _Out>
operator()(_Range&& __r, _Out __result) const
{
return (*this)(ranges::begin(__r), ranges::end(__r),
std::move(__result));
}
};

inline constexpr __move_fn move{};

using __detail::__is_reverse_iterator;
using __detail::__is_normal_iterator;
if constexpr (__is_reverse_iterator<_Iter> && same_as<_Iter, _Sent>
&& __is_reverse_iterator<_Out>)
{
auto [__in,__out]
= ranges::__copy_or_move<_IsMove>(std::move(__last).base(),
std::move(__first).base(),
std::move(__result).base());
return {reverse_iterator{std::move(__in)},
reverse_iterator{std::move(__out)}};
}
else if constexpr (__is_normal_iterator<_Iter> && same_as<_Iter, _Sent>)
{
auto [__in,__out]
= ranges::__copy_or_move_backward<_IsMove>(__first.base(),
__last.base(),
std::move(__result));
return {decltype(__first){__in}, std::move(__out)};
}
else if constexpr (__is_normal_iterator<_Out>)
{
auto [__in,__out]
= ranges::__copy_or_move_backward<_IsMove>(std::move(__first),
std::move(__last),
__result.base());
return {std::move(__in), decltype(__result){__out}};
}
else if constexpr (sized_sentinel_for<_Sent, _Iter>)
{
if (!std::__is_constant_evaluated())
{
if constexpr (__memcpyable<_Out, _Iter>::__value)
{
using _ValueTypeI = iter_value_t<_Iter>;
static_assert(_IsMove
? is_move_assignable_v<_ValueTypeI>
: is_copy_assignable_v<_ValueTypeI>);
auto __num = __last - __first;
if (__num)
__builtin_memmove(__result - __num, __first,
sizeof(_ValueTypeI) * __num);
return {__first + __num, __result - __num};
}
}

auto lasti = ranges::next(first, __last);

auto __tail = __lasti;

for (auto n = last - first; n > 0; --__n)

{
--__tail;
--__result;
if constexpr (_IsMove)
*__result = std::move(*__tail);
else
*__result = *__tail;
}
return {std::move(__lasti), std::move(__result)};
}
else
{
auto __lasti = ranges::next(__first, __last);
auto __tail = __lasti;
while (__first != __tail)
{
--__tail;
--__result;
if constexpr (_IsMove)
*__result = std::move(*__tail);
else
*__result = *__tail;
}
return {std::move(__lasti), std::move(__result)};
}
}

struct __copy_backward_fn
{
template<bidirectional_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
bidirectional_iterator _Iter2>
requires indirectly_copyable<_Iter1, _Iter2>
constexpr copy_backward_result<_Iter1, _Iter2>
operator()(_Iter1 __first, _Sent1 __last, _Iter2 __result) const
{
return ranges::__copy_or_move_backward<false>(std::move(__first),
std::move(__last),
std::move(__result));
}

template<bidirectional_range _Range, bidirectional_iterator _Iter>

requires indirectly_copyable<iterator_t<_Range>, _Iter>
constexpr copy_backward_result<borrowed_iterator_t<_Range>, _Iter>
operator()(_Range&& __r, _Iter __result) const
{
return (*this)(ranges::begin(__r), ranges::end(__r),
std::move(__result));
}
};

inline constexpr __copy_backward_fn copy_backward{};

struct __move_backward_fn
{
template<bidirectional_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
bidirectional_iterator _Iter2>
requires indirectly_movable<_Iter1, _Iter2>
constexpr move_backward_result<_Iter1, _Iter2>
operator()(_Iter1 __first, _Sent1 __last, _Iter2 __result) const
{
return ranges::__copy_or_move_backward<true>(std::move(__first),
std::move(__last),
std::move(__result));
}

template<bidirectional_range _Range, bidirectional_iterator _Iter>

requires indirectly_movable<iterator_t<_Range>, _Iter>
constexpr move_backward_result<borrowed_iterator_t<_Range>, _Iter>
operator()(_Range&& __r, _Iter __result) const
{
return (*this)(ranges::begin(__r), ranges::end(__r),
std::move(__result));
}
};

inline constexpr __move_backward_fn move_backward{};

template<typename _Iter, typename _Out>

using copy_n_result = in_out_result<_Iter, _Out>;

struct __copy_n_fn
{
template<input_iterator _Iter, weakly_incrementable _Out>
requires indirectly_copyable<_Iter, _Out>
constexpr copy_n_result<_Iter, _Out>
operator()(_Iter __first, iter_difference_t<_Iter> __n,
_Out __result) const
{
if constexpr (random_access_iterator<_Iter>)
{
if (__n > 0)
return ranges::copy(__first, __first + __n, std::move(__result));
}
else
{
for (; __n > 0; --__n, (void)++__result, (void)++__first)
*__result = *__first;
}
return {std::move(__first), std::move(__result)};
}
};

inline constexpr __copy_n_fn copy_n{};

struct __fill_n_fn
{
template<typename _Tp, output_iterator<const _Tp&> _Out>
constexpr _Out
operator()(_Out __first, iter_difference_t<_Out> __n,
const _Tp& __value) const
{

if (__n <= 0)
return __first;

if constexpr (is_scalar_v<_Tp>)
{

if constexpr (is_pointer_v<_Out>

&& __is_byte<remove_pointer_t<_Out>>::__value
&& integral<_Tp>)
{
if (!std::__is_constant_evaluated())
{
__builtin_memset(__first,
static_cast<unsigned char>(__value),
__n);
return __first + __n;
}
}

const auto tmp = value;

for (; __n > 0; --__n, (void)++__first)
*__first = __tmp;
return __first;
}
else
{
for (; __n > 0; --__n, (void)++__first)
*__first = __value;
return __first;
}
}
};

inline constexpr __fill_n_fn fill_n{};

struct __fill_fn
{
template<typename _Tp,
output_iterator<const _Tp&> _Out, sentinel_for<_Out> _Sent>
constexpr _Out
operator()(_Out __first, _Sent __last, const _Tp& __value) const
{

if constexpr (sized_sentinel_for<_Sent, _Out>)

{
const auto __len = __last - __first;
return ranges::fill_n(__first, __len, __value);
}
else if constexpr (is_scalar_v<_Tp>)
{
const auto __tmp = __value;
for (; __first != __last; ++__first)
*__first = __tmp;
return __first;
}
else
{
for (; __first != __last; ++__first)
*__first = __value;
return __first;
}
}

template<typename _Tp, output_range<const _Tp&> _Range>

constexpr borrowed_iterator_t<_Range>
operator()(_Range&& __r, const _Tp& __value) const
{
return (*this)(ranges::begin(__r), ranges::end(__r), __value);
}
};

inline constexpr __fill_fn fill{};

}

}
# 56 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/format" 2 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/unicode.h" 1 3
# 37 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/unicode.h" 3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cstdint" 1 3
# 32 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cstdint" 3

# 33 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cstdint" 3
# 45 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cstdint" 3
# 1 "D:/Enviroments/mingw64_msvcrt/lib/gcc/x86_64-w64-mingw32/14.1.0/include/
stdint.h" 1 3 4
# 9 "D:/Enviroments/mingw64_msvcrt/lib/gcc/x86_64-w64-mingw32/14.1.0/include/
stdint.h" 3 4
# 1 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/stdint.h" 1 3 4
# 32 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/stdint.h" 3 4
# 1 "D:/Enviroments/mingw64_msvcrt/lib/gcc/x86_64-w64-mingw32/14.1.0/include/
stddef.h" 1 3 4
# 1 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/stddef.h" 1 3 4
# 2 "D:/Enviroments/mingw64_msvcrt/lib/gcc/x86_64-w64-mingw32/14.1.0/include/
stddef.h" 2 3 4
# 33 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/stdint.h" 2 3 4

typedef signed char int8_t;

typedef unsigned char uint8_t;
typedef short int16_t;
typedef unsigned short uint16_t;
typedef int int32_t;
typedef unsigned uint32_t;
__extension__ typedef long long int64_t;
__extension__ typedef unsigned long long uint64_t;

typedef signed char int_least8_t;

typedef unsigned char uint_least8_t;
typedef short int_least16_t;
typedef unsigned short uint_least16_t;
typedef int int_least32_t;
typedef unsigned uint_least32_t;
__extension__ typedef long long int_least64_t;
__extension__ typedef unsigned long long uint_least64_t;

typedef signed char int_fast8_t;

typedef unsigned char uint_fast8_t;
typedef short int_fast16_t;
typedef unsigned short uint_fast16_t;
typedef int int_fast32_t;
typedef unsigned int uint_fast32_t;
__extension__ typedef long long int_fast64_t;
__extension__ typedef unsigned long long uint_fast64_t;

extension typedef long long intmax_t;

__extension__ typedef unsigned long long uintmax_t;
# 10 "D:/Enviroments/mingw64_msvcrt/lib/gcc/x86_64-w64-mingw32/14.1.0/include/
stdint.h" 2 3 4
# 46 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cstdint" 2 3

namespace std
{

using ::int8_t;
using ::int16_t;
using ::int32_t;
using ::int64_t;

using ::int_fast8_t;
using ::int_fast16_t;
using ::int_fast32_t;
using ::int_fast64_t;

using ::int_least8_t;
using ::int_least16_t;
using ::int_least32_t;
using ::int_least64_t;

using ::intmax_t;
using ::intptr_t;

using ::uint8_t;
using ::uint16_t;
using ::uint32_t;
using ::uint64_t;

using ::uint_fast8_t;
using ::uint_fast16_t;
using ::uint_fast32_t;
using ::uint_fast64_t;

using ::uint_least8_t;
using ::uint_least16_t;
using ::uint_least32_t;
using ::uint_least64_t;

using ::uintmax_t;
using ::uintptr_t;
# 142 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cstdint" 3
}
# 38 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/unicode.h" 2 3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 1 3
# 59 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/algorithmfwd.h" 1 3
# 33 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/algorithmfwd.h" 3

# 34 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/algorithmfwd.h" 3
# 42 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/algorithmfwd.h" 3
namespace std
{

# 195 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/algorithmfwd.h" 3
template<typename _IIter, typename _Predicate>
constexpr
bool
all_of(_IIter, _IIter, _Predicate);

template<typename _IIter, typename _Predicate>

constexpr
bool
any_of(_IIter, _IIter, _Predicate);

template<typename _FIter, typename _Tp>

constexpr
bool
binary_search(_FIter, _FIter, const _Tp&);

template<typename _FIter, typename _Tp, typename _Compare>

constexpr
bool
binary_search(_FIter, _FIter, const _Tp&, _Compare);

template<typename _Tp>
constexpr
const _Tp&
clamp(const _Tp&, const _Tp&, const _Tp&);

template<typename _Tp, typename _Compare>

constexpr
const _Tp&
clamp(const _Tp&, const _Tp&, const _Tp&, _Compare);

template<typename _IIter, typename _OIter>

constexpr
_OIter
copy(_IIter, _IIter, _OIter);

template<typename _BIter1, typename _BIter2>

constexpr
_BIter2
copy_backward(_BIter1, _BIter1, _BIter2);

template<typename _IIter, typename _OIter, typename _Predicate>

constexpr
_OIter
copy_if(_IIter, _IIter, _OIter, _Predicate);

template<typename _IIter, typename _Size, typename _OIter>

constexpr
_OIter
copy_n(_IIter, _Size, _OIter);

template<typename _FIter, typename _Tp>

constexpr
pair<_FIter, _FIter>
equal_range(_FIter, _FIter, const _Tp&);

template<typename _FIter, typename _Tp, typename _Compare>

constexpr
pair<_FIter, _FIter>
equal_range(_FIter, _FIter, const _Tp&, _Compare);

template<typename _FIter, typename _Tp>

constexpr
void
fill(_FIter, _FIter, const _Tp&);

template<typename _OIter, typename _Size, typename _Tp>

constexpr
_OIter
fill_n(_OIter, _Size, const _Tp&);

template<typename _FIter1, typename _FIter2>

constexpr
_FIter1
find_end(_FIter1, _FIter1, _FIter2, _FIter2);

template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>

constexpr
_FIter1
find_end(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);

template<typename _IIter, typename _Predicate>

constexpr
_IIter
find_if_not(_IIter, _IIter, _Predicate);

template<typename _IIter1, typename _IIter2>

constexpr
bool
includes(_IIter1, _IIter1, _IIter2, _IIter2);

template<typename _IIter1, typename _IIter2, typename _Compare>

constexpr
bool
includes(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);

template<typename _BIter>
void
inplace_merge(_BIter, _BIter, _BIter);

template<typename _BIter, typename _Compare>

void
inplace_merge(_BIter, _BIter, _BIter, _Compare);

template<typename _RAIter>
constexpr
bool
is_heap(_RAIter, _RAIter);

template<typename _RAIter, typename _Compare>

constexpr
bool
is_heap(_RAIter, _RAIter, _Compare);

template<typename _RAIter>
constexpr
_RAIter
is_heap_until(_RAIter, _RAIter);

template<typename _RAIter, typename _Compare>

constexpr
_RAIter
is_heap_until(_RAIter, _RAIter, _Compare);

template<typename _IIter, typename _Predicate>

constexpr
bool
is_partitioned(_IIter, _IIter, _Predicate);

template<typename _FIter1, typename _FIter2>

constexpr
bool
is_permutation(_FIter1, _FIter1, _FIter2);

template<typename _FIter1, typename _FIter2,

typename _BinaryPredicate>
constexpr
bool
is_permutation(_FIter1, _FIter1, _FIter2, _BinaryPredicate);

template<typename _FIter>
constexpr
bool
is_sorted(_FIter, _FIter);

template<typename _FIter, typename _Compare>

constexpr
bool
is_sorted(_FIter, _FIter, _Compare);

template<typename _FIter>
constexpr
_FIter
is_sorted_until(_FIter, _FIter);

template<typename _FIter, typename _Compare>

constexpr
_FIter
is_sorted_until(_FIter, _FIter, _Compare);
template<typename _FIter1, typename _FIter2>
constexpr
void
iter_swap(_FIter1, _FIter2);

template<typename _FIter, typename _Tp>

constexpr
_FIter
lower_bound(_FIter, _FIter, const _Tp&);

template<typename _FIter, typename _Tp, typename _Compare>

constexpr
_FIter
lower_bound(_FIter, _FIter, const _Tp&, _Compare);

template<typename _RAIter>
constexpr
void
make_heap(_RAIter, _RAIter);

template<typename _RAIter, typename _Compare>

constexpr
void
make_heap(_RAIter, _RAIter, _Compare);

template<typename _Tp>
constexpr
const _Tp&
max(const _Tp&, const _Tp&);

template<typename _Tp, typename _Compare>

constexpr
const _Tp&
max(const _Tp&, const _Tp&, _Compare);

template<typename _Tp>
constexpr
const _Tp&
min(const _Tp&, const _Tp&);

template<typename _Tp, typename _Compare>

constexpr
const _Tp&
min(const _Tp&, const _Tp&, _Compare);

template<typename _Tp>
constexpr
pair<const _Tp&, const _Tp&>
minmax(const _Tp&, const _Tp&);

template<typename _Tp, typename _Compare>

constexpr
pair<const _Tp&, const _Tp&>
minmax(const _Tp&, const _Tp&, _Compare);

template<typename _FIter>
constexpr
pair<_FIter, _FIter>
minmax_element(_FIter, _FIter);

template<typename _FIter, typename _Compare>

constexpr
pair<_FIter, _FIter>
minmax_element(_FIter, _FIter, _Compare);

template<typename _Tp>
constexpr
_Tp
min(initializer_list<_Tp>);

template<typename _Tp, typename _Compare>

constexpr
_Tp
min(initializer_list<_Tp>, _Compare);

template<typename _Tp>
constexpr
_Tp
max(initializer_list<_Tp>);

template<typename _Tp, typename _Compare>

constexpr
_Tp
max(initializer_list<_Tp>, _Compare);

template<typename _Tp>
constexpr
pair<_Tp, _Tp>
minmax(initializer_list<_Tp>);

template<typename _Tp, typename _Compare>

constexpr
pair<_Tp, _Tp>
minmax(initializer_list<_Tp>, _Compare);

template<typename _BIter>
constexpr
bool
next_permutation(_BIter, _BIter);

template<typename _BIter, typename _Compare>

constexpr
bool
next_permutation(_BIter, _BIter, _Compare);

template<typename _IIter, typename _Predicate>

constexpr
bool
none_of(_IIter, _IIter, _Predicate);

template<typename _IIter, typename _RAIter>

constexpr
_RAIter
partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter);

template<typename _IIter, typename _RAIter, typename _Compare>

constexpr
_RAIter
partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter, _Compare);

template<typename _IIter, typename _OIter1,

typename _OIter2, typename _Predicate>
constexpr
pair<_OIter1, _OIter2>
partition_copy(_IIter, _IIter, _OIter1, _OIter2, _Predicate);

template<typename _FIter, typename _Predicate>

constexpr
_FIter
partition_point(_FIter, _FIter, _Predicate);

template<typename _RAIter>
constexpr
void
pop_heap(_RAIter, _RAIter);

template<typename _RAIter, typename _Compare>

constexpr
void
pop_heap(_RAIter, _RAIter, _Compare);

template<typename _BIter>
constexpr
bool
prev_permutation(_BIter, _BIter);

template<typename _BIter, typename _Compare>

constexpr
bool
prev_permutation(_BIter, _BIter, _Compare);

template<typename _RAIter>
constexpr
void
push_heap(_RAIter, _RAIter);

template<typename _RAIter, typename _Compare>

constexpr
void
push_heap(_RAIter, _RAIter, _Compare);

template<typename _FIter, typename _Tp>

constexpr
_FIter
remove(_FIter, _FIter, const _Tp&);

template<typename _FIter, typename _Predicate>

constexpr
_FIter
remove_if(_FIter, _FIter, _Predicate);

template<typename _IIter, typename _OIter, typename _Tp>

constexpr
_OIter
remove_copy(_IIter, _IIter, _OIter, const _Tp&);

template<typename _IIter, typename _OIter, typename _Predicate>

constexpr
_OIter
remove_copy_if(_IIter, _IIter, _OIter, _Predicate);

template<typename _IIter, typename _OIter, typename _Tp>

constexpr
_OIter
replace_copy(_IIter, _IIter, _OIter, const _Tp&, const _Tp&);

template<typename _Iter, typename _OIter, typename _Predicate, typename _Tp>

constexpr
_OIter
replace_copy_if(_Iter, _Iter, _OIter, _Predicate, const _Tp&);

template<typename _BIter>
constexpr
void
reverse(_BIter, _BIter);

template<typename _BIter, typename _OIter>

constexpr
_OIter
reverse_copy(_BIter, _BIter, _OIter);

inline namespace _V2 {

template<typename _FIter>
constexpr
_FIter
rotate(_FIter, _FIter, _FIter);

template<typename _FIter, typename _OIter>

constexpr
_OIter
rotate_copy(_FIter, _FIter, _FIter, _OIter);
# 622 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/algorithmfwd.h" 3
template<typename _RAIter, typename _UGenerator>
void
shuffle(_RAIter, _RAIter, _UGenerator&&);

template<typename _RAIter>
constexpr
void
sort_heap(_RAIter, _RAIter);

template<typename _RAIter, typename _Compare>

constexpr
void
sort_heap(_RAIter, _RAIter, _Compare);

template<typename _BIter, typename _Predicate>

_BIter
stable_partition(_BIter, _BIter, _Predicate);
# 657 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/algorithmfwd.h" 3
template<typename _FIter1, typename _FIter2>
constexpr
_FIter2
swap_ranges(_FIter1, _FIter1, _FIter2);

template<typename _FIter>
constexpr
_FIter
unique(_FIter, _FIter);

template<typename _FIter, typename _BinaryPredicate>

constexpr
_FIter
unique(_FIter, _FIter, _BinaryPredicate);

template<typename _FIter, typename _Tp>

constexpr
_FIter
upper_bound(_FIter, _FIter, const _Tp&);

template<typename _FIter, typename _Tp, typename _Compare>

constexpr
_FIter
upper_bound(_FIter, _FIter, const _Tp&, _Compare);

template<typename _FIter>
constexpr
_FIter
adjacent_find(_FIter, _FIter);
template<typename _FIter, typename _BinaryPredicate>
constexpr
_FIter
adjacent_find(_FIter, _FIter, _BinaryPredicate);

template<typename _IIter, typename _Tp>

constexpr
typename iterator_traits<_IIter>::difference_type
count(_IIter, _IIter, const _Tp&);

template<typename _IIter, typename _Predicate>

constexpr
typename iterator_traits<_IIter>::difference_type
count_if(_IIter, _IIter, _Predicate);

template<typename _IIter1, typename _IIter2>

constexpr
bool
equal(_IIter1, _IIter1, _IIter2);

template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>

constexpr
bool
equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate);

template<typename _IIter, typename _Tp>

constexpr
_IIter
find(_IIter, _IIter, const _Tp&);

template<typename _FIter1, typename _FIter2>

constexpr
_FIter1
find_first_of(_FIter1, _FIter1, _FIter2, _FIter2);

template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>

constexpr
_FIter1
find_first_of(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);

template<typename _IIter, typename _Predicate>

constexpr
_IIter
find_if(_IIter, _IIter, _Predicate);

template<typename _IIter, typename _Funct>

constexpr
_Funct
for_each(_IIter, _IIter, _Funct);

template<typename _FIter, typename _Generator>

constexpr
void
generate(_FIter, _FIter, _Generator);

template<typename _OIter, typename _Size, typename _Generator>

constexpr
_OIter
generate_n(_OIter, _Size, _Generator);

template<typename _IIter1, typename _IIter2>

constexpr
bool
lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2);

template<typename _IIter1, typename _IIter2, typename _Compare>

constexpr
bool
lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);

template<typename _FIter>
constexpr
_FIter
max_element(_FIter, _FIter);

template<typename _FIter, typename _Compare>

constexpr
_FIter
max_element(_FIter, _FIter, _Compare);

template<typename _IIter1, typename _IIter2, typename _OIter>

constexpr
_OIter
merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);

template<typename _IIter1, typename _IIter2, typename _OIter,

typename _Compare>
constexpr
_OIter
merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);

template<typename _FIter>
constexpr
_FIter
min_element(_FIter, _FIter);

template<typename _FIter, typename _Compare>

constexpr
_FIter
min_element(_FIter, _FIter, _Compare);

template<typename _IIter1, typename _IIter2>

constexpr
pair<_IIter1, _IIter2>
mismatch(_IIter1, _IIter1, _IIter2);

template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>

constexpr
pair<_IIter1, _IIter2>
mismatch(_IIter1, _IIter1, _IIter2, _BinaryPredicate);

template<typename _RAIter>
constexpr
void
nth_element(_RAIter, _RAIter, _RAIter);

template<typename _RAIter, typename _Compare>

constexpr
void
nth_element(_RAIter, _RAIter, _RAIter, _Compare);

template<typename _RAIter>
constexpr
void
partial_sort(_RAIter, _RAIter, _RAIter);

template<typename _RAIter, typename _Compare>

constexpr
void
partial_sort(_RAIter, _RAIter, _RAIter, _Compare);

template<typename _BIter, typename _Predicate>

constexpr
_BIter
partition(_BIter, _BIter, _Predicate);

template<typename _RAIter>
__attribute__ ((__deprecated__ ("use '" "std::shuffle" "' instead")))
void
random_shuffle(_RAIter, _RAIter);

template<typename _RAIter, typename _Generator>

__attribute__ ((__deprecated__ ("use '" "std::shuffle" "' instead")))
void
random_shuffle(_RAIter, _RAIter,

_Generator&&);

template<typename _FIter, typename _Tp>

constexpr
void
replace(_FIter, _FIter, const _Tp&, const _Tp&);

template<typename _FIter, typename _Predicate, typename _Tp>

constexpr
void
replace_if(_FIter, _FIter, _Predicate, const _Tp&);

template<typename _FIter1, typename _FIter2>

constexpr
_FIter1
search(_FIter1, _FIter1, _FIter2, _FIter2);

template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>

constexpr
_FIter1
search(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);

template<typename _FIter, typename _Size, typename _Tp>

constexpr
_FIter
search_n(_FIter, _FIter, _Size, const _Tp&);

template<typename _FIter, typename _Size, typename _Tp,

typename _BinaryPredicate>
constexpr
_FIter
search_n(_FIter, _FIter, _Size, const _Tp&, _BinaryPredicate);

template<typename _IIter1, typename _IIter2, typename _OIter>

constexpr
_OIter
set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);

template<typename _IIter1, typename _IIter2, typename _OIter,

typename _Compare>
constexpr
_OIter
set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);

template<typename _IIter1, typename _IIter2, typename _OIter>

constexpr
_OIter
set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);

template<typename _IIter1, typename _IIter2, typename _OIter,

typename _Compare>
constexpr
_OIter
set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);

template<typename _IIter1, typename _IIter2, typename _OIter>

constexpr
_OIter
set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);

template<typename _IIter1, typename _IIter2, typename _OIter,

typename _Compare>
constexpr
_OIter
set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2,
_OIter, _Compare);

template<typename _IIter1, typename _IIter2, typename _OIter>

constexpr
_OIter
set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);

template<typename _IIter1, typename _IIter2, typename _OIter,

typename _Compare>
constexpr
_OIter
set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);

template<typename _RAIter>
constexpr
void
sort(_RAIter, _RAIter);

template<typename _RAIter, typename _Compare>

constexpr
void
sort(_RAIter, _RAIter, _Compare);

template<typename _RAIter>
void
stable_sort(_RAIter, _RAIter);

template<typename _RAIter, typename _Compare>

void
stable_sort(_RAIter, _RAIter, _Compare);

template<typename _IIter, typename _OIter, typename _UnaryOperation>

constexpr
_OIter
transform(_IIter, _IIter, _OIter, _UnaryOperation);

template<typename _IIter1, typename _IIter2, typename _OIter,

typename _BinaryOperation>
constexpr
_OIter
transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation);

template<typename _IIter, typename _OIter>

constexpr
_OIter
unique_copy(_IIter, _IIter, _OIter);

template<typename _IIter, typename _OIter, typename _BinaryPredicate>

constexpr
_OIter
unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate);

}
# 60 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 2 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_heap.h" 1 3
# 63 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_heap.h" 3
namespace std
{

template<typename _RandomAccessIterator, typename _Distance,

typename _Compare>
constexpr
_Distance
__is_heap_until(_RandomAccessIterator __first, _Distance __n,
_Compare& __comp)
{
_Distance __parent = 0;
for (_Distance __child = 1; __child < __n; ++__child)
{
if (__comp(__first + __parent, __first + __child))
return __child;
if ((__child & 1) == 0)
++__parent;
}
return __n;
}

template<typename _RandomAccessIterator, typename _Distance>

constexpr
inline bool
__is_heap(_RandomAccessIterator __first, _Distance __n)
{
__gnu_cxx::__ops::_Iter_less_iter __comp;
return std::__is_heap_until(__first, __n, __comp) == __n;
}

template<typename _RandomAccessIterator, typename _Compare,

typename _Distance>
constexpr
inline bool
__is_heap(_RandomAccessIterator __first, _Compare __comp, _Distance __n)
{
typedef __decltype(__comp) _Cmp;
__gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(std::move(__comp));
return std::__is_heap_until(__first, __n, __cmp) == __n;
}

template<typename _RandomAccessIterator>
constexpr
inline bool
__is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
{ return std::__is_heap(__first, std::distance(__first, __last)); }

template<typename _RandomAccessIterator, typename _Compare>

constexpr
inline bool
__is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
{
return std::__is_heap(__first, std::move(__comp),
std::distance(__first, __last));
}

template<typename _RandomAccessIterator, typename _Distance, typename _Tp,

typename _Compare>
constexpr
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 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_heap.h" 3
template<typename _RandomAccessIterator>
constexpr
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 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_heap.h" 3
template<typename _RandomAccessIterator, typename _Compare>
constexpr
inline void
push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
{
typedef typename iterator_traits<_RandomAccessIterator>::value_type
_ValueType;
typedef typename iterator_traits<_RandomAccessIterator>::difference_type
_DistanceType;

;
;
;

__decltype(__gnu_cxx::__ops::__iter_comp_val(std::move(__comp)))
__cmp(std::move(__comp));
_ValueType __value = std::move(*(__last - 1));
std::__push_heap(__first, _DistanceType((__last - __first) - 1),
_DistanceType(0), std::move(__value), __cmp);
}

template<typename _RandomAccessIterator, typename _Distance,

typename _Tp, typename _Compare>
constexpr
void
__adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
_Distance __len, _Tp __value, _Compare __comp)
{
const _Distance __topIndex = __holeIndex;
_Distance __secondChild = __holeIndex;
while (__secondChild < (__len - 1) / 2)
{
__secondChild = 2 * (__secondChild + 1);
if (__comp(__first + __secondChild,
__first + (__secondChild - 1)))
__secondChild--;
*(__first + __holeIndex) = std::move(*(__first + __secondChild));
__holeIndex = __secondChild;
}
if ((__len & 1) == 0 && __secondChild == (__len - 2) / 2)
{
__secondChild = 2 * (__secondChild + 1);
*(__first + __holeIndex) = std::move(*(__first + (__secondChild - 1)))
;
__holeIndex = __secondChild - 1;
}
__decltype(__gnu_cxx::__ops::__iter_comp_val(std::move(__comp)))
__cmp(std::move(__comp));
std::__push_heap(__first, __holeIndex, __topIndex,
std::move(__value), __cmp);
}

template<typename _RandomAccessIterator, typename _Compare>

constexpr
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 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_heap.h" 3
template<typename _RandomAccessIterator>
constexpr
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 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_heap.h" 3
template<typename _RandomAccessIterator, typename _Compare>
constexpr
inline void
pop_heap(_RandomAccessIterator __first,
_RandomAccessIterator __last, _Compare __comp)
{

;
;
;
;

if (last - first > 1)

{
typedef __decltype(__comp) _Cmp;
__gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(std::move(__comp));
--__last;
std::__pop_heap(__first, __last, __last, __cmp);
}
}

template<typename _RandomAccessIterator, typename _Compare>

constexpr
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 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_heap.h" 3
template<typename _RandomAccessIterator>
constexpr
inline void
make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
{

;
;

__gnu_cxx::__ops::_Iter_less_iter __comp;
std::__make_heap(__first, __last, __comp);
}
# 399 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_heap.h" 3
template<typename _RandomAccessIterator, typename _Compare>
constexpr
inline void
make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
{

;
;

typedef decltype(comp) _Cmp;

__gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(std::move(__comp));
std::__make_heap(__first, __last, __cmp);
}

template<typename _RandomAccessIterator, typename _Compare>

constexpr
void
__sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare& __comp)
{
while (__last - __first > 1)
{
--__last;
std::__pop_heap(__first, __last, __last, __comp);
}
}
# 437 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_heap.h" 3
template<typename _RandomAccessIterator>
constexpr
inline void
sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
{
;
;
;

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<typename _UniformRandomBitGenerator>
result_type
operator()(_UniformRandomBitGenerator& __urng)
{ return this->operator()(__urng, _M_param); }

template<typename _UniformRandomBitGenerator>
result_type
operator()(_UniformRandomBitGenerator& __urng,
const param_type& __p);

template<typename _ForwardIterator,
typename _UniformRandomBitGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomBitGenerator& __urng)
{ this->__generate(__f, __t, __urng, _M_param); }

template<typename _ForwardIterator,
typename _UniformRandomBitGenerator>
void
__generate(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomBitGenerator& __urng,
const param_type& __p)
{ this->__generate_impl(__f, __t, __urng, __p); }

template<typename _UniformRandomBitGenerator>
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<typename _ForwardIterator,
typename _UniformRandomBitGenerator>
void
__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
_UniformRandomBitGenerator& __urng,
const param_type& __p);

param_type _M_param;

template<typename _Wp, typename _Urbg, typename _Up>

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<typename _IntType>
template<typename _UniformRandomBitGenerator>
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<result_type>::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 == 0xffffffffffffffffULL)

{
long long unsigned int __u64erange = __uerange;
__ret = __extension__ _S_nd<unsigned __int128>(__urng,
__u64erange);
}
else

if constexpr (__urngrange == 0xffffffffU)

{

unsigned int u32erange = uerange;

__ret = _S_nd<long long unsigned int>(__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 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/uniform_int_dist.h" 3
__uctype __tmp;
do
{
const __uctype __uerngrange = __urngrange + 1;
__tmp = (__uerngrange * operator()
(__urng, param_type(0, __urange / __uerngrange)));
__ret = __tmp + (__uctype(__urng()) - __urngmin);
}
while (__ret > __urange || __ret < __tmp);
}
else
__ret = __uctype(__urng()) - __urngmin;

return ret + param.a();

}

template<typename _IntType>
template<typename _ForwardIterator,
typename _UniformRandomBitGenerator>
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<result_type>::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 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/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 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 2 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_tempbuf.h" 1 3
# 65 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_tempbuf.h" 3
namespace std
{

namespace __detail
{
template<typename _Tp>
inline void
__return_temporary_buffer(_Tp* __p,
size_t __len __attribute__((__unused__)))
{

::operator delete(p, len * sizeof(_Tp));

}
}
# 101 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_tempbuf.h" 3
template<typename _Tp>
[[__deprecated__]]
pair<_Tp*, ptrdiff_t>
get_temporary_buffer(ptrdiff_t __len) noexcept
{
const ptrdiff_t __max =
__gnu_cxx::__numeric_traits<ptrdiff_t>::__max / sizeof(_Tp);
if (__len > __max)
__len = __max;

while (__len > 0)

{
_Tp* __tmp = static_cast<_Tp*>(::operator new(__len * sizeof(_Tp),
std::nothrow));
if (__tmp != 0)
return std::pair<_Tp*, ptrdiff_t>(__tmp, __len);
__len = __len == 1 ? 0 : ((__len + 1) / 2);
}
return std::pair<_Tp*, ptrdiff_t>(static_cast<_Tp*>(0), 0);
}
# 129 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_tempbuf.h" 3
template<typename _Tp>
inline void
return_temporary_buffer(_Tp* __p)
{ ::operator delete(__p); }
template<typename _ForwardIterator, typename _Tp>
class _Temporary_buffer
{

public:
typedef _Tp value_type;
typedef value_type* pointer;
typedef pointer iterator;
typedef ptrdiff_t size_type;

protected:
size_type _M_original_len;
size_type _M_len;
pointer _M_buffer;

public:

size_type
size() const
{ return _M_len; }

size_type
requested_size() const
{ return _M_original_len; }

iterator
begin()
{ return _M_buffer; }

iterator
end()
{ return _M_buffer + _M_len; }

_Temporary_buffer(_ForwardIterator __seed, size_type __original_len);

~_Temporary_buffer()
{
std::_Destroy(_M_buffer, _M_buffer + _M_len);
std::__detail::__return_temporary_buffer(_M_buffer, _M_len);
}

private:

_Temporary_buffer(const _Temporary_buffer&);

void
operator=(const _Temporary_buffer&);
};
template<bool>
struct __uninitialized_construct_buf_dispatch
{
template<typename _Pointer, typename _ForwardIterator>
static void
__ucr(_Pointer __first, _Pointer __last,
_ForwardIterator __seed)
{
if (__first == __last)
return;

_Pointer cur = first;

try
{
std::_Construct(std::__addressof(*__first),
std::move(*__seed));
_Pointer __prev = __cur;
++__cur;
for(; __cur != __last; ++__cur, ++__prev)
std::_Construct(std::__addressof(*__cur),
std::move(*__prev));
*__seed = std::move(*__prev);
}
catch(...)
{
std::_Destroy(__first, __cur);
throw;
}
}
};

template<>
struct __uninitialized_construct_buf_dispatch<true>
{
template<typename _Pointer, typename _ForwardIterator>
static void
__ucr(_Pointer, _Pointer, _ForwardIterator) { }
};
# 247 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_tempbuf.h" 3
template<typename _Pointer, typename _ForwardIterator>
inline void
__uninitialized_construct_buf(_Pointer __first, _Pointer __last,
_ForwardIterator __seed)
{
typedef typename std::iterator_traits<_Pointer>::value_type
_ValueType;

std::__uninitialized_construct_buf_dispatch<
__has_trivial_constructor(_ValueType)>::
__ucr(__first, __last, __seed);
}

#pragma GCC diagnostic push

#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
template<typename _ForwardIterator, typename _Tp>
_Temporary_buffer<_ForwardIterator, _Tp>::
_Temporary_buffer(_ForwardIterator __seed, size_type __original_len)
: _M_original_len(__original_len), _M_len(0), _M_buffer(0)
{
std::pair<pointer, size_type> __p(
std::get_temporary_buffer<value_type>(_M_original_len));

if (__p.first)
{
try
{
std::__uninitialized_construct_buf(__p.first, __p.first + __p.second,
__seed);
_M_buffer = __p.first;
_M_len = __p.second;
}
catch(...)
{
std::__detail::__return_temporary_buffer(__p.first, __p.second);
throw;
}
}
}
#pragma GCC diagnostic pop

}
# 70 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 2 3

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cstdlib" 1 3
# 39 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cstdlib" 3

# 40 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cstdlib" 3
# 72 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 2 3

namespace std
{

template<typename _Iterator, typename _Compare>

constexpr
void
__move_median_to_first(_Iterator __result,_Iterator __a, _Iterator __b,
_Iterator __c, _Compare __comp)
{
if (__comp(__a, __b))
{
if (__comp(__b, __c))
std::iter_swap(__result, __b);
else if (__comp(__a, __c))
std::iter_swap(__result, __c);
else
std::iter_swap(__result, __a);
}
else if (__comp(__a, __c))
std::iter_swap(__result, __a);
else if (__comp(__b, __c))
std::iter_swap(__result, __c);
else
std::iter_swap(__result, __b);
}

template<typename _InputIterator, typename _Predicate>

constexpr
inline _InputIterator
__find_if_not(_InputIterator __first, _InputIterator __last,
_Predicate __pred)
{
return std::__find_if(__first, __last,
__gnu_cxx::__ops::__negate(__pred),
std::__iterator_category(__first));
}

template<typename _InputIterator, typename _Predicate, typename _Distance>

constexpr
_InputIterator
__find_if_not_n(_InputIterator __first, _Distance& __len, _Predicate __pred)
{
for (; __len; --__len, (void) ++__first)
if (!__pred(__first))
break;
return __first;
}
# 148 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _ForwardIterator, typename _Integer,
typename _UnaryPredicate>
constexpr
_ForwardIterator
__search_n_aux(_ForwardIterator __first, _ForwardIterator __last,
_Integer __count, _UnaryPredicate __unary_pred,
std::forward_iterator_tag)
{
__first = std::__find_if(__first, __last, __unary_pred);
while (__first != __last)
{
typename iterator_traits<_ForwardIterator>::difference_type
__n = __count;
_ForwardIterator __i = __first;
++__i;
while (__i != __last && __n != 1 && __unary_pred(__i))
{
++__i;
--__n;
}
if (__n == 1)
return __first;
if (__i == __last)
return __last;
__first = std::__find_if(++__i, __last, __unary_pred);
}
return __last;
}

template<typename _RandomAccessIter, typename _Integer,

typename _UnaryPredicate>
constexpr
_RandomAccessIter
__search_n_aux(_RandomAccessIter __first, _RandomAccessIter __last,
_Integer __count, _UnaryPredicate __unary_pred,
std::random_access_iterator_tag)
{
typedef typename std::iterator_traits<_RandomAccessIter>::difference_type
_DistanceType;

_DistanceType tailSize = last - __first;

_DistanceType __remainder = __count;

while (remainder <= tailSize)

{
__first += __remainder;
__tailSize -= __remainder;

_RandomAccessIter backTrack = first;

while (__unary_pred(--__backTrack))
{
if (--__remainder == 0)
return (__first - __count);
}
__remainder = __count + 1 - (__first - __backTrack);
}
return __last;
}

template<typename _ForwardIterator, typename _Integer,

typename _UnaryPredicate>
constexpr
_ForwardIterator
__search_n(_ForwardIterator __first, _ForwardIterator __last,
_Integer __count,
_UnaryPredicate __unary_pred)
{
if (__count <= 0)
return __first;

if (__count == 1)
return std::__find_if(__first, __last, __unary_pred);

return std::__search_n_aux(first, last, count, unary_pred,

std::__iterator_category(__first));
}

template<typename _ForwardIterator1, typename _ForwardIterator2,

typename _BinaryPredicate>
constexpr
_ForwardIterator1
__find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2,
forward_iterator_tag, forward_iterator_tag,
_BinaryPredicate __comp)
{
if (__first2 == __last2)
return __last1;

_ForwardIterator1 result = last1;

while (1)
{
_ForwardIterator1 __new_result
= std::__search(__first1, __last1, __first2, __last2, __comp);
if (__new_result == __last1)
return __result;
else
{
__result = __new_result;
__first1 = __new_result;
++__first1;
}
}
}

template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,

typename _BinaryPredicate>
constexpr
_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;
}
}
# 322 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _ForwardIterator1, typename _ForwardIterator2>
[[__nodiscard__]] constexpr
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());
}
# 371 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _ForwardIterator1, typename _ForwardIterator2,
typename _BinaryPredicate>
[[__nodiscard__]] constexpr
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));
}
# 407 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _InputIterator, typename _Predicate>
[[__nodiscard__]] constexpr
inline bool
all_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
{ return __last == std::find_if_not(__first, __last, __pred); }
# 425 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _InputIterator, typename _Predicate>
[[__nodiscard__]] constexpr
inline bool
none_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
{ return __last == std::find_if(__first, __last, __pred); }
# 444 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _InputIterator, typename _Predicate>
[[__nodiscard__]] constexpr
inline bool
any_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
{ return !std::none_of(__first, __last, __pred); }
# 460 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _InputIterator, typename _Predicate>
[[__nodiscard__]] constexpr
inline _InputIterator
find_if_not(_InputIterator __first, _InputIterator __last,
_Predicate __pred)
{

;
return std::__find_if_not(__first, __last,
__gnu_cxx::__ops::__pred_iter(__pred));
}
# 485 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _InputIterator, typename _Predicate>
[[__nodiscard__]] constexpr
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);
}
# 507 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _ForwardIterator, typename _Predicate>
[[__nodiscard__]] constexpr
_ForwardIterator
partition_point(_ForwardIterator __first, _ForwardIterator __last,
_Predicate __pred)
{

typedef typename iterator_traits<_ForwardIterator>::difference_type

_DistanceType;

_DistanceType len = std::distance(first, __last);

while (__len > 0)

{
_DistanceType __half = __len >> 1;
_ForwardIterator __middle = __first;
std::advance(__middle, __half);
if (__pred(*__middle))
{
__first = __middle;
++__first;
__len = __len - __half - 1;
}
else
__len = __half;
}
return __first;
}

template<typename _InputIterator, typename _OutputIterator,

typename _Predicate>
constexpr
_OutputIterator
__remove_copy_if(_InputIterator __first, _InputIterator __last,
_OutputIterator __result, _Predicate __pred)
{
for (; __first != __last; ++__first)
if (!__pred(__first))
{
*__result = *__first;
++__result;
}
return __result;
}
# 574 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _InputIterator, typename _OutputIterator, typename _Tp>
constexpr
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));
}
# 607 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _InputIterator, typename _OutputIterator,
typename _Predicate>
constexpr
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));
}
# 642 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _InputIterator, typename _OutputIterator,
typename _Predicate>
constexpr
_OutputIterator
copy_if(_InputIterator __first, _InputIterator __last,
_OutputIterator __result, _Predicate __pred)
{

for (; first != last; ++__first)

if (__pred(*__first))
{
*__result = *__first;
++__result;
}
return __result;
}

template<typename _InputIterator, typename _Size, typename _OutputIterator>

constexpr
_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<typename _RandomAccessIterator, typename _Size,

typename _OutputIterator>
constexpr
inline _OutputIterator
__copy_n(_RandomAccessIterator __first, _Size __n,
_OutputIterator __result, random_access_iterator_tag)
{ return std::copy(__first, __first + __n, __result); }
# 698 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _InputIterator, typename _Size, typename _OutputIterator>
constexpr
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));
}
# 734 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _InputIterator, typename _OutputIterator1,
typename _OutputIterator2, typename _Predicate>
constexpr
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);

}
# 785 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _ForwardIterator, typename _Tp>
[[__nodiscard__]] constexpr
inline _ForwardIterator
remove(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __value)
{

return std::__remove_if(first, last,

__gnu_cxx::__ops::__iter_equals_val(__value));
}
# 819 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _ForwardIterator, typename _Predicate>
[[__nodiscard__]] constexpr
inline _ForwardIterator
remove_if(_ForwardIterator __first, _ForwardIterator __last,
_Predicate __pred)
{

return std::__remove_if(first, last,

__gnu_cxx::__ops::__pred_iter(__pred));
}

template<typename _ForwardIterator, typename _BinaryPredicate>

constexpr
_ForwardIterator
__adjacent_find(_ForwardIterator __first, _ForwardIterator __last,
_BinaryPredicate __binary_pred)
{
if (__first == __last)
return __last;
_ForwardIterator __next = __first;
while (++__next != __last)
{
if (__binary_pred(__first, __next))
return __first;
__first = __next;
}
return __last;
}

template<typename _ForwardIterator, typename _BinaryPredicate>

constexpr
_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;
}
# 888 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _ForwardIterator>
[[__nodiscard__]] constexpr
inline _ForwardIterator
unique(_ForwardIterator __first, _ForwardIterator __last)
{

return std::unique(first, __last,

__gnu_cxx::__ops::__iter_equal_to_iter());
}
# 919 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _ForwardIterator, typename _BinaryPredicate>
[[__nodiscard__]] constexpr
inline _ForwardIterator
unique(_ForwardIterator __first, _ForwardIterator __last,
_BinaryPredicate __binary_pred)
{

return std::unique(first, __last,

__gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
}

template<typename _ForwardIterator, typename _OutputIterator,

typename _BinaryPredicate>
constexpr
_OutputIterator
__unique_copy(_ForwardIterator __first, _ForwardIterator __last,
_OutputIterator __result, _BinaryPredicate __binary_pred,
forward_iterator_tag, output_iterator_tag)
{

_ForwardIterator next = first;

*__result = *__first;
while (++__next != __last)
if (!__binary_pred(__first, __next))
{
__first = __next;
*++__result = *__first;
}
return ++__result;
}

template<typename _InputIterator, typename _OutputIterator,

typename _BinaryPredicate>
constexpr
_OutputIterator
__unique_copy(_InputIterator __first, _InputIterator __last,
_OutputIterator __result, _BinaryPredicate __binary_pred,
input_iterator_tag, output_iterator_tag)
{

typename iterator_traits<_InputIterator>::value_type value = *first;

__decltype(__gnu_cxx::__ops::__iter_comp_val(__binary_pred))
__rebound_pred
= __gnu_cxx::__ops::__iter_comp_val(__binary_pred);
*__result = __value;
while (++__first != __last)
if (!__rebound_pred(__first, __value))
{
__value = *__first;
*++__result = __value;
}
return ++__result;
}

template<typename _InputIterator, typename _ForwardIterator,

typename _BinaryPredicate>
constexpr
_ForwardIterator
__unique_copy(_InputIterator __first, _InputIterator __last,
_ForwardIterator __result, _BinaryPredicate __binary_pred,
input_iterator_tag, forward_iterator_tag)
{

*__result = *__first;
while (++__first != __last)
if (!__binary_pred(__result, __first))
*++__result = *__first;
return ++__result;
}

template<typename _BidirectionalIterator>
constexpr
void
__reverse(_BidirectionalIterator __first, _BidirectionalIterator __last,
bidirectional_iterator_tag)
{
while (true)
if (__first == __last || __first == --__last)
return;
else
{
std::iter_swap(__first, __last);
++__first;
}
}

template<typename _RandomAccessIterator>
constexpr
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;
}
}
# 1080 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _BidirectionalIterator>
constexpr
inline void
reverse(_BidirectionalIterator __first, _BidirectionalIterator __last)
{

;
std::__reverse(__first, __last, std::__iterator_category(__first));
}
# 1108 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _BidirectionalIterator, typename _OutputIterator>
constexpr
_OutputIterator
reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last,
_OutputIterator __result)
{

while (first != last)

{
--__last;
*__result = *__last;
++__result;
}
return __result;
}

template<typename _EuclideanRingElement>
constexpr
_EuclideanRingElement
__gcd(_EuclideanRingElement __m, _EuclideanRingElement __n)
{
while (__n != 0)
{
_EuclideanRingElement __t = __m % __n;
__m = __n;
__n = __t;
}
return __m;
}

inline namespace _V2 {

template<typename _ForwardIterator>
constexpr
_ForwardIterator
__rotate(_ForwardIterator __first,
_ForwardIterator __middle,
_ForwardIterator __last,
forward_iterator_tag)
{
if (__first == __middle)
return __last;
else if (__last == __middle)
return __first;

_ForwardIterator first2 = middle;

do
{
std::iter_swap(__first, __first2);
++__first;
++__first2;
if (__first == __middle)
__middle = __first2;
}
while (__first2 != __last);

_ForwardIterator ret = first;

__first2 = __middle;

while (first2 != last)

{
std::iter_swap(__first, __first2);
++__first;
++__first2;
if (__first == __middle)
__middle = __first2;
else if (__first2 == __last)
__first2 = __middle;
}
return __ret;
}

template<typename _BidirectionalIterator>
constexpr
_BidirectionalIterator
__rotate(_BidirectionalIterator __first,
_BidirectionalIterator __middle,
_BidirectionalIterator __last,
bidirectional_iterator_tag)
{

if (__first == __middle)
return __last;
else if (__last == __middle)
return __first;

std::reverse(first, __middle, bidirectional_iterator_tag());

std::__reverse(__middle, __last, bidirectional_iterator_tag());

while (first != middle && middle != last)

{
std::iter_swap(__first, --__last);
++__first;
}

if (__first == __middle)
{
std::__reverse(__middle, __last, bidirectional_iterator_tag());
return __last;
}
else
{
std::__reverse(__first, __middle, bidirectional_iterator_tag());
return __first;
}
}

template<typename _RandomAccessIterator>
constexpr
_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;

typedef typename make_unsigned<_Distance>::type _UDistance;

_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 = static_cast<_UDistance>(__n) % static_cast<_UDistance>(__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 = static_cast<_UDistance>(__n) % static_cast<_UDistance>(__k);
if (__n == 0)
return __ret;
std::swap(__n, __k);
}
}
}
# 1345 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _ForwardIterator>
constexpr
inline _ForwardIterator
rotate(_ForwardIterator __first, _ForwardIterator __middle,
_ForwardIterator __last)
{

;
;

return std::rotate(first, middle, last,

std::__iterator_category(__first));
}

}
# 1383 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _ForwardIterator, typename _OutputIterator>
constexpr
inline _OutputIterator
rotate_copy(_ForwardIterator __first, _ForwardIterator __middle,
_ForwardIterator __last, _OutputIterator __result)
{
;
;

return std::copy(first, middle,

std::copy(__middle, __last, __result));
}

template<typename _ForwardIterator, typename _Predicate>

constexpr
_ForwardIterator
__partition(_ForwardIterator __first, _ForwardIterator __last,
_Predicate __pred, forward_iterator_tag)
{
if (__first == __last)
return __first;

while (__pred(*__first))
if (++__first == __last)
return __first;

_ForwardIterator next = first;

while (++next != last)

if (__pred(*__next))
{
std::iter_swap(__first, __next);
++__first;
}

return __first;
}

template<typename _BidirectionalIterator, typename _Predicate>

constexpr
_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;
}
}
# 1464 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _ForwardIterator, typename _Pointer, typename _Predicate,
typename _Distance>
_ForwardIterator
__stable_partition_adaptive(_ForwardIterator __first,
_ForwardIterator __last,
_Predicate __pred, _Distance __len,
_Pointer __buffer,
_Distance __buffer_size)
{
if (__len == 1)
return __first;

if (len <= buffer_size)

{
_ForwardIterator __result1 = __first;
_Pointer __result2 = __buffer;

*__result2 = std::move(*__first);
++__result2;
++__first;
for (; __first != __last; ++__first)
if (__pred(__first))
{
*__result1 = std::move(*__first);
++__result1;
}
else
{
*__result2 = std::move(*__first);
++__result2;
}

std::move(buffer, result2, __result1);

return __result1;
}

_ForwardIterator middle = first;

std::advance(__middle, __len / 2);
_ForwardIterator __left_split =
std::__stable_partition_adaptive(__first, __middle, __pred,
__len / 2, __buffer,
__buffer_size);

_Distance __right_len = len - len / 2;

_ForwardIterator __right_split =
std::__find_if_not_n(__middle, __right_len, __pred);
if (__right_len)
__right_split =
std::__stable_partition_adaptive(__right_split, __last, __pred,
__right_len,
__buffer, __buffer_size);

return std::rotate(__left_split, middle, right_split);

}

template<typename _ForwardIterator, typename _Predicate>

_ForwardIterator
__stable_partition(_ForwardIterator __first, _ForwardIterator __last,
_Predicate __pred)
{
__first = std::__find_if_not(__first, __last, __pred);

if (__first == __last)
return __first;

typedef typename iterator_traits<_ForwardIterator>::value_type

_ValueType;
typedef typename iterator_traits<_ForwardIterator>::difference_type
_DistanceType;

_Temporary_buffer<_ForwardIterator, _ValueType>
__buf(__first, std::distance(__first, __last));
return
std::__stable_partition_adaptive(__first, __last, __pred,
_DistanceType(__buf.requested_size()),
__buf.begin(),
_DistanceType(__buf.size()));
}
# 1566 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _ForwardIterator, typename _Predicate>
inline _ForwardIterator
stable_partition(_ForwardIterator __first, _ForwardIterator __last,
_Predicate __pred)
{

return std::__stable_partition(first, last,

__gnu_cxx::__ops::__pred_iter(__pred));
}

template<typename _RandomAccessIterator, typename _Compare>

constexpr
void
__heap_select(_RandomAccessIterator __first,
_RandomAccessIterator __middle,
_RandomAccessIterator __last, _Compare __comp)
{
std::__make_heap(__first, __middle, __comp);
for (_RandomAccessIterator __i = __middle; __i < __last; ++__i)
if (__comp(__i, __first))
std::__pop_heap(__first, __middle, __i, __comp);
}

template<typename _InputIterator, typename _RandomAccessIterator,

typename _Compare>
constexpr
_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;
}
# 1659 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _InputIterator, typename _RandomAccessIterator>
constexpr
inline _RandomAccessIterator
partial_sort_copy(_InputIterator __first, _InputIterator __last,
_RandomAccessIterator __result_first,
_RandomAccessIterator __result_last)
{
# 1674 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
;
;
;

return std::__partial_sort_copy(first, last,

__result_first, __result_last,
__gnu_cxx::__ops::__iter_less_iter());
}
# 1709 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _InputIterator, typename _RandomAccessIterator,
typename _Compare>
constexpr
inline _RandomAccessIterator
partial_sort_copy(_InputIterator __first, _InputIterator __last,
_RandomAccessIterator __result_first,
_RandomAccessIterator __result_last,
_Compare __comp)
{
# 1726 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3

;
;
;

return std::__partial_sort_copy(first, last,

__result_first, __result_last,
__gnu_cxx::__ops::__iter_comp_iter(__comp));
}

template<typename _RandomAccessIterator, typename _Compare>

constexpr
void
__unguarded_linear_insert(_RandomAccessIterator __last,
_Compare __comp)
{
typename iterator_traits<_RandomAccessIterator>::value_type
__val = std::move(*__last);
_RandomAccessIterator __next = __last;
--__next;
while (__comp(__val, __next))
{
*__last = std::move(*__next);
__last = __next;
--__next;
}
*__last = std::move(__val);
}

template<typename _RandomAccessIterator, typename _Compare>

constexpr
void
__insertion_sort(_RandomAccessIterator __first,
_RandomAccessIterator __last, _Compare __comp)
{
if (__first == __last) return;

for (_RandomAccessIterator i = first + 1; i != last; ++__i)

{
if (__comp(__i, __first))
{
typename iterator_traits<_RandomAccessIterator>::value_type
__val = std::move(*__i);
std::move_backward(__first, __i, __i + 1);
*__first = std::move(__val);
}
else
std::__unguarded_linear_insert(__i,
__gnu_cxx::__ops::__val_comp_iter(__comp));
}
}

template<typename _RandomAccessIterator, typename _Compare>

constexpr
inline void
__unguarded_insertion_sort(_RandomAccessIterator __first,
_RandomAccessIterator __last, _Compare __comp)
{
for (_RandomAccessIterator __i = __first; __i != __last; ++__i)
std::__unguarded_linear_insert(__i,
__gnu_cxx::__ops::__val_comp_iter(__comp));
}

enum { _S_threshold = 16 };

template<typename _RandomAccessIterator, typename _Compare>

constexpr
void
__final_insertion_sort(_RandomAccessIterator __first,
_RandomAccessIterator __last, _Compare __comp)
{
if (__last - __first > int(_S_threshold))
{
std::__insertion_sort(__first, __first + int(_S_threshold), __comp);
std::__unguarded_insertion_sort(__first + int(_S_threshold), __last,
__comp);
}
else
std::__insertion_sort(__first, __last, __comp);
}

template<typename _RandomAccessIterator, typename _Compare>

constexpr
_RandomAccessIterator
__unguarded_partition(_RandomAccessIterator __first,
_RandomAccessIterator __last,
_RandomAccessIterator __pivot, _Compare __comp)
{
while (true)
{
while (__comp(__first, __pivot))
++__first;
--__last;
while (__comp(__pivot, __last))
--__last;
if (!(__first < __last))
return __first;
std::iter_swap(__first, __last);
++__first;
}
}

template<typename _RandomAccessIterator, typename _Compare>

constexpr
inline _RandomAccessIterator
__unguarded_partition_pivot(_RandomAccessIterator __first,
_RandomAccessIterator __last, _Compare __comp)
{
_RandomAccessIterator __mid = __first + (__last - __first) / 2;
std::__move_median_to_first(__first, __first + 1, __mid, __last - 1,
__comp);
return std::__unguarded_partition(__first + 1, __last, __first, __comp);
}

template<typename _RandomAccessIterator, typename _Compare>

constexpr
inline void
__partial_sort(_RandomAccessIterator __first,
_RandomAccessIterator __middle,
_RandomAccessIterator __last,
_Compare __comp)
{
std::__heap_select(__first, __middle, __last, __comp);
std::__sort_heap(__first, __middle, __comp);
}

template<typename _RandomAccessIterator, typename _Size, typename _Compare>

constexpr
void
__introsort_loop(_RandomAccessIterator __first,
_RandomAccessIterator __last,
_Size __depth_limit, _Compare __comp)
{
while (__last - __first > int(_S_threshold))
{
if (__depth_limit == 0)
{
std::__partial_sort(__first, __last, __last, __comp);
return;
}
--__depth_limit;
_RandomAccessIterator __cut =
std::__unguarded_partition_pivot(__first, __last, __comp);
std::__introsort_loop(__cut, __last, __depth_limit, __comp);
__last = __cut;
}
}

template<typename _RandomAccessIterator, typename _Compare>

constexpr
inline void
__sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
{
if (__first != __last)
{
std::__introsort_loop(__first, __last,
std::__lg(__last - __first) * 2,
__comp);
std::__final_insertion_sort(__first, __last, __comp);
}
}

template<typename _RandomAccessIterator, typename _Size, typename _Compare>

constexpr
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);
}
# 1960 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _ForwardIterator, typename _Tp, typename _Compare>
[[__nodiscard__]] constexpr
inline _ForwardIterator
lower_bound(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val, _Compare __comp)
{

return std::__lower_bound(first, last, __val,

__gnu_cxx::__ops::__iter_comp_val(__comp));
}

template<typename _ForwardIterator, typename _Tp, typename _Compare>

constexpr
_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;
}
# 2016 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _ForwardIterator, typename _Tp>
[[__nodiscard__]] constexpr
inline _ForwardIterator
upper_bound(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val)
{

return std::__upper_bound(first, last, __val,

__gnu_cxx::__ops::__val_less_iter());
}
# 2047 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _ForwardIterator, typename _Tp, typename _Compare>
[[__nodiscard__]] constexpr
inline _ForwardIterator
upper_bound(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val, _Compare __comp)
{

return std::__upper_bound(first, last, __val,

__gnu_cxx::__ops::__val_comp_iter(__comp));
}

template<typename _ForwardIterator, typename _Tp,

typename _CompareItTp, typename _CompareTpIt>
constexpr
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);
}
# 2120 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _ForwardIterator, typename _Tp>
[[__nodiscard__]] constexpr
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());
}
# 2157 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _ForwardIterator, typename _Tp, typename _Compare>
[[__nodiscard__]] constexpr
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));
}
# 2191 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _ForwardIterator, typename _Tp>
[[__nodiscard__]] constexpr
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);
}
# 2225 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _ForwardIterator, typename _Tp, typename _Compare>
[[__nodiscard__]] constexpr
bool
binary_search(_ForwardIterator __first, _ForwardIterator __last,
const _Tp& __val, _Compare __comp)
{

_ForwardIterator __i
= std::__lower_bound(__first, __last, __val,
__gnu_cxx::__ops::__iter_comp_val(__comp));
return __i != __last && !bool(__comp(__val, *__i));
}

template<typename _InputIterator1, typename _InputIterator2,

typename _OutputIterator, typename _Compare>
void
__move_merge_adaptive(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result, _Compare __comp)
{
while (__first1 != __last1 && __first2 != __last2)
{
if (__comp(__first2, __first1))
{
*__result = std::move(*__first2);
++__first2;
}
else
{
*__result = std::move(*__first1);
++__first1;
}
++__result;
}
if (__first1 != __last1)
std::move(__first1, __last1, __result);
}

template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,

typename _BidirectionalIterator3, typename _Compare>
void
__move_merge_adaptive_backward(_BidirectionalIterator1 __first1,
_BidirectionalIterator1 __last1,
_BidirectionalIterator2 __first2,
_BidirectionalIterator2 __last2,
_BidirectionalIterator3 __result,
_Compare __comp)
{
if (__first1 == __last1)
{
std::move_backward(__first2, __last2, __result);
return;
}
else if (__first2 == __last2)
return;

--__last1;
--__last2;
while (true)
{
if (__comp(__last2, __last1))
{
*--__result = std::move(*__last1);
if (__first1 == __last1)
{
std::move_backward(__first2, ++__last2, __result);
return;
}
--__last1;
}
else
{
*--__result = std::move(*__last2);
if (__first2 == __last2)
return;
--__last2;
}
}
}

template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,

typename _Distance>
_BidirectionalIterator1
__rotate_adaptive(_BidirectionalIterator1 __first,
_BidirectionalIterator1 __middle,
_BidirectionalIterator1 __last,
_Distance __len1, _Distance __len2,
_BidirectionalIterator2 __buffer,
_Distance __buffer_size)
{
_BidirectionalIterator2 __buffer_end;
if (__len1 > __len2 && __len2 <= __buffer_size)
{
if (__len2)
{
__buffer_end = std::move(__middle, __last, __buffer);
std::move_backward(__first, __middle, __last);
return std::move(__buffer, __buffer_end, __first);
}
else
return __first;
}
else if (__len1 <= __buffer_size)
{
if (__len1)
{
__buffer_end = std::move(__first, __middle, __buffer);
std::move(__middle, __last, __first);
return std::move_backward(__buffer, __buffer_end, __last);
}
else
return __last;
}
else
return std::rotate(__first, __middle, __last);
}

template<typename _BidirectionalIterator, typename _Distance,

typename _Pointer, typename _Compare>
void
__merge_adaptive(_BidirectionalIterator __first,
_BidirectionalIterator __middle,
_BidirectionalIterator __last,
_Distance __len1, _Distance __len2,
_Pointer __buffer, _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<typename _BidirectionalIterator, typename _Distance,

typename _Pointer, typename _Compare>
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<typename _BidirectionalIterator, typename _Distance,

typename _Compare>
void
__merge_without_buffer(_BidirectionalIterator __first,
_BidirectionalIterator __middle,
_BidirectionalIterator __last,
_Distance __len1, _Distance __len2,
_Compare __comp)
{
if (__len1 == 0 || __len2 == 0)
return;

if (__len1 + __len2 == 2)
{
if (__comp(__middle, __first))
std::iter_swap(__first, __middle);
return;
}

_BidirectionalIterator __first_cut = __first;

_BidirectionalIterator __second_cut = __middle;
_Distance __len11 = 0;
_Distance __len22 = 0;
if (__len1 > __len2)
{
__len11 = __len1 / 2;
std::advance(__first_cut, __len11);
__second_cut
= std::__lower_bound(__middle, __last, *__first_cut,
__gnu_cxx::__ops::__iter_comp_val(__comp));
__len22 = std::distance(__middle, __second_cut);
}
else
{
__len22 = __len2 / 2;
std::advance(__second_cut, __len22);
__first_cut
= std::__upper_bound(__first, __middle, *__second_cut,
__gnu_cxx::__ops::__val_comp_iter(__comp));
__len11 = std::distance(__first, __first_cut);
}

_BidirectionalIterator __new_middle
= std::rotate(__first_cut, __middle, __second_cut);
std::__merge_without_buffer(__first, __first_cut, __new_middle,
__len11, __len22, __comp);
std::__merge_without_buffer(__new_middle, __second_cut, __last,
__len1 - __len11, __len2 - __len22, __comp);
}

template<typename _BidirectionalIterator, typename _Compare>

void
__inplace_merge(_BidirectionalIterator __first,
_BidirectionalIterator __middle,
_BidirectionalIterator __last,
_Compare __comp)
{
typedef typename iterator_traits<_BidirectionalIterator>::value_type
_ValueType;
typedef typename iterator_traits<_BidirectionalIterator>::difference_type
_DistanceType;

if (first == middle || middle == last)

return;

const _DistanceType len1 = std::distance(first, __middle);

const _DistanceType __len2 = std::distance(__middle, __last);

typedef _Temporary_buffer<_BidirectionalIterator, _ValueType> _TmpBuf;

_TmpBuf buf(first, 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);

}
# 2540 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _BidirectionalIterator>
inline void
inplace_merge(_BidirectionalIterator __first,
_BidirectionalIterator __middle,
_BidirectionalIterator __last)
{

;
;
;

std::__inplace_merge(first, middle, __last,

__gnu_cxx::__ops::__iter_less_iter());
}
# 2581 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _BidirectionalIterator, typename _Compare>
inline void
inplace_merge(_BidirectionalIterator __first,
_BidirectionalIterator __middle,
_BidirectionalIterator __last,
_Compare __comp)
{

;
;
;

std::__inplace_merge(first, middle, __last,

__gnu_cxx::__ops::__iter_comp_iter(__comp));
}

template<typename _InputIterator, typename _OutputIterator,

typename _Compare>
_OutputIterator
__move_merge(_InputIterator __first1, _InputIterator __last1,
_InputIterator __first2, _InputIterator __last2,
_OutputIterator __result, _Compare __comp)
{
while (__first1 != __last1 && __first2 != __last2)
{
if (__comp(__first2, __first1))
{
*__result = std::move(*__first2);
++__first2;
}
else
{
*__result = std::move(*__first1);
++__first1;
}
++__result;
}
return std::move(__first2, __last2, std::move(__first1, __last1, __result))

;
}

template<typename _RandomAccessIterator1, typename _RandomAccessIterator2,

typename _Distance, typename _Compare>
void
__merge_sort_loop(_RandomAccessIterator1 __first,
_RandomAccessIterator1 __last,
_RandomAccessIterator2 __result, _Distance __step_size,
_Compare __comp)
{
const _Distance __two_step = 2 * __step_size;

while (last - first >= __two_step)

{
__result = std::__move_merge(__first, __first + __step_size,
__first + __step_size,
__first + __two_step,
__result, __comp);
__first += __two_step;
}
__step_size = std::min(_Distance(__last - __first), __step_size);

std::__move_merge(first, first + __step_size,

__first + __step_size, __last, __result, __comp);
}

template<typename _RandomAccessIterator, typename _Distance,

typename _Compare>
constexpr
void
__chunk_insertion_sort(_RandomAccessIterator __first,
_RandomAccessIterator __last,
_Distance __chunk_size, _Compare __comp)
{
while (__last - __first >= __chunk_size)
{
std::__insertion_sort(__first, __first + __chunk_size, __comp);
__first += __chunk_size;
}
std::__insertion_sort(__first, __last, __comp);
}

enum { _S_chunk_size = 7 };

template<typename _RandomAccessIterator, typename _Pointer, typename _Compare>

void
__merge_sort_with_buffer(_RandomAccessIterator __first,
_RandomAccessIterator __last,
_Pointer __buffer, _Compare __comp)
{
typedef typename iterator_traits<_RandomAccessIterator>::difference_type
_Distance;

const _Distance len = last - __first;

const _Pointer __buffer_last = __buffer + __len;

_Distance __step_size = _S_chunk_size;

std::__chunk_insertion_sort(__first, __last, __step_size, __comp);

while (__step_size < __len)

{
std::__merge_sort_loop(__first, __last, __buffer,
__step_size, __comp);
__step_size *= 2;
std::__merge_sort_loop(__buffer, __buffer_last, __first,
__step_size, __comp);
__step_size *= 2;
}
}

template<typename _RandomAccessIterator, typename _Pointer, typename _Compare>

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<typename _RandomAccessIterator, typename _Pointer,

typename _Distance, typename _Compare>
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<typename _RandomAccessIterator, typename _Compare>

void
__inplace_stable_sort(_RandomAccessIterator __first,
_RandomAccessIterator __last, _Compare __comp)
{
if (__last - __first < 15)
{
std::__insertion_sort(__first, __last, __comp);
return;
}
_RandomAccessIterator __middle = __first + (__last - __first) / 2;
std::__inplace_stable_sort(__first, __middle, __comp);
std::__inplace_stable_sort(__middle, __last, __comp);
std::__merge_without_buffer(__first, __middle, __last,
__middle - __first,
__last - __middle,
__comp);
}
# 2767 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _InputIterator1, typename _InputIterator2,
typename _Compare>
constexpr
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;

template<typename _InputIterator, typename _OutputIterator,

typename _Predicate, typename _Tp>
constexpr
_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;
}
# 3124 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _InputIterator, typename _OutputIterator, typename _Tp>
constexpr
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);
}
# 3159 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _InputIterator, typename _OutputIterator,
typename _Predicate, typename _Tp>
constexpr
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);
}
# 3188 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _ForwardIterator>
[[__nodiscard__]] constexpr
inline bool
is_sorted(_ForwardIterator __first, _ForwardIterator __last)
{ return std::is_sorted_until(__first, __last) == __last; }
# 3203 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _ForwardIterator, typename _Compare>
[[__nodiscard__]] constexpr
inline bool
is_sorted(_ForwardIterator __first, _ForwardIterator __last,
_Compare __comp)
{ return std::is_sorted_until(__first, __last, __comp) == __last; }

template<typename _ForwardIterator, typename _Compare>

constexpr
_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;
}
# 3234 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _ForwardIterator>
[[__nodiscard__]] constexpr
inline _ForwardIterator
is_sorted_until(_ForwardIterator __first, _ForwardIterator __last)
{

;
;

return std::__is_sorted_until(first, last,

__gnu_cxx::__ops::__iter_less_iter());
}
# 3259 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _ForwardIterator, typename _Compare>
[[__nodiscard__]] constexpr
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));
}
# 3285 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _Tp>
[[__nodiscard__]] constexpr
inline pair<const _Tp&, const _Tp&>
minmax(const _Tp& __a, const _Tp& __b)
{

return b < a ? pair<const _Tp&, const _Tp&>(b, a)

: pair<const _Tp&, const _Tp&>(__a, __b);
}
# 3306 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _Tp, typename _Compare>
[[__nodiscard__]] constexpr
inline pair<const _Tp&, const _Tp&>
minmax(const _Tp& __a, const _Tp& __b, _Compare __comp)
{
return __comp(__b, __a) ? pair<const _Tp&, const _Tp&>(__b, __a)
: pair<const _Tp&, const _Tp&>(__a, __b);
}

template<typename _ForwardIterator, typename _Compare>

constexpr
pair<_ForwardIterator, _ForwardIterator>
__minmax_element(_ForwardIterator __first, _ForwardIterator __last,
_Compare __comp)
{
_ForwardIterator __next = __first;
if (__first == __last
|| ++__next == __last)
return std::make_pair(__first, __first);

_ForwardIterator min{}, max{};

if (__comp(__next, __first))
{
__min = __next;
__max = __first;
}
else
{
__min = __first;
__max = __next;
}

__first = __next;
++__first;

while (first != last)

{
__next = __first;
if (++__next == __last)
{
if (__comp(__first, __min))
__min = __first;
else if (!__comp(__first, __max))
__max = __first;
break;
}

if (__comp(__next, __first))
{
if (__comp(__next, __min))
__min = __next;
if (!__comp(__first, __max))
__max = __first;
}
else
{
if (__comp(__first, __min))
__min = __first;
if (!__comp(__next, __max))
__max = __next;
}

__first = __next;
++__first;
}

return std::make_pair(min, max);

}
# 3386 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _ForwardIterator>
[[__nodiscard__]] constexpr
inline pair<_ForwardIterator, _ForwardIterator>
minmax_element(_ForwardIterator __first, _ForwardIterator __last)
{

;
;

return std::__minmax_element(first, last,

__gnu_cxx::__ops::__iter_less_iter());
}
# 3414 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _ForwardIterator, typename _Compare>
[[__nodiscard__]] constexpr
inline pair<_ForwardIterator, _ForwardIterator>
minmax_element(_ForwardIterator __first, _ForwardIterator __last,
_Compare __comp)
{
;
;

return std::__minmax_element(first, last,

__gnu_cxx::__ops::__iter_comp_iter(__comp));
}

template<typename _Tp>
[[__nodiscard__]] constexpr
inline pair<_Tp, _Tp>
minmax(initializer_list<_Tp> __l)
{
;
pair<const _Tp*, const _Tp*> __p =
std::__minmax_element(__l.begin(), __l.end(),
__gnu_cxx::__ops::__iter_less_iter());
return std::make_pair(*__p.first, *__p.second);
}

template<typename _Tp, typename _Compare>

[[__nodiscard__]] constexpr
inline pair<_Tp, _Tp>
minmax(initializer_list<_Tp> __l, _Compare __comp)
{
;
pair<const _Tp*, const _Tp*> __p =
std::__minmax_element(__l.begin(), __l.end(),
__gnu_cxx::__ops::__iter_comp_iter(__comp));
return std::make_pair(*__p.first, *__p.second);
}
# 3470 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _ForwardIterator1, typename _ForwardIterator2,
typename _BinaryPredicate>
[[__nodiscard__]] constexpr
inline bool
is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _BinaryPredicate __pred)
{

return std::__is_permutation(first1, last1, __first2,

__gnu_cxx::__ops::__iter_comp_iter(__pred));
}

template<typename _ForwardIterator1, typename _ForwardIterator2,

typename _BinaryPredicate>
constexpr
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;
}
# 3565 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _ForwardIterator1, typename _ForwardIterator2>
[[__nodiscard__]] constexpr
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());
}
# 3593 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _ForwardIterator1, typename _ForwardIterator2,
typename _BinaryPredicate>
[[__nodiscard__]] constexpr
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));
}
# 3621 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _Tp>
[[nodiscard]] constexpr const _Tp&
clamp(const _Tp& __val, const _Tp& __lo, const _Tp& __hi)
{
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(!(__hi <
__lo)), false)) std::__glibcxx_assert_fail(); } while (false);
return std::min(std::max(__val, __lo), __hi);
}
# 3641 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _Tp, typename _Compare>
[[nodiscard]] constexpr const _Tp&
clamp(const _Tp& __val, const _Tp& __lo, const _Tp& __hi, _Compare __comp)
{
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(!
__comp(__hi, __lo)), false)) std::__glibcxx_assert_fail(); } while (false);
return std::min(std::max(__val, __lo, __comp), __hi, __comp);
}
# 3671 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _IntType, typename _UniformRandomBitGenerator>
pair<_IntType, _IntType>
__gen_two_uniform_ints(_IntType __b0, _IntType __b1,
_UniformRandomBitGenerator&& __g)
{
_IntType __x
= uniform_int_distribution<_IntType>{0, (__b0 * __b1) - 1}(__g);
return std::make_pair(__x / __b1, __x % __b1);
}
# 3693 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _RandomAccessIterator,
typename _UniformRandomNumberGenerator>
void
shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
_UniformRandomNumberGenerator&& __g)
{
;

if (__first == __last)
return;

typedef typename iterator_traits<_RandomAccessIterator>::difference_type

_DistanceType;

typedef typename std::make_unsigned<_DistanceType>::type __ud_type;

typedef typename std::uniform_int_distribution<__ud_type> __distr_type;
typedef typename __distr_type::param_type __p_type;

typedef typename remove_reference<_UniformRandomNumberGenerator>::type

_Gen;
typedef typename common_type<typename _Gen::result_type, __ud_type>::type
__uc_type;

const __uc_type urngrange = g.max() - __g.min();

const __uc_type __urange = __uc_type(__last - __first);

if (urngrange / urange >= __urange)

{
_RandomAccessIterator __i = __first + 1;

if ((__urange % 2) == 0)
{
__distr_type __d{0, 1};
std::iter_swap(__i++, __first + __d(__g));
}

while (i != last)

{
const __uc_type __swap_range = __uc_type(__i - __first) + 1;

const pair<__uc_type, __uc_type> __pospos =

__gen_two_uniform_ints(__swap_range, __swap_range + 1, __g);

std::iter_swap(i++, first + __pospos.first);

std::iter_swap(__i++, __first + __pospos.second);
}

return;
}

__distr_type __d;

for (_RandomAccessIterator i = first + 1; i != last; ++__i)

std::iter_swap(__i, __first + __d(__g, __p_type(0, __i - __first)));
}

# 3776 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _InputIterator, typename _Function>
constexpr
_Function
for_each(_InputIterator __first, _InputIterator __last, _Function __f)
{

;
for (; __first != __last; ++__first)
__f(*__first);
return __f;
}
# 3802 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _InputIterator, typename _Size, typename _Function>
constexpr
_InputIterator
for_each_n(_InputIterator __first, _Size __n, _Function __f)
{
auto __n2 = std::__size_to_integer(__n);
using _Cat = typename iterator_traits<_InputIterator>::iterator_category;
if constexpr (is_base_of_v<random_access_iterator_tag, _Cat>)
{
if (__n2 <= 0)
return __first;
auto __last = __first + __n2;
std::for_each(__first, __last, std::move(__f));
return __last;
}
else
{
while (__n2-->0)
{
__f(*__first);
++__first;
}
return __first;
}
}
# 3838 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _InputIterator, typename _Tp>
constexpr
inline _InputIterator
find(_InputIterator __first, _InputIterator __last,
const _Tp& __val)
{

;
return std::__find_if(__first, __last,
__gnu_cxx::__ops::__iter_equals_val(__val));
}
# 3863 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _InputIterator, typename _Predicate>
[[__nodiscard__]] constexpr
inline _InputIterator
find_if(_InputIterator __first, _InputIterator __last,
_Predicate __pred)
{

return std::__find_if(first, last,

__gnu_cxx::__ops::__pred_iter(__pred));
}
# 3895 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _InputIterator, typename _ForwardIterator>
[[__nodiscard__]] constexpr
_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;
}
# 3936 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _InputIterator, typename _ForwardIterator,
typename _BinaryPredicate>
[[__nodiscard__]] constexpr
_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;
}
# 3969 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _ForwardIterator>
[[__nodiscard__]] constexpr
inline _ForwardIterator
adjacent_find(_ForwardIterator __first, _ForwardIterator __last)
{

return std::__adjacent_find(first, last,

__gnu_cxx::__ops::__iter_equal_to_iter());
}
# 3995 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _ForwardIterator, typename _BinaryPredicate>
[[__nodiscard__]] constexpr
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));
}
# 4021 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _InputIterator, typename _Tp>
[[__nodiscard__]] constexpr
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));
}
# 4045 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _InputIterator, typename _Predicate>
[[__nodiscard__]] constexpr
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));
}
# 4086 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _ForwardIterator1, typename _ForwardIterator2>
[[__nodiscard__]] constexpr
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());
}
# 4120 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _ForwardIterator, typename _Integer, typename _Tp>
[[__nodiscard__]] constexpr
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));
}
# 4154 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _ForwardIterator, typename _Integer, typename _Tp,
typename _BinaryPredicate>
[[__nodiscard__]] constexpr
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));
}
# 4180 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _ForwardIterator, typename _Searcher>
[[__nodiscard__]] constexpr
inline _ForwardIterator
search(_ForwardIterator __first, _ForwardIterator __last,
const _Searcher& __searcher)
{ return __searcher(__first, __last).first; }
# 4204 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _InputIterator, typename _OutputIterator,
typename _UnaryOperation>
constexpr
_OutputIterator
transform(_InputIterator __first, _InputIterator __last,
_OutputIterator __result, _UnaryOperation __unary_op)
{

for (; first != last; ++first, (void)++result)

*__result = __unary_op(*__first);
return __result;
}
# 4242 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator, typename _BinaryOperation>
constexpr
_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;
}
# 4276 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _ForwardIterator, typename _Tp>
constexpr
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;
}
# 4309 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _ForwardIterator, typename _Predicate, typename _Tp>
constexpr
void
replace_if(_ForwardIterator __first, _ForwardIterator __last,
_Predicate __pred, const _Tp& __new_value)
{

for (; first != last; ++__first)

if (__pred(*__first))
*__first = __new_value;
}
# 4341 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _ForwardIterator, typename _Generator>
constexpr
void
generate(_ForwardIterator __first, _ForwardIterator __last,
_Generator __gen)
{

for (; first != last; ++__first)

*__first = __gen();
}
# 4374 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _OutputIterator, typename _Size, typename _Generator>
constexpr
_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;
}
# 4409 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _InputIterator, typename _OutputIterator>
constexpr
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));
}
# 4449 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _InputIterator, typename _OutputIterator,
typename _BinaryPredicate>
constexpr
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));
}
# 4488 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _RandomAccessIterator>
__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);
}
}
# 4527 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _RandomAccessIterator, typename _RandomNumberGenerator>
__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);
}
}
# 4569 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _ForwardIterator, typename _Predicate>
constexpr
inline _ForwardIterator
partition(_ForwardIterator __first, _ForwardIterator __last,
_Predicate __pred)
{

return std::partition(first, last, pred,

std::__iterator_category(__first));
}
# 4604 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _RandomAccessIterator>
constexpr
inline void
partial_sort(_RandomAccessIterator __first,
_RandomAccessIterator __middle,
_RandomAccessIterator __last)
{
;
;
;

std::__partial_sort(first, middle, __last,

__gnu_cxx::__ops::__iter_less_iter());
}
# 4643 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _RandomAccessIterator, typename _Compare>
constexpr
inline void
partial_sort(_RandomAccessIterator __first,
_RandomAccessIterator __middle,
_RandomAccessIterator __last,
_Compare __comp)
{

}
# 4789 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _RandomAccessIterator, typename _Compare>
constexpr
inline void
sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
{

;
;

std::sort(first, last, gnu_cxx::ops::iter_comp_iter(__comp));

}

template<typename _InputIterator1, typename _InputIterator2,

typename _OutputIterator, typename _Compare>
constexpr
_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));
}
# 4852 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator>
constexpr
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());
}
# 4903 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator, typename _Compare>
constexpr
inline _OutputIterator
merge(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result, _Compare __comp)
{
;
;
;
;

return std::merge(first1, __last1,

__first2, __last2, __result,
__gnu_cxx::__ops::__iter_comp_iter(__comp));
}

template<typename _RandomAccessIterator, typename _Compare>

inline void
__stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
{
typedef typename iterator_traits<_RandomAccessIterator>::value_type
_ValueType;
typedef typename iterator_traits<_RandomAccessIterator>::difference_type
_DistanceType;

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);

}
# 4981 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _RandomAccessIterator>
inline void
stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
{
;
;

std::__stable_sort(__first, __last,
__gnu_cxx::__ops::__iter_less_iter());
}
# 5015 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _RandomAccessIterator, typename _Compare>
inline void
stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
{

;
;

std::__stable_sort(__first, __last,
__gnu_cxx::__ops::__iter_comp_iter(__comp));
}

template<typename _InputIterator1, typename _InputIterator2,

typename _OutputIterator,
typename _Compare>
constexpr
_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));
}
# 5085 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _InputIterator1, typename _InputIterator2,
typename _OutputIterator>
constexpr
inline _OutputIterator
set_union(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result)
{

;
;
;
;

return std::__set_union(first1, last1,

return std::__set_symmetric_difference(first1, last1,

__first2, __last2, __result,
__gnu_cxx::__ops::__iter_comp_iter(__comp));
}

template<typename _ForwardIterator, typename _Compare>

constexpr
_ForwardIterator
__min_element(_ForwardIterator __first, _ForwardIterator __last,
_Compare __comp)
{
if (__first == __last)
return __first;
_ForwardIterator __result = __first;
while (++__first != __last)
if (__comp(__first, __result))
__result = __first;
return __result;
}
# 5573 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _ForwardIterator>
[[__nodiscard__]] constexpr
_ForwardIterator
inline min_element(_ForwardIterator __first, _ForwardIterator __last)
{

;
;
return std::__min_element(__first, __last,
__gnu_cxx::__ops::__iter_less_iter());
}
# 5598 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _ForwardIterator, typename _Compare>
[[__nodiscard__]] constexpr
inline _ForwardIterator
min_element(_ForwardIterator __first, _ForwardIterator __last,
_Compare __comp)
{

;
;

return std::__min_element(first, last,

__gnu_cxx::__ops::__iter_comp_iter(__comp));
}

template<typename _ForwardIterator, typename _Compare>

constexpr
_ForwardIterator
__max_element(_ForwardIterator __first, _ForwardIterator __last,
_Compare __comp)
{
if (__first == __last) return __first;
_ForwardIterator __result = __first;
while (++__first != __last)
if (__comp(__result, __first))
__result = __first;
return __result;
}
# 5637 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _ForwardIterator>
[[__nodiscard__]] constexpr
inline _ForwardIterator
max_element(_ForwardIterator __first, _ForwardIterator __last)
{

;
;

return std::__max_element(first, last,

__gnu_cxx::__ops::__iter_less_iter());
}
# 5662 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/stl_algo.h" 3
template<typename _ForwardIterator, typename _Compare>
[[__nodiscard__]] constexpr
inline _ForwardIterator
max_element(_ForwardIterator __first, _ForwardIterator __last,
_Compare __comp)
{
;
;

return std::__max_element(first, last,

__gnu_cxx::__ops::__iter_comp_iter(__comp));
}

template<typename _Tp>
constexpr
inline _Tp
min(initializer_list<_Tp> __l)
{
;
return *std::__min_element(__l.begin(), __l.end(),
__gnu_cxx::__ops::__iter_less_iter());
}

template<typename _Tp, typename _Compare>

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<typename _Tp>
constexpr
inline _Tp
max(initializer_list<_Tp> __l)
{
;
return *std::__max_element(__l.begin(), __l.end(),
__gnu_cxx::__ops::__iter_less_iter());
}

template<typename _Tp, typename _Compare>

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<typename _InputIterator, typename _RandomAccessIterator,

typename _Size, typename _UniformRandomBitGenerator>
_RandomAccessIterator
__sample(_InputIterator __first, _InputIterator __last, input_iterator_tag,
_RandomAccessIterator __out, random_access_iterator_tag,
_Size __n, _UniformRandomBitGenerator&& __g)
{
using __distrib_type = uniform_int_distribution<_Size>;
using __param_type = typename __distrib_type::param_type;
__distrib_type __d{};
_Size __sample_sz = 0;
while (__first != __last && __sample_sz != __n)
{
__out[__sample_sz++] = *__first;
++__first;
}
for (auto __pop_sz = __sample_sz; __first != __last;
++__first, (void) ++__pop_sz)
{
const auto __k = __d(__g, __param_type{0, __pop_sz});
if (__k < __n)
__out[__k] = *__first;
}
return __out + __sample_sz;
}

template<typename _ForwardIterator, typename _OutputIterator, typename _Cat,

typename _Size, typename _UniformRandomBitGenerator>
_OutputIterator
__sample(_ForwardIterator __first, _ForwardIterator __last,
forward_iterator_tag,
_OutputIterator __out, _Cat,
_Size __n, _UniformRandomBitGenerator&& __g)
{
using __distrib_type = uniform_int_distribution<_Size>;
using __param_type = typename __distrib_type::param_type;
using _USize = make_unsigned_t<_Size>;
using _Gen = remove_reference_t<_UniformRandomBitGenerator>;
using __uc_type = common_type_t<typename _Gen::result_type, _USize>;

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<typename _PopulationIterator, typename _SampleIterator,

typename _Distance, typename _UniformRandomBitGenerator>
_SampleIterator
sample(_PopulationIterator __first, _PopulationIterator __last,
_SampleIterator __out, _Distance __n,
_UniformRandomBitGenerator&& __g)
{
using __pop_cat = typename
std::iterator_traits<_PopulationIterator>::iterator_category;
using __samp_cat = typename
std::iterator_traits<_SampleIterator>::iterator_category;

static_assert(
__or_<is_convertible<__pop_cat, forward_iterator_tag>,
is_convertible<__samp_cat, random_access_iterator_tag>>::value,
"output range must use a RandomAccessIterator when input range"
" does not meet the ForwardIterator requirements");

static_assert(is_integral<_Distance>::value,
"sample size must be an integer type");

typename iterator_traits<_PopulationIterator>::difference_type d = n;

return std::
__sample(__first, __last, __pop_cat{}, __out, __samp_cat{}, __d,
std::forward<_UniformRandomBitGenerator>(__g));
}

}
# 39 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/unicode.h" 2 3

namespace std
{

namespace __unicode
{

constexpr bool
__is_scalar_value(char32_t __c)
{
if (__c < 0xD800) [[likely]]
return true;
return 0xDFFF < __c && __c <= 0x10FFFF;
}

template<typename _CharT>
constexpr bool
__is_single_code_unit(char32_t __c)
{
if constexpr (__gnu_cxx::__int_traits<_CharT>::__max <= 0xFF)
return __c < 0x7F;
else
return __c < __gnu_cxx::__int_traits<_CharT>::__max
&& __is_scalar_value(__c);
}

struct _Repl
{
constexpr char32_t
operator()() const noexcept
{ return 0xFFFD; }
};

struct _Null_sentinel_t
{
template<input_iterator _It>
requires default_initializable<iter_value_t<_It>>
&& equality_comparable_with<iter_reference_t<_It>, iter_value_t<_It>>
friend constexpr auto
operator==(_It __it, _Null_sentinel_t)
{ return *__it == iter_value_t<_It>{}; }
};

template<typename _FromFmt, typename _ToFmt,

input_iterator _Iter, sentinel_for<_Iter> _Sent = _Iter,
typename _ErrorHandler = _Repl>
requires convertible_to<iter_value_t<_Iter>, _FromFmt>
class _Utf_iterator
{
static_assert(forward_iterator<_Iter> || noexcept(_ErrorHandler()()));

public:
using value_type = _ToFmt;
using difference_type = iter_difference_t<_Iter>;
using reference = value_type;
using iterator_concept
= std::__detail::__clamp_iter_cat<__iter_category_t<_Iter>,
bidirectional_iterator_tag>;

constexpr _Utf_iterator() = default;

constexpr
_Utf_iterator(_Iter __first, _Iter __it, _Sent __last)
requires bidirectional_iterator<_Iter>
: _M_first_and_curr{__first, __it}, _M_last(__last)
{
if (_M_curr() != _M_last)
_M_read();
else
_M_buf = {};
}

constexpr
_Utf_iterator(_Iter __it, _Sent __last)
requires (!bidirectional_iterator<_Iter>)
: _M_first_and_curr{__it}, _M_last(__last)
{
if (_M_curr() != _M_last)
_M_read();
else
_M_buf = {};
}

template<class _Iter2, class _Sent2>

requires convertible_to<_Iter2, _Iter> && convertible_to<_Sent2, _Sent>
constexpr
_Utf_iterator(const _Utf_iterator<_FromFmt, _ToFmt, _Iter2, _Sent2,
_ErrorHandler>& __other)
: _M_buf(__other._M_buf), _M_first_and_curr(__other._M_first_and_curr),
_M_buf_index(__other._M_buf_index), _M_buf_last(__other._M_buf_last),
_M_last(__other._M_last)
{ }

[[nodiscard]]
constexpr _Iter
begin() const requires bidirectional_iterator<_Iter>
{ return _M_first(); }

[[nodiscard]]
constexpr _Sent
end() const { return _M_last; }

[[nodiscard]]
constexpr _Iter
base() const requires forward_iterator<_Iter>
{ return _M_curr(); }

[[nodiscard]]
constexpr value_type
operator*() const { return _M_buf[_M_buf_index]; }

constexpr _Utf_iterator&
operator++()
{
if (_M_buf_index + 1 == _M_buf_last && _M_curr() != _M_last)
{
if constexpr (forward_iterator<_Iter>)
std::advance(_M_curr(), _M_to_increment);
if (_M_curr() == _M_last)
_M_buf_index = 0;
else
_M_read();
}
else if (_M_buf_index + 1 < _M_buf_last)
++_M_buf_index;
return *this;
}

constexpr _Utf_iterator
operator++(int)
{
auto __tmp = *this;
++*this;
return __tmp;
}

constexpr _Utf_iterator&
operator--() requires bidirectional_iterator<_Iter>
{
if (!_M_buf_index && _M_curr() != _M_first())
_M_read_reverse();
else if (_M_buf_index)
--_M_buf_index;
return *this;
}

constexpr _Utf_iterator
operator--(int)
{
auto __tmp = *this;
--*this;
return __tmp;
}

[[nodiscard]]
friend constexpr bool
operator==(_Utf_iterator __lhs, _Utf_iterator __rhs)
requires forward_iterator<_Iter> || requires (_Iter __i) { __i != __i; }
{
if constexpr (forward_iterator<_Iter>)
return __lhs._M_curr() == __rhs._M_curr()
&& __lhs._M_buf_index == __rhs._M_buf_index;
else if (__lhs._M_curr() != __rhs._M_curr())
return false;
else if (__lhs._M_buf_index == __rhs._M_buf_index
&& __lhs._M_buf_last == __rhs._M_buf_last)
return true;
else
return __lhs._M_buf_index == __lhs._M_buf_last
&& __rhs._M_buf_index == __rhs._M_buf_last;
}

[[nodiscard]]
friend constexpr bool
operator==(_Utf_iterator __lhs, _Sent __rhs)
{
if constexpr (forward_iterator<_Iter>)
return __lhs._M_curr() == __rhs;
else
return __lhs._M_curr() == __rhs
&& __lhs._M_buf_index == __lhs._M_buf_last;
}

private:
constexpr void
_M_read()
{
if constexpr (sizeof(_FromFmt) == sizeof(uint8_t))
_M_read_utf8();
else if constexpr (sizeof(_FromFmt) == sizeof(uint16_t))
_M_read_utf16();
else
{
static_assert(sizeof(_FromFmt) == sizeof(uint32_t));
_M_read_utf32();
}
}

constexpr void
_M_read_reverse();

template<typename>
struct _Guard
{
_Guard(void*, _Iter&) { }
};

template<typename _It> requires forward_iterator<_It>

struct _Guard<_It>
{
constexpr ~_Guard() { _M_this->_M_curr() = std::move(_M_orig); }
_Utf_iterator* _M_this;
_It _M_orig;
};

constexpr void
_M_read_utf8()
{
_Guard<_Iter> __g{this, _M_curr()};
char32_t __c{};
uint8_t __u = *_M_curr()++;
const uint8_t __lo_bound = 0x80, __hi_bound = 0xBF;
uint8_t __to_incr = 1;
if (__u <= 0x7F) [[likely]]
__c = __u;
else if (__u < 0xC2) [[unlikely]]
__c = _S_error();
else if (_M_curr() == _M_last) [[unlikely]]
__c = _S_error();
else if (__u <= 0xDF)
{
__c = __u & 0x1F;
__u = *_M_curr();

if (u < lo_bound || u > hi_bound) [[unlikely]]

__c = _S_error();
else
{
__c = (__c << 6) | (__u & 0x3F);
++_M_curr();
++__to_incr;
}
}
else if (__u <= 0xEF)
{
const uint8_t __lo_bound_2 = __u == 0xE0 ? 0xA0 : __lo_bound;
const uint8_t __hi_bound_2 = __u == 0xED ? 0x9F : __hi_bound;

c = u & 0x0F;

__u = *_M_curr();

if (u < lo_bound_2 || u > hi_bound_2) [[unlikely]]

__c = _S_error();
else if (++_M_curr() == _M_last) [[unlikely]]
__c = _S_error();
else
{
++__to_incr;
__c = (__c << 6) | (__u & 0x3F);
__u = *_M_curr();

if (u < lo_bound || u > hi_bound) [[unlikely]]

__c = _S_error();
else
{
__c = (__c << 6) | (__u & 0x3F);
++_M_curr();
++__to_incr;
}
}
}
else if (__u <= 0xF4)
{
const uint8_t __lo_bound_2 = __u == 0xF0 ? 0x90 : __lo_bound;
const uint8_t __hi_bound_2 = __u == 0xF4 ? 0x8F : __hi_bound;

c = u & 0x07;

__u = *_M_curr();

if (u < lo_bound_2 || u > hi_bound_2) [[unlikely]]

__c = _S_error();
else if (++_M_curr() == _M_last) [[unlikely]]
__c = _S_error();
else
{
++__to_incr;
__c = (__c << 6) | (__u & 0x3F);
__u = *_M_curr();

if (u < lo_bound || u > hi_bound) [[unlikely]]

__c = _S_error();
else if (++_M_curr() == _M_last) [[unlikely]]
__c = _S_error();
else
{
++__to_incr;
__c = (__c << 6) | (__u & 0x3F);
__u = *_M_curr();

if (u < lo_bound || u > hi_bound) [[unlikely]]

__c = _S_error();
else
{
__c = (__c << 6) | (__u & 0x3F);
++_M_curr();
++__to_incr;
}
}
}
}
else [[unlikely]]
__c = _S_error();

_M_update(__c, __to_incr);
}

constexpr void
_M_read_utf16()
{
_Guard<_Iter> __g{this, _M_curr()};
char32_t __c{};
uint16_t __u = *_M_curr()++;
uint8_t __to_incr = 1;

if (u < 0xD800 || u > 0xDFFF) [[likely]]

__c = __u;
else if (__u < 0xDC00 && _M_curr() != _M_last)
{
uint16_t __u2 = *_M_curr();
if (__u2 < 0xDC00 || __u2 > 0xDFFF) [[unlikely]]
__c = _S_error();
else
{
++_M_curr();
__to_incr = 2;
uint32_t __x = (__u & 0x3F) << 10 | __u2 & 0x3FF;
uint32_t __w = (__u >> 6) & 0x1F;
__c = (__w + 1) << 16 | __x;
}
}
else
__c = _S_error();

_M_update(__c, __to_incr);
}

constexpr void
_M_read_utf32()
{
_Guard<_Iter> __g{this, _M_curr()};
char32_t __c = *_M_curr()++;
if (!__is_scalar_value(__c)) [[unlikely]]
__c = _S_error();
_M_update(__c, 1);
}

constexpr void
_M_update(char32_t __c, uint8_t __to_incr)
{
_M_to_increment = __to_incr;
_M_buf_index = 0;
if constexpr (sizeof(_ToFmt) == sizeof(uint32_t))
{
_M_buf[0] = __c;
_M_buf_last = 1;
}
else if constexpr (sizeof(_ToFmt) == sizeof(uint16_t))
{
if (__is_single_code_unit<_ToFmt>(__c))
{
_M_buf[0] = __c;
_M_buf[1] = 0;
_M_buf_last = 1;
}
else
{

const char32_t __lead_offset = 0xD800 - (0x10000 >> 10);

char16_t __lead = __lead_offset + (__c >> 10);
char16_t __trail = 0xDC00 + (__c & 0x3FF);
_M_buf[0] = __lead;
_M_buf[1] = __trail;
_M_buf_last = 2;
}
}
else
{
static_assert(sizeof(_ToFmt) == 1);
int __bits = std::bit_width((uint32_t)__c);
if (__bits <= 7) [[likely]]
{
_M_buf[0] = __c;
_M_buf[1] = _M_buf[2] = _M_buf[3] = 0;
_M_buf_last = 1;
}
else if (__bits <= 11)
{
_M_buf[0] = 0xC0 | (__c >> 6);
_M_buf[1] = 0x80 | (__c & 0x3F);
_M_buf[2] = _M_buf[3] = 0;
_M_buf_last = 2;
}
else if (__bits <= 16)
{
_M_buf[0] = 0xE0 | (__c >> 12);
_M_buf[1] = 0x80 | ((__c >> 6) & 0x3F);
_M_buf[2] = 0x80 | (__c & 0x3F);
_M_buf[3] = 0;
_M_buf_last = 3;
}
else
{
_M_buf[0] = 0xF0 | ((__c >> 18) & 0x07);
_M_buf[1] = 0x80 | ((__c >> 12) & 0x3F);
_M_buf[2] = 0x80 | ((__c >> 6) & 0x3F);
_M_buf[3] = 0x80 | (__c & 0x3F);
_M_buf_last = 4;
}
}
}

constexpr char32_t
_S_error()
{
char32_t __c = _ErrorHandler()();
do { if (std::__is_constant_evaluated()) if (__builtin_expect(!
bool(__is_scalar_value(__c)), false)) std::__glibcxx_assert_fail(); } while
(false);
return __c;
}

constexpr _Iter
_M_first() const requires bidirectional_iterator<_Iter>
{ return _M_first_and_curr._M_first; }

constexpr _Iter&
_M_curr() { return _M_first_and_curr._M_curr; }

constexpr _Iter
_M_curr() const { return _M_first_and_curr._M_curr; }

array<value_type, 4 / sizeof(_ToFmt)> _M_buf;

template<typename _It>
struct _First_and_curr
{
_First_and_curr() = default;

constexpr
_First_and_curr(_It __curr) : _M_curr(__curr) { }

template<convertible_to<_It> _It2>
constexpr
_First_and_curr(const _First_and_curr<_It2>& __other)
: _M_curr(__other._M_curr) { }

_It _M_curr;
};

template<typename _It> requires bidirectional_iterator<_It>

struct _First_and_curr<_It>
{
_First_and_curr() = default;

constexpr
_First_and_curr(_It __first, _It __curr)
: _M_first(__first), _M_curr(__curr) { }

template<convertible_to<_It> _It2>
constexpr
_First_and_curr(const _First_and_curr<_It2>& __other)
: _M_first(__other._M_first), _M_curr(__other._M_curr) { }

_It _M_first;
_It _M_curr;
};

_First_and_curr<_Iter> _M_first_and_curr;

uint8_t _M_buf_index = 0;
uint8_t _M_buf_last = 0;
uint8_t _M_to_increment = 0;

[[no_unique_address]] _Sent _M_last;

template<typename _FromFmt2, typename _ToFmt2,

input_iterator _Iter2, sentinel_for<_Iter2> _Sent2,
typename _ErrHandler>
requires convertible_to<iter_value_t<_Iter2>, _FromFmt2>
friend class _Utf_iterator;
};

template<typename _ToFormat, ranges::input_range _Range>

class _Utf_view
: public ranges::view_interface<_Utf_view<_ToFormat, _Range>>
{
using _Iterator = _Utf_iterator<ranges::range_value_t<_Range>,
_ToFormat, ranges::iterator_t<_Range>,
ranges::sentinel_t<_Range>>;

template<typename _Iter, typename _Sent>

constexpr auto
_M_begin(_Iter __first, _Sent __last)
{
if constexpr (bidirectional_iterator<_Iter>)
return _Iterator(__first, __first, __last);
else
return _Iterator(__first, __last);
}

template<typename _Iter, typename _Sent>

constexpr auto
_M_end(_Iter __first, _Sent __last)
{
if constexpr (!is_same_v<_Iter, _Sent>)
return __last;
else if constexpr (bidirectional_iterator<_Iter>)
return _Iterator(__first, __last, __last);
else
return _Iterator(__last, __last);
}

_Range _M_base;

public:
constexpr explicit
_Utf_view(_Range&& __r) : _M_base(std::forward<_Range>(__r)) { }

constexpr auto begin()

{ return _M_begin(ranges::begin(_M_base), ranges::end(_M_base)); }

constexpr auto end()

{ return _M_end(ranges::begin(_M_base), ranges::end(_M_base)); }

constexpr bool empty() const { return ranges::empty(_M_base); }

};

template<typename _View>
using _Utf8_view = _Utf_view<char8_t, _View>;

template<typename _View>
using _Utf16_view = _Utf_view<char16_t, _View>;
template<typename _View>
using _Utf32_view = _Utf_view<char32_t, _View>;

inline namespace __v15_1_0

{

# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/unicode-data.h" 1 3
# 38 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/unicode-data.h" 3
inline constexpr char32_t __width_edges[] = {
0x1100, 0x1160, 0x231a, 0x231c, 0x2329, 0x232b, 0x23e9, 0x23ed,
0x23f0, 0x23f1, 0x23f3, 0x23f4, 0x25fd, 0x25ff, 0x2614, 0x2616,
0x2648, 0x2654, 0x267f, 0x2680, 0x2693, 0x2694, 0x26a1, 0x26a2,
0x26aa, 0x26ac, 0x26bd, 0x26bf, 0x26c4, 0x26c6, 0x26ce, 0x26cf,
0x26d4, 0x26d5, 0x26ea, 0x26eb, 0x26f2, 0x26f4, 0x26f5, 0x26f6,
0x26fa, 0x26fb, 0x26fd, 0x26fe, 0x2705, 0x2706, 0x270a, 0x270c,
0x2728, 0x2729, 0x274c, 0x274d, 0x274e, 0x274f, 0x2753, 0x2756,
0x2757, 0x2758, 0x2795, 0x2798, 0x27b0, 0x27b1, 0x27bf, 0x27c0,
0x2b1b, 0x2b1d, 0x2b50, 0x2b51, 0x2b55, 0x2b56, 0x2e80, 0x2e9a,
0x2e9b, 0x2ef4, 0x2f00, 0x2fd6, 0x2ff0, 0x303f, 0x3041, 0x3097,
0x3099, 0x3100, 0x3105, 0x3130, 0x3131, 0x318f, 0x3190, 0x31e4,
0x31ef, 0x321f, 0x3220, 0x3248, 0x3250, 0xa48d, 0xa490, 0xa4c7,
0xa960, 0xa97d, 0xac00, 0xd7a4, 0xf900, 0xfb00, 0xfe10, 0xfe1a,
0xfe30, 0xfe53, 0xfe54, 0xfe67, 0xfe68, 0xfe6c, 0xff01, 0xff61,
0xffe0, 0xffe7, 0x16fe0, 0x16fe5, 0x16ff0, 0x16ff2, 0x17000, 0x187f8,
0x18800, 0x18cd6, 0x18d00, 0x18d09, 0x1aff0, 0x1aff4, 0x1aff5, 0x1affc,
0x1affd, 0x1afff, 0x1b000, 0x1b123, 0x1b132, 0x1b133, 0x1b150, 0x1b153,
0x1b155, 0x1b156, 0x1b164, 0x1b168, 0x1b170, 0x1b2fc, 0x1f004, 0x1f005,
0x1f0cf, 0x1f0d0, 0x1f18e, 0x1f18f, 0x1f191, 0x1f19b, 0x1f200, 0x1f203,
0x1f210, 0x1f23c, 0x1f240, 0x1f249, 0x1f250, 0x1f252, 0x1f260, 0x1f266,
0x1f300, 0x1f650, 0x1f680, 0x1f6c6, 0x1f6cc, 0x1f6cd, 0x1f6d0, 0x1f6d3,
0x1f6d5, 0x1f6d8, 0x1f6dc, 0x1f6e0, 0x1f6eb, 0x1f6ed, 0x1f6f4, 0x1f6fd,
0x1f7e0, 0x1f7ec, 0x1f7f0, 0x1f7f1, 0x1f900, 0x1fa00, 0x1fa70, 0x1fa7d,
0x1fa80, 0x1fa89, 0x1fa90, 0x1fabe, 0x1fabf, 0x1fac6, 0x1face, 0x1fadc,
0x1fae0, 0x1fae9, 0x1faf0, 0x1faf9, 0x20000, 0x2fffe, 0x30000, 0x3fffe,
};

enum class _Gcb_property {

_Gcb_Other = 0,
_Gcb_Control = 1,
_Gcb_LF = 2,
_Gcb_CR = 3,
_Gcb_Extend = 4,
_Gcb_Prepend = 5,
_Gcb_SpacingMark = 6,
_Gcb_L = 7,
_Gcb_V = 8,
_Gcb_T = 9,
_Gcb_ZWJ = 10,
_Gcb_LV = 11,
_Gcb_LVT = 12,
_Gcb_Regional_Indicator = 13,
};

inline constexpr int __gcb_shift_bits = 0x4;

inline constexpr uint32_t __gcb_edges[] = {
0x1, 0xa2, 0xb1, 0xd3, 0xe1, 0x200,
0x7f1, 0xa00, 0xad1, 0xae0, 0x3004, 0x3700,
0x4834, 0x48a0, 0x5914, 0x5be0, 0x5bf4, 0x5c00,
0x5c14, 0x5c30, 0x5c44, 0x5c60, 0x5c74, 0x5c80,
0x6005, 0x6060, 0x6104, 0x61b0, 0x61c1, 0x61d0,
0x64b4, 0x6600, 0x6704, 0x6710, 0x6d64, 0x6dd5,
0x6de0, 0x6df4, 0x6e50, 0x6e74, 0x6e90, 0x6ea4,
0x6ee0, 0x70f5, 0x7100, 0x7114, 0x7120, 0x7304,
0x74b0, 0x7a64, 0x7b10, 0x7eb4, 0x7f40, 0x7fd4,
0x7fe0, 0x8164, 0x81a0, 0x81b4, 0x8240, 0x8254,
0x8280, 0x8294, 0x82e0, 0x8594, 0x85c0, 0x8905,
0x8920, 0x8984, 0x8a00, 0x8ca4, 0x8e25, 0x8e34,
0x9036, 0x9040, 0x93a4, 0x93b6, 0x93c4, 0x93d0,
0x93e6, 0x9414, 0x9496, 0x94d4, 0x94e6, 0x9500,
0x9514, 0x9580, 0x9624, 0x9640, 0x9814, 0x9826,
0x9840, 0x9bc4, 0x9bd0, 0x9be4, 0x9bf6, 0x9c14,
0x9c50, 0x9c76, 0x9c90, 0x9cb6, 0x9cd4, 0x9ce0,
0x9d74, 0x9d80, 0x9e24, 0x9e40, 0x9fe4, 0x9ff0,
0xa014, 0xa036, 0xa040, 0xa3c4, 0xa3d0, 0xa3e6,
0xa414, 0xa430, 0xa474, 0xa490, 0xa4b4, 0xa4e0,
0xa514, 0xa520, 0xa704, 0xa720, 0xa754, 0xa760,
0xa814, 0xa836, 0xa840, 0xabc4, 0xabd0, 0xabe6,
0xac14, 0xac60, 0xac74, 0xac96, 0xaca0, 0xacb6,
0xacd4, 0xace0, 0xae24, 0xae40, 0xafa4, 0xb000,
0xb014, 0xb026, 0xb040, 0xb3c4, 0xb3d0, 0xb3e4,
0xb406, 0xb414, 0xb450, 0xb476, 0xb490, 0xb4b6,
0xb4d4, 0xb4e0, 0xb554, 0xb580, 0xb624, 0xb640,
0xb824, 0xb830, 0xbbe4, 0xbbf6, 0xbc04, 0xbc16,
0xbc30, 0xbc66, 0xbc90, 0xbca6, 0xbcd4, 0xbce0,
0xbd74, 0xbd80, 0xc004, 0xc016, 0xc044, 0xc050,
0xc3c4, 0xc3d0, 0xc3e4, 0xc416, 0xc450, 0xc464,
0xc490, 0xc4a4, 0xc4e0, 0xc554, 0xc570, 0xc624,
0xc640, 0xc814, 0xc826, 0xc840, 0xcbc4, 0xcbd0,
0xcbe6, 0xcbf4, 0xcc06, 0xcc24, 0xcc36, 0xcc50,
0xcc64, 0xcc76, 0xcc90, 0xcca6, 0xccc4, 0xcce0,
0xcd54, 0xcd70, 0xce24, 0xce40, 0xcf36, 0xcf40,
0xd004, 0xd026, 0xd040, 0xd3b4, 0xd3d0, 0xd3e4,
0xd3f6, 0xd414, 0xd450, 0xd466, 0xd490, 0xd4a6,
0xd4d4, 0xd4e5, 0xd4f0, 0xd574, 0xd580, 0xd624,
0xd640, 0xd814, 0xd826, 0xd840, 0xdca4, 0xdcb0,
0xdcf4, 0xdd06, 0xdd24, 0xdd50, 0xdd64, 0xdd70,
0xdd86, 0xddf4, 0xde00, 0xdf26, 0xdf40, 0xe314,
0xe320, 0xe336, 0xe344, 0xe3b0, 0xe474, 0xe4f0,
0xeb14, 0xeb20, 0xeb36, 0xeb44, 0xebd0, 0xec84,
0xecf0, 0xf184, 0xf1a0, 0xf354, 0xf360, 0xf374,
0xf380, 0xf394, 0xf3a0, 0xf3e6, 0xf400, 0xf714,
0xf7f6, 0xf804, 0xf850, 0xf864, 0xf880, 0xf8d4,
0xf980, 0xf994, 0xfbd0, 0xfc64, 0xfc70, 0x102d4,
0x10316, 0x10324, 0x10380, 0x10394, 0x103b6, 0x103d4,
0x103f0, 0x10566, 0x10584, 0x105a0, 0x105e4, 0x10610,
0x10714, 0x10750, 0x10824, 0x10830, 0x10846, 0x10854,
0x10870, 0x108d4, 0x108e0, 0x109d4, 0x109e0, 0x11007,
0x11608, 0x11a89, 0x12000, 0x135d4, 0x13600, 0x17124,
0x17156, 0x17160, 0x17324, 0x17346, 0x17350, 0x17524,
0x17540, 0x17724, 0x17740, 0x17b44, 0x17b66, 0x17b74,
0x17be6, 0x17c64, 0x17c76, 0x17c94, 0x17d40, 0x17dd4,
0x17de0, 0x180b4, 0x180e1, 0x180f4, 0x18100, 0x18854,
0x18870, 0x18a94, 0x18aa0, 0x19204, 0x19236, 0x19274,
0x19296, 0x192c0, 0x19306, 0x19324, 0x19336, 0x19394,
0x193c0, 0x1a174, 0x1a196, 0x1a1b4, 0x1a1c0, 0x1a556,
0x1a564, 0x1a576, 0x1a584, 0x1a5f0, 0x1a604, 0x1a610,
0x1a624, 0x1a630, 0x1a654, 0x1a6d6, 0x1a734, 0x1a7d0,
0x1a7f4, 0x1a800, 0x1ab04, 0x1acf0, 0x1b004, 0x1b046,
0x1b050, 0x1b344, 0x1b3b6, 0x1b3c4, 0x1b3d6, 0x1b424,
0x1b436, 0x1b450, 0x1b6b4, 0x1b740, 0x1b804, 0x1b826,
0x1b830, 0x1ba16, 0x1ba24, 0x1ba66, 0x1ba84, 0x1baa6,
0x1bab4, 0x1bae0, 0x1be64, 0x1be76, 0x1be84, 0x1bea6,
0x1bed4, 0x1bee6, 0x1bef4, 0x1bf26, 0x1bf40, 0x1c246,
0x1c2c4, 0x1c346, 0x1c364, 0x1c380, 0x1cd04, 0x1cd30,
0x1cd44, 0x1ce16, 0x1ce24, 0x1ce90, 0x1ced4, 0x1cee0,
0x1cf44, 0x1cf50, 0x1cf76, 0x1cf84, 0x1cfa0, 0x1dc04,
0x1e000, 0x200b1, 0x200c4, 0x200da, 0x200e1, 0x20100,
0x20281, 0x202f0, 0x20601, 0x20700, 0x20d04, 0x20f10,
0x2cef4, 0x2cf20, 0x2d7f4, 0x2d800, 0x2de04, 0x2e000,
0x302a4, 0x30300, 0x30994, 0x309b0, 0xa66f4, 0xa6730,
0xa6744, 0xa67e0, 0xa69e4, 0xa6a00, 0xa6f04, 0xa6f20,
0xa8024, 0xa8030, 0xa8064, 0xa8070, 0xa80b4, 0xa80c0,
0xa8236, 0xa8254, 0xa8276, 0xa8280, 0xa82c4, 0xa82d0,
0xa8806, 0xa8820, 0xa8b46, 0xa8c44, 0xa8c60, 0xa8e04,
0xa8f20, 0xa8ff4, 0xa9000, 0xa9264, 0xa92e0, 0xa9474,
0xa9526, 0xa9540, 0xa9607, 0xa97d0, 0xa9804, 0xa9836,
0xa9840, 0xa9b34, 0xa9b46, 0xa9b64, 0xa9ba6, 0xa9bc4,
0xa9be6, 0xa9c10, 0xa9e54, 0xa9e60, 0xaa294, 0xaa2f6,
0xaa314, 0xaa336, 0xaa354, 0xaa370, 0xaa434, 0xaa440,
0xaa4c4, 0xaa4d6, 0xaa4e0, 0xaa7c4, 0xaa7d0, 0xaab04,
0xaab10, 0xaab24, 0xaab50, 0xaab74, 0xaab90, 0xaabe4,
0xaac00, 0xaac14, 0xaac20, 0xaaeb6, 0xaaec4, 0xaaee6,
0xaaf00, 0xaaf56, 0xaaf64, 0xaaf70, 0xabe36, 0xabe54,
0xabe66, 0xabe84, 0xabe96, 0xabeb0, 0xabec6, 0xabed4,
0xabee0, 0xac00b, 0xac01c, 0xac1cb, 0xac1dc, 0xac38b,
0xac39c, 0xac54b, 0xac55c, 0xac70b, 0xac71c, 0xac8cb,
0xac8dc, 0xaca8b, 0xaca9c, 0xacc4b, 0xacc5c, 0xace0b,
0xace1c, 0xacfcb, 0xacfdc, 0xad18b, 0xad19c, 0xad34b,
0xad35c, 0xad50b, 0xad51c, 0xad6cb, 0xad6dc, 0xad88b,
0xad89c, 0xada4b, 0xada5c, 0xadc0b, 0xadc1c, 0xaddcb,
0xadddc, 0xadf8b, 0xadf9c, 0xae14b, 0xae15c, 0xae30b,
0xae31c, 0xae4cb, 0xae4dc, 0xae68b, 0xae69c, 0xae84b,
0xae85c, 0xaea0b, 0xaea1c, 0xaebcb, 0xaebdc, 0xaed8b,
0xaed9c, 0xaef4b, 0xaef5c, 0xaf10b, 0xaf11c, 0xaf2cb,
0xaf2dc, 0xaf48b, 0xaf49c, 0xaf64b, 0xaf65c, 0xaf80b,
0xaf81c, 0xaf9cb, 0xaf9dc, 0xafb8b, 0xafb9c, 0xafd4b,
0xafd5c, 0xaff0b, 0xaff1c, 0xb00cb, 0xb00dc, 0xb028b,
0xb029c, 0xb044b, 0xb045c, 0xb060b, 0xb061c, 0xb07cb,
0xb07dc, 0xb098b, 0xb099c, 0xb0b4b, 0xb0b5c, 0xb0d0b,
0xb0d1c, 0xb0ecb, 0xb0edc, 0xb108b, 0xb109c, 0xb124b,
0xb125c, 0xb140b, 0xb141c, 0xb15cb, 0xb15dc, 0xb178b,
0xb179c, 0xb194b, 0xb195c, 0xb1b0b, 0xb1b1c, 0xb1ccb,
0xb1cdc, 0xb1e8b, 0xb1e9c, 0xb204b, 0xb205c, 0xb220b,
0xb221c, 0xb23cb, 0xb23dc, 0xb258b, 0xb259c, 0xb274b,
0xb275c, 0xb290b, 0xb291c, 0xb2acb, 0xb2adc, 0xb2c8b,
0xb2c9c, 0xb2e4b, 0xb2e5c, 0xb300b, 0xb301c, 0xb31cb,
0xb31dc, 0xb338b, 0xb339c, 0xb354b, 0xb355c, 0xb370b,
0xb371c, 0xb38cb, 0xb38dc, 0xb3a8b, 0xb3a9c, 0xb3c4b,
0xb3c5c, 0xb3e0b, 0xb3e1c, 0xb3fcb, 0xb3fdc, 0xb418b,
0xb419c, 0xb434b, 0xb435c, 0xb450b, 0xb451c, 0xb46cb,
0xb46dc, 0xb488b, 0xb489c, 0xb4a4b, 0xb4a5c, 0xb4c0b,
0xb4c1c, 0xb4dcb, 0xb4ddc, 0xb4f8b, 0xb4f9c, 0xb514b,
0xb515c, 0xb530b, 0xb531c, 0xb54cb, 0xb54dc, 0xb568b,
0xb569c, 0xb584b, 0xb585c, 0xb5a0b, 0xb5a1c, 0xb5bcb,
0xb5bdc, 0xb5d8b, 0xb5d9c, 0xb5f4b, 0xb5f5c, 0xb610b,
0xb611c, 0xb62cb, 0xb62dc, 0xb648b, 0xb649c, 0xb664b,
0xb665c, 0xb680b, 0xb681c, 0xb69cb, 0xb69dc, 0xb6b8b,
0xb6b9c, 0xb6d4b, 0xb6d5c, 0xb6f0b, 0xb6f1c, 0xb70cb,
0xb70dc, 0xb728b, 0xb729c, 0xb744b, 0xb745c, 0xb760b,
0xb761c, 0xb77cb, 0xb77dc, 0xb798b, 0xb799c, 0xb7b4b,
0xb7b5c, 0xb7d0b, 0xb7d1c, 0xb7ecb, 0xb7edc, 0xb808b,
0xb809c, 0xb824b, 0xb825c, 0xb840b, 0xb841c, 0xb85cb,
0xb85dc, 0xb878b, 0xb879c, 0xb894b, 0xb895c, 0xb8b0b,
0xb8b1c, 0xb8ccb, 0xb8cdc, 0xb8e8b, 0xb8e9c, 0xb904b,
0xb905c, 0xb920b, 0xb921c, 0xb93cb, 0xb93dc, 0xb958b,
0xb959c, 0xb974b, 0xb975c, 0xb990b, 0xb991c, 0xb9acb,
0xb9adc, 0xb9c8b, 0xb9c9c, 0xb9e4b, 0xb9e5c, 0xba00b,
0xba01c, 0xba1cb, 0xba1dc, 0xba38b, 0xba39c, 0xba54b,
0xba55c, 0xba70b, 0xba71c, 0xba8cb, 0xba8dc, 0xbaa8b,
0xbaa9c, 0xbac4b, 0xbac5c, 0xbae0b, 0xbae1c, 0xbafcb,
0xbafdc, 0xbb18b, 0xbb19c, 0xbb34b, 0xbb35c, 0xbb50b,
0xbb51c, 0xbb6cb, 0xbb6dc, 0xbb88b, 0xbb89c, 0xbba4b,
0xbba5c, 0xbbc0b, 0xbbc1c, 0xbbdcb, 0xbbddc, 0xbbf8b,
0xbbf9c, 0xbc14b, 0xbc15c, 0xbc30b, 0xbc31c, 0xbc4cb,
0xbc4dc, 0xbc68b, 0xbc69c, 0xbc84b, 0xbc85c, 0xbca0b,
0xbca1c, 0xbcbcb, 0xbcbdc, 0xbcd8b, 0xbcd9c, 0xbcf4b,
0xbcf5c, 0xbd10b, 0xbd11c, 0xbd2cb, 0xbd2dc, 0xbd48b,
0xbd49c, 0xbd64b, 0xbd65c, 0xbd80b, 0xbd81c, 0xbd9cb,
0xbd9dc, 0xbdb8b, 0xbdb9c, 0xbdd4b, 0xbdd5c, 0xbdf0b,
0xbdf1c, 0xbe0cb, 0xbe0dc, 0xbe28b, 0xbe29c, 0xbe44b,
0xbe45c, 0xbe60b, 0xbe61c, 0xbe7cb, 0xbe7dc, 0xbe98b,
0xbe99c, 0xbeb4b, 0xbeb5c, 0xbed0b, 0xbed1c, 0xbeecb,
0xbeedc, 0xbf08b, 0xbf09c, 0xbf24b, 0xbf25c, 0xbf40b,
0xbf41c, 0xbf5cb, 0xbf5dc, 0xbf78b, 0xbf79c, 0xbf94b,
0xbf95c, 0xbfb0b, 0xbfb1c, 0xbfccb, 0xbfcdc, 0xbfe8b,
0xbfe9c, 0xc004b, 0xc005c, 0xc020b, 0xc021c, 0xc03cb,
0xc03dc, 0xc058b, 0xc059c, 0xc074b, 0xc075c, 0xc090b,
0xc091c, 0xc0acb, 0xc0adc, 0xc0c8b, 0xc0c9c, 0xc0e4b,
0xc0e5c, 0xc100b, 0xc101c, 0xc11cb, 0xc11dc, 0xc138b,
0xc139c, 0xc154b, 0xc155c, 0xc170b, 0xc171c, 0xc18cb,
0xc18dc, 0xc1a8b, 0xc1a9c, 0xc1c4b, 0xc1c5c, 0xc1e0b,
0xc1e1c, 0xc1fcb, 0xc1fdc, 0xc218b, 0xc219c, 0xc234b,
0xc235c, 0xc250b, 0xc251c, 0xc26cb, 0xc26dc, 0xc288b,
0xc289c, 0xc2a4b, 0xc2a5c, 0xc2c0b, 0xc2c1c, 0xc2dcb,
0xc2ddc, 0xc2f8b, 0xc2f9c, 0xc314b, 0xc315c, 0xc330b,
0xc331c, 0xc34cb, 0xc34dc, 0xc368b, 0xc369c, 0xc384b,
0xc385c, 0xc3a0b, 0xc3a1c, 0xc3bcb, 0xc3bdc, 0xc3d8b,
0xc3d9c, 0xc3f4b, 0xc3f5c, 0xc410b, 0xc411c, 0xc42cb,
0xc42dc, 0xc448b, 0xc449c, 0xc464b, 0xc465c, 0xc480b,
0xc481c, 0xc49cb, 0xc49dc, 0xc4b8b, 0xc4b9c, 0xc4d4b,
0xc4d5c, 0xc4f0b, 0xc4f1c, 0xc50cb, 0xc50dc, 0xc528b,
0xc529c, 0xc544b, 0xc545c, 0xc560b, 0xc561c, 0xc57cb,
0xc57dc, 0xc598b, 0xc599c, 0xc5b4b, 0xc5b5c, 0xc5d0b,
0xc5d1c, 0xc5ecb, 0xc5edc, 0xc608b, 0xc609c, 0xc624b,
0xc625c, 0xc640b, 0xc641c, 0xc65cb, 0xc65dc, 0xc678b,
0xc679c, 0xc694b, 0xc695c, 0xc6b0b, 0xc6b1c, 0xc6ccb,
0xc6cdc, 0xc6e8b, 0xc6e9c, 0xc704b, 0xc705c, 0xc720b,
0xc721c, 0xc73cb, 0xc73dc, 0xc758b, 0xc759c, 0xc774b,
0xc775c, 0xc790b, 0xc791c, 0xc7acb, 0xc7adc, 0xc7c8b,
0xc7c9c, 0xc7e4b, 0xc7e5c, 0xc800b, 0xc801c, 0xc81cb,
0xc81dc, 0xc838b, 0xc839c, 0xc854b, 0xc855c, 0xc870b,
0xc871c, 0xc88cb, 0xc88dc, 0xc8a8b, 0xc8a9c, 0xc8c4b,
0xc8c5c, 0xc8e0b, 0xc8e1c, 0xc8fcb, 0xc8fdc, 0xc918b,
0xc919c, 0xc934b, 0xc935c, 0xc950b, 0xc951c, 0xc96cb,
0xc96dc, 0xc988b, 0xc989c, 0xc9a4b, 0xc9a5c, 0xc9c0b,
0xc9c1c, 0xc9dcb, 0xc9ddc, 0xc9f8b, 0xc9f9c, 0xca14b,
0xca15c, 0xca30b, 0xca31c, 0xca4cb, 0xca4dc, 0xca68b,
0xca69c, 0xca84b, 0xca85c, 0xcaa0b, 0xcaa1c, 0xcabcb,
0xcabdc, 0xcad8b, 0xcad9c, 0xcaf4b, 0xcaf5c, 0xcb10b,
0xcb11c, 0xcb2cb, 0xcb2dc, 0xcb48b, 0xcb49c, 0xcb64b,
0xcb65c, 0xcb80b, 0xcb81c, 0xcb9cb, 0xcb9dc, 0xcbb8b,
0xcbb9c, 0xcbd4b, 0xcbd5c, 0xcbf0b, 0xcbf1c, 0xcc0cb,
0xcc0dc, 0xcc28b, 0xcc29c, 0xcc44b, 0xcc45c, 0xcc60b,
0xcc61c, 0xcc7cb, 0xcc7dc, 0xcc98b, 0xcc99c, 0xccb4b,
0xccb5c, 0xccd0b, 0xccd1c, 0xccecb, 0xccedc, 0xcd08b,
0xcd09c, 0xcd24b, 0xcd25c, 0xcd40b, 0xcd41c, 0xcd5cb,
0xcd5dc, 0xcd78b, 0xcd79c, 0xcd94b, 0xcd95c, 0xcdb0b,
0xcdb1c, 0xcdccb, 0xcdcdc, 0xcde8b, 0xcde9c, 0xce04b,
0xce05c, 0xce20b, 0xce21c, 0xce3cb, 0xce3dc, 0xce58b,
0xce59c, 0xce74b, 0xce75c, 0xce90b, 0xce91c, 0xceacb,
0xceadc, 0xcec8b, 0xcec9c, 0xcee4b, 0xcee5c, 0xcf00b,
0xcf01c, 0xcf1cb, 0xcf1dc, 0xcf38b, 0xcf39c, 0xcf54b,
0xcf55c, 0xcf70b, 0xcf71c, 0xcf8cb, 0xcf8dc, 0xcfa8b,
0xcfa9c, 0xcfc4b, 0xcfc5c, 0xcfe0b, 0xcfe1c, 0xcffcb,
0xcffdc, 0xd018b, 0xd019c, 0xd034b, 0xd035c, 0xd050b,
0xd051c, 0xd06cb, 0xd06dc, 0xd088b, 0xd089c, 0xd0a4b,
0xd0a5c, 0xd0c0b, 0xd0c1c, 0xd0dcb, 0xd0ddc, 0xd0f8b,
0xd0f9c, 0xd114b, 0xd115c, 0xd130b, 0xd131c, 0xd14cb,
0xd14dc, 0xd168b, 0xd169c, 0xd184b, 0xd185c, 0xd1a0b,
0xd1a1c, 0xd1bcb, 0xd1bdc, 0xd1d8b, 0xd1d9c, 0xd1f4b,
0xd1f5c, 0xd210b, 0xd211c, 0xd22cb, 0xd22dc, 0xd248b,
0xd249c, 0xd264b, 0xd265c, 0xd280b, 0xd281c, 0xd29cb,
0xd29dc, 0xd2b8b, 0xd2b9c, 0xd2d4b, 0xd2d5c, 0xd2f0b,
0xd2f1c, 0xd30cb, 0xd30dc, 0xd328b, 0xd329c, 0xd344b,
0xd345c, 0xd360b, 0xd361c, 0xd37cb, 0xd37dc, 0xd398b,
0xd399c, 0xd3b4b, 0xd3b5c, 0xd3d0b, 0xd3d1c, 0xd3ecb,
0xd3edc, 0xd408b, 0xd409c, 0xd424b, 0xd425c, 0xd440b,
0xd441c, 0xd45cb, 0xd45dc, 0xd478b, 0xd479c, 0xd494b,
0xd495c, 0xd4b0b, 0xd4b1c, 0xd4ccb, 0xd4cdc, 0xd4e8b,
0xd4e9c, 0xd504b, 0xd505c, 0xd520b, 0xd521c, 0xd53cb,
0xd53dc, 0xd558b, 0xd559c, 0xd574b, 0xd575c, 0xd590b,
0xd591c, 0xd5acb, 0xd5adc, 0xd5c8b, 0xd5c9c, 0xd5e4b,
0xd5e5c, 0xd600b, 0xd601c, 0xd61cb, 0xd61dc, 0xd638b,
0xd639c, 0xd654b, 0xd655c, 0xd670b, 0xd671c, 0xd68cb,
0xd68dc, 0xd6a8b, 0xd6a9c, 0xd6c4b, 0xd6c5c, 0xd6e0b,
0xd6e1c, 0xd6fcb, 0xd6fdc, 0xd718b, 0xd719c, 0xd734b,
0xd735c, 0xd750b, 0xd751c, 0xd76cb, 0xd76dc, 0xd788b,
0xd789c, 0xd7a40, 0xd7b08, 0xd7c70, 0xd7cb9, 0xd7fc0,
0xfb1e4, 0xfb1f0, 0xfe004, 0xfe100, 0xfe204, 0xfe300,
0xfeff1, 0xff000, 0xff9e4, 0xffa00, 0xfff01, 0xfffc0,
0x101fd4, 0x101fe0, 0x102e04, 0x102e10, 0x103764, 0x1037b0,
0x10a014, 0x10a040, 0x10a054, 0x10a070, 0x10a0c4, 0x10a100,
0x10a384, 0x10a3b0, 0x10a3f4, 0x10a400, 0x10ae54, 0x10ae70,
0x10d244, 0x10d280, 0x10eab4, 0x10ead0, 0x10efd4, 0x10f000,
0x10f464, 0x10f510, 0x10f824, 0x10f860, 0x110006, 0x110014,
0x110026, 0x110030, 0x110384, 0x110470, 0x110704, 0x110710,
0x110734, 0x110750, 0x1107f4, 0x110826, 0x110830, 0x110b06,
0x110b34, 0x110b76, 0x110b94, 0x110bb0, 0x110bd5, 0x110be0,
0x110c24, 0x110c30, 0x110cd5, 0x110ce0, 0x111004, 0x111030,
0x111274, 0x1112c6, 0x1112d4, 0x111350, 0x111456, 0x111470,
0x111734, 0x111740, 0x111804, 0x111826, 0x111830, 0x111b36,
0x111b64, 0x111bf6, 0x111c10, 0x111c25, 0x111c40, 0x111c94,
0x111cd0, 0x111ce6, 0x111cf4, 0x111d00, 0x1122c6, 0x1122f4,
0x112326, 0x112344, 0x112356, 0x112364, 0x112380, 0x1123e4,
0x1123f0, 0x112414, 0x112420, 0x112df4, 0x112e06, 0x112e34,
0x112eb0, 0x113004, 0x113026, 0x113040, 0x1133b4, 0x1133d0,
0x1133e4, 0x1133f6, 0x113404, 0x113416, 0x113450, 0x113476,
0x113490, 0x1134b6, 0x1134e0, 0x113574, 0x113580, 0x113626,
0x113640, 0x113664, 0x1136d0, 0x113704, 0x113750, 0x114356,
0x114384, 0x114406, 0x114424, 0x114456, 0x114464, 0x114470,
0x1145e4, 0x1145f0, 0x114b04, 0x114b16, 0x114b34, 0x114b96,
0x114ba4, 0x114bb6, 0x114bd4, 0x114be6, 0x114bf4, 0x114c16,
0x114c24, 0x114c40, 0x115af4, 0x115b06, 0x115b24, 0x115b60,
0x115b86, 0x115bc4, 0x115be6, 0x115bf4, 0x115c10, 0x115dc4,
0x115de0, 0x116306, 0x116334, 0x1163b6, 0x1163d4, 0x1163e6,
0x1163f4, 0x116410, 0x116ab4, 0x116ac6, 0x116ad4, 0x116ae6,
0x116b04, 0x116b66, 0x116b74, 0x116b80, 0x1171d4, 0x117200,
0x117224, 0x117266, 0x117274, 0x1172c0, 0x1182c6, 0x1182f4,
0x118386, 0x118394, 0x1183b0, 0x119304, 0x119316, 0x119360,
0x119376, 0x119390, 0x1193b4, 0x1193d6, 0x1193e4, 0x1193f5,
0x119406, 0x119415, 0x119426, 0x119434, 0x119440, 0x119d16,
0x119d44, 0x119d80, 0x119da4, 0x119dc6, 0x119e04, 0x119e10,
0x119e46, 0x119e50, 0x11a014, 0x11a0b0, 0x11a334, 0x11a396,
0x11a3a5, 0x11a3b4, 0x11a3f0, 0x11a474, 0x11a480, 0x11a514,
0x11a576, 0x11a594, 0x11a5c0, 0x11a845, 0x11a8a4, 0x11a976,
0x11a984, 0x11a9a0, 0x11c2f6, 0x11c304, 0x11c370, 0x11c384,
0x11c3e6, 0x11c3f4, 0x11c400, 0x11c924, 0x11ca80, 0x11ca96,
0x11caa4, 0x11cb16, 0x11cb24, 0x11cb46, 0x11cb54, 0x11cb70,
0x11d314, 0x11d370, 0x11d3a4, 0x11d3b0, 0x11d3c4, 0x11d3e0,
0x11d3f4, 0x11d465, 0x11d474, 0x11d480, 0x11d8a6, 0x11d8f0,
0x11d904, 0x11d920, 0x11d936, 0x11d954, 0x11d966, 0x11d974,
0x11d980, 0x11ef34, 0x11ef56, 0x11ef70, 0x11f004, 0x11f025,
0x11f036, 0x11f040, 0x11f346, 0x11f364, 0x11f3b0, 0x11f3e6,
0x11f404, 0x11f416, 0x11f424, 0x11f430, 0x134301, 0x134404,
0x134410, 0x134474, 0x134560, 0x16af04, 0x16af50, 0x16b304,
0x16b370, 0x16f4f4, 0x16f500, 0x16f516, 0x16f880, 0x16f8f4,
0x16f930, 0x16fe44, 0x16fe50, 0x16ff06, 0x16ff20, 0x1bc9d4,
0x1bc9f0, 0x1bca01, 0x1bca40, 0x1cf004, 0x1cf2e0, 0x1cf304,
0x1cf470, 0x1d1654, 0x1d1666, 0x1d1674, 0x1d16a0, 0x1d16d6,
0x1d16e4, 0x1d1731, 0x1d17b4, 0x1d1830, 0x1d1854, 0x1d18c0,
0x1d1aa4, 0x1d1ae0, 0x1d2424, 0x1d2450, 0x1da004, 0x1da370,
0x1da3b4, 0x1da6d0, 0x1da754, 0x1da760, 0x1da844, 0x1da850,
0x1da9b4, 0x1daa00, 0x1daa14, 0x1dab00, 0x1e0004, 0x1e0070,
0x1e0084, 0x1e0190, 0x1e01b4, 0x1e0220, 0x1e0234, 0x1e0250,
0x1e0264, 0x1e02b0, 0x1e08f4, 0x1e0900, 0x1e1304, 0x1e1370,
0x1e2ae4, 0x1e2af0, 0x1e2ec4, 0x1e2f00, 0x1e4ec4, 0x1e4f00,
0x1e8d04, 0x1e8d70, 0x1e9444, 0x1e94b0, 0x1f1e6d, 0x1f2000,
0x1f3fb4, 0x1f4000, 0xe00001, 0xe00204, 0xe00801, 0xe01004,
0xe01f01, 0xe10000,
};

inline constexpr char32_t __incb_linkers[] = {

0x094d, 0x09cd, 0x0acd, 0x0b4d, 0x0c4d, 0x0d4d,
};

enum class _InCB { _Consonant = 1, _Extend = 2 };

inline constexpr uint32_t __incb_edges[] = {

0xc02, 0xd3c, 0xd42, 0xdc0, 0x120e, 0x1220,
0x1646, 0x16f8, 0x16fe, 0x1700, 0x1706, 0x170c,
0x1712, 0x1718, 0x171e, 0x1720, 0x1842, 0x186c,
0x192e, 0x1980, 0x19c2, 0x19c4, 0x1b5a, 0x1b74,
0x1b7e, 0x1b94, 0x1b9e, 0x1ba4, 0x1baa, 0x1bb8,
0x1c46, 0x1c48, 0x1cc2, 0x1d2c, 0x1fae, 0x1fd0,
0x1ff6, 0x1ff8, 0x205a, 0x2068, 0x206e, 0x2090,
0x2096, 0x20a0, 0x20a6, 0x20b8, 0x2166, 0x2170,
0x2262, 0x2280, 0x232a, 0x2388, 0x238e, 0x2400,
0x2455, 0x24e8, 0x24f2, 0x24f4, 0x2546, 0x2554,
0x2561, 0x2580, 0x25e1, 0x2600, 0x2655, 0x26a4,
0x26a9, 0x26c4, 0x26c9, 0x26cc, 0x26d9, 0x26e8,
0x26f2, 0x26f4, 0x2771, 0x2778, 0x277d, 0x2780,
0x27c1, 0x27c8, 0x27fa, 0x27fc, 0x28f2, 0x28f4,
0x2a55, 0x2aa4, 0x2aa9, 0x2ac4, 0x2ac9, 0x2ad0,
0x2ad5, 0x2ae8, 0x2af2, 0x2af4, 0x2be5, 0x2be8,
0x2c55, 0x2ca4, 0x2ca9, 0x2cc4, 0x2cc9, 0x2cd0,
0x2cd5, 0x2ce8, 0x2cf2, 0x2cf4, 0x2d71, 0x2d78,
0x2d7d, 0x2d80, 0x2dc5, 0x2dc8, 0x3055, 0x30a4,
0x30a9, 0x30e8, 0x30f2, 0x30f4, 0x3156, 0x315c,
0x3161, 0x316c, 0x32f2, 0x32f4, 0x3455, 0x34ee,
0x34f4, 0x38e2, 0x38ec, 0x3922, 0x3930, 0x3ae2,
0x3aec, 0x3b22, 0x3b30, 0x3c62, 0x3c68, 0x3cd6,
0x3cd8, 0x3cde, 0x3ce0, 0x3ce6, 0x3ce8, 0x3dc6,
0x3dcc, 0x3dd2, 0x3dd4, 0x3dea, 0x3df8, 0x3e02,
0x3e04, 0x3e0a, 0x3e14, 0x3e1a, 0x3e20, 0x3f1a,
0x3f1c, 0x40de, 0x40e0, 0x40e6, 0x40ec, 0x4236,
0x4238, 0x4d76, 0x4d80, 0x5c52, 0x5c54, 0x5f4a,
0x5f4c, 0x5f76, 0x5f78, 0x62a6, 0x62a8, 0x64e6,
0x64f0, 0x685e, 0x6864, 0x6982, 0x6984, 0x69d6,
0x69f4, 0x69fe, 0x6a00, 0x6ac2, 0x6af8, 0x6afe,
0x6b3c, 0x6cd2, 0x6cd4, 0x6dae, 0x6dd0, 0x6eae,
0x6eb0, 0x6f9a, 0x6f9c, 0x70de, 0x70e0, 0x7342,
0x734c, 0x7352, 0x7384, 0x738a, 0x73a4, 0x73b6,
0x73b8, 0x73d2, 0x73d4, 0x73e2, 0x73e8, 0x7702,
0x7800, 0x8036, 0x8038, 0x8342, 0x8374, 0x8386,
0x8388, 0x8396, 0x83c4, 0xb3be, 0xb3c8, 0xb5fe,
0xb600, 0xb782, 0xb800, 0xc0aa, 0xc0c0, 0xc266,
0xc26c, 0x299be, 0x299c0, 0x299d2, 0x299f8, 0x29a7a,
0x29a80, 0x29bc2, 0x29bc8, 0x2a0b2, 0x2a0b4, 0x2a382,
0x2a3c8, 0x2a4ae, 0x2a4b8, 0x2a6ce, 0x2a6d0, 0x2aac2,
0x2aac4, 0x2aaca, 0x2aad4, 0x2aade, 0x2aae4, 0x2aafa,
0x2ab00, 0x2ab06, 0x2ab08, 0x2abda, 0x2abdc, 0x2afb6,
0x2afb8, 0x3ec7a, 0x3ec7c, 0x3f882, 0x3f8c0, 0x407f6,
0x407f8, 0x40b82, 0x40b84, 0x40dda, 0x40dec, 0x42836,
0x42838, 0x4283e, 0x42840, 0x428e2, 0x428ec, 0x428fe,
0x42900, 0x42b96, 0x42b9c, 0x43492, 0x434a0, 0x43aae,
0x43ab4, 0x43bf6, 0x43c00, 0x43d1a, 0x43d44, 0x43e0a,
0x43e18, 0x441c2, 0x441c4, 0x441fe, 0x44200, 0x442ea,
0x442ec, 0x44402, 0x4440c, 0x444ce, 0x444d4, 0x445ce,
0x445d0, 0x4472a, 0x4472c, 0x448da, 0x448dc, 0x44ba6,
0x44bac, 0x44cee, 0x44cf4, 0x44d9a, 0x44db4, 0x44dc2,
0x44dd4, 0x4511a, 0x4511c, 0x4517a, 0x4517c, 0x4530e,
0x45310, 0x45702, 0x45704, 0x45ade, 0x45ae0, 0x45cae,
0x45cb0, 0x460ea, 0x460ec, 0x464fa, 0x464fc, 0x4650e,
0x46510, 0x468d2, 0x468d4, 0x4691e, 0x46920, 0x46a66,
0x46a68, 0x4750a, 0x4750c, 0x47512, 0x47518, 0x4765e,
0x47660, 0x47d0a, 0x47d0c, 0x5abc2, 0x5abd4, 0x5acc2,
0x5acdc, 0x6f27a, 0x6f27c, 0x74596, 0x74598, 0x7459e,
0x745a8, 0x745ba, 0x745cc, 0x745ee, 0x7460c, 0x74616,
0x74630, 0x746aa, 0x746b8, 0x7490a, 0x74914, 0x78002,
0x7801c, 0x78022, 0x78064, 0x7806e, 0x78088, 0x7808e,
0x78094, 0x7809a, 0x780ac, 0x7823e, 0x78240, 0x784c2,
0x784dc, 0x78aba, 0x78abc, 0x78bb2, 0x78bc0, 0x793b2,
0x793c0, 0x7a342, 0x7a35c, 0x7a512, 0x7a52c,
};

inline constexpr char32_t __xpicto_edges[] = {

0xa9, 0xaa, 0xae, 0xaf, 0x203c, 0x203d, 0x2049, 0x204a,
0x2122, 0x2123, 0x2139, 0x213a, 0x2194, 0x219a, 0x21a9, 0x21ab,
0x231a, 0x231c, 0x2328, 0x2329, 0x2388, 0x2389, 0x23cf, 0x23d0,
0x23e9, 0x23f4, 0x23f8, 0x23fb, 0x24c2, 0x24c3, 0x25aa, 0x25ac,
0x25b6, 0x25b7, 0x25c0, 0x25c1, 0x25fb, 0x25ff, 0x2600, 0x2606,
0x2607, 0x2613, 0x2614, 0x2686, 0x2690, 0x2706, 0x2708, 0x2713,
0x2714, 0x2715, 0x2716, 0x2717, 0x271d, 0x271e, 0x2721, 0x2722,
0x2728, 0x2729, 0x2733, 0x2735, 0x2744, 0x2745, 0x2747, 0x2748,
0x274c, 0x274d, 0x274e, 0x274f, 0x2753, 0x2756, 0x2757, 0x2758,
0x2763, 0x2768, 0x2795, 0x2798, 0x27a1, 0x27a2, 0x27b0, 0x27b1,
0x27bf, 0x27c0, 0x2934, 0x2936, 0x2b05, 0x2b08, 0x2b1b, 0x2b1d,
0x2b50, 0x2b51, 0x2b55, 0x2b56, 0x3030, 0x3031, 0x303d, 0x303e,
0x3297, 0x3298, 0x3299, 0x329a, 0x1f000, 0x1f100, 0x1f10d, 0x1f110,
0x1f12f, 0x1f130, 0x1f16c, 0x1f172, 0x1f17e, 0x1f180, 0x1f18e, 0x1f18f,
0x1f191, 0x1f19b, 0x1f1ad, 0x1f1e6, 0x1f201, 0x1f210, 0x1f21a, 0x1f21b,
0x1f22f, 0x1f230, 0x1f232, 0x1f23b, 0x1f23c, 0x1f240, 0x1f249, 0x1f3fb,
0x1f400, 0x1f53e, 0x1f546, 0x1f650, 0x1f680, 0x1f700, 0x1f774, 0x1f780,
0x1f7d5, 0x1f800, 0x1f80c, 0x1f810, 0x1f848, 0x1f850, 0x1f85a, 0x1f860,
0x1f888, 0x1f890, 0x1f8ae, 0x1f900, 0x1f90c, 0x1f93b, 0x1f93c, 0x1f946,
0x1f947, 0x1fb00, 0x1fc00, 0x1fffe,
};
# 597 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/unicode.h" 2 3

constexpr int
__field_width(char32_t __c) noexcept
{
if (__c < __width_edges[0]) [[likely]]
return 1;

auto* __p = std::upper_bound(__width_edges, std::end(__width_edges), __c);

return (__p - __width_edges) % 2 + 1;
}

constexpr _Gcb_property
__grapheme_cluster_break_property(char32_t __c) noexcept
{
constexpr uint32_t __mask = (1 << __gcb_shift_bits) - 1;
auto* __end = std::end(__gcb_edges);
auto* __p = std::lower_bound(__gcb_edges, __end,
(__c << __gcb_shift_bits) | __mask);
return _Gcb_property(__p[-1] & __mask);
}

constexpr bool
__is_incb_linker(char32_t __c) noexcept
{
const auto __end = std::end(__incb_linkers);

return std::find(__incb_linkers, end, c) != __end;

}

constexpr _InCB
__incb_property(char32_t __c) noexcept
{
if ((__c << 2) < __incb_edges[0]) [[likely]]
return _InCB(0);

constexpr uint32_t __mask = 0x3;

auto* __end = std::end(__incb_edges);
auto* __p = std::lower_bound(__incb_edges, __end, (__c << 2) | __mask);
return _InCB(__p[-1] & __mask);
}

constexpr bool
__is_extended_pictographic(char32_t __c)
{
if (__c < __xpicto_edges[0]) [[likely]]
return 0;

auto* __p = std::upper_bound(__xpicto_edges, std::end(__xpicto_edges), __c);

return (__p - __xpicto_edges) % 2;
}

struct _Grapheme_cluster_iterator_base
{
char32_t _M_c;
_Gcb_property _M_prop;
enum class _XPicto : unsigned char { _Init, _Zwj, _Matched, _Failed };
_XPicto _M_xpicto_seq_state = _XPicto::_Init;
unsigned char _M_RI_count = 0;
bool _M_incb_linker_seen = false;

constexpr void
_M_reset(char32_t __c, _Gcb_property __p)
{
_M_c = __c;
_M_prop = __p;
_M_xpicto_seq_state = _XPicto::_Init;
_M_RI_count = 0;
_M_incb_linker_seen = false;
}

constexpr void
_M_update_xpicto_seq_state(char32_t __c, _Gcb_property __p)
{
if (_M_xpicto_seq_state == _XPicto::_Failed)
return;

auto __next_state = _XPicto::_Failed;

if (_M_xpicto_seq_state != _XPicto::_Zwj)
{
if (__p == _Gcb_property::_Gcb_ZWJ)
{
if (_M_xpicto_seq_state == _XPicto::_Matched)
__next_state = _XPicto::_Zwj;

else if (__is_extended_pictographic(_M_c))
__next_state = _XPicto::_Zwj;
}
else if (__p == _Gcb_property::_Gcb_Extend)
__next_state = _M_xpicto_seq_state;
}
else
{

if (__p == _Gcb_property::_Gcb_Other
&& __is_extended_pictographic(__c))
__next_state = _XPicto::_Matched;
}
_M_xpicto_seq_state = __next_state;
}

constexpr void
_M_update_ri_count(_Gcb_property __p)
{
if (__p == _Gcb_property::_Gcb_Regional_Indicator)
++_M_RI_count;
else
_M_RI_count = 0;
}

constexpr void
_M_update_incb_state(char32_t __c, _Gcb_property)
{
if (__is_incb_linker(__c))
_M_incb_linker_seen = true;
}
};

template<ranges::forward_range _View> requires ranges::view<_View>

class _Grapheme_cluster_view
: public ranges::view_interface<_Grapheme_cluster_view<_View>>
{
public:

constexpr
_Grapheme_cluster_view(_View __v)
: _M_begin(_Utf32_view<_View>(std::move(__v)).begin())
{ }

constexpr auto begin() const { return _M_begin; }

constexpr auto end() const { return _M_begin.end(); }

private:
struct _Iterator : private _Grapheme_cluster_iterator_base
{
private:

using _U32_iterator = ranges::iterator_t<_Utf32_view<_View>>;

public:

using value_type = char32_t;

using iterator_concept = forward_iterator_tag;
using difference_type = ptrdiff_t;

constexpr
_Iterator(_U32_iterator __i)
: _M_base(__i)
{
if (__i != __i.end())
{
_M_c = *__i;
_M_prop = __grapheme_cluster_break_property(_M_c);
}
}

constexpr value_type
operator*() const
{ return _M_c; }
constexpr auto
operator->() const
{ return &_M_c; }

constexpr _Iterator&
operator++()
{
const auto __end = _M_base.end();
if (_M_base != __end)
{
auto __p_prev = _M_prop;
auto __it = _M_base;
while (++__it != __end)
{
char32_t __c = *__it;
auto __p = __grapheme_cluster_break_property(*__it);
_M_update_xpicto_seq_state(__c, __p);
_M_update_ri_count(__p);
_M_update_incb_state(__c, __p);
if (_M_is_break(__p_prev, __p, __it))
{

_M_reset(__c, __p);
break;
}
__p_prev = __p;
}
_M_base = __it;
}
return *this;
}

constexpr _Iterator
operator++(int)
{
auto __tmp = *this;
++this;
return __tmp;
}

constexpr bool
operator==(const _Iterator& __i) const
{ return _M_base == __i._M_base; }

constexpr bool
operator==(const ranges::sentinel_t<_View>& __i) const
{ return _M_base == __i; }

constexpr auto base() const { return _M_base.base(); }

constexpr auto end() const { return _M_base.end(); }

constexpr int
width() const noexcept
{ return __field_width(_M_c); }

private:
_U32_iterator _M_base;

constexpr bool
_M_is_break(_Gcb_property __p1, _Gcb_property __p2,
_U32_iterator __curr) const
{
using enum _Gcb_property;

if (__p1 == _Gcb_Control || __p1 == _Gcb_LF)

return true;

if (__p1 == _Gcb_CR)
return __p2 != _Gcb_LF;

if (__p2 == _Gcb_Control || __p2 == _Gcb_CR || __p2 == _Gcb_LF)

return true;

if (__p1 == _Gcb_L)
switch (__p2)
{
case _Gcb_L:
case _Gcb_V:
case _Gcb_LV:
case _Gcb_LVT:
return false;
default:
return true;
}

if (__p1 == _Gcb_LV || __p1 == _Gcb_V)

switch (__p2)
{
case _Gcb_V:
case _Gcb_T:
return false;
default:
return true;
}

if (__p1 == _Gcb_LVT || __p1 == _Gcb_T)

return __p2 != _Gcb_T;

if (__p2 == _Gcb_Extend || __p2 == _Gcb_ZWJ)

return false;
if (__p2 == _Gcb_SpacingMark)
return false;

if (__p1 == _Gcb_Prepend)
return false;

if (_M_incb_linker_seen
&& __incb_property(_M_c) == _InCB::_Consonant
&& __incb_property(*__curr) == _InCB::_Consonant)
{

bool __have_linker = false;

auto __it = _M_base;
while (++__it != __curr)
{
if (__is_incb_linker(*__it))
__have_linker = true;
else
{
auto __incb = __incb_property(*__it);
if (__incb == _InCB::_Consonant)
__have_linker = false;
else if (__incb != _InCB::_Extend)
break;
}
}
if (__it == __curr && __have_linker)
return false;
}

if (__p1 == _Gcb_ZWJ && _M_xpicto_seq_state == _XPicto::_Matched)

return false;

if (__p1 == _Gcb_property::_Gcb_Regional_Indicator && p1 == p2)

return (_M_RI_count & 1) == 0;

return true;
}
};

_Iterator _M_begin;
};

}
template<typename _CharT>
constexpr size_t
__field_width(basic_string_view<_CharT> __s)
{
if (__s.empty()) [[unlikely]]
return 0;
_Grapheme_cluster_view<basic_string_view<_CharT>> __gc(__s);
auto __it = __gc.begin();
const auto __end = __gc.end();
size_t __n = __it.width();
while (++__it != __end)
__n += __it.width();
return __n;
}

template<typename _CharT>
constexpr size_t
__truncate(basic_string_view<_CharT>& __s, size_t __max)
{
if (__s.empty()) [[unlikely]]
return 0;

_Grapheme_cluster_view<basic_string_view<_CharT>> __gc(__s);
auto __it = __gc.begin();
const auto __end = __gc.end();
size_t __n = __it.width();
if (__n > __max)
{
__s = {};
return 0;
}
while (++__it != __end)
{
size_t __n2 = __n + __it.width();
if (__n2 > __max)
{
__s = basic_string_view<_CharT>(__s.begin(), __it.base());
return __n;
}
__n = __n2;
}
return __n;
}

template<typename _CharT>
consteval bool
__literal_encoding_is_unicode()
{
if constexpr (is_same_v<_CharT, char16_t>)
return true;
else if constexpr (is_same_v<_CharT, char32_t>)
return true;

else if constexpr (is_same_v<_CharT, char8_t>)

return true;
const char* __enc = "";

auto __remove_iso10646_prefix = [](const char* __s) {

if (s[0] == 'I' || s[0] == 'i')

if (__s[1] == 'S' || __s[1] == 's')
if (__s[2] == 'O' || __s[2] == 'o')
if (string_view(__s + 3).starts_with("-10646/"))
return __s + 10;
return __s;
};

if constexpr (is_same_v<_CharT, char>)

__enc = __remove_iso10646_prefix("UTF-8");

else
__enc = __remove_iso10646_prefix("UTF-16LE");

if ((enc[0] == 'U' || enc[0] == 'u')

&& (__enc[1] == 'T' || __enc[1] == 't')
&& (__enc[2] == 'F' || __enc[2] == 'f'))
{
__enc += 3;
if (__enc[0] == '-')
++__enc;
if (__enc[0] == '8')
return __enc[1] == '\0' || string_view(__enc + 1) == "//";
else if constexpr (!is_same_v<_CharT, char>)
{
string_view __s(__enc);
if (__s.ends_with("//"))
__s.remove_suffix(2);
return __s == "16" || __s == "32";
}
}
# 1060 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/bits/unicode.h" 3
return false;
}

consteval bool
__literal_encoding_is_utf8()
{ return __literal_encoding_is_unicode<char>(); }

consteval bool
__literal_encoding_is_extended_ascii()
{
return '0' == 0x30 && 'A' == 0x41 && 'Z' == 0x5a
&& 'a' == 0x61 && 'z' == 0x7a;
}

constexpr bool
__charset_alias_match(string_view __a, string_view __b)
{
auto __map = [](char __c, bool& __num) -> unsigned char {
if (__c == '0') [[unlikely]]
return __num ? 0 : 127;
const auto __v = __detail::__from_chars_alnum_to_val(__c);
__num = __v < 10;
return __v;
};

auto __ptr_a = a.begin(), end_a = __a.end();

auto __ptr_b = __b.begin(), __end_b = __b.end();
bool __num_a = false, __num_b = false;

while (true)
{

unsigned char __val_a{}, __val_b{};

while (__ptr_a != __end_a
&& (__val_a = __map(*__ptr_a, __num_a)) == 127)
++__ptr_a;
while (__ptr_b != __end_b
&& (__val_b = __map(*__ptr_b, __num_b)) == 127)
++__ptr_b;

if (__ptr_a == __end_a)
return __ptr_b == __end_b;
else if (__ptr_b == __end_b)
return false;
else if (__val_a != __val_b)
return false;
++__ptr_a;
++__ptr_b;
}
return true;
}

namespace ranges
{
template<typename _To, typename _Range>
inline constexpr bool
enable_borrowed_range<std::__unicode::_Utf_view<_To, _Range>>
= enable_borrowed_range<_Range>;

template<typename _Range>
inline constexpr bool
enable_borrowed_range<std::__unicode::_Grapheme_cluster_view<_Range>>
= enable_borrowed_range<_Range>;
}

}
# 59 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/format" 2 3
namespace std
{

template<typename _Out, typename _CharT> class basic_format_context;

template<typename _CharT, typename... _Args> struct basic_format_string;

namespace __format
{

template<typename _CharT> class _Sink;

template<typename _CharT>
class _Sink_iter;

template<typename _CharT>
using __format_context = basic_format_context<_Sink_iter<_CharT>, _CharT>;

template<typename _CharT>
struct _Runtime_format_string
{
[[__gnu__::__always_inline__]]
_Runtime_format_string(basic_string_view<_CharT> __s) noexcept
: _M_str(__s) { }

_Runtime_format_string(const _Runtime_format_string&) = delete;

void operator=(const _Runtime_format_string&) = delete;

private:
basic_string_view<_CharT> _M_str;

template<typename, typename...> friend struct std::basic_format_string;

};
}

using format_context = format::format_context<char>;

using wformat_context = format::format_context<wchar_t>;

template<typename _Context> class basic_format_args;

using format_args = basic_format_args<format_context>;

using wformat_args = basic_format_args<wformat_context>;

template<typename _Context>
class basic_format_arg;
template<typename _CharT, typename... _Args>
struct basic_format_string
{
template<typename _Tp>
requires convertible_to<const _Tp&, basic_string_view<_CharT>>
consteval
basic_format_string(const _Tp& __s);

[[__gnu__::__always_inline__]]
basic_format_string(__format::_Runtime_format_string<_CharT> __s) noexcept
: _M_str(__s._M_str)
{ }

[[__gnu__::__always_inline__]]
constexpr basic_string_view<_CharT>
get() const noexcept
{ return _M_str; }

private:
basic_string_view<_CharT> _M_str;
};

template<typename... _Args>
using format_string = basic_format_string<char, type_identity_t<_Args>...>;

template<typename... _Args>
using wformat_string
= basic_format_string<wchar_t, type_identity_t<_Args>...>;

[[__gnu__::__always_inline__]]
inline __format::_Runtime_format_string<char>
runtime_format(string_view __fmt) noexcept
{ return __fmt; }

[[__gnu__::__always_inline__]]
inline __format::_Runtime_format_string<wchar_t>
runtime_format(wstring_view __fmt) noexcept
{ return __fmt; }

template<typename _Tp, typename _CharT = char>

struct formatter
{
formatter() = delete;
formatter(const formatter&) = delete;
formatter& operator=(const formatter&) = delete;
};
class format_error : public runtime_error
{
public:
explicit format_error(const string& __what) : runtime_error(__what) { }
explicit format_error(const char* __what) : runtime_error(__what) { }
};

[[noreturn]]
inline void
__throw_format_error(const char* __what)
{ (throw (format_error(__what))); }

namespace __format
{

[[noreturn]]
inline void
__unmatched_left_brace_in_format_string()
{ __throw_format_error("format error: unmatched '{' in format string"); }

[[noreturn]]
inline void
__unmatched_right_brace_in_format_string()
{ __throw_format_error("format error: unmatched '}' in format string"); }

[[noreturn]]
inline void
__conflicting_indexing_in_format_string()
{ __throw_format_error("format error: conflicting indexing style in format
string"); }

[[noreturn]]
inline void
__invalid_arg_id_in_format_string()
{ __throw_format_error("format error: invalid arg-id in format string"); }

[[noreturn]]
inline void
__failed_to_parse_format_spec()
{ __throw_format_error("format error: failed to parse format-spec"); }
}

template<typename _CharT> class basic_format_parse_context;

using format_parse_context = basic_format_parse_context<char>;

using wformat_parse_context = basic_format_parse_context<wchar_t>;

template<typename _CharT>
class basic_format_parse_context
{
public:
using char_type = _CharT;
using const_iterator = typename basic_string_view<_CharT>::const_iterator;
using iterator = const_iterator;

constexpr explicit
basic_format_parse_context(basic_string_view<_CharT> __fmt,
size_t __num_args = 0) noexcept
: _M_begin(__fmt.begin()), _M_end(__fmt.end()), _M_num_args(__num_args)
{ }

basic_format_parse_context(const basic_format_parse_context&) = delete;

void operator=(const basic_format_parse_context&) = delete;

constexpr const_iterator begin() const noexcept { return _M_begin; }

constexpr const_iterator end() const noexcept { return _M_end; }

constexpr void
advance_to(const_iterator __it) noexcept
{ _M_begin = __it; }

constexpr size_t
next_arg_id()
{
if (_M_indexing == _Manual)
__format::__conflicting_indexing_in_format_string();
_M_indexing = _Auto;

if (std::is_constant_evaluated())
if (_M_next_arg_id == _M_num_args)
__format::__invalid_arg_id_in_format_string();
return _M_next_arg_id++;
}

constexpr void
check_arg_id(size_t __id)
{
if (_M_indexing == _Auto)
__format::__conflicting_indexing_in_format_string();
_M_indexing = _Manual;

if (std::is_constant_evaluated())
if (__id >= _M_num_args)
__format::__invalid_arg_id_in_format_string();
}

private:
iterator _M_begin;
iterator _M_end;
enum _Indexing { _Unknown, _Manual, _Auto };
_Indexing _M_indexing = _Unknown;
size_t _M_next_arg_id = 0;
size_t _M_num_args;
};

template<typename _Tp, template<typename...> class _Class>

static constexpr bool __is_specialization_of = false;
template<template<typename...> class _Class, typename... _Args>
static constexpr bool __is_specialization_of<_Class<_Args...>, _Class>
= true;

namespace __format
{

template<typename _CharT>
constexpr pair<unsigned short, const _CharT*>
__parse_integer(const _CharT* __first, const _CharT* __last)
{
if (__first == __last)
__builtin_unreachable();

if constexpr (is_same_v<_CharT, char>)

{
const auto __start = __first;
unsigned short __val = 0;

if (detail::from_chars_alnum<true>(first, last, __val, 10)

&& __first != __start) [[likely]]
return {__val, __first};
}
else
{
constexpr int __n = 32;
char __buf[__n]{};
for (int __i = 0; __i < __n && (__first + __i) != __last; ++__i)
__buf[__i] = __first[__i];
auto [__v, __ptr] = __format::__parse_integer(__buf, __buf + __n);
if (__ptr) [[likely]]
return {__v, __first + (__ptr - __buf)};
}
return {0, nullptr};
}

template<typename _CharT>
constexpr pair<unsigned short, const _CharT*>
__parse_arg_id(const _CharT* __first, const _CharT* __last)
{
if (__first == __last)
__builtin_unreachable();

if (*__first == '0')
return {0, __first + 1};

if ('1' <= first && first <= '9')

{
const unsigned short __id = *__first - '0';
const auto __next = __first + 1;

if (next == last || !('0' <= next && next <= '9'))

return {__id, __next};
else
return __format::__parse_integer(__first, __last);
}
return {0, nullptr};
}

enum _Pres_type {
_Pres_none = 0,
_Pres_d = 1, _Pres_b, _Pres_B, _Pres_o, _Pres_x, _Pres_X, _Pres_c,

_Pres_a = 1, _Pres_A, _Pres_e, _Pres_E, _Pres_f, _Pres_F, _Pres_g, _Pres_G,

_Pres_p = 0, _Pres_P,
_Pres_s = 0,
_Pres_esc = 0xf,
};

enum _Align {
_Align_default,
_Align_left,
_Align_right,
_Align_centre,
};

enum _Sign {
_Sign_default,
_Sign_plus,
_Sign_minus,
_Sign_space,
};

enum _WidthPrec {
_WP_none,
_WP_value,
_WP_from_arg
};

template<typename _Context>
size_t
__int_from_arg(const basic_format_arg<_Context>& __arg);

constexpr bool __is_digit(char __c)

{ return std::__detail::__from_chars_alnum_to_val(__c) < 10; }

constexpr bool __is_xdigit(char __c)

{ return std::__detail::__from_chars_alnum_to_val(__c) < 16; }

template<typename _CharT>
struct _Spec
{
_Align _M_align : 2;
_Sign _M_sign : 2;
unsigned _M_alt : 1;
unsigned _M_localized : 1;
unsigned _M_zero_fill : 1;
_WidthPrec _M_width_kind : 2;
_WidthPrec _M_prec_kind : 2;
_Pres_type _M_type : 4;
unsigned _M_reserved : 1;
unsigned _M_reserved2 : 16;
unsigned short _M_width;
unsigned short _M_prec;
char32_t _M_fill = ' ';

using iterator = typename basic_string_view<_CharT>::iterator;

static constexpr _Align

_S_align(_CharT __c) noexcept
{
switch (__c)
{
case '<': return _Align_left;
case '>': return _Align_right;
case '^': return _Align_centre;
default: return _Align_default;
}
}

constexpr iterator
_M_parse_fill_and_align(iterator __first, iterator __last) noexcept
{
if (*__first != '{')
{
using namespace __unicode;
if constexpr (__literal_encoding_is_unicode<_CharT>())
{

_Utf32_view<ranges::subrange<iterator>> uv({first, __last});

if (!__uv.empty())
{
auto __beg = __uv.begin();
char32_t __c = *__beg++;
if (__is_scalar_value(__c))
if (auto __next = __beg.base(); __next != __last)
if (_Align __align = _S_align(*__next))
{
_M_fill = __c;
_M_align = __align;
return ++__next;
}
}
}
else if (__last - __first >= 2)
if (_Align __align = _S_align(__first[1]))
{
_M_fill = *__first;
_M_align = __align;
return __first + 2;
}

if (_Align __align = _S_align(__first[0]))

{
_M_fill = ' ';
_M_align = __align;
return __first + 1;
}
}
return __first;
}

static constexpr _Sign

_S_sign(_CharT __c) noexcept
{
switch (__c)
{
case '+': return _Sign_plus;
case '-': return _Sign_minus;
case ' ': return _Sign_space;
default: return _Sign_default;
}
}

constexpr iterator
_M_parse_sign(iterator __first, iterator) noexcept
{
if (_Sign __sign = _S_sign(*__first))
{
_M_sign = __sign;
return __first + 1;
}
return __first;
}

constexpr iterator
_M_parse_alternate_form(iterator __first, iterator) noexcept
{
if (*__first == '#')
{
_M_alt = true;
++__first;
}
return __first;
}

constexpr iterator
_M_parse_zero_fill(iterator __first, iterator ) noexcept
{
if (*__first == '0')
{
_M_zero_fill = true;
++__first;
}
return __first;
}

static constexpr iterator

_S_parse_width_or_precision(iterator __first, iterator __last,
unsigned short& __val, bool& __arg_id,
basic_format_parse_context<_CharT>& __pc)
{
if (__format::__is_digit(*__first))
{
auto [__v, __ptr] = __format::__parse_integer(__first, __last);
if (!__ptr)
__throw_format_error("format error: invalid width or precision "
"in format-spec");
__first = __ptr;
__val = __v;
}
else if (*__first == '{')
{
__arg_id = true;
++__first;
if (__first == __last)
__format::__unmatched_left_brace_in_format_string();
if (*__first == '}')
__val = __pc.next_arg_id();
else
{
auto [__v, __ptr] = __format::__parse_arg_id(__first, __last);
if (__ptr == nullptr || __ptr == __last || *__ptr != '}')
__format::__invalid_arg_id_in_format_string();
__first = __ptr;
__pc.check_arg_id(__v);
__val = __v;
}
++__first;
}
return __first;
}

constexpr iterator
_M_parse_width(iterator __first, iterator __last,
basic_format_parse_context<_CharT>& __pc)
{
bool __arg_id = false;
if (*__first == '0')
__throw_format_error("format error: width must be non-zero in "
"format string");
auto __next = _S_parse_width_or_precision(__first, __last, _M_width,
__arg_id, __pc);
if (__next != __first)
_M_width_kind = __arg_id ? _WP_from_arg : _WP_value;
return __next;
}

constexpr iterator
_M_parse_precision(iterator __first, iterator __last,
basic_format_parse_context<_CharT>& __pc)
{
if (__first[0] != '.')
return __first;

iterator next = ++first;

bool __arg_id = false;
if (__next != __last)
__next = _S_parse_width_or_precision(__first, __last, _M_prec,
__arg_id, __pc);
if (__next == __first)
__throw_format_error("format error: missing precision after '.' in "
"format string");
_M_prec_kind = __arg_id ? _WP_from_arg : _WP_value;
return __next;
}

constexpr iterator
_M_parse_locale(iterator __first, iterator ) noexcept
{
if (*__first == 'L')
{
_M_localized = true;
++__first;
}
return __first;
}

template<typename _Context>
size_t
_M_get_width(_Context& __ctx) const
{
size_t __width = 0;
if (_M_width_kind == _WP_value)
__width = _M_width;
else if (_M_width_kind == _WP_from_arg)
__width = __format::__int_from_arg(__ctx.arg(_M_width));
return __width;
}

template<typename _Context>
size_t
_M_get_precision(_Context& __ctx) const
{
size_t __prec = -1;
if (_M_prec_kind == _WP_value)
__prec = _M_prec;
else if (_M_prec_kind == _WP_from_arg)
__prec = __format::__int_from_arg(__ctx.arg(_M_prec));
return __prec;
}
};

template<typename _Int>
inline char*
__put_sign(_Int __i, _Sign __sign, char* __dest) noexcept
{
if (__i < 0)
*__dest = '-';
else if (__sign == _Sign_plus)
*__dest = '+';
else if (__sign == _Sign_space)
*__dest = ' ';
else
++__dest;
return __dest;
}

template<typename _Out, typename _CharT>

requires output_iterator<_Out, const _CharT&>
inline _Out
__write(_Out __out, basic_string_view<_CharT> __str)
{
if constexpr (is_same_v<_Out, _Sink_iter<_CharT>>)
{
if (__str.size())
__out = __str;
}
else
for (_CharT __c : __str)
*__out++ = __c;
return __out;
}

template<typename _Out, typename _CharT>

_Out
__write_padded(_Out __out, basic_string_view<_CharT> __str,
_Align __align, size_t __nfill, char32_t __fill_char)
{
const size_t __buflen = 0x20;
_CharT __padding_chars[__buflen];
__padding_chars[0] = _CharT();
basic_string_view<_CharT> __padding{__padding_chars, __buflen};

auto pad = [&padding] (size_t __n, _Out& __o) {

if (__n == 0)
return;
while (__n > __padding.size())
{
__o = __format::__write(std::move(__o), __padding);
__n -= __padding.size();
}
if (__n != 0)
__o = __format::__write(std::move(__o), __padding.substr(0, __n));
};

size_t l, r, __max;

if (__align == _Align_centre)
{
__l = __nfill / 2;
__r = __l + (__nfill & 1);
__max = __r;
}
else if (__align == _Align_right)
{
__l = __nfill;
__r = 0;
__max = __l;
}
else
{
__l = 0;
__r = __nfill;
__max = __r;
}

using namespace __unicode;

if constexpr (__literal_encoding_is_unicode<_CharT>())
if (!__is_single_code_unit<_CharT>(__fill_char)) [[unlikely]]
{

const char32_t arr[1]{ fill_char };

_Utf_view<_CharT, const char32_t(&)[1]> __v(__arr);
basic_string<_CharT> __padstr(__v.begin(), __v.end());
__padding = __padstr;
while (__l-- > 0)
__out = __format::__write(std::move(__out), __padding);
__out = __format::__write(std::move(__out), __str);
while (__r-- > 0)
__out = __format::__write(std::move(__out), __padding);
return __out;
}

if (max < buflen)

__padding.remove_suffix(__buflen - __max);
else
__max = __buflen;

char_traits<_CharT>::assign(__padding_chars, max, fill_char);

__pad(__l, __out);
__out = __format::__write(std::move(__out), __str);
__pad(__r, __out);

return __out;
}

template<typename _CharT, typename _Out>

_Out
__write_padded_as_spec(basic_string_view<type_identity_t<_CharT>> __str,
size_t __estimated_width,
basic_format_context<_Out, _CharT>& __fc,
const _Spec<_CharT>& __spec,
_Align __align = _Align_left)
{
size_t __width = __spec._M_get_width(__fc);

if (width <= estimated_width)

return __format::__write(__fc.out(), __str);

const size_t nfill = width - __estimated_width;

if (__spec._M_align)
__align = __spec._M_align;

return format::write_padded(fc.out(), str, align, nfill,

__spec._M_fill);
}

struct _Optional_locale
{
[[__gnu__::__always_inline__]]
_Optional_locale() : _M_dummy(), _M_hasval(false) { }

_Optional_locale(const locale& __loc) noexcept

: _M_loc(__loc), _M_hasval(true)
{ }

_Optional_locale(const _Optional_locale& __l) noexcept

: _M_dummy(), _M_hasval(__l._M_hasval)
{
if (_M_hasval)
std::construct_at(&_M_loc, __l._M_loc);
}

_Optional_locale&
operator=(const _Optional_locale& __l) noexcept
{
if (_M_hasval)
{
if (__l._M_hasval)
_M_loc = __l._M_loc;
else
{
_M_loc.~locale();
_M_hasval = false;
}
}
else if (__l._M_hasval)
{
std::construct_at(&_M_loc, __l._M_loc);
_M_hasval = true;
}
return *this;
}

~_Optional_locale() { if (_M_hasval) _M_loc.~locale(); }

_Optional_locale&
operator=(locale&& __loc) noexcept
{
if (_M_hasval)
_M_loc = std::move(__loc);
else
{
std::construct_at(&_M_loc, std::move(__loc));
_M_hasval = true;
}
return *this;
}

const locale&
value() noexcept
{
if (!_M_hasval)
{
std::construct_at(&_M_loc);
_M_hasval = true;
}
return _M_loc;
}

bool has_value() const noexcept { return _M_hasval; }

union {
char _M_dummy = '\0';
std::locale _M_loc;
};
bool _M_hasval = false;
};

template<typename _CharT>
concept __char = same_as<_CharT, char> || same_as<_CharT, wchar_t>;

template<__char _CharT>
struct __formatter_str
{
constexpr typename basic_format_parse_context<_CharT>::iterator
parse(basic_format_parse_context<_CharT>& __pc)
{
auto __first = __pc.begin();
const auto __last = __pc.end();
_Spec<_CharT> __spec{};

auto finalize = [this, &spec] {

_M_spec = __spec;
};

auto __finished = [&] {

if (__first == __last || *__first == '}')
{
__finalize();
return true;
}
return false;
};

if (__finished())
return __first;

first = spec._M_parse_fill_and_align(first, last);

if (__finished())
return __first;

first = spec._M_parse_width(first, last, __pc);

if (__finished())
return __first;

first = spec._M_parse_precision(first, last, __pc);

if (__finished())
return __first;

if (*__first == 's')
++__first;
# 889 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/format" 3
if (__finished())
return __first;

__format::__failed_to_parse_format_spec();
}

template<typename _Out>
_Out
format(basic_string_view<_CharT> __s,
basic_format_context<_Out, _CharT>& __fc) const
{
if (_M_spec._M_type == _Pres_esc)
{

if (_M_spec._M_width_kind == _WP_none
&& _M_spec._M_prec_kind == _WP_none)
return __format::__write(__fc.out(), __s);

size_t __estimated_width;
if constexpr (__unicode::__literal_encoding_is_unicode<_CharT>())
{
if (_M_spec._M_prec_kind != _WP_none)
{
size_t __prec = _M_spec._M_get_precision(__fc);
__estimated_width = __unicode::__truncate(__s, __prec);
}
else
__estimated_width = __unicode::__field_width(__s);
}
else
{
__s = __s.substr(0, _M_spec._M_get_precision(__fc));
__estimated_width = __s.size();
}

return format::write_padded_as_spec(s, estimated_width,

__fc, _M_spec);
}

private:
_Spec<_CharT> _M_spec{};
};

template<__char _CharT>
struct __formatter_int
{

static constexpr _Pres_type _AsInteger = _Pres_d;

static constexpr _Pres_type _AsBool = _Pres_s;
static constexpr _Pres_type _AsChar = _Pres_c;

constexpr typename basic_format_parse_context<_CharT>::iterator

_M_do_parse(basic_format_parse_context<_CharT>& __pc, _Pres_type __type)
{
_Spec<_CharT> __spec{};
__spec._M_type = __type;

const auto last = pc.end();

auto __first = __pc.begin();

auto finalize = [this, &spec] {

_M_spec = __spec;
};

auto __finished = [&] {

if (__first == __last || *__first == '}')
{
__finalize();
return true;
}
return false;
};

if (__finished())
return __first;

first = spec._M_parse_fill_and_align(first, last);

if (__finished())
return __first;

first = spec._M_parse_sign(first, last);

if (__finished())
return __first;

first = spec._M_parse_alternate_form(first, last);

if (__finished())
return __first;

first = spec._M_parse_zero_fill(first, last);

if (__finished())
return __first;

first = spec._M_parse_width(first, last, __pc);

if (__finished())
return __first;

first = spec._M_parse_locale(first, last);

if (__finished())
return __first;

switch (*__first)
{
case 'b':
__spec._M_type = _Pres_b;
++__first;
break;
case 'B':
__spec._M_type = _Pres_B;
++__first;
break;
case 'c':

if (__type != _AsBool)
{
__spec._M_type = _Pres_c;
++__first;
}
break;
case 'd':
__spec._M_type = _Pres_d;
++__first;
break;
case 'o':
__spec._M_type = _Pres_o;
++__first;
break;
case 'x':
__spec._M_type = _Pres_x;
++__first;
break;
case 'X':
__spec._M_type = _Pres_X;
++__first;
break;
case 's':
if (__type == _AsBool)
{
__spec._M_type = _Pres_s;
++__first;
}
break;
# 1048 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/format" 3
break;
}

if (__finished())
return __first;

__format::__failed_to_parse_format_spec();
}

template<typename _Tp>
constexpr typename basic_format_parse_context<_CharT>::iterator
_M_parse(basic_format_parse_context<_CharT>& __pc)
{
if constexpr (is_same_v<_Tp, bool>)
{
auto __end = _M_do_parse(__pc, _AsBool);
if (_M_spec._M_type == _Pres_s)
if (_M_spec._M_sign || _M_spec._M_alt || _M_spec._M_zero_fill)
__throw_format_error("format error: format-spec contains "
"invalid formatting options for "
"'bool'");
return __end;
}
else if constexpr (__char<_Tp>)
{
auto __end = _M_do_parse(__pc, _AsChar);
if (_M_spec._M_type == _Pres_c || _M_spec._M_type == _Pres_esc)
if (_M_spec._M_sign || _M_spec._M_alt || _M_spec._M_zero_fill
)
__throw_format_error("format error: format-spec contains "
"invalid formatting options for "
"'charT'");
return __end;
}
else
return _M_do_parse(__pc, _AsInteger);
}

template<typename _Int, typename _Out>

typename basic_format_context<_Out, _CharT>::iterator
format(_Int __i, basic_format_context<_Out, _CharT>& __fc) const
{
if (_M_spec._M_type == _Pres_c)
return _M_format_character(_S_to_character(__i), __fc);

char __buf[sizeof(_Int) * 8 + 3];

to_chars_result __res{};

string_view __base_prefix;
make_unsigned_t<_Int> __u;
if (__i < 0)
__u = -static_cast<make_unsigned_t<_Int>>(__i);
else
__u = __i;

char* start = buf + 3;

char* const __end = __buf + sizeof(__buf);
char* const __start_digits = __start;

switch (_M_spec._M_type)
{
case _Pres_b:
case _Pres_B:
__base_prefix = _M_spec._M_type == _Pres_b ? "0b" : "0B";
__res = to_chars(__start, __end, __u, 2);
break;

case _Pres_none:

[[fallthrough]];
case _Pres_d:
__res = to_chars(__start, __end, __u, 10);
break;
case _Pres_o:
if (__i != 0)
__base_prefix = "0";
__res = to_chars(__start, __end, __u, 8);
break;
case _Pres_x:
case _Pres_X:
__base_prefix = _M_spec._M_type == _Pres_x ? "0x" : "0X";
__res = to_chars(__start, __end, __u, 16);
if (_M_spec._M_type == _Pres_X)
for (auto __p = __start; __p != __res.ptr; ++__p)

*__p = __builtin_toupper(*__p);
break;
default:
__builtin_unreachable();
}

if (_M_spec._M_alt && __base_prefix.size())

{
__start -= __base_prefix.size();
__builtin_memcpy(__start, __base_prefix.data(),
__base_prefix.size());
}
__start = __format::__put_sign(__i, _M_spec._M_sign, __start - 1);

return _M_format_int(string_view(start, res.ptr - __start),

__start_digits - __start, __fc);
}

template<typename _Out>
typename basic_format_context<_Out, _CharT>::iterator
format(bool __i, basic_format_context<_Out, _CharT>& __fc) const
{
if (_M_spec._M_type == _Pres_c)
return _M_format_character(static_cast<unsigned char>(__i), __fc);
if (_M_spec._M_type != _Pres_s)
return format(static_cast<unsigned char>(__i), __fc);

basic_string<_CharT> __s;
size_t __est_width;
if (_M_spec._M_localized) [[unlikely]]
{
auto& __np = std::use_facet<numpunct<_CharT>>(__fc.locale());
__s = __i ? __np.truename() : __np.falsename();
__est_width = __s.size();
}
else
{
if constexpr (is_same_v<char, _CharT>)
__s = __i ? "true" : "false";
else
__s = __i ? L"true" : L"false";
__est_width = __s.size();
}

return format::write_padded_as_spec(s, est_width, __fc,

_M_spec);
}

template<typename _Out>
typename basic_format_context<_Out, _CharT>::iterator
_M_format_character(_CharT __c,
basic_format_context<_Out, _CharT>& __fc) const
{
return __format::__write_padded_as_spec({&__c, 1u}, 1, __fc, _M_spec);
}

template<typename _Int>
static _CharT
_S_to_character(_Int __i)
{
using _Traits = __gnu_cxx::__int_traits<_CharT>;
if constexpr (is_signed_v<_Int> == is_signed_v<_CharT>)
{
if (_Traits::__min <= __i && __i <= _Traits::__max)
return static_cast<_CharT>(__i);
}
else if constexpr (is_signed_v<_Int>)
{
if (__i >= 0 && make_unsigned_t<_Int>(__i) <= _Traits::__max)
return static_cast<_CharT>(__i);
}
else if (__i <= make_unsigned_t<_CharT>(_Traits::__max))
return static_cast<_CharT>(__i);
__throw_format_error("format error: integer not representable as "
"character");
}

template<typename _Out>
typename basic_format_context<_Out, _CharT>::iterator
_M_format_int(string_view __narrow_str, size_t __prefix_len,
basic_format_context<_Out, _CharT>& __fc) const
{
size_t __width = _M_spec._M_get_width(__fc);

basic_string_view<_CharT> __str;
if constexpr (is_same_v<char, _CharT>)
__str = __narrow_str;

else
{
size_t __n = __narrow_str.size();
auto __p = (_CharT*)__builtin_alloca(__n * sizeof(_CharT));
std::__to_wstring_numeric(__narrow_str.data(), __n, __p);
__str = {__p, __n};
}

if (_M_spec._M_localized)
{
const auto& __l = __fc.locale();
if (__l.name() != "C")
{
auto& __np = use_facet<numpunct<_CharT>>(__l);
string __grp = __np.grouping();
if (!__grp.empty())
{
size_t __n = __str.size() - __prefix_len;
auto __p = (_CharT*)__builtin_alloca(2 * __n
* sizeof(_CharT)
+ __prefix_len);
auto __s = __str.data();
char_traits<_CharT>::copy(__p, __s, __prefix_len);
__s += __prefix_len;
auto __end = std::__add_grouping(__p + __prefix_len,
__np.thousands_sep(),
__grp.data(),
__grp.size(),
__s, __s + __n);
__str = {__p, size_t(__end - __p)};
}
}
}

if (width <= str.size())

return __format::__write(__fc.out(), __str);

char32_t __fill_char = _M_spec._M_fill;

_Align __align = _M_spec._M_align;

size_t nfill = width - __str.size();

auto __out = __fc.out();
if (__align == _Align_default)
{
__align = _Align_right;
if (_M_spec._M_zero_fill)
{
__fill_char = _CharT('0');

if (__prefix_len != 0)
{
__out = __format::__write(std::move(__out),
__str.substr(0, __prefix_len));
__str.remove_prefix(__prefix_len);
}
}
else
__fill_char = _CharT(' ');
}
return __format::__write_padded(std::move(__out), __str,
__align, __nfill, __fill_char);
}
# 1305 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/format" 3
_Spec<_CharT> _M_spec{};
};
# 1393 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/format" 3
using std::to_chars;

template<typename _Tp>
concept __formattable_float = requires (_Tp __t, char* __p)
{ __format::to_chars(__p, __p, __t, chars_format::scientific, 6); };

template<__char _CharT>
struct __formatter_fp
{
constexpr typename basic_format_parse_context<_CharT>::iterator
parse(basic_format_parse_context<_CharT>& __pc)
{
_Spec<_CharT> __spec{};
const auto __last = __pc.end();
auto __first = __pc.begin();

auto finalize = [this, &spec] {

_M_spec = __spec;
};

auto __finished = [&] {

if (__first == __last || *__first == '}')
{
__finalize();
return true;
}
return false;
};

if (__finished())
return __first;

first = spec._M_parse_fill_and_align(first, last);

if (__finished())
return __first;

first = spec._M_parse_sign(first, last);

if (__finished())
return __first;

first = spec._M_parse_alternate_form(first, last);

if (__finished())
return __first;

first = spec._M_parse_zero_fill(first, last);

if (__finished())
return __first;

if (__first[0] != '.')
{
__first = __spec._M_parse_width(__first, __last, __pc);
if (__finished())
return __first;
}

first = spec._M_parse_precision(first, last, __pc);

if (__finished())
return __first;

first = spec._M_parse_locale(first, last);

if (__finished())
return __first;

switch (*__first)
{
case 'a':
__spec._M_type = _Pres_a;
++__first;
break;
case 'A':
__spec._M_type = _Pres_A;
++__first;
break;
case 'e':
__spec._M_type = _Pres_e;
++__first;
break;
case 'E':
__spec._M_type = _Pres_E;
++__first;
break;
case 'f':
__spec._M_type = _Pres_f;
++__first;
break;
case 'F':
__spec._M_type = _Pres_F;
++__first;
break;
case 'g':
__spec._M_type = _Pres_g;
++__first;
break;
case 'G':
__spec._M_type = _Pres_G;
++__first;
break;
}

if (__finished())
return __first;

__format::__failed_to_parse_format_spec();
}

template<typename _Fp, typename _Out>

typename basic_format_context<_Out, _CharT>::iterator
format(_Fp __v, basic_format_context<_Out, _CharT>& __fc) const
{
std::string __dynbuf;
char __buf[128];
to_chars_result __res{};

size_t __prec = 6;
bool __use_prec = _M_spec._M_prec_kind != _WP_none;
if (__use_prec)
__prec = _M_spec._M_get_precision(__fc);

char* start = buf + 1;

char* __end = __buf + sizeof(__buf);

chars_format __fmt{};
bool __upper = false;
bool __trailing_zeros = false;
char __expc = 'e';

switch (_M_spec._M_type)
{
case _Pres_A:
__upper = true;
__expc = 'P';
[[fallthrough]];
case _Pres_a:
if (_M_spec._M_type != _Pres_A)
__expc = 'p';
__fmt = chars_format::hex;
break;
case _Pres_E:
__upper = true;
__expc = 'E';
[[fallthrough]];
case _Pres_e:
__use_prec = true;
__fmt = chars_format::scientific;
break;
case _Pres_F:
__upper = true;
[[fallthrough]];
case _Pres_f:
__use_prec = true;
__fmt = chars_format::fixed;
break;
case _Pres_G:
__upper = true;
__expc = 'E';
[[fallthrough]];
case _Pres_g:
__trailing_zeros = true;
__use_prec = true;
__fmt = chars_format::general;
break;
case _Pres_none:
if (__use_prec)
__fmt = chars_format::general;
break;
default:
__builtin_unreachable();
}

auto __to_chars = [&](char* b, char* e) {

if (__use_prec)
return __format::to_chars(__b, __e, __v, __fmt, __prec);
else if (__fmt != chars_format{})
return __format::to_chars(__b, __e, __v, __fmt);
else
return __format::to_chars(__b, __e, __v);
};

res = to_chars(start, end);

if (__builtin_expect(__res.ec == errc::value_too_large, 0))

{

size_t guess = 8 + prec;

if (__fmt == chars_format::fixed)
{
if constexpr (is_same_v<_Fp, float> || is_same_v<_Fp, double>
|| is_same_v<_Fp, long double>)
{

int __exp{};
if constexpr (is_same_v<_Fp, float>)
__builtin_frexpf(__v, &__exp);
else if constexpr (is_same_v<_Fp, double>)
__builtin_frexp(__v, &__exp);
else if constexpr (is_same_v<_Fp, long double>)
__builtin_frexpl(__v, &__exp);
if (__exp > 0)
__guess += 1U + __exp * 4004U / 13301U;
}
else
__guess += numeric_limits<_Fp>::max_exponent10;
}
if (__guess <= sizeof(__buf)) [[unlikely]]
__guess = sizeof(__buf) * 2;
__dynbuf.reserve(__guess);

do
{
auto __overwrite = [&__to_chars, &__res] (char* __p, size_t __n)
{
__res = __to_chars(__p + 1, __p + __n - 1);
return __res.ec == errc{} ? __res.ptr - __p : 0;
};

__dynbuf.__resize_and_overwrite(__dynbuf.capacity() * 2,
__overwrite);
__start = __dynbuf.data() + 1;
__end = __dynbuf.data() + __dynbuf.size();
}
while (__builtin_expect(__res.ec == errc::value_too_large, 0));
}

if (__upper)
{
for (char* __p = __start; __p != __res.ptr; ++__p)
*__p = std::toupper(*__p);
}

bool __have_sign = true;

if (!__builtin_signbit(__v))
{
if (_M_spec._M_sign == _Sign_plus)
*--__start = '+';
else if (_M_spec._M_sign == _Sign_space)
*--__start = ' ';
else
__have_sign = false;
}

string_view __narrow_str(start, res.ptr - __start);

if (_M_spec._M_alt && __builtin_isfinite(__v))

{
string_view __s = __narrow_str;
size_t __sigfigs;
size_t __z = 0;
size_t __p;
size_t __d = __s.find('.');
if (__d != __s.npos)
{
__p = __s.find(__expc, __d + 1);
if (__p == __s.npos)
__p = __s.size();

if (__trailing_zeros)
{

if (__s[__have_sign] != '0')

sigfigs = p - __have_sign - 1;

else

sigfigs = p - __s.find_first_not_of('0', __d + 1);

}
}
else
{
__p = __s.find(__expc);
if (__p == __s.npos)
__p = __s.size();
__d = __p;
__sigfigs = __d - __have_sign;
}

if (__trailing_zeros && __prec != 0)

{

z = prec - __sigfigs;

}

if (size_t extras = int(d == p) + z)

{
if (__dynbuf.empty() && __extras <= size_t(__end - __res.ptr))
{

__builtin_memmove(start + p + __extras,

__start + __p,
__s.size() - __p);
if (__d == __p)
__start[__p++] = '.';
__builtin_memset(__start + __p, '0', __z);
__narrow_str = {__s.data(), __s.size() + __extras};
}
else
{
__dynbuf.reserve(__s.size() + __extras);
if (__dynbuf.empty())
{
__dynbuf = __s.substr(0, __p);
if (__d == __p)
__dynbuf += '.';
if (__z)
__dynbuf.append(__z, '0');
__dynbuf.append(__s.substr(__p));
}
else
{
__dynbuf.insert(__p, __extras, '0');
if (__d == __p)
__dynbuf[__p] = '.';
}
__narrow_str = __dynbuf;
}
}
}

basic_string<_CharT> __wstr;
basic_string_view<_CharT> __str;
if constexpr (is_same_v<_CharT, char>)
__str = __narrow_str;

else
{
__wstr = std::__to_wstring_numeric(__narrow_str);
__str = __wstr;
}

if (_M_spec._M_localized && __builtin_isfinite(__v))

{
__wstr = _M_localize(__str, __expc, __fc.locale());
if (!__wstr.empty())
__str = __wstr;
}

size_t __width = _M_spec._M_get_width(__fc);

if (width <= str.size())

return __format::__write(__fc.out(), __str);

char32_t __fill_char = _M_spec._M_fill;

_Align __align = _M_spec._M_align;

size_t nfill = width - __str.size();

auto __out = __fc.out();
if (__align == _Align_default)
{
__align = _Align_right;
if (_M_spec._M_zero_fill && __builtin_isfinite(__v))
{
__fill_char = _CharT('0');

if (!__format::__is_xdigit(__narrow_str[0]))
{
*__out++ = __str[0];
__str.remove_prefix(1);
}
}
else
__fill_char = _CharT(' ');
}
return __format::__write_padded(std::move(__out), __str,
__align, __nfill, __fill_char);
}

basic_string<_CharT>
_M_localize(basic_string_view<_CharT> __str, char __expc,
const locale& __loc) const
{
basic_string<_CharT> __lstr;

if (__loc == locale::classic())
return __lstr;

const auto& __np = use_facet<numpunct<_CharT>>(__loc);

const _CharT __point = __np.decimal_point();
const string __grp = __np.grouping();

_CharT dot, exp;

if constexpr (is_same_v<_CharT, char>)
{
__dot = '.';
__exp = __expc;
}
else
{
__dot = L'.';
switch (__expc)
{
case 'e':
__exp = L'e';
break;
case 'E':
__exp = L'E';
break;
case 'p':
__exp = L'p';
break;
case 'P':
__exp = L'P';
break;
default:
__builtin_unreachable();
}
}

if (grp.empty() && point == __dot)

return __lstr;

size_t d = str.find(__dot);

size_t __e = min(__d, __str.find(__exp));
if (__e == __str.npos)
__e = __str.size();
const size_t __r = __str.size() - __e;
auto __overwrite = [&](_CharT* __p, size_t) {
auto __end = std::__add_grouping(__p, __np.thousands_sep(),
__grp.data(), __grp.size(),
__str.data(), __str.data() + __e);
if (__r)
{
if (__d != __str.npos)
{
*__end = __point;
++__end;
++__e;
}
if (__r > 1)
__end += __str.copy(__end, __str.npos, __e);
}
return (__end - __p);
};
__lstr.__resize_and_overwrite(__e * 2 + __r, __overwrite);
return __lstr;
}

_Spec<_CharT> _M_spec{};
};

template<__format::__char _CharT>
struct formatter<_CharT, _CharT>
{
formatter() = default;

constexpr typename basic_format_parse_context<_CharT>::iterator

parse(basic_format_parse_context<_CharT>& __pc)
{
return _M_f.template _M_parse<_CharT>(__pc);
}

template<typename _Out>
typename basic_format_context<_Out, _CharT>::iterator
format(_CharT __u, basic_format_context<_Out, _CharT>& __fc) const
{
if (_M_f._M_spec._M_type == __format::_Pres_none
|| _M_f._M_spec._M_type == __format::_Pres_c)
return _M_f._M_format_character(__u, __fc);
else if (_M_f._M_spec._M_type == __format::_Pres_esc)
{

return __fc.out();
}
else
return _M_f.format(static_cast<make_unsigned_t<_CharT>>(__u), __fc);
}

private:
__format::__formatter_int<_CharT> _M_f;
};
template<>
struct formatter<char, wchar_t>
{
formatter() = default;

constexpr typename basic_format_parse_context<wchar_t>::iterator

parse(basic_format_parse_context<wchar_t>& __pc)
{
return _M_f._M_parse<char>(__pc);
}

template<typename _Out>
typename basic_format_context<_Out, wchar_t>::iterator
format(char __u, basic_format_context<_Out, wchar_t>& __fc) const
{
if (_M_f._M_spec._M_type == __format::_Pres_none
|| _M_f._M_spec._M_type == __format::_Pres_c)
return _M_f._M_format_character(__u, __fc);
else if (_M_f._M_spec._M_type == __format::_Pres_esc)
{

return __fc.out();
}
else
return _M_f.format(static_cast<unsigned char>(__u), __fc);
}

private:
__format::__formatter_int<wchar_t> _M_f;
};

template<__format::__char _CharT>
struct formatter<_CharT*, _CharT>
{
formatter() = default;

[[__gnu__::__always_inline__]]
constexpr typename basic_format_parse_context<_CharT>::iterator
parse(basic_format_parse_context<_CharT>& __pc)
{ return _M_f.parse(__pc); }

template<typename _Out>
[[__gnu__::__nonnull__]]
typename basic_format_context<_Out, _CharT>::iterator
format(_CharT* __u, basic_format_context<_Out, _CharT>& __fc) const
{ return _M_f.format(__u, __fc); }
private:
__format::__formatter_str<_CharT> _M_f;
};

template<__format::__char _CharT>
struct formatter<const _CharT*, _CharT>
{
formatter() = default;

[[__gnu__::__always_inline__]]
constexpr typename basic_format_parse_context<_CharT>::iterator
parse(basic_format_parse_context<_CharT>& __pc)
{ return _M_f.parse(__pc); }

template<typename _Out>
[[__gnu__::__nonnull__]]
typename basic_format_context<_Out, _CharT>::iterator
format(const _CharT* __u,
basic_format_context<_Out, _CharT>& __fc) const
{ return _M_f.format(__u, __fc); }

private:
__format::__formatter_str<_CharT> _M_f;
};

template<format::char _CharT, size_t _Nm>

struct formatter<_CharT[_Nm], _CharT>
{
formatter() = default;

[[__gnu__::__always_inline__]]
constexpr typename basic_format_parse_context<_CharT>::iterator
parse(basic_format_parse_context<_CharT>& __pc)
{ return _M_f.parse(__pc); }

template<typename _Out>
typename basic_format_context<_Out, _CharT>::iterator
format(const _CharT (&__u)[_Nm],
basic_format_context<_Out, _CharT>& __fc) const
{ return _M_f.format({__u, _Nm}, __fc); }

private:
__format::__formatter_str<_CharT> _M_f;
};

template<typename _Traits, typename _Alloc>

struct formatter<basic_string<char, _Traits, _Alloc>, char>
{
formatter() = default;

[[__gnu__::__always_inline__]]
constexpr typename basic_format_parse_context<char>::iterator
parse(basic_format_parse_context<char>& __pc)
{ return _M_f.parse(__pc); }

template<typename _Out>
typename basic_format_context<_Out, char>::iterator
format(const basic_string<char, _Traits, _Alloc>& __u,
basic_format_context<_Out, char>& __fc) const
{ return _M_f.format(__u, __fc); }

private:
__format::__formatter_str<char> _M_f;
};

template<typename _Traits, typename _Alloc>

struct formatter<basic_string<wchar_t, _Traits, _Alloc>, wchar_t>
{
formatter() = default;

[[__gnu__::__always_inline__]]
constexpr typename basic_format_parse_context<wchar_t>::iterator
parse(basic_format_parse_context<wchar_t>& __pc)
{ return _M_f.parse(__pc); }

template<typename _Out>
typename basic_format_context<_Out, wchar_t>::iterator
format(const basic_string<wchar_t, _Traits, _Alloc>& __u,
basic_format_context<_Out, wchar_t>& __fc) const
{ return _M_f.format(__u, __fc); }

private:
__format::__formatter_str<wchar_t> _M_f;
};

template<typename _Traits>
struct formatter<basic_string_view<char, _Traits>, char>
{
formatter() = default;

[[__gnu__::__always_inline__]]
constexpr typename basic_format_parse_context<char>::iterator
parse(basic_format_parse_context<char>& __pc)
{ return _M_f.parse(__pc); }
template<typename _Out>
typename basic_format_context<_Out, char>::iterator
format(basic_string_view<char, _Traits> __u,
basic_format_context<_Out, char>& __fc) const
{ return _M_f.format(__u, __fc); }

private:
__format::__formatter_str<char> _M_f;
};

template<typename _Traits>
struct formatter<basic_string_view<wchar_t, _Traits>, wchar_t>
{
formatter() = default;

[[__gnu__::__always_inline__]]
constexpr typename basic_format_parse_context<wchar_t>::iterator
parse(basic_format_parse_context<wchar_t>& __pc)
{ return _M_f.parse(__pc); }

template<typename _Out>
typename basic_format_context<_Out, wchar_t>::iterator
format(basic_string_view<wchar_t, _Traits> __u,
basic_format_context<_Out, wchar_t>& __fc) const
{ return _M_f.format(__u, __fc); }

private:
__format::__formatter_str<wchar_t> _M_f;
};

template<integral _Tp, format::char _CharT>

requires (!__is_one_of<_Tp, char, wchar_t, char16_t, char32_t>::value)
struct formatter<_Tp, _CharT>
{
formatter() = default;

[[__gnu__::__always_inline__]]
constexpr typename basic_format_parse_context<_CharT>::iterator
parse(basic_format_parse_context<_CharT>& __pc)
{
return _M_f.template _M_parse<_Tp>(__pc);
}

template<typename _Out>
typename basic_format_context<_Out, _CharT>::iterator
format(_Tp __u, basic_format_context<_Out, _CharT>& __fc) const
{ return _M_f.format(__u, __fc); }
private:
__format::__formatter_int<_CharT> _M_f;
};
# 2155 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/format" 3
template<__format::__formattable_float _Tp, __format::__char _CharT>
struct formatter<_Tp, _CharT>
{
formatter() = default;

[[__gnu__::__always_inline__]]
constexpr typename basic_format_parse_context<_CharT>::iterator
parse(basic_format_parse_context<_CharT>& __pc)
{ return _M_f.parse(__pc); }

template<typename _Out>
typename basic_format_context<_Out, _CharT>::iterator
format(_Tp __u, basic_format_context<_Out, _CharT>& __fc) const
{ return _M_f.format(__u, __fc); }

private:
__format::__formatter_fp<_CharT> _M_f;
};
# 2198 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/format" 3
template<__format::__char _CharT>
struct formatter<_Float16, _CharT>
{
formatter() = default;

[[__gnu__::__always_inline__]]
constexpr typename basic_format_parse_context<_CharT>::iterator
parse(basic_format_parse_context<_CharT>& __pc)
{ return _M_f.parse(__pc); }

template<typename _Out>
typename basic_format_context<_Out, _CharT>::iterator
format(_Float16 __u, basic_format_context<_Out, _CharT>& __fc) const
{ return _M_f.format((float)__u, __fc); }

private:
__format::__formatter_fp<_CharT> _M_f;
};

template<__format::__char _CharT>
struct formatter<_Float32, _CharT>
{
formatter() = default;

[[__gnu__::__always_inline__]]
constexpr typename basic_format_parse_context<_CharT>::iterator
parse(basic_format_parse_context<_CharT>& __pc)
{ return _M_f.parse(__pc); }

template<typename _Out>
typename basic_format_context<_Out, _CharT>::iterator
format(_Float32 __u, basic_format_context<_Out, _CharT>& __fc) const
{ return _M_f.format((float)__u, __fc); }

private:
__format::__formatter_fp<_CharT> _M_f;
};

template<__format::__char _CharT>
struct formatter<_Float64, _CharT>
{
formatter() = default;

[[__gnu__::__always_inline__]]
constexpr typename basic_format_parse_context<_CharT>::iterator
parse(basic_format_parse_context<_CharT>& __pc)
{ return _M_f.parse(__pc); }

template<typename _Out>
typename basic_format_context<_Out, _CharT>::iterator
format(_Float64 __u, basic_format_context<_Out, _CharT>& __fc) const
{ return _M_f.format((double)__u, __fc); }

private:
__format::__formatter_fp<_CharT> _M_f;
};
# 2286 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/format" 3
template<__format::__char _CharT>
struct formatter<__gnu_cxx::__bfloat16_t, _CharT>
{
formatter() = default;

[[__gnu__::__always_inline__]]
constexpr typename basic_format_parse_context<_CharT>::iterator
parse(basic_format_parse_context<_CharT>& __pc)
{ return _M_f.parse(__pc); }

template<typename _Out>
typename basic_format_context<_Out, _CharT>::iterator
format(__gnu_cxx::__bfloat16_t __u,
basic_format_context<_Out, _CharT>& __fc) const
{ return _M_f.format((float)__u, __fc); }

private:
__format::__formatter_fp<_CharT> _M_f;
};

template<__format::__char _CharT>
struct formatter<const void*, _CharT>
{
formatter() = default;

constexpr typename basic_format_parse_context<_CharT>::iterator

parse(basic_format_parse_context<_CharT>& __pc)
{
__format::_Spec<_CharT> __spec{};
const auto __last = __pc.end();
auto __first = __pc.begin();

auto finalize = [this, &spec] {

_M_spec = __spec;
};

auto __finished = [&] {

if (__first == __last || *__first == '}')
{
__finalize();
return true;
}
return false;
};

if (__finished())
return __first;

first = spec._M_parse_fill_and_align(first, last);

if (__finished())
return __first;
# 2352 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/format" 3
__first = __spec._M_parse_zero_fill(__first, __last);
if (__finished())
return __first;

first = spec._M_parse_width(first, last, __pc);

if (__first != __last)
{
if (*__first == 'p')
++__first;

else if (*__first == 'P')

{

__spec._M_type = __format::_Pres_P;
++__first;
}

if (__finished())
return __first;

__format::__failed_to_parse_format_spec();
}

template<typename _Out>
typename basic_format_context<_Out, _CharT>::iterator
format(const void* __v, basic_format_context<_Out, _CharT>& __fc) const
{
auto __u = reinterpret_cast<long long unsigned int>(__v);
char __buf[2 + sizeof(__v) * 2];
auto [__ptr, __ec] = std::to_chars(__buf + 2, std::end(__buf),
__u, 16);
int __n = __ptr - __buf;
__buf[0] = '0';
__buf[1] = 'x';

if (_M_spec._M_type == __format::_Pres_P)
{
__buf[1] = 'X';
for (auto __p = __buf + 2; __p != __ptr; ++__p)

*__p = __builtin_toupper(*__p);

basic_string_view<_CharT> __str;
if constexpr (is_same_v<_CharT, char>)
__str = string_view(__buf, __n);

else
{
auto __p = (_CharT*)__builtin_alloca(__n * sizeof(_CharT));
std::__to_wstring_numeric(__buf, __n, __p);
__str = wstring_view(__p, __n);
}

if (_M_spec._M_zero_fill)
{
size_t __width = _M_spec._M_get_width(__fc);
if (__width <= __str.size())
return __format::__write(__fc.out(), __str);

auto out = fc.out();

out = format::write(std::move(out), __str.substr(0, 2));

__str.remove_prefix(2);
size_t __nfill = __width - __n;
return __format::__write_padded(std::move(__out), __str,
__format::_Align_right,
__nfill, _CharT('0'));
}

return format::write_padded_as_spec(str, n, __fc, _M_spec,

__format::_Align_right);
}

private:
__format::_Spec<_CharT> _M_spec{};
};

template<__format::__char _CharT>
struct formatter<void*, _CharT>
{
formatter() = default;

[[__gnu__::__always_inline__]]
constexpr typename basic_format_parse_context<_CharT>::iterator
parse(basic_format_parse_context<_CharT>& __pc)
{ return _M_f.parse(__pc); }

template<typename _Out>
typename basic_format_context<_Out, _CharT>::iterator
format(void* __v, basic_format_context<_Out, _CharT>& __fc) const
{ return _M_f.format(__v, __fc); }

private:
formatter<const void*, _CharT> _M_f;
};

template<__format::__char _CharT>
struct formatter<nullptr_t, _CharT>
{
formatter() = default;

[[__gnu__::__always_inline__]]
constexpr typename basic_format_parse_context<_CharT>::iterator
parse(basic_format_parse_context<_CharT>& __pc)
{ return _M_f.parse(__pc); }

template<typename _Out>
typename basic_format_context<_Out, _CharT>::iterator
format(nullptr_t, basic_format_context<_Out, _CharT>& __fc) const
{ return _M_f.format(nullptr, __fc); }

private:
formatter<const void*, _CharT> _M_f;
};
# 2506 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/format" 3
namespace __format
{
template<typename _Tp, typename _Context,
typename _Formatter
= typename _Context::template formatter_type<remove_const_t<_Tp>>,
typename _ParseContext
= basic_format_parse_context<typename _Context::char_type>>
concept __parsable_with
= semiregular<_Formatter>
&& requires (_Formatter __f, _ParseContext __pc)
{
{ __f.parse(__pc) } -> same_as<typename _ParseContext::iterator>;
};

template<typename _Tp, typename _Context,

typename _Formatter
= typename _Context::template formatter_type<remove_const_t<_Tp>>,
typename _ParseContext
= basic_format_parse_context<typename _Context::char_type>>
concept __formattable_with
= semiregular<_Formatter>
&& requires (const _Formatter __cf, _Tp&& __t, _Context __fc)
{
{ __cf.format(__t, __fc) } -> same_as<typename _Context::iterator>;
};

template<typename _CharT>
using _Iter_for = back_insert_iterator<basic_string<_CharT>>;

template<typename _Tp, typename _CharT,

typename _Context = basic_format_context<_Iter_for<_CharT>, _CharT>>
concept __formattable_impl
= __parsable_with<_Tp, _Context> && __formattable_with<_Tp, _Context>;

template<typename _Tp, typename _CharT>

concept formattable
= __format::__formattable_impl<remove_reference_t<_Tp>, _CharT>;
# 2569 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/format" 3
template<typename _Out>
struct format_to_n_result
{
_Out out;
iter_difference_t<_Out> size;
};

template<typename, typename> class vector;

namespace __format
{
template<typename _CharT>
class _Sink_iter
{
_Sink<_CharT>* _M_sink = nullptr;

public:
using iterator_category = output_iterator_tag;
using value_type = void;
using difference_type = ptrdiff_t;
using pointer = void;
using reference = void;

_Sink_iter() = default;
_Sink_iter(const _Sink_iter&) = default;
_Sink_iter& operator=(const _Sink_iter&) = default;

[[__gnu__::__always_inline__]]
explicit constexpr
_Sink_iter(_Sink<_CharT>& __sink) : _M_sink(std::addressof(__sink)) { }

[[__gnu__::__always_inline__]]
constexpr _Sink_iter&
operator=(_CharT __c)
{
_M_sink->_M_write(__c);
return *this;
}

[[__gnu__::__always_inline__]]
constexpr _Sink_iter&
operator=(basic_string_view<_CharT> __s)
{
_M_sink->_M_write(__s);
return *this;
}

[[__gnu__::__always_inline__]]
constexpr _Sink_iter&
operator*() { return *this; }

[[__gnu__::__always_inline__]]
constexpr _Sink_iter&
operator++() { return *this; }

[[__gnu__::__always_inline__]]
constexpr _Sink_iter
operator++(int) { return *this; }

auto
_M_reserve(size_t __n) const
{ return _M_sink->_M_reserve(__n); }
};

template<typename _CharT>
class _Sink
{
friend class _Sink_iter<_CharT>;

span<_CharT> _M_span;
typename span<_CharT>::iterator _M_next;

virtual void _M_overflow() = 0;

protected:

[[__gnu__::__always_inline__]]
explicit constexpr
_Sink(span<_CharT> __span) noexcept
: _M_span(__span), _M_next(__span.begin())
{ }

[[__gnu__::__always_inline__]]
span<_CharT>
_M_used() const noexcept
{ return _M_span.first(_M_next - _M_span.begin()); }
[[__gnu__::__always_inline__]]
constexpr span<_CharT>
_M_unused() const noexcept
{ return _M_span.subspan(_M_next - _M_span.begin()); }

[[__gnu__::__always_inline__]]
constexpr void
_M_rewind() noexcept
{ _M_next = _M_span.begin(); }

void
_M_reset(span<_CharT> __s, size_t __pos = 0) noexcept
{
_M_span = __s;
_M_next = __s.begin() + __pos;
}

constexpr void
_M_write(_CharT __c)
{
*_M_next++ = __c;
if (_M_next - _M_span.begin() == std::ssize(_M_span)) [[unlikely]]
_M_overflow();
}

constexpr void
_M_write(basic_string_view<_CharT> __s)
{
span __to = _M_unused();
while (__to.size() <= __s.size())
{
__s.copy(__to.data(), __to.size());
_M_next += __to.size();
__s.remove_prefix(__to.size());
_M_overflow();
__to = _M_unused();
}
if (__s.size())
{
__s.copy(__to.data(), __s.size());
_M_next += __s.size();
}
}

struct _Reservation
{

explicit operator bool() const noexcept { return _M_sink; }

_CharT* get() const noexcept { return _M_sink->_M_next.operator->(); }

void _M_bump(size_t __n) { _M_sink->_M_bump(__n); }

_Sink* _M_sink;
};

virtual _Reservation
_M_reserve(size_t __n)
{
if (__n <= _M_unused().size())
return { this };

if (__n <= _M_span.size())

{
_M_overflow();
if (__n <= _M_unused().size())
return { this };
}
return { nullptr };
}

virtual void
_M_bump(size_t __n)
{ _M_next += __n; }

public:
_Sink(const _Sink&) = delete;
_Sink& operator=(const _Sink&) = delete;

[[__gnu__::__always_inline__]]
constexpr _Sink_iter<_CharT>
out() noexcept
{ return _Sink_iter<_CharT>(*this); }
};

template<typename _CharT>
class _Buf_sink : public _Sink<_CharT>
{
protected:
_CharT _M_buf[32 * sizeof(void*) / sizeof(_CharT)];

[[__gnu__::__always_inline__]]
constexpr
_Buf_sink() noexcept
: _Sink<_CharT>(_M_buf)
{ }
};

using std::vector;

template<typename _Seq>
class _Seq_sink final : public _Buf_sink<typename _Seq::value_type>
{
using _CharT = typename _Seq::value_type;

_Seq _M_seq;

void
_M_overflow() override
{
auto __s = this->_M_used();
if (__s.empty()) [[unlikely]]
return;

if constexpr (__is_specialization_of<_Seq, basic_string>)

_M_seq.append(__s.data(), __s.size());
else
_M_seq.insert(_M_seq.end(), __s.begin(), __s.end());

this->_M_rewind();
}

typename _Sink<_CharT>::_Reservation
_M_reserve(size_t __n) override
{

if constexpr (__is_specialization_of<_Seq, basic_string>

|| __is_specialization_of<_Seq, vector>)
{

if (this->_M_used().size()) [[unlikely]]
_Seq_sink::_M_overflow();

const auto __sz = _M_seq.size();

if constexpr (is_same_v<string, _Seq> || is_same_v<wstring, _Seq>)
_M_seq.__resize_and_overwrite(__sz + __n,
[](auto, auto __n2) {
return __n2;
});
else
_M_seq.resize(__sz + __n);

this->_M_reset(_M_seq, __sz);
return { this };
}
else
return _Sink<_CharT>::_M_reserve(__n);
}
void
_M_bump(size_t __n) override
{
if constexpr (__is_specialization_of<_Seq, basic_string>
|| __is_specialization_of<_Seq, vector>)
{
auto __s = this->_M_used();
;

_M_seq.resize(__s.size() + __n);

this->_M_reset(this->_M_buf);
}
}

public:

[[__gnu__::__always_inline__]]
_Seq_sink() noexcept(is_nothrow_default_constructible_v<_Seq>)
{ }

_Seq_sink(_Seq&& __s) noexcept(is_nothrow_move_constructible_v<_Seq>)

: _M_seq(std::move(__s))
{ }

using _Sink<_CharT>::out;

_Seq
get() &&
{
if (this->_M_used().size() != 0)
_Seq_sink::_M_overflow();
return std::move(_M_seq);
}

span<_CharT>
view()
{
auto __s = this->_M_used();
if (_M_seq.size())
{
if (__s.size() != 0)
_Seq_sink::_M_overflow();
return _M_seq;
}
return __s;
}
};

template<typename _CharT, typename _Alloc = allocator<_CharT>>

using _Str_sink
= _Seq_sink<basic_string<_CharT, char_traits<_CharT>, _Alloc>>;
template<typename _CharT, typename _OutIter>
class _Iter_sink : public _Buf_sink<_CharT>
{
_OutIter _M_out;
iter_difference_t<_OutIter> _M_max;

protected:
size_t _M_count = 0;

void
_M_overflow() override
{
auto __s = this->_M_used();
if (_M_max < 0)
_M_out = ranges::copy(__s, std::move(_M_out)).out;
else if (_M_count < static_cast<size_t>(_M_max))
{
auto __max = _M_max - _M_count;
span<_CharT> __first;
if (__max < __s.size())
__first = __s.first(static_cast<size_t>(__max));
else
__first = __s;
_M_out = ranges::copy(__first, std::move(_M_out)).out;
}
this->_M_rewind();
_M_count += __s.size();
}

public:
[[__gnu__::__always_inline__]]
explicit
_Iter_sink(_OutIter __out, iter_difference_t<_OutIter> __max = -1)
: _M_out(std::move(__out)), _M_max(__max)
{ }

using _Sink<_CharT>::out;

format_to_n_result<_OutIter>
_M_finish() &&
{
if (this->_M_used().size() != 0)
_Iter_sink::_M_overflow();
iter_difference_t<_OutIter> __count(_M_count);
return { std::move(_M_out), __count };
}
};
# 2962 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/format" 3
template<typename _CharT, contiguous_iterator _OutIter>
requires same_as<iter_value_t<_OutIter>, _CharT>
class _Iter_sink<_CharT, _OutIter> : public _Sink<_CharT>
{
_OutIter _M_first;
iter_difference_t<_OutIter> _M_max = -1;
protected:
size_t _M_count = 0;
private:
_CharT _M_buf[64];

protected:
void
_M_overflow() override
{
if (this->_M_unused().size() != 0)
return;

auto __s = this->_M_used();

if (_M_max >= 0)
{
_M_count += __s.size();

this->_M_reset(this->_M_buf);
}
else
{

this->_M_reset({s.data(), s.size() + 1024}, __s.size());

}
}

typename _Sink<_CharT>::_Reservation
_M_reserve(size_t __n) final
{
auto __avail = this->_M_unused();
if (__n > __avail.size())
{
if (_M_max >= 0)
return {};

auto __s = this->_M_used();

this->_M_reset({__s.data(), __s.size() + __n}, __s.size());
}
return { this };
}

private:
static span<_CharT>
_S_make_span(_CharT* __ptr, iter_difference_t<_OutIter> __n,
span<_CharT> __buf) noexcept
{
if (__n == 0)
return __buf;

if (__n > 0)
{
if constexpr (!is_integral_v<iter_difference_t<_OutIter>>
|| sizeof(__n) > sizeof(size_t))
{
auto __m = iter_difference_t<_OutIter>((size_t)-1);
if (__n > __m)
__n = __m;
}
return {__ptr, (size_t)__n};
}

if (size_t bytes = builtin_dynamic_object_size(__ptr, 2))

return {__ptr, __bytes / sizeof(_CharT)};

const auto __off = reinterpret_cast<long long unsigned int>(__ptr) % 1024;

__n = (1024 - __off) / sizeof(_CharT);
if (__n > 0) [[likely]]
return {__ptr, static_cast<size_t>(__n)};
else
return {__ptr, 1};
}

public:
explicit
_Iter_sink(_OutIter __out, iter_difference_t<_OutIter> __n = -1) noexcept
: _Sink<_CharT>(_S_make_span(std::to_address(__out), __n, _M_buf)),
_M_first(__out), _M_max(__n)
{ }

format_to_n_result<_OutIter>
_M_finish() &&
{
auto __s = this->_M_used();
if (__s.data() == _M_buf)
{

iter_difference_t<_OutIter> __count(_M_count + __s.size());

return { _M_first + _M_max, __count };
}
else
{
iter_difference_t<_OutIter> __count(__s.size());
return { _M_first + __count, __count };
}
}
};

enum _Arg_t : unsigned char {

_Arg_none, _Arg_bool, _Arg_c, _Arg_i, _Arg_u, _Arg_ll, _Arg_ull,
_Arg_flt, _Arg_dbl, _Arg_ldbl, _Arg_str, _Arg_sv, _Arg_ptr, _Arg_handle,
_Arg_i128, _Arg_u128,
_Arg_bf16, _Arg_f16, _Arg_f32, _Arg_f64,

_Arg_f128,

_Arg_max_
};
template<typename _Context>
struct _Arg_value
{
using _CharT = typename _Context::char_type;

struct _HandleBase
{
const void* _M_ptr;
void (*_M_func)();
};

union
{
monostate _M_none;
bool _M_bool;
_CharT _M_c;
int _M_i;
unsigned _M_u;
long long _M_ll;
unsigned long long _M_ull;
float _M_flt;
double _M_dbl;

long double _M_ldbl;

const _CharT* _M_str;

basic_string_view<_CharT> _M_sv;
const void* _M_ptr;
_HandleBase _M_handle;

__int128 _M_i128;
unsigned __int128 _M_u128;

};

[[__gnu__::__always_inline__]]
_Arg_value() : _M_none() { }

template<typename _Tp, typename _Self>

[[__gnu__::__always_inline__]]
static auto&
_S_get(_Self& __u) noexcept
{
if constexpr (is_same_v<_Tp, bool>)
return __u._M_bool;
else if constexpr (is_same_v<_Tp, _CharT>)
return __u._M_c;
else if constexpr (is_same_v<_Tp, int>)
return __u._M_i;
else if constexpr (is_same_v<_Tp, unsigned>)
return __u._M_u;
else if constexpr (is_same_v<_Tp, long long>)
return __u._M_ll;
else if constexpr (is_same_v<_Tp, unsigned long long>)
return __u._M_ull;
else if constexpr (is_same_v<_Tp, float>)
return __u._M_flt;
else if constexpr (is_same_v<_Tp, double>)
return __u._M_dbl;

else if constexpr (is_same_v<_Tp, long double>)

return __u._M_ldbl;

else if constexpr (is_same_v<_Tp, const _CharT*>)

return __u._M_str;
else if constexpr (is_same_v<_Tp, basic_string_view<_CharT>>)
return __u._M_sv;
else if constexpr (is_same_v<_Tp, const void*>)
return __u._M_ptr;

else if constexpr (is_same_v<_Tp, __int128>)

return __u._M_i128;
else if constexpr (is_same_v<_Tp, unsigned __int128>)
return __u._M_u128;

else if constexpr (derived_from<_Tp, _HandleBase>)

return static_cast<_Tp&>(__u._M_handle);

template<typename _Tp>
[[__gnu__::__always_inline__]]
auto&
_M_get() noexcept
{ return _S_get<_Tp>(*this); }

template<typename _Tp>
[[__gnu__::__always_inline__]]
const auto&
_M_get() const noexcept
{ return _S_get<_Tp>(*this); }

template<typename _Tp>
[[__gnu__::__always_inline__]]
void
_M_set(_Tp __v) noexcept
{
if constexpr (derived_from<_Tp, _HandleBase>)
std::construct_at(&_M_handle, __v);
else
_S_get<_Tp>(*this) = __v;
}
};

template<typename _Context, typename... _Args>

class _Arg_store;

template<typename _Context>
class basic_format_arg
{
using _CharT = typename _Context::char_type;

template<typename _Tp>
static constexpr bool __formattable
= __format::__formattable_with<_Tp, _Context>;

public:
class handle : public __format::_Arg_value<_Context>::_HandleBase
{
using _Base = typename __format::_Arg_value<_Context>::_HandleBase;

template<typename _Tp>
using __maybe_const_t
= __conditional_t<__formattable<const _Tp>, const _Tp, _Tp>;

template<typename _Tq>
static void
_S_format(basic_format_parse_context<_CharT>& __parse_ctx,
_Context& __format_ctx, const void* __ptr)
{
using _Td = remove_const_t<_Tq>;
typename _Context::template formatter_type<_Td> __f;
__parse_ctx.advance_to(__f.parse(__parse_ctx));
_Tq& __val = *const_cast<_Tq*>(static_cast<const _Td*>(__ptr));
__format_ctx.advance_to(__f.format(__val, __format_ctx));
}

template<typename _Tp>
explicit
handle(_Tp& __val) noexcept
{
this->_M_ptr = __builtin_addressof(__val);
auto __func = _S_format<__maybe_const_t<_Tp>>;
this->_M_func = reinterpret_cast<void(*)()>(__func);
}

friend class basic_format_arg<_Context>;

public:
handle(const handle&) = default;
handle& operator=(const handle&) = default;

[[__gnu__::__always_inline__]]
void
format(basic_format_parse_context<_CharT>& __pc, _Context& __fc) const
{
using _Func = void(*)(basic_format_parse_context<_CharT>&,
_Context&, const void*);
auto __f = reinterpret_cast<_Func>(this->_M_func);
__f(__pc, __fc, this->_M_ptr);
}
};

[[__gnu__::__always_inline__]]
basic_format_arg() noexcept : _M_type(__format::_Arg_none) { }

[[nodiscard,__gnu__::__always_inline__]]
explicit operator bool() const noexcept
{ return _M_type != __format::_Arg_none; }

private:
template<typename _Ctx>
friend class basic_format_args;

template<typename _Ctx, typename... _Args>

friend class __format::_Arg_store;

static_assert(is_trivially_copyable_v<__format::_Arg_value<_Context>>);

__format::_Arg_value<_Context> _M_val;
__format::_Arg_t _M_type;

template<typename _Tp>
static consteval auto
_S_to_arg_type()
{
using _Td = remove_const_t<_Tp>;
if constexpr (is_same_v<_Td, bool>)
return type_identity<bool>();
else if constexpr (is_same_v<_Td, _CharT>)
return type_identity<_CharT>();
else if constexpr (is_same_v<_Td, char> && is_same_v<_CharT, wchar_t>)
return type_identity<_CharT>();

else if constexpr (is_same_v<_Td, __int128>)

return type_identity<__int128>();
else if constexpr (is_same_v<_Td, unsigned __int128>)
return type_identity<unsigned __int128>();

else if constexpr (__is_signed_integer<_Td>::value)

{
if constexpr (sizeof(_Td) <= sizeof(int))
return type_identity<int>();
else if constexpr (sizeof(_Td) <= sizeof(long long))
return type_identity<long long>();
}
else if constexpr (__is_unsigned_integer<_Td>::value)
{
if constexpr (sizeof(_Td) <= sizeof(unsigned))
return type_identity<unsigned>();
else if constexpr (sizeof(_Td) <= sizeof(unsigned long long))
return type_identity<unsigned long long>();
}
else if constexpr (is_same_v<_Td, float>)
return type_identity<float>();
else if constexpr (is_same_v<_Td, double>)
return type_identity<double>();

else if constexpr (is_same_v<_Td, long double>)

return type_identity<long double>();
# 3344 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/format" 3
else if constexpr (is_same_v<_Td, _Float16>)
return type_identity<float>();

else if constexpr (is_same_v<_Td, decltype(0.0bf16)>)

return type_identity<float>();

else if constexpr (is_same_v<_Td, _Float32>)

return type_identity<float>();

else if constexpr (is_same_v<_Td, _Float64>)

return type_identity<double>();
# 3379 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/format" 3
else if constexpr (__is_specialization_of<_Td, basic_string_view>
|| __is_specialization_of<_Td, basic_string>)
{
if constexpr (is_same_v<typename _Td::value_type, _CharT>)
return type_identity<basic_string_view<_CharT>>();
else
return type_identity<handle>();
}
else if constexpr (is_same_v<decay_t<_Td>, const _CharT*>)
return type_identity<const _CharT*>();
else if constexpr (is_same_v<decay_t<_Td>, _CharT*>)
return type_identity<const _CharT*>();
else if constexpr (is_void_v<remove_pointer_t<_Td>>)
return type_identity<const void*>();
else if constexpr (is_same_v<_Td, nullptr_t>)
return type_identity<const void*>();
else
return type_identity<handle>();
}

template<typename _Tp>
using _Normalize = typename decltype(_S_to_arg_type<_Tp>())::type;

template<typename _Tp>
static consteval __format::_Arg_t
_S_to_enum()
{
using namespace __format;
if constexpr (is_same_v<_Tp, bool>)
return _Arg_bool;
else if constexpr (is_same_v<_Tp, _CharT>)
return _Arg_c;
else if constexpr (is_same_v<_Tp, int>)
return _Arg_i;
else if constexpr (is_same_v<_Tp, unsigned>)
return _Arg_u;
else if constexpr (is_same_v<_Tp, long long>)
return _Arg_ll;
else if constexpr (is_same_v<_Tp, unsigned long long>)
return _Arg_ull;
else if constexpr (is_same_v<_Tp, float>)
return _Arg_flt;
else if constexpr (is_same_v<_Tp, double>)
return _Arg_dbl;

else if constexpr (is_same_v<_Tp, long double>)

return _Arg_ldbl;

else if constexpr (is_same_v<_Tp, const _CharT*>)

return _Arg_str;
else if constexpr (is_same_v<_Tp, basic_string_view<_CharT>>)
return _Arg_sv;
else if constexpr (is_same_v<_Tp, const void*>)
return _Arg_ptr;

else if constexpr (is_same_v<_Tp, __int128>)

return _Arg_i128;
else if constexpr (is_same_v<_Tp, unsigned __int128>)
return _Arg_u128;
# 3462 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/format" 3
else if constexpr (is_same_v<_Tp, handle>)
return _Arg_handle;
}

template<typename _Tp>
void
_M_set(_Tp __v) noexcept
{
_M_type = _S_to_enum<_Tp>();
_M_val._M_set(__v);
}

template<typename _Tp>
requires __format::__formattable_with<_Tp, _Context>
explicit
basic_format_arg(_Tp& __v) noexcept
{
using _Td = _Normalize<_Tp>;
if constexpr (is_same_v<_Td, basic_string_view<_CharT>>)
_M_set(_Td{__v.data(), __v.size()});
else if constexpr (is_same_v<remove_const_t<_Tp>, char>
&& is_same_v<_CharT, wchar_t>)
_M_set(static_cast<_Td>(static_cast<unsigned char>(__v)));
else
_M_set(static_cast<_Td>(__v));
}

template<typename _Ctx, typename... _Argz>

friend auto
make_format_args(_Argz&...) noexcept;

template<typename _Visitor, typename _Ctx>

friend decltype(auto)
visit_format_arg(_Visitor&& __vis, basic_format_arg<_Ctx>);

template<typename _Visitor>
decltype(auto)
_M_visit(_Visitor&& __vis, __format::_Arg_t __type)
{
using namespace __format;
switch (__type)
{
case _Arg_none:
return std::forward<_Visitor>(__vis)(_M_val._M_none);
case _Arg_bool:
return std::forward<_Visitor>(__vis)(_M_val._M_bool);
case _Arg_c:
return std::forward<_Visitor>(__vis)(_M_val._M_c);
case _Arg_i:
return std::forward<_Visitor>(__vis)(_M_val._M_i);
case _Arg_u:
return std::forward<_Visitor>(__vis)(_M_val._M_u);
case _Arg_ll:
return std::forward<_Visitor>(__vis)(_M_val._M_ll);
case _Arg_ull:
return std::forward<_Visitor>(__vis)(_M_val._M_ull);

case _Arg_flt:
return std::forward<_Visitor>(__vis)(_M_val._M_flt);
case _Arg_dbl:
return std::forward<_Visitor>(__vis)(_M_val._M_dbl);

case _Arg_ldbl:
return std::forward<_Visitor>(__vis)(_M_val._M_ldbl);

case _Arg_str:
return std::forward<_Visitor>(__vis)(_M_val._M_str);
case _Arg_sv:
return std::forward<_Visitor>(__vis)(_M_val._M_sv);
case _Arg_ptr:
return std::forward<_Visitor>(__vis)(_M_val._M_ptr);
case _Arg_handle:
{
auto& __h = static_cast<handle&>(_M_val._M_handle);
return std::forward<_Visitor>(__vis)(__h);
}

case _Arg_i128:
return std::forward<_Visitor>(__vis)(_M_val._M_i128);
case _Arg_u128:
return std::forward<_Visitor>(__vis)(_M_val._M_u128);

default:

__builtin_unreachable();
}
}
};

template<typename _Visitor, typename _Context>

inline decltype(auto)
visit_format_arg(_Visitor&& __vis, basic_format_arg<_Context> __arg)
{
return __arg._M_visit(std::forward<_Visitor>(__vis), __arg._M_type);
}

namespace __format
{
struct _WidthPrecVisitor
{
template<typename _Tp>
size_t
operator()(_Tp& __arg) const
{
if constexpr (is_same_v<_Tp, monostate>)
__format::__invalid_arg_id_in_format_string();

else if constexpr (sizeof(_Tp) <= sizeof(long long))

{

if constexpr (__is_unsigned_integer<_Tp>::value)
return __arg;
else if constexpr (__is_signed_integer<_Tp>::value)
if (__arg >= 0)
return __arg;
}
__throw_format_error("format error: argument used for width or "
"precision must be a non-negative integer");
}
};

template<typename _Context>
inline size_t
__int_from_arg(const basic_format_arg<_Context>& __arg)
{ return std::visit_format_arg(_WidthPrecVisitor(), __arg); }

template<int _Bits, size_t _Nm>

constexpr auto
__pack_arg_types(const array<_Arg_t, _Nm>& __types)
{
long long unsigned int __packed_types = 0;
for (auto __i = __types.rbegin(); __i != __types.rend(); ++__i)
__packed_types = (__packed_types << _Bits) | *__i;
return __packed_types;
}
}

template<typename _Context>
class basic_format_args
{
static constexpr int _S_packed_type_bits = 5;
static constexpr int _S_packed_type_mask = 0b11111;
static constexpr int _S_max_packed_args = 12;

static_assert( __format::_Arg_max_ <= (1 << _S_packed_type_bits) );

template<typename... _Args>
using _Store = __format::_Arg_store<_Context, _Args...>;

template<typename _Ctx, typename... _Args>

friend class __format::_Arg_store;

using uint64_t = long long unsigned int;

using _Format_arg = basic_format_arg<_Context>;
using _Format_arg_val = __format::_Arg_value<_Context>;

uint64_t _M_packed_size : 4;
uint64_t _M_unpacked_size : 60;

union {
const _Format_arg_val* _M_values;
const _Format_arg* _M_args;
};

size_t
_M_size() const noexcept
{ return _M_packed_size ? _M_packed_size : _M_unpacked_size; }
typename __format::_Arg_t
_M_type(size_t __i) const noexcept
{
uint64_t __t = _M_unpacked_size >> (__i * _S_packed_type_bits);
return static_cast<__format::_Arg_t>(__t & _S_packed_type_mask);
}

template<typename _Ctx, typename... _Args>

friend auto
make_format_args(_Args&...) noexcept;

template<typename... _Args>
static consteval array<__format::_Arg_t, sizeof...(_Args)>
_S_types_to_pack()
{ return {_Format_arg::template _S_to_enum<_Args>()...}; }

public:
basic_format_args() noexcept = default;

template<typename... _Args>
basic_format_args(const _Store<_Args...>& __store) noexcept;

[[nodiscard,__gnu__::__always_inline__]]
basic_format_arg<_Context>
get(size_t __i) const noexcept
{
basic_format_arg<_Context> __arg;
if (__i < _M_packed_size)
{
__arg._M_type = _M_type(__i);
__arg._M_val = _M_values[__i];
}
else if (_M_packed_size == 0 && __i < _M_unpacked_size)
__arg = _M_args[__i];
return __arg;
}
};

template<typename _Context, typename... _Args>

basic_format_args(__format::_Arg_store<_Context, _Args...>)
-> basic_format_args<_Context>;

template<typename _Context, typename... _Args>

auto
make_format_args(_Args&... __fmt_args) noexcept;

template<typename _Context, typename... _Args>

class __format::_Arg_store
{
friend std::basic_format_args<_Context>;

template<typename _Ctx, typename... _Argz>

friend auto std::
make_format_args(_Argz&...) noexcept;

static constexpr bool _S_values_only

= sizeof...(_Args) <= basic_format_args<_Context>::_S_max_packed_args;

using _Element_t
= __conditional_t<_S_values_only,
__format::_Arg_value<_Context>,
basic_format_arg<_Context>>;

_Element_t _M_args[sizeof...(_Args)];

template<typename _Tp>
static _Element_t
_S_make_elt(_Tp& __v)
{
using _Tq = remove_const_t<_Tp>;
using _CharT = typename _Context::char_type;
static_assert(is_default_constructible_v<formatter<_Tq, _CharT>>,
"std::formatter must be specialized for the type "
"of each format arg");
using __format::__formattable_with;
if constexpr (is_const_v<_Tp>)
if constexpr (!__formattable_with<_Tp, _Context>)
if constexpr (__formattable_with<_Tq, _Context>)
static_assert(__formattable_with<_Tp, _Context>,
"format arg must be non-const because its "
"std::formatter specialization has a "
"non-const reference parameter");
basic_format_arg<_Context> __arg(__v);
if constexpr (_S_values_only)
return __arg._M_val;
else
return __arg;
}

template<typename... _Tp>
requires (sizeof...(_Tp) == sizeof...(_Args))
[[__gnu__::__always_inline__]]
_Arg_store(_Tp&... __a) noexcept
: _M_args{_S_make_elt(__a)...}
{ }
};

template<typename _Context>
class __format::_Arg_store<_Context>
{ };

template<typename _Context>
template<typename... _Args>
inline
basic_format_args<_Context>::
basic_format_args(const _Store<_Args...>& __store) noexcept
{
if constexpr (sizeof...(_Args) == 0)
{
_M_packed_size = 0;
_M_unpacked_size = 0;
_M_args = nullptr;
}
else if constexpr (sizeof...(_Args) <= _S_max_packed_args)
{

_M_packed_size = sizeof...(_Args);

_M_unpacked_size
=
__format::__pack_arg_types<_S_packed_type_bits>(_S_types_to_pack<_Args...>());

_M_values = __store._M_args;
}
else
{

_M_packed_size = 0;

_M_unpacked_size = sizeof...(_Args);

_M_args = __store._M_args;
}
}

template<typename _Context = format_context, typename... _Args>

[[nodiscard,__gnu__::__always_inline__]]
inline auto
make_format_args(_Args&... __fmt_args) noexcept
{
using _Fmt_arg = basic_format_arg<_Context>;
using _Store = __format::_Arg_store<_Context, typename _Fmt_arg::template
_Normalize<_Args>...>;
return _Store(__fmt_args...);
}

template<typename... _Args>
[[nodiscard,__gnu__::__always_inline__]]
inline auto
make_wformat_args(_Args&... __args) noexcept
{ return std::make_format_args<wformat_context>(__args...); }

namespace __format
{
template<typename _Out, typename _CharT, typename _Context>
_Out
__do_vformat_to(_Out, basic_string_view<_CharT>,
const basic_format_args<_Context>&,
const locale* = nullptr);
}
# 3835 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/format" 3
template<typename _Out, typename _CharT>
class basic_format_context
{
static_assert( output_iterator<_Out, const _CharT&> );

basic_format_args<basic_format_context> _M_args;
_Out _M_out;
__format::_Optional_locale _M_loc;

basic_format_context(basic_format_args<basic_format_context> __args,
_Out __out)
: _M_args(__args), _M_out(std::move(__out))
{ }

basic_format_context(basic_format_args<basic_format_context> __args,
_Out __out, const std::locale& __loc)
: _M_args(__args), _M_out(std::move(__out)), _M_loc(__loc)
{ }

template<typename _Out2, typename _CharT2, typename _Context2>

friend _Out2
__format::__do_vformat_to(_Out2, basic_string_view<_CharT2>,
const basic_format_args<_Context2>&,
const locale*);

public:
basic_format_context() = default;
~basic_format_context() = default;

using iterator = _Out;

using char_type = _CharT;
template<typename _Tp>
using formatter_type = formatter<_Tp, _CharT>;

[[nodiscard]]
basic_format_arg<basic_format_context>
arg(size_t __id) const noexcept
{ return _M_args.get(__id); }

[[nodiscard]]
std::locale locale() { return _M_loc.value(); }

[[nodiscard]]
iterator out() { return std::move(_M_out); }

void advance_to(iterator __it) { _M_out = std::move(__it); }

};

namespace __format
{

template<typename _CharT>
struct _Scanner
{
using iterator = typename basic_format_parse_context<_CharT>::iterator;
basic_format_parse_context<_CharT> _M_pc;

constexpr explicit
_Scanner(basic_string_view<_CharT> __str, size_t __nargs = -1)
: _M_pc(__str, __nargs)
{ }

constexpr iterator begin() const noexcept { return _M_pc.begin(); }

constexpr iterator end() const noexcept { return _M_pc.end(); }

constexpr void
_M_scan()
{
basic_string_view<_CharT> __fmt = _M_fmt_str();

if (fmt.size() == 2 && fmt[0] == '{' && __fmt[1] == '}')

{
_M_pc.advance_to(begin() + 1);
_M_format_arg(_M_pc.next_arg_id());
return;
}

size_t lbr = fmt.find('{');

size_t __rbr = __fmt.find('}');

while (__fmt.size())
{
auto __cmp = __lbr <=> __rbr;
if (__cmp == 0)
{
_M_on_chars(end());
_M_pc.advance_to(end());
return;
}
else if (__cmp < 0)
{
if (__lbr + 1 == __fmt.size()
|| (__rbr == __fmt.npos && __fmt[__lbr + 1] != '{'))
__format::__unmatched_left_brace_in_format_string();
const bool __is_escape = __fmt[__lbr + 1] == '{';
iterator __last = begin() + __lbr + int(__is_escape);
_M_on_chars(__last);
_M_pc.advance_to(__last + 1);
__fmt = _M_fmt_str();
if (__is_escape)
{
if (__rbr != __fmt.npos)
__rbr -= __lbr + 2;
__lbr = __fmt.find('{');
}
else
{
_M_on_replacement_field();
__fmt = _M_fmt_str();
__lbr = __fmt.find('{');
__rbr = __fmt.find('}');
}
}
else
{
if (++__rbr == __fmt.size() || __fmt[__rbr] != '}')
__format::__unmatched_right_brace_in_format_string();
iterator __last = begin() + __rbr;
_M_on_chars(__last);
_M_pc.advance_to(__last + 1);
__fmt = _M_fmt_str();
if (__lbr != __fmt.npos)
__lbr -= __rbr + 1;
__rbr = __fmt.find('}');
}
}
}

constexpr basic_string_view<_CharT>
_M_fmt_str() const noexcept
{ return {begin(), end()}; }

constexpr virtual void _M_on_chars(iterator) { }

constexpr void _M_on_replacement_field()

{
auto __next = begin();

size_t __id;
if (*__next == '}')
__id = _M_pc.next_arg_id();
else if (*__next == ':')
{
__id = _M_pc.next_arg_id();
_M_pc.advance_to(++__next);
}
else
{
auto [__i, __ptr] = __format::__parse_arg_id(begin(), end());
if (!__ptr || !(*__ptr == '}' || *__ptr == ':'))
__format::__invalid_arg_id_in_format_string();
_M_pc.check_arg_id(__id = __i);
if (*__ptr == ':')
{
_M_pc.advance_to(++__ptr);
}
else
_M_pc.advance_to(__ptr);
}
_M_format_arg(__id);
if (begin() == end() || *begin() != '}')
__format::__unmatched_left_brace_in_format_string();
_M_pc.advance_to(begin() + 1);
}

constexpr virtual void _M_format_arg(size_t __id) = 0;

};

template<typename _Out, typename _CharT>

class _Formatting_scanner : public _Scanner<_CharT>
{
public:
_Formatting_scanner(basic_format_context<_Out, _CharT>& __fc,
basic_string_view<_CharT> __str)
: _Scanner<_CharT>(__str), _M_fc(__fc)
{ }

private:
basic_format_context<_Out, _CharT>& _M_fc;

using iterator = typename _Scanner<_CharT>::iterator;

constexpr void
_M_on_chars(iterator __last) override
{
basic_string_view<_CharT> __str(this->begin(), __last);
_M_fc.advance_to(__format::__write(_M_fc.out(), __str));
}

constexpr void
_M_format_arg(size_t __id) override
{
using _Context = basic_format_context<_Out, _CharT>;
using handle = typename basic_format_arg<_Context>::handle;

std::visit_format_arg([this](auto& __arg) {
using _Type = remove_reference_t<decltype(__arg)>;
using _Formatter = typename _Context::template formatter_type<_Type>;
if constexpr (is_same_v<_Type, monostate>)
__format::__invalid_arg_id_in_format_string();
else if constexpr (is_same_v<_Type, handle>)
__arg.format(this->_M_pc, this->_M_fc);
else if constexpr (is_default_constructible_v<_Formatter>)
{
_Formatter __f;
this->_M_pc.advance_to(__f.parse(this->_M_pc));
this->_M_fc.advance_to(__f.format(__arg, this->_M_fc));
}
else
static_assert(__format::__formattable_with<_Type, _Context>);
}, _M_fc.arg(__id));
}
};

template<typename _CharT, typename... _Args>

class _Checking_scanner : public _Scanner<_CharT>
{
static_assert(
(is_default_constructible_v<formatter<_Args, _CharT>> && ...),
"std::formatter must be specialized for each type being formatted");

public:
constexpr
_Checking_scanner(basic_string_view<_CharT> __str)
: _Scanner<_CharT>(__str, sizeof...(_Args))
{ }

private:
constexpr void
_M_format_arg(size_t __id) override
{
if constexpr (sizeof...(_Args) != 0)
{
if (__id < sizeof...(_Args))
{
_M_parse_format_spec<_Args...>(__id);
return;
}
}
__builtin_unreachable();
}

template<typename _Tp, typename... _OtherArgs>

constexpr void
_M_parse_format_spec(size_t __id)
{
if (__id == 0)
{
formatter<_Tp, _CharT> __f;
this->_M_pc.advance_to(__f.parse(this->_M_pc));
}
else if constexpr (sizeof...(_OtherArgs) != 0)
_M_parse_format_spec<_OtherArgs...>(__id - 1);
else
__builtin_unreachable();
}
};

template<typename _Out, typename _CharT, typename _Context>

inline _Out
__do_vformat_to(_Out __out, basic_string_view<_CharT> __fmt,
const basic_format_args<_Context>& __args,
const locale* __loc)
{
_Iter_sink<_CharT, _Out> __sink(std::move(__out));
_Sink_iter<_CharT> __sink_out;

if constexpr (is_same_v<_Out, _Sink_iter<_CharT>>)

__sink_out = __out;
else
__sink_out = __sink.out();

if constexpr (is_same_v<_CharT, char>)

if (fmt.size() == 2 && fmt[0] == '{' && __fmt[1] == '}')

{
bool __done = false;
std::visit_format_arg([&](auto& __arg) {
using _Tp = remove_cvref_t<decltype(__arg)>;
if constexpr (is_same_v<_Tp, bool>)
{
size_t __len = 4 + !__arg;
const char* __chars[] = { "false", "true" };
if (auto __res = __sink_out._M_reserve(__len))
{
__builtin_memcpy(__res.get(), __chars[__arg], __len);
__res._M_bump(__len);
__done = true;
}
}
else if constexpr (is_same_v<_Tp, char>)
{
if (auto __res = __sink_out._M_reserve(1))
{
*__res.get() = __arg;
__res._M_bump(1);
__done = true;
}
}
else if constexpr (is_integral_v<_Tp>)
{
make_unsigned_t<_Tp> __uval;
const bool __neg = __arg < 0;
if (__neg)
__uval = make_unsigned_t<_Tp>(~__arg) + 1u;
else
__uval = __arg;
const auto __n = __detail::__to_chars_len(__uval);
if (auto __res = __sink_out._M_reserve(__n + __neg))
{
auto __ptr = __res.get();
*__ptr = '-';
__detail::__to_chars_10_impl(__ptr + (int)__neg, __n,
__uval);
__res._M_bump(__n + __neg);
__done = true;
}
}
else if constexpr (is_convertible_v<_Tp, string_view>)
{
string_view __sv = __arg;
if (auto __res = __sink_out._M_reserve(__sv.size()))
{
__builtin_memcpy(__res.get(), __sv.data(), __sv.size());
__res._M_bump(__sv.size());
__done = true;
}
}
}, __args.get(0));

if (__done)
{
if constexpr (is_same_v<_Out, _Sink_iter<_CharT>>)
return __sink_out;
else
return std::move(__sink)._M_finish().out;
}
}

auto ctx = loc == nullptr

? _Context(__args, __sink_out)
: _Context(__args, __sink_out, *__loc);
_Formatting_scanner<_Sink_iter<_CharT>, _CharT> __scanner(__ctx, __fmt);
__scanner._M_scan();

if constexpr (is_same_v<_Out, _Sink_iter<_CharT>>)

return __ctx.out();
else
return std::move(__sink)._M_finish().out;
}

template<typename _CharT, typename... _Args>

template<typename _Tp>
requires convertible_to<const _Tp&, basic_string_view<_CharT>>
consteval
basic_format_string<_CharT, _Args...>::
basic_format_string(const _Tp& __s)
: _M_str(__s)
{
__format::_Checking_scanner<_CharT, remove_cvref_t<_Args>...>
__scanner(_M_str);
__scanner._M_scan();
}

template<typename _Out> requires output_iterator<_Out, const char&>

[[__gnu__::__always_inline__]]
inline _Out
vformat_to(_Out __out, string_view __fmt, format_args __args)
{ return __format::__do_vformat_to(std::move(__out), __fmt, __args); }

template<typename _Out> requires output_iterator<_Out, const wchar_t&>

[[__gnu__::__always_inline__]]
inline _Out
vformat_to(_Out __out, wstring_view __fmt, wformat_args __args)
{ return __format::__do_vformat_to(std::move(__out), __fmt, __args); }

template<typename _Out> requires output_iterator<_Out, const char&>

[[__gnu__::__always_inline__]]
inline _Out
vformat_to(_Out __out, const locale& __loc, string_view __fmt,
format_args __args)
{
return __format::__do_vformat_to(std::move(__out), __fmt, __args, &__loc);
}

template<typename _Out> requires output_iterator<_Out, const wchar_t&>

[[__gnu__::__always_inline__]]
inline _Out
vformat_to(_Out __out, const locale& __loc, wstring_view __fmt,
wformat_args __args)
{
return __format::__do_vformat_to(std::move(__out), __fmt, __args, &__loc);
}

[[nodiscard]]
inline string
vformat(string_view __fmt, format_args __args)
{
__format::_Str_sink<char> __buf;
std::vformat_to(__buf.out(), __fmt, __args);
return std::move(__buf).get();
}

[[nodiscard]]
inline wstring
vformat(wstring_view __fmt, wformat_args __args)
{
__format::_Str_sink<wchar_t> __buf;
std::vformat_to(__buf.out(), __fmt, __args);
return std::move(__buf).get();
}

[[nodiscard]]
inline string
vformat(const locale& __loc, string_view __fmt, format_args __args)
{
__format::_Str_sink<char> __buf;
std::vformat_to(__buf.out(), __loc, __fmt, __args);
return std::move(__buf).get();
}

[[nodiscard]]
inline wstring
vformat(const locale& __loc, wstring_view __fmt, wformat_args __args)
{
__format::_Str_sink<wchar_t> __buf;
std::vformat_to(__buf.out(), __loc, __fmt, __args);
return std::move(__buf).get();
}

template<typename... _Args>
[[nodiscard]]
inline string
format(format_string<_Args...> __fmt, _Args&&... __args)
{ return std::vformat(__fmt.get(), std::make_format_args(__args...)); }

template<typename... _Args>
[[nodiscard]]
inline wstring
format(wformat_string<_Args...> __fmt, _Args&&... __args)
{ return std::vformat(__fmt.get(), std::make_wformat_args(__args...)); }

template<typename... _Args>
[[nodiscard]]
inline string
format(const locale& __loc, format_string<_Args...> __fmt,
_Args&&... __args)
{
return std::vformat(__loc, __fmt.get(),
std::make_format_args(__args...));
}

template<typename... _Args>
[[nodiscard]]
inline wstring
format(const locale& __loc, wformat_string<_Args...> __fmt,
_Args&&... __args)
{
return std::vformat(__loc, __fmt.get(),
std::make_wformat_args(__args...));
}

template<typename _Out, typename... _Args>

requires output_iterator<_Out, const char&>
inline _Out
format_to(_Out __out, format_string<_Args...> __fmt, _Args&&... __args)
{
return std::vformat_to(std::move(__out), __fmt.get(),
std::make_format_args(__args...));
}

template<typename _Out, typename... _Args>

requires output_iterator<_Out, const wchar_t&>
inline _Out
format_to(_Out __out, wformat_string<_Args...> __fmt, _Args&&... __args)
{
return std::vformat_to(std::move(__out), __fmt.get(),
std::make_wformat_args(__args...));
}

template<typename _Out, typename... _Args>

requires output_iterator<_Out, const char&>
inline _Out
format_to(_Out __out, const locale& __loc, format_string<_Args...> __fmt,
_Args&&... __args)
{
return std::vformat_to(std::move(__out), __loc, __fmt.get(),
std::make_format_args(__args...));
}

template<typename _Out, typename... _Args>

requires output_iterator<_Out, const wchar_t&>
inline _Out
format_to(_Out __out, const locale& __loc, wformat_string<_Args...> __fmt,
_Args&&... __args)
{
return std::vformat_to(std::move(__out), __loc, __fmt.get(),
std::make_wformat_args(__args...));
}

template<typename _Out, typename... _Args>

requires output_iterator<_Out, const char&>
inline format_to_n_result<_Out>
format_to_n(_Out __out, iter_difference_t<_Out> __n,
format_string<_Args...> __fmt, _Args&&... __args)
{
__format::_Iter_sink<char, _Out> __sink(std::move(__out), __n);
std::vformat_to(__sink.out(), __fmt.get(),
std::make_format_args(__args...));
return std::move(__sink)._M_finish();
}

template<typename _Out, typename... _Args>

requires output_iterator<_Out, const wchar_t&>
inline format_to_n_result<_Out>
format_to_n(_Out __out, iter_difference_t<_Out> __n,
wformat_string<_Args...> __fmt, _Args&&... __args)
{
__format::_Iter_sink<wchar_t, _Out> __sink(std::move(__out), __n);
std::vformat_to(__sink.out(), __fmt.get(),
std::make_wformat_args(__args...));
return std::move(__sink)._M_finish();
}

template<typename _Out, typename... _Args>

requires output_iterator<_Out, const char&>
inline format_to_n_result<_Out>
format_to_n(_Out __out, iter_difference_t<_Out> __n, const locale& __loc,
format_string<_Args...> __fmt, _Args&&... __args)
{
__format::_Iter_sink<char, _Out> __sink(std::move(__out), __n);
std::vformat_to(__sink.out(), __loc, __fmt.get(),
std::make_format_args(__args...));
return std::move(__sink)._M_finish();
}

template<typename _Out, typename... _Args>

requires output_iterator<_Out, const wchar_t&>
inline format_to_n_result<_Out>
format_to_n(_Out __out, iter_difference_t<_Out> __n, const locale& __loc,
wformat_string<_Args...> __fmt, _Args&&... __args)
{
__format::_Iter_sink<wchar_t, _Out> __sink(std::move(__out), __n);
std::vformat_to(__sink.out(), __loc, __fmt.get(),
std::make_wformat_args(__args...));
return std::move(__sink)._M_finish();
}

namespace __format
{

template<typename _CharT>
class _Counting_sink final : public _Iter_sink<_CharT, _CharT*>
{
public:
_Counting_sink() : _Iter_sink<_CharT, _CharT*>(nullptr, 0) { }
[[__gnu__::__always_inline__]]
size_t
count() const
{ return this->_M_count + this->_M_used().size(); }
};
# 4458 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/format" 3
}

template<typename... _Args>
[[nodiscard]]
inline size_t
formatted_size(format_string<_Args...> __fmt, _Args&&... __args)
{
__format::_Counting_sink<char> __buf;
std::vformat_to(__buf.out(), __fmt.get(),
std::make_format_args(__args...));
return __buf.count();
}

template<typename... _Args>
[[nodiscard]]
inline size_t
formatted_size(wformat_string<_Args...> __fmt, _Args&&... __args)
{
__format::_Counting_sink<wchar_t> __buf;
std::vformat_to(__buf.out(), __fmt.get(),
std::make_wformat_args(__args...));
return __buf.count();
}

template<typename... _Args>
[[nodiscard]]
inline size_t
formatted_size(const locale& __loc, format_string<_Args...> __fmt,
_Args&&... __args)
{
__format::_Counting_sink<char> __buf;
std::vformat_to(__buf.out(), __loc, __fmt.get(),
std::make_format_args(__args...));
return __buf.count();
}

template<typename... _Args>
[[nodiscard]]
inline size_t
formatted_size(const locale& __loc, wformat_string<_Args...> __fmt,
_Args&&... __args)
{
__format::_Counting_sink<wchar_t> __buf;
std::vformat_to(__buf.out(), __loc, __fmt.get(),
std::make_wformat_args(__args...));
return __buf.count();
}
# 4580 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/format" 3
}
# 42 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/print" 2 3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cstdio" 1 3
# 39 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cstdio" 3

# 40 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cstdio" 3
# 43 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/print" 2 3
# 1 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cerrno" 1 3
# 39 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cerrno" 3

# 40 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/cerrno" 3
# 44 "D:/Enviroments/mingw64_msvcrt/include/c++/14.1.0/print" 2 3

namespace std
{

inline void
vprint_nonunicode(FILE* __stream, string_view __fmt, format_args __args)
{
__format::_Str_sink<char> __buf;
std::vformat_to(__buf.out(), __fmt, __args);
auto __out = __buf.view();
if (std::fwrite(__out.data(), 1, __out.size(), __stream) != __out.size())
__throw_system_error(5);
}

inline void
vprint_unicode(FILE* __stream, string_view __fmt, format_args __args)
{

__format::_Str_sink<char> __buf;
std::vformat_to(__buf.out(), __fmt, __args);
auto __out = __buf.view();

void* __open_terminal(FILE*);
error_code __write_to_terminal(void*, span<char>);

if (auto term = open_terminal(__stream))

{
string __out = std::vformat(__fmt, __args);
error_code __e;
if (!std::fflush(__stream))
{
__e = __write_to_terminal(__term, __out);
if (!__e)
return;
if (__e == std::make_error_code(errc::illegal_byte_sequence))
return;
}
else
__e = error_code((*_errno()), generic_category());
(throw (system_error(__e, "std::vprint_unicode")));
}

if (std::fwrite(out.data(), 1, out.size(), stream) != out.size())

__throw_system_error(5);

template<typename... _Args>
inline void
print(FILE* __stream, format_string<_Args...> __fmt, _Args&&... __args)
{
auto __fmtargs = std::make_format_args(__args...);
if constexpr (__unicode::__literal_encoding_is_utf8())
std::vprint_unicode(__stream, __fmt.get(), __fmtargs);
else
std::vprint_nonunicode(__stream, __fmt.get(), __fmtargs);
}

template<typename... _Args>
inline void
print(format_string<_Args...> __fmt, _Args&&... __args)
{ std::print((__acrt_iob_func(1)), __fmt, std::forward<_Args>(__args)...); }

template<typename... _Args>
inline void
println(FILE* __stream, format_string<_Args...> __fmt, _Args&&... __args)
{
std::print(__stream, "{}\n",
std::format(__fmt, std::forward<_Args>(__args)...));
}

template<typename... _Args>
inline void
println(format_string<_Args...> __fmt, _Args&&... __args)
{ std::println((__acrt_iob_func(1)), __fmt, std::forward<_Args>(__args)...); }

inline void
vprint_unicode(string_view __fmt, format_args __args)
{ std::vprint_unicode((__acrt_iob_func(1)), __fmt, __args); }

inline void
vprint_nonunicode(string_view __fmt, format_args __args)
{ std::vprint_nonunicode((__acrt_iob_func(1)), __fmt, __args); }

inline void println(FILE* __stream)

{

if constexpr (__unicode::__literal_encoding_is_utf8())
std::vprint_unicode(__stream, "\n", std::make_format_args());
else

if (std::putc('\n', __stream) == (-1))

__throw_system_error(5);
}
inline void println() { std::println((__acrt_iob_func(1))); }

}
# 2 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/main.cpp" 2
# 1 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h" 1
# 33 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"

# 33 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
extern "C" {
# 103 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
# 1 "D:/Enviroments/mingw64_msvcrt/lib/gcc/x86_64-w64-mingw32/14.1.0/include/
stddef.h" 1 3 4
# 1 "D:/Enviroments/mingw64_msvcrt/x86_64-w64-mingw32/include/stddef.h" 1 3 4
# 2 "D:/Enviroments/mingw64_msvcrt/lib/gcc/x86_64-w64-mingw32/14.1.0/include/
stddef.h" 2 3 4
# 104 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h" 2
# 1365 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
typedef void (*GLFWglproc)(void);
# 1379 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
typedef void (*GLFWvkproc)(void);
# 1391 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
typedef struct GLFWmonitor GLFWmonitor;
# 1403 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
typedef struct GLFWwindow GLFWwindow;
# 1415 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
typedef struct GLFWcursor GLFWcursor;
# 1468 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
typedef void* (* GLFWallocatefun)(size_t size, void* user);
# 1524 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
typedef void* (* GLFWreallocatefun)(void* block, size_t size, void* user);
# 1566 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
typedef void (* GLFWdeallocatefun)(void* block, void* user);
# 1590 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
typedef void (* GLFWerrorfun)(int error_code, const char* description);
# 1613 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
typedef void (* GLFWwindowposfun)(GLFWwindow* window, int xpos, int ypos);
# 1635 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
typedef void (* GLFWwindowsizefun)(GLFWwindow* window, int width, int height);
# 1655 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
typedef void (* GLFWwindowclosefun)(GLFWwindow* window);
# 1675 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
typedef void (* GLFWwindowrefreshfun)(GLFWwindow* window);
# 1696 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
typedef void (* GLFWwindowfocusfun)(GLFWwindow* window, int focused);
# 1717 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
typedef void (* GLFWwindowiconifyfun)(GLFWwindow* window, int iconified);
# 1738 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
typedef void (* GLFWwindowmaximizefun)(GLFWwindow* window, int maximized);
# 1759 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
typedef void (* GLFWframebuffersizefun)(GLFWwindow* window, int width, int height);
# 1780 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
typedef void (* GLFWwindowcontentscalefun)(GLFWwindow* window, float xscale, float
yscale);
# 1806 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
typedef void (* GLFWmousebuttonfun)(GLFWwindow* window, int button, int action, int
mods);
# 1829 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
typedef void (* GLFWcursorposfun)(GLFWwindow* window, double xpos, double ypos);
# 1850 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
typedef void (* GLFWcursorenterfun)(GLFWwindow* window, int entered);
# 1871 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
typedef void (* GLFWscrollfun)(GLFWwindow* window, double xoffset, double yoffset);
# 1897 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
typedef void (* GLFWkeyfun)(GLFWwindow* window, int key, int scancode, int action,
int mods);
# 1918 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
typedef void (* GLFWcharfun)(GLFWwindow* window, unsigned int codepoint);
# 1945 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
typedef void (* GLFWcharmodsfun)(GLFWwindow* window, unsigned int codepoint, int
mods);
# 1969 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
typedef void (* GLFWdropfun)(GLFWwindow* window, int path_count, const char*
paths[]);
# 1990 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
typedef void (* GLFWmonitorfun)(GLFWmonitor* monitor, int event);
# 2011 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
typedef void (* GLFWjoystickfun)(int jid, int event);
# 2026 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
typedef struct GLFWvidmode
{

int width;

int height;

int redBits;

int greenBits;

int blueBits;

int refreshRate;
} GLFWvidmode;
# 2060 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
typedef struct GLFWgammaramp
{

unsigned short* red;

unsigned short* green;

unsigned short* blue;

unsigned int size;

} GLFWgammaramp;
# 2089 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
typedef struct GLFWimage
{

int width;

int height;

unsigned char* pixels;

} GLFWimage;
# 2113 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
typedef struct GLFWgamepadstate
{

unsigned char buttons[15];

float axes[6];
} GLFWgamepadstate;
# 2137 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
typedef struct GLFWallocator
{

GLFWallocatefun allocate;

GLFWreallocatefun reallocate;

GLFWdeallocatefun deallocate;

void* user;
} GLFWallocator;
# 2220 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) int glfwInit(void);
# 2254 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) void glfwTerminate(void);
# 2286 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) void glfwInitHint(int hint, int value);
# 2317 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) void glfwInitAllocator(const GLFWallocator* allocator);
# 2392 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) void glfwGetVersion(int* major, int* minor, int* rev);
# 2426 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) const char* glfwGetVersionString(void);
# 2457 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) int glfwGetError(const char** description);
# 2503 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) GLFWerrorfun glfwSetErrorCallback(GLFWerrorfun
callback);
# 2524 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) int glfwGetPlatform(void);
# 2548 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) int glfwPlatformSupported(int platform);
# 2577 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) GLFWmonitor** glfwGetMonitors(int* count);
# 2601 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) GLFWmonitor* glfwGetPrimaryMonitor(void);
# 2626 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) void glfwGetMonitorPos(GLFWmonitor* monitor, int* xpos,
int* ypos);
# 2657 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) void glfwGetMonitorWorkarea(GLFWmonitor* monitor, int*
xpos, int* ypos, int* width, int* height);
# 2692 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) void glfwGetMonitorPhysicalSize(GLFWmonitor* monitor,
int* widthMM, int* heightMM);
# 2727 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) void glfwGetMonitorContentScale(GLFWmonitor* monitor,
float* xscale, float* yscale);
# 2753 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) const char* glfwGetMonitorName(GLFWmonitor* monitor);
# 2779 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) void glfwSetMonitorUserPointer(GLFWmonitor* monitor,
void* pointer);
# 2803 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) void* glfwGetMonitorUserPointer(GLFWmonitor* monitor);
# 2833 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) GLFWmonitorfun glfwSetMonitorCallback(GLFWmonitorfun
callback);
# 2867 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) const GLFWvidmode* glfwGetVideoModes(GLFWmonitor*
monitor, int* count);
# 2895 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) const GLFWvidmode* glfwGetVideoMode(GLFWmonitor*
monitor);
# 2928 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) void glfwSetGamma(GLFWmonitor* monitor, float gamma);
# 2958 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) const GLFWgammaramp* glfwGetGammaRamp(GLFWmonitor*
monitor);
# 2999 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) void glfwSetGammaRamp(GLFWmonitor* monitor, const
GLFWgammaramp* ramp);
# 3018 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) void glfwDefaultWindowHints(void);
# 3053 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) void glfwWindowHint(int hint, int value);
# 3091 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) void glfwWindowHintString(int hint, const char* value);
# 3235 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) GLFWwindow* glfwCreateWindow(int width, int height,
const char* title, GLFWmonitor* monitor, GLFWwindow* share);
# 3264 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) void glfwDestroyWindow(GLFWwindow* window);
# 3284 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) int glfwWindowShouldClose(GLFWwindow* window);
# 3306 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) void glfwSetWindowShouldClose(GLFWwindow* window, int
value);
# 3338 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) const char* glfwGetWindowTitle(GLFWwindow* window);
# 3364 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) void glfwSetWindowTitle(GLFWwindow* window, const char*
title);
# 3413 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) void glfwSetWindowIcon(GLFWwindow* window, int count,
const GLFWimage* images);
# 3445 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) void glfwGetWindowPos(GLFWwindow* window, int* xpos,
int* ypos);
# 3480 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) void glfwSetWindowPos(GLFWwindow* window, int xpos, int
ypos);
# 3510 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) void glfwGetWindowSize(GLFWwindow* window, int* width,
int* height);
# 3553 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) void glfwSetWindowSizeLimits(GLFWwindow* window, int
minwidth, int minheight, int maxwidth, int maxheight);
# 3596 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) void glfwSetWindowAspectRatio(GLFWwindow* window, int
numer, int denom);
# 3634 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) void glfwSetWindowSize(GLFWwindow* window, int width,
int height);
# 3663 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) void glfwGetFramebufferSize(GLFWwindow* window, int*
width, int* height);
# 3700 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) void glfwGetWindowFrameSize(GLFWwindow* window, int*
left, int* top, int* right, int* bottom);
# 3733 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) void glfwGetWindowContentScale(GLFWwindow* window,
float* xscale, float* yscale);
# 3760 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) float glfwGetWindowOpacity(GLFWwindow* window);
# 3792 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) void glfwSetWindowOpacity(GLFWwindow* window, float
opacity);
# 3824 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) void glfwIconifyWindow(GLFWwindow* window);
# 3851 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) void glfwRestoreWindow(GLFWwindow* window);
# 3876 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) void glfwMaximizeWindow(GLFWwindow* window);
# 3908 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) void glfwShowWindow(GLFWwindow* window);
# 3930 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) void glfwHideWindow(GLFWwindow* window);
# 3969 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) void glfwFocusWindow(GLFWwindow* window);
# 3996 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) void glfwRequestWindowAttention(GLFWwindow* window);
# 4018 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) GLFWmonitor* glfwGetWindowMonitor(GLFWwindow* window);
# 4074 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) void glfwSetWindowMonitor(GLFWwindow* window,
GLFWmonitor* monitor, int xpos, int ypos, int width, int height, int refreshRate);
# 4111 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) int glfwGetWindowAttrib(GLFWwindow* window, int attrib);
# 4153 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) void glfwSetWindowAttrib(GLFWwindow* window, int attrib,
int value);
# 4176 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) void glfwSetWindowUserPointer(GLFWwindow* window, void*
pointer);
# 4197 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) void* glfwGetWindowUserPointer(GLFWwindow* window);
# 4232 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) GLFWwindowposfun glfwSetWindowPosCallback(GLFWwindow*
window, GLFWwindowposfun callback);
# 4264 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) GLFWwindowsizefun glfwSetWindowSizeCallback(GLFWwindow*
window, GLFWwindowsizefun callback);
# 4304 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) GLFWwindowclosefun
glfwSetWindowCloseCallback(GLFWwindow* window, GLFWwindowclosefun callback);
# 4340 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) GLFWwindowrefreshfun
glfwSetWindowRefreshCallback(GLFWwindow* window, GLFWwindowrefreshfun callback);
# 4375 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) GLFWwindowfocusfun
glfwSetWindowFocusCallback(GLFWwindow* window, GLFWwindowfocusfun callback);
# 4405 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) GLFWwindowiconifyfun
glfwSetWindowIconifyCallback(GLFWwindow* window, GLFWwindowiconifyfun callback);
# 4435 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) GLFWwindowmaximizefun
glfwSetWindowMaximizeCallback(GLFWwindow* window, GLFWwindowmaximizefun callback);
# 4465 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) GLFWframebuffersizefun
glfwSetFramebufferSizeCallback(GLFWwindow* window, GLFWframebuffersizefun
callback);
# 4496 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) GLFWwindowcontentscalefun
glfwSetWindowContentScaleCallback(GLFWwindow* window, GLFWwindowcontentscalefun
callback);
# 4534 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) void glfwPollEvents(void);
# 4579 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) void glfwWaitEvents(void);
# 4628 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) void glfwWaitEventsTimeout(double timeout);
# 4648 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) void glfwPostEmptyEvent(void);
# 4673 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) int glfwGetInputMode(GLFWwindow* window, int mode);
# 4738 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) void glfwSetInputMode(GLFWwindow* window, int mode, int
value);
# 4767 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) int glfwRawMouseMotionSupported(void);
# 4835 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) const char* glfwGetKeyName(int key, int scancode);
# 4862 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) int glfwGetKeyScancode(int key);
# 4901 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) int glfwGetKey(GLFWwindow* window, int key);
# 4930 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) int glfwGetMouseButton(GLFWwindow* window, int button);
# 4968 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) void glfwGetCursorPos(GLFWwindow* window, double* xpos,
double* ypos);
# 5008 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) void glfwSetCursorPos(GLFWwindow* window, double xpos,
double ypos);
# 5046 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) GLFWcursor* glfwCreateCursor(const GLFWimage* image, int
xhot, int yhot);
# 5094 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) GLFWcursor* glfwCreateStandardCursor(int shape);
# 5121 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) void glfwDestroyCursor(GLFWcursor* cursor);
# 5148 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) void glfwSetCursor(GLFWwindow* window, GLFWcursor*
cursor);
# 5198 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) GLFWkeyfun glfwSetKeyCallback(GLFWwindow* window,
GLFWkeyfun callback);
# 5241 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) GLFWcharfun glfwSetCharCallback(GLFWwindow* window,
GLFWcharfun callback);
# 5283 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) GLFWcharmodsfun glfwSetCharModsCallback(GLFWwindow*
window, GLFWcharmodsfun callback);
# 5320 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) GLFWmousebuttonfun
glfwSetMouseButtonCallback(GLFWwindow* window, GLFWmousebuttonfun callback);
# 5352 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) GLFWcursorposfun glfwSetCursorPosCallback(GLFWwindow*
window, GLFWcursorposfun callback);
# 5383 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) GLFWcursorenterfun
glfwSetCursorEnterCallback(GLFWwindow* window, GLFWcursorenterfun callback);
# 5417 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) GLFWscrollfun glfwSetScrollCallback(GLFWwindow* window,
GLFWscrollfun callback);
# 5452 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) GLFWdropfun glfwSetDropCallback(GLFWwindow* window,
GLFWdropfun callback);
# 5476 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) int glfwJoystickPresent(int jid);
# 5509 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) const float* glfwGetJoystickAxes(int jid, int* count);
# 5550 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) const unsigned char* glfwGetJoystickButtons(int jid,
int* count);
# 5607 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) const unsigned char* glfwGetJoystickHats(int jid, int*
count);
# 5638 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) const char* glfwGetJoystickName(int jid);
# 5679 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) const char* glfwGetJoystickGUID(int jid);
# 5705 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) void glfwSetJoystickUserPointer(int jid, void* pointer);
# 5729 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) void* glfwGetJoystickUserPointer(int jid);
# 5757 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) int glfwJoystickIsGamepad(int jid);
# 5793 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) GLFWjoystickfun glfwSetJoystickCallback(GLFWjoystickfun
callback);
# 5827 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) int glfwUpdateGamepadMappings(const char* string);
# 5859 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) const char* glfwGetGamepadName(int jid);
# 5897 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) int glfwGetGamepadState(int jid, GLFWgamepadstate*
state);
# 5927 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) void glfwSetClipboardString(GLFWwindow* window, const
char* string);
# 5962 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) const char* glfwGetClipboardString(GLFWwindow* window);
# 5992 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) double glfwGetTime(void);
# 6022 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) void glfwSetTime(double time);
# 6044 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) uint64_t glfwGetTimerValue(void);
# 6064 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) uint64_t glfwGetTimerFrequency(void);
# 6109 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) void glfwMakeContextCurrent(GLFWwindow* window);
# 6130 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) GLFWwindow* glfwGetCurrentContext(void);
# 6164 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) void glfwSwapBuffers(GLFWwindow* window);
# 6210 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) void glfwSwapInterval(int interval);
# 6248 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) int glfwExtensionSupported(const char* extension);
# 6290 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) GLFWglproc glfwGetProcAddress(const char* procname);
# 6316 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) int glfwVulkanSupported(void);
# 6360 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
__attribute__((dllimport)) const char** glfwGetRequiredInstanceExtensions(uint32_t*
count);
# 6543 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/GLFW/glfw3.h"
}
# 3 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/main.cpp" 2
# 1 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/creepy/Window.hpp" 1

class Window
{
public:
static bool Init(int width, int height, std::string_view title);
static bool IsShouldClose();
static void SwapBuffer();
static void Close();
static void Terminate();
public:
static struct GLFWwindow* s_window;
};
# 4 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/main.cpp" 2
# 1 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/include/creepy/Events.hpp" 1

class Events
{
public:
static bool Init();
static void PollEvents();
static void Destroy();

static bool IsKeyHolded(int keyCode);

static bool IsKeyPressed(int keyCode);

static bool IsButtonHolded(int buttonCode);

static bool IsButtonClicked(int buttonCode);
public:
static inline bool* s_keys{nullptr};
static inline uint32_t* s_frames{nullptr};
static inline uint32_t s_currentFrame{};
static inline float deltaX{};
static inline float deltaY{};
static inline float x{};
static inline float y{};
static inline bool cursorLocked{};
static inline bool cursorStarted{};
};
# 5 "D:/Code/VSCode/C++/MiniOpenGL/Voxel_1/main.cpp" 2

int main(){

Window::Init(1280, 720, "Voxel Engine");

Events::Init();

while(!Window::IsShouldClose()){
Events::PollEvents();

if(Events::IsKeyPressed(65)){
std::println("Pressed");
}

if(Events::IsButtonClicked(0)){
std::println("Clicked");
}

Window::SwapBuffer();
}

Events::Destroy();
Window::Terminate();
std::println("Ok");
}

Sample ITK Code, Item and Dataset
No ratings yet
Sample ITK Code, Item and Dataset
7 pages
Cost Center Creation Using LSMW
0% (1)
Cost Center Creation Using LSMW
17 pages
Mensajess 7
No ratings yet
Mensajess 7
23 pages
C++ MCQ
No ratings yet
C++ MCQ
100 pages
CPP Notes Upto Recursion
No ratings yet
CPP Notes Upto Recursion
24 pages
Boost - Concept - Check C++ Source Code
No ratings yet
Boost - Concept - Check C++ Source Code
16 pages
Inept Key
No ratings yet
Inept Key
7 pages
C++ Smart Pointer
No ratings yet
C++ Smart Pointer
30 pages
Practical List: No. Aim of The Practical
No ratings yet
Practical List: No. Aim of The Practical
20 pages
1157 CS F111 20231220111312 Comprehensive Exam Question Paper
No ratings yet
1157 CS F111 20231220111312 Comprehensive Exam Question Paper
4 pages
01 Chapter 3 Code From Pages 83-84
No ratings yet
01 Chapter 3 Code From Pages 83-84
2 pages
Unit IV
No ratings yet
Unit IV
17 pages
CCS354 Network Security
No ratings yet
CCS354 Network Security
87 pages
C++ Programs
No ratings yet
C++ Programs
70 pages
Python Scripts
No ratings yet
Python Scripts
5 pages
Krishiv OOPS
No ratings yet
Krishiv OOPS
2 pages
STL Deque
No ratings yet
STL Deque
25 pages
One Dimensional Array OBJECTIVES: The Students Should Be Able To
No ratings yet
One Dimensional Array OBJECTIVES: The Students Should Be Able To
4 pages
C Programming Quiz
No ratings yet
C Programming Quiz
37 pages
CSE 230 - C++ Notes 3 Classes and Data Abstraction - Part II Constant Objects
No ratings yet
CSE 230 - C++ Notes 3 Classes and Data Abstraction - Part II Constant Objects
10 pages
Lab5-1-A.ipynb - Colaboratory
No ratings yet
Lab5-1-A.ipynb - Colaboratory
5 pages
Email Spam Classifier
No ratings yet
Email Spam Classifier
22 pages
meooooo
No ratings yet
meooooo
8 pages
1682437601
No ratings yet
1682437601
6 pages
Atul Soni - C Programming to Improve Coding Skills_ Only Learning and Algorithm Based Programs With Source Code-Independently Published (2024)
No ratings yet
Atul Soni - C Programming to Improve Coding Skills_ Only Learning and Algorithm Based Programs With Source Code-Independently Published (2024)
837 pages
Banner Code Permium
No ratings yet
Banner Code Permium
7 pages
Import As Import As Import Import As Import As From Import From Import From Import From Import From Import From Import
No ratings yet
Import As Import As Import Import As Import As From Import From Import From Import From Import From Import From Import
4 pages
Accessing Class Member Example
No ratings yet
Accessing Class Member Example
24 pages
instrucciones git
No ratings yet
instrucciones git
3 pages
OOPS Practcal Code
No ratings yet
OOPS Practcal Code
16 pages
C - STL
100% (1)
C - STL
81 pages
Cplusplus Lab Sheet 04
No ratings yet
Cplusplus Lab Sheet 04
28 pages
King Fahd University of Petroleum and Minerals: Information & Computer Science Department
No ratings yet
King Fahd University of Petroleum and Minerals: Information & Computer Science Department
8 pages
PPS LAB PROGRAMS
No ratings yet
PPS LAB PROGRAMS
83 pages
Kal013 00000000008db481
No ratings yet
Kal013 00000000008db481
4 pages
Lstm-Load-Forecasting:6 - All - Features - Ipynb at Master Dafrie:lstm-Load-Forecasting GitHub
No ratings yet
Lstm-Load-Forecasting:6 - All - Features - Ipynb at Master Dafrie:lstm-Load-Forecasting GitHub
5 pages
OOPS Lab File
No ratings yet
OOPS Lab File
39 pages
Problem
No ratings yet
Problem
13 pages
meoooo
No ratings yet
meoooo
5 pages
Code Fragment (Host by Theang Yinh)
No ratings yet
Code Fragment (Host by Theang Yinh)
46 pages
uyrtazdhb
No ratings yet
uyrtazdhb
10 pages
OOP Lab Assignments
No ratings yet
OOP Lab Assignments
18 pages
Semester: II Hours/week: 2 Code: 08UCS2403:P Credits: 2
No ratings yet
Semester: II Hours/week: 2 Code: 08UCS2403:P Credits: 2
31 pages
C++ lab program
No ratings yet
C++ lab program
35 pages
PIC QB
No ratings yet
PIC QB
7 pages
UDF
No ratings yet
UDF
37 pages
Hcxhashtool
No ratings yet
Hcxhashtool
53 pages
C Class Sep6
No ratings yet
C Class Sep6
5 pages
Making C++ Code Beautiful - Gregory and McNellis - CppCon 2014
No ratings yet
Making C++ Code Beautiful - Gregory and McNellis - CppCon 2014
85 pages
Personalized Cancer Diagnosis
No ratings yet
Personalized Cancer Diagnosis
100 pages
Lte (4G)
No ratings yet
Lte (4G)
10 pages
Daa Lab Manual
No ratings yet
Daa Lab Manual
37 pages
HPC (Pra 04)
No ratings yet
HPC (Pra 04)
11 pages
Isrecord (21211a05b5)
No ratings yet
Isrecord (21211a05b5)
37 pages
SP Assignment
No ratings yet
SP Assignment
4 pages
Fuzzing The Msxml6 Library With Winafl: Symeon
No ratings yet
Fuzzing The Msxml6 Library With Winafl: Symeon
35 pages
Lecture4 PDF
No ratings yet
Lecture4 PDF
18 pages
CH 1
No ratings yet
CH 1
9 pages
Programming in C: Control and Iterative Constructs
No ratings yet
Programming in C: Control and Iterative Constructs
18 pages
Tanveer_Younas_B22F0047AI067
No ratings yet
Tanveer_Younas_B22F0047AI067
3 pages
Computer Engineering Laboratory Solution Primer
From Everand
Computer Engineering Laboratory Solution Primer
Karan Bhandari
No ratings yet
Python Brochure 999 PDF
No ratings yet
Python Brochure 999 PDF
11 pages
Adrian Salas, MIAS 250, Access Policies
No ratings yet
Adrian Salas, MIAS 250, Access Policies
7 pages
Introduction To Harmonic Analysis Basics - R2
100% (2)
Introduction To Harmonic Analysis Basics - R2
46 pages
Steps To Successful Writing
No ratings yet
Steps To Successful Writing
46 pages
Activity. Relations and Functions
No ratings yet
Activity. Relations and Functions
5 pages
GR 7 CH 4 - Rational Numbers
No ratings yet
GR 7 CH 4 - Rational Numbers
2 pages
Phone Service
No ratings yet
Phone Service
2 pages
WeatherWork 1
No ratings yet
WeatherWork 1
9 pages
TableLlama Towards Open Large Generalist Models For Tables
No ratings yet
TableLlama Towards Open Large Generalist Models For Tables
21 pages
Calibration Certificate PNW-2000
No ratings yet
Calibration Certificate PNW-2000
4 pages
Availability Check (Atp) & Transfer of Requirement (Tor) : Checking Group
No ratings yet
Availability Check (Atp) & Transfer of Requirement (Tor) : Checking Group
3 pages
s14980.r3 - Acorn - Rev4, Gecko g540 With Db25 Connections
No ratings yet
s14980.r3 - Acorn - Rev4, Gecko g540 With Db25 Connections
1 page
MiniNova Guide
No ratings yet
MiniNova Guide
41 pages
Grindhouse Final A5
100% (1)
Grindhouse Final A5
8 pages
Free Bitcoin MOOC Dfin-511
No ratings yet
Free Bitcoin MOOC Dfin-511
3 pages
Manual - PHOTOMETER-FM1-4-6 - WIP-WASH - A5 v1.6 2.2017
No ratings yet
Manual - PHOTOMETER-FM1-4-6 - WIP-WASH - A5 v1.6 2.2017
28 pages
GPS Tracking System: TK06A User Manual
100% (1)
GPS Tracking System: TK06A User Manual
12 pages
ISO 9001 Clause 4.1
No ratings yet
ISO 9001 Clause 4.1
6 pages
dSPACE Tutorial PDF
No ratings yet
dSPACE Tutorial PDF
22 pages
DIPLOMA COMPUTER SEM 1 TO 5 TIME TABLE (1)
No ratings yet
DIPLOMA COMPUTER SEM 1 TO 5 TIME TABLE (1)
2 pages
Brian Rickyantara: Personal Info Experience
No ratings yet
Brian Rickyantara: Personal Info Experience
2 pages
Cps 303 Note
No ratings yet
Cps 303 Note
40 pages
MozaMap Digital Maps en
No ratings yet
MozaMap Digital Maps en
19 pages
Ingenic Zeratul T31 USB Burning Instructions 20200901 EN
No ratings yet
Ingenic Zeratul T31 USB Burning Instructions 20200901 EN
10 pages
Leon Couch Communication System Files
No ratings yet
Leon Couch Communication System Files
3 pages
Business Requirement Document: Prepared By-Apurva
No ratings yet
Business Requirement Document: Prepared By-Apurva
22 pages
Vertical DIY Instructions
No ratings yet
Vertical DIY Instructions
20 pages
Unit 1
No ratings yet
Unit 1
36 pages
Manual Samplitudeprox4suite en PDF
No ratings yet
Manual Samplitudeprox4suite en PDF
1,010 pages